From f52b234579abb8045da366c8fd5f24e0cf2c7ed2 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Tue, 3 Mar 2015 13:38:14 -0800 Subject: [dev.ssa] cmd/internal/ssa: SSA backend compiler skeleton First pass adding code for SSA backend. It is standalone for now. I've included just a few passes to make the review size manageable - I have more passes coming. cmd/internal/ssa is the library containing the ssa compiler proper. cmd/internal/ssa/ssac is a driver that loads an sexpr-based IR, converts it to SSA form, and calls the above library. It is essentially throwaway code - it will disappear once the Go compiler calls cmd/internal/ssa itself. The .goir files in ssac/ are dumps of fibonacci programs I made from a hacked-up compiler. They are just for testing. Change-Id: I5ee89356ec12c87cd916681097cd3c2cd591040c Reviewed-on: https://go-review.googlesource.com/6681 Reviewed-by: Alan Donovan --- src/cmd/internal/ssa/block.go | 92 +++++++ src/cmd/internal/ssa/blockkind_string.go | 16 ++ src/cmd/internal/ssa/check.go | 125 +++++++++ src/cmd/internal/ssa/compile.go | 65 +++++ src/cmd/internal/ssa/copyelim.go | 29 ++ src/cmd/internal/ssa/deadcode.go | 153 +++++++++++ src/cmd/internal/ssa/deadcode_test.go | 112 ++++++++ src/cmd/internal/ssa/export_test.go | 9 + src/cmd/internal/ssa/func.go | 61 +++++ src/cmd/internal/ssa/id.go | 41 +++ src/cmd/internal/ssa/location.go | 42 +++ src/cmd/internal/ssa/op.go | 345 ++++++++++++++++++++++++ src/cmd/internal/ssa/op_string.go | 16 ++ src/cmd/internal/ssa/phielim.go | 44 ++++ src/cmd/internal/ssa/print.go | 63 +++++ src/cmd/internal/ssa/sparseset.go | 60 +++++ src/cmd/internal/ssa/ssac/.gitignore | 1 + src/cmd/internal/ssa/ssac/fib.goir | 46 ++++ src/cmd/internal/ssa/ssac/fibiter.goir | 62 +++++ src/cmd/internal/ssa/ssac/main.go | 436 +++++++++++++++++++++++++++++++ src/cmd/internal/ssa/ssac/sexpr.go | 82 ++++++ src/cmd/internal/ssa/ssac/sparsemap.go | 69 +++++ src/cmd/internal/ssa/type.go | 84 ++++++ src/cmd/internal/ssa/types/object.go | 39 +++ src/cmd/internal/ssa/types/type.go | 229 ++++++++++++++++ src/cmd/internal/ssa/value.go | 117 +++++++++ 26 files changed, 2438 insertions(+) create mode 100644 src/cmd/internal/ssa/block.go create mode 100644 src/cmd/internal/ssa/blockkind_string.go create mode 100644 src/cmd/internal/ssa/check.go create mode 100644 src/cmd/internal/ssa/compile.go create mode 100644 src/cmd/internal/ssa/copyelim.go create mode 100644 src/cmd/internal/ssa/deadcode.go create mode 100644 src/cmd/internal/ssa/deadcode_test.go create mode 100644 src/cmd/internal/ssa/export_test.go create mode 100644 src/cmd/internal/ssa/func.go create mode 100644 src/cmd/internal/ssa/id.go create mode 100644 src/cmd/internal/ssa/location.go create mode 100644 src/cmd/internal/ssa/op.go create mode 100644 src/cmd/internal/ssa/op_string.go create mode 100644 src/cmd/internal/ssa/phielim.go create mode 100644 src/cmd/internal/ssa/print.go create mode 100644 src/cmd/internal/ssa/sparseset.go create mode 100644 src/cmd/internal/ssa/ssac/.gitignore create mode 100644 src/cmd/internal/ssa/ssac/fib.goir create mode 100644 src/cmd/internal/ssa/ssac/fibiter.goir create mode 100644 src/cmd/internal/ssa/ssac/main.go create mode 100644 src/cmd/internal/ssa/ssac/sexpr.go create mode 100644 src/cmd/internal/ssa/ssac/sparsemap.go create mode 100644 src/cmd/internal/ssa/type.go create mode 100644 src/cmd/internal/ssa/types/object.go create mode 100644 src/cmd/internal/ssa/types/type.go create mode 100644 src/cmd/internal/ssa/value.go (limited to 'src/cmd') diff --git a/src/cmd/internal/ssa/block.go b/src/cmd/internal/ssa/block.go new file mode 100644 index 0000000000..ff1cb1b30a --- /dev/null +++ b/src/cmd/internal/ssa/block.go @@ -0,0 +1,92 @@ +// 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" + "strings" +) + +// 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 blocks 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 + + // The unordered set of Values contained in this block. + // The list must include the control value, if any. (TODO: need this last condition?) + Values []*Value + + // The containing function + Func *Func +} + +// 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 int8 + +const ( + BlockExit BlockKind = iota // no successors. There should only be 1 of these. + BlockPlain // a single successor + BlockIf // 2 successors, if control goto Succs[0] else goto Succs[1] + BlockCall // 2 successors, normal return and panic + BlockUnknown + + // 386/amd64 variants of BlockIf that take the flags register as an arg + BlockEQ + BlockNE + BlockLT + BlockLE + BlockGT + BlockGE + BlockULT + BlockULE + BlockUGT + BlockUGE +) + +//go:generate stringer -type=BlockKind + +// short form print +func (b *Block) String() string { + return fmt.Sprintf("b%d", b.ID) +} + +// long form print +func (b *Block) LongString() string { + s := strings.TrimPrefix(b.Kind.String(), "Block") + if b.Control != nil { + s += fmt.Sprintf(" %s", b.Control) + } + if len(b.Succs) > 0 { + s += " ->" + for _, c := range b.Succs { + s += " " + c.String() + } + } + return s +} diff --git a/src/cmd/internal/ssa/blockkind_string.go b/src/cmd/internal/ssa/blockkind_string.go new file mode 100644 index 0000000000..6204f1948f --- /dev/null +++ b/src/cmd/internal/ssa/blockkind_string.go @@ -0,0 +1,16 @@ +// generated by stringer -type=BlockKind; DO NOT EDIT + +package ssa + +import "fmt" + +const _BlockKind_name = "BlockExitBlockPlainBlockIfBlockCallBlockUnknownBlockEQBlockNEBlockLTBlockLEBlockGTBlockGEBlockULTBlockULEBlockUGTBlockUGE" + +var _BlockKind_index = [...]uint8{0, 9, 19, 26, 35, 47, 54, 61, 68, 75, 82, 89, 97, 105, 113, 121} + +func (i BlockKind) String() string { + if i < 0 || i+1 >= BlockKind(len(_BlockKind_index)) { + return fmt.Sprintf("BlockKind(%d)", i) + } + return _BlockKind_name[_BlockKind_index[i]:_BlockKind_index[i+1]] +} diff --git a/src/cmd/internal/ssa/check.go b/src/cmd/internal/ssa/check.go new file mode 100644 index 0000000000..b501cdb54c --- /dev/null +++ b/src/cmd/internal/ssa/check.go @@ -0,0 +1,125 @@ +// 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 "log" + +// 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] { + log.Panicf("block %s appears twice in %s!", b, f.Name) + } + blockMark[b.ID] = true + if b.Func != f { + log.Panicf("%s.Func=%s, want %s", b, b.Func.Name, f.Name) + } + + for i, c := range b.Succs { + for j, d := range b.Succs { + if i != j && c == d { + log.Panicf("%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). + + for _, p := range b.Preds { + var found bool + for _, c := range p.Succs { + if c == b { + found = true + break + } + } + if !found { + log.Panicf("block %s is not a succ of its pred block %s", b, p) + } + } + + switch b.Kind { + case BlockExit: + if len(b.Succs) != 0 { + log.Panicf("exit block %s has successors", b) + } + if b.Control == nil { + log.Panicf("exit block %s has no control value", b) + } + if b.Control.Type != TypeMem { + log.Panicf("exit block %s has non-memory control value %s", b, b.Control.LongString()) + } + case BlockPlain: + if len(b.Succs) != 1 { + log.Panicf("plain block %s len(Succs)==%d, want 1", b, len(b.Succs)) + } + if b.Control != nil { + log.Panicf("plain block %s has non-nil control %s", b, b.Control.LongString()) + } + case BlockIf: + if len(b.Succs) != 2 { + log.Panicf("if block %s len(Succs)==%d, want 2", b, len(b.Succs)) + } + if b.Control == nil { + log.Panicf("if block %s has no control value", b) + } + if b.Control.Type != TypeBool { + log.Panicf("if block %s has non-bool control value %s", b, b.Control.LongString()) + } + case BlockCall: + if len(b.Succs) != 2 { + log.Panicf("call block %s len(Succs)==%d, want 2", b, len(b.Succs)) + } + if b.Control == nil { + log.Panicf("call block %s has no control value", b) + } + if b.Control.Type != TypeMem { + log.Panicf("call block %s has non-memory control value %s", b, b.Control.LongString()) + } + if b.Succs[1].Kind != BlockExit { + log.Panicf("exception edge from call block %s does not go to exit but %s", b, b.Succs[1]) + } + } + + for _, v := range b.Values { + if valueMark[v.ID] { + log.Panicf("value %s appears twice!", v.LongString()) + } + valueMark[v.ID] = true + + if v.Block != b { + log.Panicf("%s.block != %s", v, b) + } + if v.Op == OpPhi && len(v.Args) != len(b.Preds) { + log.Panicf("phi length %s does not match pred length %d for block %s", v.LongString(), len(b.Preds), b) + } + + // TODO: check idom + // TODO: check for cycles in values + // TODO: check type + } + } + + for _, id := range f.bid.free { + if blockMark[id] { + log.Panicf("used block b%d in free list", id) + } + } + for _, id := range f.vid.free { + if valueMark[id] { + log.Panicf("used value v%d in free list", id) + } + } +} diff --git a/src/cmd/internal/ssa/compile.go b/src/cmd/internal/ssa/compile.go new file mode 100644 index 0000000000..5e21bdf6e1 --- /dev/null +++ b/src/cmd/internal/ssa/compile.go @@ -0,0 +1,65 @@ +// 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" + +// 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. + fmt.Printf("compiling %s\n", f.Name) + + // hook to print function & phase if panic happens + phaseName := "init" + defer func() { + if phaseName != "" { + fmt.Printf("panic during %s while compiling %s\n", phaseName, f.Name) + } + }() + + // Run all the passes + printFunc(f) + checkFunc(f) + for _, p := range passes { + phaseName = p.name + fmt.Printf(" pass %s begin\n", p.name) + p.fn(f) + fmt.Printf(" pass %s end\n", p.name) + printFunc(f) + checkFunc(f) + } + + // Squash error printing defer + phaseName = "" +} + +type pass struct { + name string + fn func(*Func) +} + +// list of passes for the compiler +var passes = [...]pass{ + {"phielim", phielim}, + {"copyelim", copyelim}, + //{"opt", opt}, + // cse + {"deadcode", deadcode}, + //{"fuse", fuse}, + //{"lower", lower}, + // cse + //{"critical", critical}, // remove critical edges + //{"layout", layout}, // schedule blocks + //{"schedule", schedule}, // schedule values + // regalloc + // stack slot alloc (+size stack frame) + //{"cgen", cgen}, +} diff --git a/src/cmd/internal/ssa/copyelim.go b/src/cmd/internal/ssa/copyelim.go new file mode 100644 index 0000000000..10c2dcc440 --- /dev/null +++ b/src/cmd/internal/ssa/copyelim.go @@ -0,0 +1,29 @@ +// 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 { + for i, w := range v.Args { + x := w + for x.Op == OpCopy { + x = x.Args[0] + } + if x != w { + v.Args[i] = x + } + } + } + v := b.Control + if v != nil { + for v.Op == OpCopy { + v = v.Args[0] + } + b.Control = v + } + } +} diff --git a/src/cmd/internal/ssa/deadcode.go b/src/cmd/internal/ssa/deadcode.go new file mode 100644 index 0000000000..1647ea955d --- /dev/null +++ b/src/cmd/internal/ssa/deadcode.go @@ -0,0 +1,153 @@ +// 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 "log" + +// deadcode removes dead code from f. +func deadcode(f *Func) { + + // Find all reachable basic blocks. + 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] + + // constant-fold conditionals + // TODO: rewrite rules instead? + if b.Kind == BlockIf && b.Control.Op == OpConstBool { + cond := b.Control.Aux.(bool) + var c *Block + if cond { + // then branch is always taken + c = b.Succs[1] + } else { + // else branch is always taken + c = b.Succs[0] + b.Succs[0] = b.Succs[1] + } + b.Succs[1] = nil // aid GC + b.Succs = b.Succs[:1] + removePredecessor(b, c) + b.Kind = BlockPlain + b.Control = nil + } + + for _, c := range b.Succs { + if !reachable[c.ID] { + reachable[c.ID] = true + p = append(p, c) // push + } + } + } + + // Find all live values + live := make([]bool, f.NumValues()) // flag to set for each live value + 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 _, x := range v.Args { + if !live[x.ID] { + live[x.ID] = true + q = append(q, x) // push + } + } + } + + // Remove dead values from blocks' value list. Return dead + // value ids 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.vid.put(v.ID) + } + } + for j := i; j < len(b.Values); j++ { + b.Values[j] = nil // aid GC + } + b.Values = b.Values[:i] + } + + // Remove unreachable blocks. Return dead block ids to allocator. + i := 0 + for _, b := range f.Blocks { + if reachable[b.ID] { + f.Blocks[i] = b + i++ + } else { + if len(b.Values) > 0 { + panic("live value in unreachable block") + } + f.bid.put(b.ID) + } + } + // zero remainder to help gc + for j := i; j < len(f.Blocks); j++ { + f.Blocks[j] = nil + } + f.Blocks = f.Blocks[:i] + + // TODO: renumber Blocks and Values densely? +} + +// There was an edge b->c. It has been removed from b's successors. +// Fix up c to handle that fact. +func removePredecessor(b, c *Block) { + n := len(c.Preds) - 1 + if n == 0 { + // c is now dead - don't bother working on it + if c.Preds[0] != b { + log.Panicf("%s.Preds[0]==%s, want %s", c, c.Preds[0], b) + } + return + } + + // find index of b in c's predecessor list + var i int + for j, p := range c.Preds { + if p == b { + i = j + break + } + } + + c.Preds[i] = c.Preds[n] + c.Preds[n] = nil // aid GC + c.Preds = c.Preds[:n] + // rewrite phi ops to match the new predecessor list + for _, v := range c.Values { + if v.Op != OpPhi { + continue + } + v.Args[i] = v.Args[n] + v.Args[n] = nil // aid GC + v.Args = v.Args[:n] + if n == 1 { + v.Op = OpCopy + } + } +} diff --git a/src/cmd/internal/ssa/deadcode_test.go b/src/cmd/internal/ssa/deadcode_test.go new file mode 100644 index 0000000000..94fc359af7 --- /dev/null +++ b/src/cmd/internal/ssa/deadcode_test.go @@ -0,0 +1,112 @@ +// 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: these tests are pretty verbose. Is there a way to simplify +// building a small Func for testing? + +package ssa_test + +import ( + . "cmd/internal/ssa" + "testing" +) + +func TestDeadLoop(t *testing.T) { + f := new(Func) + entry := f.NewBlock(BlockPlain) + exit := f.NewBlock(BlockExit) + f.Entry = entry + addEdge(entry, exit) + mem := entry.NewValue(OpArg, TypeMem, ".mem") + exit.Control = mem + + // dead loop + deadblock := f.NewBlock(BlockIf) + addEdge(deadblock, deadblock) + addEdge(deadblock, exit) + + // dead value in dead block + deadval := deadblock.NewValue(OpConstBool, TypeBool, true) + deadblock.Control = deadval + + CheckFunc(f) + Deadcode(f) + CheckFunc(f) + + for _, b := range f.Blocks { + if b == deadblock { + t.Errorf("dead block not removed") + } + for _, v := range b.Values { + if v == deadval { + t.Errorf("control value of dead block not removed") + } + } + } +} + +func TestDeadValue(t *testing.T) { + f := new(Func) + entry := f.NewBlock(BlockPlain) + exit := f.NewBlock(BlockExit) + f.Entry = entry + addEdge(entry, exit) + mem := entry.NewValue(OpArg, TypeMem, ".mem") + exit.Control = mem + + deadval := entry.NewValue(OpConstInt, TypeInt, 37) + + CheckFunc(f) + Deadcode(f) + CheckFunc(f) + + for _, b := range f.Blocks { + for _, v := range b.Values { + if v == deadval { + t.Errorf("dead value not removed") + } + } + } +} + +func TestNeverTaken(t *testing.T) { + f := new(Func) + entry := f.NewBlock(BlockIf) + exit := f.NewBlock(BlockExit) + then := f.NewBlock(BlockPlain) + else_ := f.NewBlock(BlockPlain) + f.Entry = entry + addEdge(entry, then) + addEdge(entry, else_) + addEdge(then, exit) + addEdge(else_, exit) + mem := entry.NewValue(OpArg, TypeMem, ".mem") + exit.Control = mem + + cond := entry.NewValue(OpConstBool, TypeBool, false) + entry.Control = cond + + CheckFunc(f) + Deadcode(f) + CheckFunc(f) + + if entry.Kind != BlockPlain { + t.Errorf("if(false) not simplified") + } + for _, b := range f.Blocks { + if b == then { + t.Errorf("then block still present") + } + for _, v := range b.Values { + if v == cond { + t.Errorf("constant condition still present") + } + } + } +} + +func addEdge(b, c *Block) { + b.Succs = append(b.Succs, c) + c.Preds = append(c.Preds, b) +} diff --git a/src/cmd/internal/ssa/export_test.go b/src/cmd/internal/ssa/export_test.go new file mode 100644 index 0000000000..ab4ab82345 --- /dev/null +++ b/src/cmd/internal/ssa/export_test.go @@ -0,0 +1,9 @@ +// 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 + +var CheckFunc = checkFunc +var PrintFunc = printFunc +var Deadcode = deadcode diff --git a/src/cmd/internal/ssa/func.go b/src/cmd/internal/ssa/func.go new file mode 100644 index 0000000000..6868e3d1ed --- /dev/null +++ b/src/cmd/internal/ssa/func.go @@ -0,0 +1,61 @@ +// 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 + +// A Func represents a Go func declaration (or function literal) and +// its body. This package compiles each Func independently. +type Func struct { + Name string // e.g. bytes·Compare + Type Type // type signature of the function. + 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 + + // when register allocation is done, maps value ids to locations + RegAlloc []Location +} + +// 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() +} + +// NewBlock returns a new block of the given kind and appends it to f.Blocks. +func (f *Func) NewBlock(kind BlockKind) *Block { + b := &Block{ + ID: f.bid.get(), + Kind: kind, + Func: f, + } + f.Blocks = append(f.Blocks, b) + return b +} + +// NewValue returns a new value in the block with no arguments. +func (b *Block) NewValue(op Op, t Type, aux interface{}) *Value { + v := &Value{ + ID: b.Func.vid.get(), + Op: op, + Type: t, + Aux: aux, + Block: b, + } + v.Args = v.argstorage[:0] + b.Values = append(b.Values, v) + return v +} + +// ConstInt returns an int constant representing its argument. +func (f *Func) ConstInt(c int64) *Value { + // TODO: cache? + // TODO: different types? + return f.Entry.NewValue(OpConstInt, TypeInt, c) +} diff --git a/src/cmd/internal/ssa/id.go b/src/cmd/internal/ssa/id.go new file mode 100644 index 0000000000..43f23c838c --- /dev/null +++ b/src/cmd/internal/ssa/id.go @@ -0,0 +1,41 @@ +// 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 + free []ID +} + +// get allocates an ID and returns it. +func (a *idAlloc) get() ID { + if n := len(a.free); n > 0 { + x := a.free[n-1] + a.free = a.free[:n-1] + return x + } + x := a.last + x++ + if x == 1<<31-1 { + panic("too many ids for this function") + } + a.last = x + return x +} + +// put deallocates an ID. +func (a *idAlloc) put(x ID) { + a.free = append(a.free, x) + // TODO: IR check should make sure that the IR contains + // no IDs that are in the free list. +} + +// num returns the maximum ID ever returned + 1. +func (a *idAlloc) num() int { + return int(a.last + 1) +} diff --git a/src/cmd/internal/ssa/location.go b/src/cmd/internal/ssa/location.go new file mode 100644 index 0000000000..94c1b426a2 --- /dev/null +++ b/src/cmd/internal/ssa/location.go @@ -0,0 +1,42 @@ +// 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. +type Register struct { + name string +} + +func (r *Register) Name() string { + return r.name +} + +// A LocalSlot is a location in the stack frame. +type LocalSlot struct { + idx int64 // offset in locals area (distance down from FP == caller's SP) +} + +func (s *LocalSlot) Name() string { + return fmt.Sprintf("loc%d", s.idx) +} + +// An ArgSlot is a location in the parents' stack frame where it passed us an argument. +type ArgSlot struct { + idx int64 // offset in argument area +} + +// A CalleeSlot is a location in the stack frame where we pass an argument to a callee. +type CalleeSlot struct { + idx int64 // offset in callee area +} diff --git a/src/cmd/internal/ssa/op.go b/src/cmd/internal/ssa/op.go new file mode 100644 index 0000000000..a4364b1c5c --- /dev/null +++ b/src/cmd/internal/ssa/op.go @@ -0,0 +1,345 @@ +// 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 + +// 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 below. +// Ops come in two flavors, architecture-independent and architecture-dependent. +type Op int32 + +// All the opcodes +const ( + OpUnknown Op = iota + + // machine-independent opcodes + + OpNop // should never be used, appears only briefly during construction, Has type Void. + OpThunk // used during ssa construction. Like OpCopy, but the arg has not been specified yet. + + // 2-input arithmetic + OpAdd + OpSub + OpMul + + // 2-input comparisons + OpLess + + // constants + OpConstNil + OpConstBool // aux is type bool + OpConstString // aux is type string + OpConstInt // aux is type int64 + OpConstFloat // aux is type float64 + OpConstComplex // aux is type complex128 + + OpArg // address of a function parameter/result + OpGlobal // address of a global variable + OpFunc // entry address of a function + OpCopy // output = input + OpPhi // select an input based on which predecessor we came from + + OpSliceMake // args are ptr/len/cap + OpSlicePtr + OpSliceLen + OpSliceCap + + OpStringMake // args are ptr/len + OpStringPtr + OpStringLen + + OpSlice + OpIndex + OpIndexAddr + + OpLoad // args are ptr, memory + OpStore // args are ptr, memory, returns memory + + OpCheckNil // arg[0] != nil + OpCheckBound // 0 <= arg[0] < arg[1] + + // function calls. Arguments to the call have already been written to the stack. + // Return values appear on the stack. + OpCall // args are function ptr, memory + OpStaticCall // aux is function, arg is memory + + OpConvert + OpConvNop + + // These ops return a pointer to a location on the stack. Aux contains an int64 + // indicating an offset from the base pointer. + OpFPAddr // offset from FP (+ == args from caller, - == locals) + OpSPAddr // offset from SP + + // load/store from constant offsets from SP/FP + // The distinction between FP/SP needs to be maintained until after + // register allocation because we don't know the size of the frame yet. + OpLoadFP + OpLoadSP + OpStoreFP + OpStoreSP + + // 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 with that because + // we know there is no aliasing to spill slots on the stack. + OpStoreReg8 + OpLoadReg8 + + // machine-dependent opcodes go here + + // x86 + OpADDQ + OpSUBQ + OpADDCQ // 1 input arg, add aux which is an int64 constant + OpSUBCQ // 1 input arg. output = input - aux.(int64) + OpNEGQ + OpCMPQ + OpCMPCQ // 1 input arg. Compares input with aux.(int64) + OpADDL + OpInvertFlags // inverts interpretation of the flags register (< to >=, etc.) + OpSETL // generate bool = "flags encode less than" + OpSETGE + + OpLEAQ // x+y + OpLEAQ2 // x+2*y + OpLEAQ4 // x+4*y + OpLEAQ8 // x+8*y + + OpLoadFP8 + OpLoadSP8 + OpStoreFP8 + OpStoreSP8 + + OpMax // sentinel +) + +//go:generate stringer -type=Op + +type OpInfo struct { + flags int32 + + // assembly template + // %In: location of input n + // %On: location of output n + // %A: print aux with fmt.Print + asm string + + // computes type for values with this opcode + typer func(v *Value) + + // returns a reg constraint for the instruction. [0] gives a reg constraint + // for each input, [1] gives a reg constraint for each output. (Values have + // exactly one output for now) + reg [2][]regMask +} + +type regMask uint64 + +var regs386 = [...]string{ + "AX", + "BX", + "CX", + "DX", + "SI", + "DI", + "SP", + "BP", + "X0", + + // pseudo registers + "FLAGS", + "OVERWRITE0", // the same register as the first input +} + +// TODO: match up these with regs386 above +var gp regMask = 0xff +var cx regMask = 0x4 +var flags regMask = 1 << 9 +var overwrite0 regMask = 1 << 10 + +const ( + // possible properties of opcodes + OpFlagCommutative int32 = 1 << iota + + // architecture constants + Arch386 + ArchAmd64 + ArchArm +) + +func firstArgTyper(v *Value) { + v.Type = v.Args[0].Type +} +func boolTyper(v *Value) { + v.Type = TypeBool +} +func stringTyper(v *Value) { + v.Type = TypeString +} +func flagsTyper(v *Value) { + v.Type = TypeFlags +} +func uint8Typer(v *Value) { + v.Type = TypeUint8 +} +func uint64Typer(v *Value) { + v.Type = TypeUint64 +} +func auxTyper(v *Value) { + v.Type = v.Aux.(Type) +} + +// general purpose registers, 2 input, 1 output +var gp21 = [2][]regMask{{gp, gp}, {gp}} +var gp21_overwrite = [2][]regMask{{gp, gp}, {overwrite0}} + +// general purpose registers, 1 input, 1 output +var gp11 = [2][]regMask{{gp}, {gp}} +var gp11_overwrite = [2][]regMask{{gp}, {overwrite0}} + +// shift operations +var shift = [2][]regMask{{gp, cx}, {overwrite0}} + +var gp2_flags = [2][]regMask{{gp, gp}, {flags}} +var gp1_flags = [2][]regMask{{gp}, {flags}} +var gpload = [2][]regMask{{gp, 0}, {gp}} +var gpstore = [2][]regMask{{gp, gp, 0}, {0}} + +// Opcodes that represent the input Go program +var genericTable = [...]OpInfo{ + // the unknown op is used only during building and should not appear in a + // fully formed ssa representation. + + OpAdd: {flags: OpFlagCommutative, typer: firstArgTyper}, + OpSub: {typer: firstArgTyper}, + OpMul: {flags: OpFlagCommutative, typer: firstArgTyper}, + OpLess: {typer: boolTyper}, + + OpConstBool: {typer: boolTyper}, // aux is a bool + OpConstString: {typer: stringTyper}, // aux is a string + OpConstInt: {}, // aux is an int64 + OpConstFloat: {}, // aux is a float64 + OpConstComplex: {}, + OpArg: {}, // aux is the name of the input variable TODO:? + OpGlobal: {}, // address of a global variable + OpFunc: {}, + OpCopy: {}, + OpPhi: {}, + + OpConvNop: {}, // aux is the type to convert to + + /* + // build and take apart slices + {name: "slicemake"}, // (ptr,len,cap) -> slice + {name: "sliceptr"}, // pointer part of slice + {name: "slicelen"}, // length part of slice + {name: "slicecap"}, // capacity part of slice + + // build and take apart strings + {name: "stringmake"}, // (ptr,len) -> string + {name: "stringptr"}, // pointer part of string + {name: "stringlen"}, // length part of string + + // operations on arrays/slices/strings + {name: "slice"}, // (s, i, j) -> s[i:j] + {name: "index"}, // (mem, ptr, idx) -> val + {name: "indexaddr"}, // (ptr, idx) -> ptr + + // loads & stores + {name: "load"}, // (mem, check, ptr) -> val + {name: "store"}, // (mem, check, ptr, val) -> mem + + // checks + {name: "checknil"}, // (mem, ptr) -> check + {name: "checkbound"}, // (mem, idx, len) -> check + + // functions + {name: "call"}, + + // builtins + {name: "len"}, + {name: "convert"}, + + // tuples + {name: "tuple"}, // build a tuple out of its arguments + {name: "extract"}, // aux is an int64. Extract that index out of a tuple + {name: "extractsuffix"}, // aux is an int64. Slice a tuple with [aux:] + + */ +} + +// Opcodes that appear in an output amd64 program +var amd64Table = [...]OpInfo{ + OpADDQ: {flags: OpFlagCommutative, asm: "ADDQ\t%I0,%I1,%O0", reg: gp21, typer: firstArgTyper}, // TODO: overwrite + OpADDCQ: {asm: "ADDQ\t$%A,%I0,%O0", reg: gp11_overwrite, typer: firstArgTyper}, // aux = int64 constant to add + OpSUBQ: {asm: "SUBQ\t%I0,%I1,%O0", reg: gp21, typer: firstArgTyper}, + OpSUBCQ: {asm: "SUBQ\t$%A,%I0,%O0", reg: gp11_overwrite, typer: firstArgTyper}, + + OpCMPQ: {asm: "CMPQ\t%I0,%I1", reg: gp2_flags, typer: flagsTyper}, // compute arg[0]-arg[1] and produce flags + OpCMPCQ: {asm: "CMPQ\t$%A,%I0", reg: gp1_flags}, + + OpLEAQ: {flags: OpFlagCommutative, asm: "LEAQ\t%A(%I0)(%I1*1),%O0", reg: gp21}, // aux = int64 constant to add + OpLEAQ2: {asm: "LEAQ\t%A(%I0)(%I1*2),%O0"}, + OpLEAQ4: {asm: "LEAQ\t%A(%I0)(%I1*4),%O0"}, + OpLEAQ8: {asm: "LEAQ\t%A(%I0)(%I1*8),%O0"}, + + //OpLoad8: {asm: "MOVQ\t%A(%I0),%O0", reg: gpload}, + //OpStore8: {asm: "MOVQ\t%I1,%A(%I0)", reg: gpstore}, + + OpStaticCall: {asm: "CALL\t%A(SB)"}, + + OpCopy: {asm: "MOVQ\t%I0,%O0", reg: gp11}, + + // convert from flags back to boolean + OpSETL: {typer: boolTyper}, + + // ops for load/store to stack + OpLoadFP8: {asm: "MOVQ\t%A(FP),%O0"}, + OpLoadSP8: {asm: "MOVQ\t%A(SP),%O0"}, + OpStoreFP8: {asm: "MOVQ\t%I0,%A(FP)"}, + OpStoreSP8: {asm: "MOVQ\t%I0,%A(SP)"}, + + // ops for spilling of registers + // unlike regular loads & stores, these take no memory argument. + // They are just like OpCopy but we use them during register allocation. + // TODO: different widths, float + OpLoadReg8: {asm: "MOVQ\t%I0,%O0", reg: gp11}, + OpStoreReg8: {asm: "MOVQ\t%I0,%O0", reg: gp11}, +} + +// A Table is a list of opcodes with a common set of flags. +type Table struct { + t []OpInfo + flags int32 +} + +var tables = []Table{ + {genericTable[:], 0}, + {amd64Table[:], ArchAmd64}, // TODO: pick this dynamically +} + +// table of opcodes, indexed by opcode ID +var opcodeTable [OpMax]OpInfo + +// map from opcode names to opcode IDs +var nameToOp map[string]Op + +func init() { + // build full opcode table + // Note that the arch-specific table overwrites the generic table + for _, t := range tables { + for op, entry := range t.t { + entry.flags |= t.flags + opcodeTable[op] = entry + } + } + // build name to opcode mapping + nameToOp = make(map[string]Op) + for op := range opcodeTable { + nameToOp[Op(op).String()] = Op(op) + } +} diff --git a/src/cmd/internal/ssa/op_string.go b/src/cmd/internal/ssa/op_string.go new file mode 100644 index 0000000000..40051eb321 --- /dev/null +++ b/src/cmd/internal/ssa/op_string.go @@ -0,0 +1,16 @@ +// generated by stringer -type=Op; DO NOT EDIT + +package ssa + +import "fmt" + +const _Op_name = "OpUnknownOpNopOpThunkOpAddOpSubOpMulOpLessOpConstNilOpConstBoolOpConstStringOpConstIntOpConstFloatOpConstComplexOpArgOpGlobalOpFuncOpCopyOpPhiOpSliceMakeOpSlicePtrOpSliceLenOpSliceCapOpStringMakeOpStringPtrOpStringLenOpSliceOpIndexOpIndexAddrOpLoadOpStoreOpCheckNilOpCheckBoundOpCallOpStaticCallOpConvertOpConvNopOpFPAddrOpSPAddrOpLoadFPOpLoadSPOpStoreFPOpStoreSPOpStoreReg8OpLoadReg8OpADDQOpSUBQOpADDCQOpSUBCQOpNEGQOpCMPQOpCMPCQOpADDLOpInvertFlagsOpSETLOpSETGEOpLEAQOpLEAQ2OpLEAQ4OpLEAQ8OpLoadFP8OpLoadSP8OpStoreFP8OpStoreSP8OpMax" + +var _Op_index = [...]uint16{0, 9, 14, 21, 26, 31, 36, 42, 52, 63, 76, 86, 98, 112, 117, 125, 131, 137, 142, 153, 163, 173, 183, 195, 206, 217, 224, 231, 242, 248, 255, 265, 277, 283, 295, 304, 313, 321, 329, 337, 345, 354, 363, 374, 384, 390, 396, 403, 410, 416, 422, 429, 435, 448, 454, 461, 467, 474, 481, 488, 497, 506, 516, 526, 531} + +func (i Op) String() string { + if i < 0 || i+1 >= Op(len(_Op_index)) { + return fmt.Sprintf("Op(%d)", i) + } + return _Op_name[_Op_index[i]:_Op_index[i+1]] +} diff --git a/src/cmd/internal/ssa/phielim.go b/src/cmd/internal/ssa/phielim.go new file mode 100644 index 0000000000..19c0d077e5 --- /dev/null +++ b/src/cmd/internal/ssa/phielim.go @@ -0,0 +1,44 @@ +// 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) +func phielim(f *Func) { + args := newSparseSet(f.NumValues()) + for _, b := range f.Blocks { + for _, v := range b.Values { + if v.Op != OpPhi { + continue + } + args.clear() + for _, x := range v.Args { + for x.Op == OpCopy { + x = x.Args[0] + } + args.add(x.ID) + } + switch { + case args.size() == 1: + v.Op = OpCopy + v.SetArgs1(v.Args[0]) + case args.size() == 2 && args.contains(v.ID): + var w *Value + for _, x := range v.Args { + if x.ID != v.ID { + w = x + break + } + } + v.Op = OpCopy + v.SetArgs1(w) + } + } + } +} diff --git a/src/cmd/internal/ssa/print.go b/src/cmd/internal/ssa/print.go new file mode 100644 index 0000000000..eeea30d970 --- /dev/null +++ b/src/cmd/internal/ssa/print.go @@ -0,0 +1,63 @@ +// 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" + +func printFunc(f *Func) { + fmt.Print(f.Name) + fmt.Print(" ") + fmt.Println(f.Type) + printed := make([]bool, f.NumValues()) + for _, b := range f.Blocks { + fmt.Printf(" b%d:\n", b.ID) + n := 0 + + // print phis first since all value cycles contain a phi + for _, v := range b.Values { + if v.Op != OpPhi { + continue + } + fmt.Print(" ") + fmt.Println(v.LongString()) + 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 { + if w.Block == b && !printed[w.ID] { + continue outer + } + } + fmt.Print(" ") + fmt.Println(v.LongString()) + printed[v.ID] = true + n++ + } + if m == n { + fmt.Println("dependency cycle!") + for _, v := range b.Values { + if printed[v.ID] { + continue + } + fmt.Print(" ") + fmt.Println(v.LongString()) + printed[v.ID] = true + n++ + } + } + } + + fmt.Println(" " + b.LongString()) + } +} diff --git a/src/cmd/internal/ssa/sparseset.go b/src/cmd/internal/ssa/sparseset.go new file mode 100644 index 0000000000..e1f9a9a81d --- /dev/null +++ b/src/cmd/internal/ssa/sparseset.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 + +// 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) 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 := len(s.dense) + s.dense = append(s.dense, x) + s.sparse[x] = i +} + +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/internal/ssa/ssac/.gitignore b/src/cmd/internal/ssa/ssac/.gitignore new file mode 100644 index 0000000000..ab17b9d28e --- /dev/null +++ b/src/cmd/internal/ssa/ssac/.gitignore @@ -0,0 +1 @@ +ssac diff --git a/src/cmd/internal/ssa/ssac/fib.goir b/src/cmd/internal/ssa/ssac/fib.goir new file mode 100644 index 0000000000..b572cdaa3a --- /dev/null +++ b/src/cmd/internal/ssa/ssac/fib.goir @@ -0,0 +1,46 @@ + (TYPE T127bd68 int) + (TYPE T127bd68 int) + (TYPE T127bd68 int) + (TYPE T127bd68 int) + (TYPE T7faedc523360 (FUNC (int) (int))) + (TYPE T127bd68 int) + (TYPE T127bd68 int) + (TYPE T7faedc523360 (FUNC (int) (int))) + (TYPE T127bd68 int) + (TYPE T127bd68 int) + (TYPE T127bd68 int) + (TYPE T127bd68 int) + (TYPE T127bd68 int) + (TYPE T127bd68 int) + (DCL n T127bd68) + (DCL ~r1 T127bd68) + (DCL n T127bd68) + (DCL autotmp_0000 T127bd68) + (DCL fib T7faedc523360) + (DCL n T127bd68) + (DCL autotmp_0001 T127bd68) + (DCL fib T7faedc523360) + (DCL n T127bd68) + (DCL ~r1 T127bd68) + (DCL autotmp_0000 T127bd68) + (DCL autotmp_0001 T127bd68) + (DCL autotmp_0001 T127bd68) + (DCL autotmp_0000 T127bd68) + (IF (LT n (CINT 2)) .then0 .else0) + (LABEL .then0) + (AS ~r1 n) + (AS (SP T127bd68 8) ~r1) + (RETURN) + (GOTO .end0) + (LABEL .else0) + (GOTO .end0) + (LABEL .end0) + (AS (SP T127bd68 0) (SUB n (CINT 1))) + (CALL fib) + (AS autotmp_0000 (LOAD (SP T127bd68 8))) + (AS (SP T127bd68 0) (SUB n (CINT 2))) + (CALL fib) + (AS autotmp_0001 (LOAD (SP T127bd68 8))) + (AS ~r1 (ADD autotmp_0000 autotmp_0001)) + (AS (SP T127bd68 8) ~r1) + (RETURN) diff --git a/src/cmd/internal/ssa/ssac/fibiter.goir b/src/cmd/internal/ssa/ssac/fibiter.goir new file mode 100644 index 0000000000..43c7a3de91 --- /dev/null +++ b/src/cmd/internal/ssa/ssac/fibiter.goir @@ -0,0 +1,62 @@ + (NAME runtime·fibiter) + (TYPE Tf5dd68 int) + (TYPE Tf5dd68 int) + (TYPE Tf5dd68 int) + (TYPE Tf5dd68 int) + (TYPE Tf5dd68 int) + (TYPE Tf5dd68 int) + (TYPE Tf5dd68 int) + (TYPE Tf5dd68 int) + (TYPE Tf5dd68 int) + (TYPE Tf5dd68 int) + (TYPE Tf5dd68 int) + (TYPE Tf5dd68 int) + (TYPE Tf5dd68 int) + (TYPE Tf5dd68 int) + (TYPE Tf5dd68 int) + (TYPE Tf5dd68 int) + (TYPE Tf5dd68 int) + (TYPE Tf5dd68 int) + (TYPE Tf5dd68 int) + (TYPE Tf5dd68 int) + (TYPE Tf5dd68 int) + (TYPE Tf5dd68 int) + (DCL a Tf5dd68) + (DCL a Tf5dd68) + (DCL b Tf5dd68) + (DCL b Tf5dd68) + (DCL i Tf5dd68) + (DCL i Tf5dd68) + (DCL i Tf5dd68) + (DCL n Tf5dd68) + (DCL autotmp_0002 Tf5dd68) + (DCL i Tf5dd68) + (DCL i Tf5dd68) + (DCL autotmp_0002 Tf5dd68) + (DCL autotmp_0002 Tf5dd68) + (DCL autotmp_0003 Tf5dd68) + (DCL a Tf5dd68) + (DCL b Tf5dd68) + (DCL a Tf5dd68) + (DCL b Tf5dd68) + (DCL b Tf5dd68) + (DCL autotmp_0003 Tf5dd68) + (DCL ~r1 Tf5dd68) + (DCL a Tf5dd68) + (AS n (LOAD (SP Tf5dd68 0))) + (AS a (CINT 0)) + (AS b (CINT 1)) + (AS i (CINT 0)) + (GOTO .top0) + (LABEL .top0) + (IF (LT i n) .body0 .end0) + (LABEL .body0) + (AS autotmp_0003 (ADD a b)) + (AS a b) + (AS b autotmp_0003) + (AS autotmp_0002 i) + (AS i (ADD autotmp_0002 (CINT 1))) + (GOTO .top0) + (LABEL .end0) + (AS (SP Tf5dd68 8) a) + (RETURN) diff --git a/src/cmd/internal/ssa/ssac/main.go b/src/cmd/internal/ssa/ssac/main.go new file mode 100644 index 0000000000..4975b50db4 --- /dev/null +++ b/src/cmd/internal/ssa/ssac/main.go @@ -0,0 +1,436 @@ +// 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 + +// Stub package for testing ssa compiler backend. Will eventually +// be deleted when ssa is called directly from the main compiler. + +import ( + "bufio" + "flag" + "fmt" + "io" + "os" + "strconv" + "strings" + + "cmd/internal/ssa/types" + + "cmd/internal/ssa" +) + +// testing harness which runs the compiler using an IR read from a file +func main() { + flag.Parse() + file := flag.Arg(0) + r, err := os.Open(file) + if err != nil { + panic(err) + } + f := buildFunc(readFunc(r)) + ssa.Compile(f) + // TODO: output f +} + +// readFunc reads the intermediate representation generated by the +// compiler frontend and returns it as a list of sexpressions. +func readFunc(r io.Reader) []sexpr { + var lines []sexpr + s := bufio.NewScanner(r) + for s.Scan() { + line := s.Text() + e := parseSexpr(strings.Trim(line, " ")) + + if !e.compound { + panic("bad stmt: " + line) + } + if e.parts[0].compound { + panic("bad op: " + line) + } + lines = append(lines, e) + } + return lines +} + +// buildFunc converts from the 6g IR dump format to the internal +// form. Builds SSA and all that. +func buildFunc(lines []sexpr) *ssa.Func { + f := new(ssa.Func) + + // We construct SSA using an algorithm similar to + // Brau, Buchwald, Hack, Leißa, Mallon, and Zwinkau + // http://pp.info.uni-karlsruhe.de/uploads/publikationen/braun13cc.pdf + + // allocate starting block + f.Entry = f.NewBlock(ssa.BlockPlain) + // TODO: all args. Make a struct containing args/returnvals, declare + // an FP which contains a pointer to that struct. + + var exit *ssa.Block // all returns (if any) branch to here TODO: defers & panics? + + // add a block for each label + // Also a few other preprocessing steps, all in one pass. + labels := map[string]*ssa.Block{} + types := map[string]ssa.Type{} + callFallthrough := map[int]*ssa.Block{} + for i, e := range lines { + switch e.parts[0].name { + case "LABEL": + labels[e.parts[1].name] = f.NewBlock(ssa.BlockPlain) + case "NAME": + f.Name = e.parts[1].name + case "RETURN": + if exit == nil { + exit = f.NewBlock(ssa.BlockExit) + } + case "TYPE": + types[e.parts[1].name] = parseSexprType(e.parts[2]) + case "CALL": + // allocate a new block for fallthrough + callFallthrough[i] = f.NewBlock(ssa.BlockPlain) + if exit == nil { + exit = f.NewBlock(ssa.BlockExit) + } + } + } + + // map from block id to sexprs in that block + blocklines := make([][]sexpr, f.NumBlocks()) + + // Add sexprs to the correct block. Add edges between blocks. + b := f.Entry + var i int + for j, e := range lines { + if b == nil && e.parts[0].name != "LABEL" { + // dead code (e.g. return in "if" branch makes the "goto end" statement dead) + continue + } + switch e.parts[0].name { + case "IF": + if b.Kind != ssa.BlockPlain { + panic("bad b state") + } + b.Kind = ssa.BlockIf + edge(b, labels[e.parts[2].name]) + edge(b, labels[e.parts[3].name]) + blocklines[b.ID] = lines[i : j+1] + b = nil + case "GOTO": + edge(b, labels[e.parts[1].name]) + blocklines[b.ID] = lines[i:j] + b = nil + case "LABEL": + b = labels[e.parts[1].name] + i = j + 1 + case "RETURN": + if b.Kind != ssa.BlockPlain { + panic("bad b state") + } + edge(b, exit) + blocklines[b.ID] = lines[i:j] + b = nil + case "CALL": + if b.Kind != ssa.BlockPlain { + panic("bad b state") + } + b.Kind = ssa.BlockCall + c := callFallthrough[j] + edge(b, c) + edge(b, exit) + blocklines[b.ID] = lines[i : j+1] + b = c + i = j + 1 + } + // note that we don't keep goto/label/return sexprs + } + if b != nil { + panic("control flow falls off end of function") + } + + // Read types for each variable + // Number the variables densely + varids := map[string]int{} // map from variable name to id + var varnames []string // map from id to variable name + var vartypes []ssa.Type // map from variable id to type + for _, e := range lines { + if e.parts[0].name != "DCL" { + continue + } + name := e.parts[1].name + if _, ok := varids[name]; ok { + continue + } + id := len(varids) + if id == 1<<31-1 { + panic("too many variables") + } + fmt.Printf("var %d = %s\n", id, name) + varids[name] = id + varnames = append(varnames, name) + vartypes = append(vartypes, types[e.parts[2].name]) + } + memID := len(varids) + fmt.Printf("var %d = .mem\n", memID) + varids[".mem"] = memID // TODO: need .mem here? + varnames = append(varnames, ".mem") + vartypes = append(vartypes, ssa.TypeMem) + + // map from variable ID to current Value of that variable + curBlock := NewSparseMap(len(varids)) + + var state ssaFuncState + state.types = types + state.varids = varids + state.varnames = varnames + state.vartypes = vartypes + state.curBlock = curBlock + state.done = make([]bool, f.NumBlocks()) + state.defs = map[blockvar]*ssa.Value{} + state.memID = memID + + // Convert each block to ssa + // TODO: order blocks for maximum happiness - we want to process + // all the predecessors of a block before processing the block itself, + // if at all possible. + for _, b := range f.Blocks { + fmt.Printf("processing block %d\n", b.ID) + curBlock.Clear() + for _, e := range blocklines[b.ID] { + switch e.parts[0].name { + case "AS": + if e.parts[1].compound { + // store expression + lhs := genExpr(&state, b, e.parts[1]) + rhs := genExpr(&state, b, e.parts[2]) + mem := genVar(&state, b, memID) + v := b.NewValue(ssa.OpStore, ssa.TypeMem, nil) + v.AddArg(lhs) + v.AddArg(rhs) + v.AddArg(mem) + curBlock.Put(memID, v) + } else { + // variable assignment + v := genExpr(&state, b, e.parts[2]) + curBlock.Put(varids[e.parts[1].name], v) + } + case "DCL": + // nothing to do + case "IF": + b.Control = genExpr(&state, b, e.parts[1]) + case "CALL": + // only direct call for now - indirect call takes addr value as well + v := b.NewValue(ssa.OpStaticCall, ssa.TypeMem, e.parts[1].name) + v.AddArg(genVar(&state, b, memID)) + curBlock.Put(memID, v) + b.Control = v + } + } + // link up thunks to their actual values + for _, v := range b.Values { + if v.Op != ssa.OpThunk { + continue + } + varid := v.Aux.(int) + w := genVar(&state, b, varid) + v.Op = ssa.OpCopy + v.Aux = nil + v.AddArg(w) + } + + // record final values at the end of the block + for _, e := range curBlock.Contents() { + state.defs[blockvar{b.ID, e.Key}] = e.Val + // TODO: somehow avoid storing dead values to this map. + } + curBlock.Clear() + state.done[b.ID] = true + } + + // the final store value is returned + if exit != nil { + exit.Control = genVar(&state, exit, memID) + } + + return f +} + +func edge(a, b *ssa.Block) { + a.Succs = append(a.Succs, b) + b.Preds = append(b.Preds, a) +} + +func genVar(state *ssaFuncState, b *ssa.Block, id int) *ssa.Value { + // look up variable + v := state.curBlock.Get(id) + if v != nil { + // variable was defined previously in this block + // (or we memoized the result) + return v + } + + // Variable comes in from outside of basic block. + v = lookupVarIncoming(state, b, id) + + // memoize result so future callers will not look it up again + state.curBlock.Put(id, v) + return v +} + +func genExpr(state *ssaFuncState, b *ssa.Block, e sexpr) *ssa.Value { + if !e.compound { + return genVar(state, b, state.varids[e.name]) + } + switch e.parts[0].name { + case "ADD": + x := genExpr(state, b, e.parts[1]) + y := genExpr(state, b, e.parts[2]) + v := b.NewValue(ssa.OpAdd, x.Type, nil) + v.AddArg(x) + v.AddArg(y) + return v + case "SUB": + x := genExpr(state, b, e.parts[1]) + y := genExpr(state, b, e.parts[2]) + v := b.NewValue(ssa.OpSub, x.Type, nil) + v.AddArg(x) + v.AddArg(y) + return v + case "CINT": + c, err := strconv.ParseInt(e.parts[1].name, 10, 64) + if err != nil { + panic("bad cint value") + } + return b.Func.ConstInt(c) + case "LT": + x := genExpr(state, b, e.parts[1]) + y := genExpr(state, b, e.parts[2]) + v := b.NewValue(ssa.OpLess, ssa.TypeBool, nil) + v.AddArg(x) + v.AddArg(y) + return v + case "FP": + typ := state.types[e.parts[1].name] + offset, err := strconv.ParseInt(e.parts[2].name, 10, 64) + if err != nil { + panic(err) + } + v := b.NewValue(ssa.OpFPAddr, types.NewPointer(typ), offset) + return v + case "SP": + typ := state.types[e.parts[1].name] + offset, err := strconv.ParseInt(e.parts[2].name, 10, 64) + if err != nil { + panic(err) + } + v := b.NewValue(ssa.OpSPAddr, types.NewPointer(typ), offset) + return v + case "LOAD": + p := genExpr(state, b, e.parts[1]) + v := b.NewValue(ssa.OpLoad, p.Type.(*types.Pointer).Elem(), nil) + v.AddArg(p) + v.AddArg(genVar(state, b, state.memID)) + return v + default: + fmt.Println(e.parts[0].name) + panic("unknown op") + } +} + +// map key combining block id and variable id +type blockvar struct { + bid ssa.ID + varid int +} + +type ssaFuncState struct { + types map[string]ssa.Type + varnames []string + varids map[string]int + vartypes []ssa.Type + curBlock *SparseMap // value of each variable in block we're working on + defs map[blockvar]*ssa.Value // values for variables at the end of blocks + done []bool + memID int +} + +// Find the value of the variable with the given id leaving block b. +func lookupVarOutgoing(state *ssaFuncState, b *ssa.Block, id int) *ssa.Value { + fmt.Printf("lookupOutgoing var=%d block=%d\n", id, b.ID) + v := state.defs[blockvar{b.ID, id}] + if v != nil { + return v + } + if state.done[b.ID] { + // The variable was not defined in this block, and we haven't + // memoized the answer yet. Look it up recursively. This might + // cause infinite recursion, so add a copy first. + v = b.NewValue(ssa.OpCopy, state.vartypes[id], nil) + state.defs[blockvar{b.ID, id}] = v + v.AddArg(lookupVarIncoming(state, b, id)) + return v + } + // We don't know about defined variables in this block (yet). + // Make a thunk for this variable. + fmt.Printf("making thunk for var=%d in block=%d\n", id, b.ID) + v = b.NewValue(ssa.OpThunk, state.vartypes[id], id) + + // memoize result + state.defs[blockvar{b.ID, id}] = v + return v +} + +// Find the Value of the variable coming into block b. +func lookupVarIncoming(state *ssaFuncState, b *ssa.Block, id int) *ssa.Value { + fmt.Printf("lookupIncoming var=%d block=%d\n", id, b.ID) + var v *ssa.Value + switch len(b.Preds) { + case 0: + // TODO: handle function args some other way (assignments in starting block?) + // TODO: error if variable isn't a function arg (including mem input) + v = b.NewValue(ssa.OpArg, state.vartypes[id], state.varnames[id]) + case 1: + v = lookupVarOutgoing(state, b.Preds[0], id) + default: + v = b.NewValue(ssa.OpCopy, state.vartypes[id], nil) + + args := make([]*ssa.Value, len(b.Preds)) + for i, p := range b.Preds { + args[i] = lookupVarOutgoing(state, p, id) + } + + // if <=1 value that isn't this variable's thunk, don't make phi + v.Op = ssa.OpPhi + v.AddArgs(args...) // note: order corresponding to b.Pred + } + return v +} + +func parseSexprType(e sexpr) ssa.Type { + if !e.compound { + switch e.name { + case "int": + return ssa.TypeInt + default: + fmt.Println(e.name) + panic("unknown type") + } + } + if e.parts[0].name == "FUNC" { + // TODO: receiver? Already folded into args? Variadic? + var args, rets []*types.Var + for _, s := range e.parts[1].parts { + t := parseSexprType(s) + args = append(args, types.NewParam(0, nil, "noname", t)) + } + for _, s := range e.parts[2].parts { + t := parseSexprType(s) + rets = append(rets, types.NewParam(0, nil, "noname", t)) + } + sig := types.NewSignature(nil, nil, types.NewTuple(args...), types.NewTuple(rets...), false) + return ssa.Type(sig) + } + // TODO: array/struct/... + panic("compound type") +} diff --git a/src/cmd/internal/ssa/ssac/sexpr.go b/src/cmd/internal/ssa/ssac/sexpr.go new file mode 100644 index 0000000000..77e8923dd0 --- /dev/null +++ b/src/cmd/internal/ssa/ssac/sexpr.go @@ -0,0 +1,82 @@ +// 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" + +// an sexpr is an s-expression. It is either a token or a +// parenthesized list of s-expressions. +// +// Used just for initial development. Should we keep it for testing, or +// ditch it once we've plugged into the main compiler output? + +type sexpr struct { + compound bool + name string // !compound + parts []sexpr // compound +} + +func (s *sexpr) String() string { + if !s.compound { + return s.name + } + x := "(" + for i, p := range s.parts { + if i != 0 { + x += " " + } + x += p.String() + } + return x + ")" +} + +func parseSexpr(s string) sexpr { + var e string + e, s = grabOne(s) + if len(e) > 0 && e[0] == '(' { + e = e[1 : len(e)-1] + var parts []sexpr + for e != "" { + var p string + p, e = grabOne(e) + parts = append(parts, parseSexpr(p)) + } + return sexpr{true, "", parts} + } + return sexpr{false, e, nil} +} + +// grabOne peels off first token or parenthesized string from s. +// returns first thing and the remainder of s. +func grabOne(s string) (string, string) { + for len(s) > 0 && s[0] == ' ' { + s = s[1:] + } + if len(s) == 0 || s[0] != '(' { + i := strings.Index(s, " ") + if i < 0 { + return s, "" + } + return s[:i], s[i:] + } + d := 0 + i := 0 + for { + if len(s) == i { + panic("unterminated s-expression: " + s) + } + if s[i] == '(' { + d++ + } + if s[i] == ')' { + d-- + if d == 0 { + i++ + return s[:i], s[i:] + } + } + i++ + } +} diff --git a/src/cmd/internal/ssa/ssac/sparsemap.go b/src/cmd/internal/ssa/ssac/sparsemap.go new file mode 100644 index 0000000000..b7a0fb0fde --- /dev/null +++ b/src/cmd/internal/ssa/ssac/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 main + +// Maintains a map[int]*ssa.Value, but cheaper. + +// from http://research.swtch.com/sparse +// in turn, from Briggs and Torczon + +import ( + "cmd/internal/ssa" +) + +type SparseMap struct { + dense []SparseMapEntry + sparse []int +} +type SparseMapEntry struct { + Key int + Val *ssa.Value +} + +// NewSparseMap returns a SparseMap that can have +// integers between 0 and n-1 as keys. +func NewSparseMap(n int) *SparseMap { + return &SparseMap{nil, make([]int, n)} +} + +func (s *SparseMap) Get(x int) *ssa.Value { + i := s.sparse[x] + if i < len(s.dense) && s.dense[i].Key == x { + return s.dense[i].Val + } + return nil +} + +func (s *SparseMap) Put(x int, v *ssa.Value) { + i := s.sparse[x] + if i < len(s.dense) && s.dense[i].Key == x { + s.dense[i].Val = v + return + } + i = len(s.dense) + s.dense = append(s.dense, SparseMapEntry{x, v}) + s.sparse[x] = i +} + +func (s *SparseMap) Remove(x int) { + i := s.sparse[x] + if i < len(s.dense) && s.dense[i].Key == x { + 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] +} + +// Contents returns a slice of key/value pairs. +// Caller must not modify any returned entries. +// The return value is invalid after the SparseMap is modified in any way. +func (s *SparseMap) Contents() []SparseMapEntry { + return s.dense +} diff --git a/src/cmd/internal/ssa/type.go b/src/cmd/internal/ssa/type.go new file mode 100644 index 0000000000..3389622c74 --- /dev/null +++ b/src/cmd/internal/ssa/type.go @@ -0,0 +1,84 @@ +// 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/ssa/types" // TODO: use golang.org/x/tools/go/types instead +) + +// We just inherit types from go/types +type Type types.Type + +var ( + // shortcuts for commonly used basic types + TypeInt = types.Typ[types.Int] + TypeUint = types.Typ[types.Uint] + TypeInt8 = types.Typ[types.Int8] + TypeInt16 = types.Typ[types.Int16] + TypeInt32 = types.Typ[types.Int32] + TypeInt64 = types.Typ[types.Int64] + TypeUint8 = types.Typ[types.Uint8] + TypeUint16 = types.Typ[types.Uint16] + TypeUint32 = types.Typ[types.Uint32] + TypeUint64 = types.Typ[types.Uint64] + TypeUintptr = types.Typ[types.Uintptr] + TypeBool = types.Typ[types.Bool] + TypeString = types.Typ[types.String] + + TypeInvalid = types.Typ[types.Invalid] + + // Additional compiler-only types go here. + TypeMem = &Memory{} + TypeFlags = &Flags{} +) + +// typeIdentical returns whether it two arguments are the same type. +func typeIdentical(t, u Type) bool { + if t == TypeMem { + return u == TypeMem + } + if t == TypeFlags { + return u == TypeFlags + } + return types.Identical(t, u) +} + +// A type representing all of memory +type Memory struct { +} + +func (t *Memory) Underlying() types.Type { panic("Underlying of Memory") } +func (t *Memory) String() string { return "mem" } + +// A type representing the unknown type +type Unknown struct { +} + +func (t *Unknown) Underlying() types.Type { panic("Underlying of Unknown") } +func (t *Unknown) String() string { return "unk" } + +// A type representing the void type. Used during building, should always +// be eliminated by the first deadcode pass. +type Void struct { +} + +func (t *Void) Underlying() types.Type { panic("Underlying of Void") } +func (t *Void) String() string { return "void" } + +// A type representing the results of a nil check or bounds check. +// TODO: or type check? +// TODO: just use bool? +type Check struct { +} + +func (t *Check) Underlying() types.Type { panic("Underlying of Check") } +func (t *Check) String() string { return "check" } + +// x86 flags type +type Flags struct { +} + +func (t *Flags) Underlying() types.Type { panic("Underlying of Flags") } +func (t *Flags) String() string { return "flags" } diff --git a/src/cmd/internal/ssa/types/object.go b/src/cmd/internal/ssa/types/object.go new file mode 100644 index 0000000000..cd0be163b7 --- /dev/null +++ b/src/cmd/internal/ssa/types/object.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. + +// This package is a drop-in replacement for go/types +// for use until go/types is included in the main repo. + +package types + +// An Object describes a named language entity such as a package, +// constant, type, variable, function (incl. methods), or label. +// All objects implement the Object interface. +// +type Object interface { + Name() string // package local object name + Type() Type // object type +} + +// An object implements the common parts of an Object. +type object struct { + name string + typ Type +} + +func (obj *object) Name() string { return obj.name } +func (obj *object) Type() Type { return obj.typ } + +// A Variable represents a declared variable (including function parameters and results, and struct fields). +type Var struct { + object + anonymous bool // if set, the variable is an anonymous struct field, and name is the type name + visited bool // for initialization cycle detection + isField bool // var is struct field + used bool // set if the variable was used +} + +func NewParam(pos int, pkg *int, name string, typ Type) *Var { + return &Var{object: object{name, typ}, used: true} // parameters are always 'used' +} diff --git a/src/cmd/internal/ssa/types/type.go b/src/cmd/internal/ssa/types/type.go new file mode 100644 index 0000000000..e01de5c1e4 --- /dev/null +++ b/src/cmd/internal/ssa/types/type.go @@ -0,0 +1,229 @@ +// 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 is a drop-in replacement for go/types +// for use until go/types is included in the main repo. + +package types + +// A Type represents a type of Go. +// All types implement the Type interface. +type Type interface { + // Underlying returns the underlying type of a type. + Underlying() Type + + // String returns a string representation of a type. + String() string +} + +// BasicKind describes the kind of basic type. +type BasicKind int + +const ( + Invalid BasicKind = iota // type is invalid + + // predeclared types + Bool + Int + Int8 + Int16 + Int32 + Int64 + Uint + Uint8 + Uint16 + Uint32 + Uint64 + Uintptr + Float32 + Float64 + Complex64 + Complex128 + String + UnsafePointer + + // types for untyped values + UntypedBool + UntypedInt + UntypedRune + UntypedFloat + UntypedComplex + UntypedString + UntypedNil + + // aliases + Byte = Uint8 + Rune = Int32 +) + +// BasicInfo is a set of flags describing properties of a basic type. +type BasicInfo int + +// Properties of basic types. +const ( + IsBoolean BasicInfo = 1 << iota + IsInteger + IsUnsigned + IsFloat + IsComplex + IsString + IsUntyped + + IsOrdered = IsInteger | IsFloat | IsString + IsNumeric = IsInteger | IsFloat | IsComplex + IsConstType = IsBoolean | IsNumeric | IsString +) + +// A Basic represents a basic type. +type Basic struct { + kind BasicKind + info BasicInfo + name string +} + +// Kind returns the kind of basic type b. +func (b *Basic) Kind() BasicKind { return b.kind } + +// Info returns information about properties of basic type b. +func (b *Basic) Info() BasicInfo { return b.info } + +// Name returns the name of basic type b. +func (b *Basic) Name() string { return b.name } + +// A Pointer represents a pointer type. +type Pointer struct { + base Type // element type +} + +// NewPointer returns a new pointer type for the given element (base) type. +func NewPointer(elem Type) *Pointer { return &Pointer{base: elem} } + +// Elem returns the element type for the given pointer p. +func (p *Pointer) Elem() Type { return p.base } + +// A Slice represents a slice type. +type Slice struct { + elem Type +} + +// NewSlice returns a new slice type for the given element type. +func NewSlice(elem Type) *Slice { return &Slice{elem} } + +// Elem returns the element type of slice s. +func (s *Slice) Elem() Type { return s.elem } + +// Implementations for Type methods. +func (t *Basic) Underlying() Type { return t } +func (t *Slice) Underlying() Type { return t } +func (t *Pointer) Underlying() Type { return t } +func (t *Signature) Underlying() Type { return t } + +func (b *Basic) String() string { return b.name } +func (t *Slice) String() string { return "[]" + t.elem.String() } +func (t *Pointer) String() string { return "*" + t.base.String() } +func (t *Signature) String() string { return "sig" /* TODO */ } + +var Typ = [...]*Basic{ + Invalid: {Invalid, 0, "invalid type"}, + + Bool: {Bool, IsBoolean, "bool"}, + Int: {Int, IsInteger, "int"}, + Int8: {Int8, IsInteger, "int8"}, + Int16: {Int16, IsInteger, "int16"}, + Int32: {Int32, IsInteger, "int32"}, + Int64: {Int64, IsInteger, "int64"}, + Uint: {Uint, IsInteger | IsUnsigned, "uint"}, + Uint8: {Uint8, IsInteger | IsUnsigned, "uint8"}, + Uint16: {Uint16, IsInteger | IsUnsigned, "uint16"}, + Uint32: {Uint32, IsInteger | IsUnsigned, "uint32"}, + Uint64: {Uint64, IsInteger | IsUnsigned, "uint64"}, + Uintptr: {Uintptr, IsInteger | IsUnsigned, "uintptr"}, + Float32: {Float32, IsFloat, "float32"}, + Float64: {Float64, IsFloat, "float64"}, + Complex64: {Complex64, IsComplex, "complex64"}, + Complex128: {Complex128, IsComplex, "complex128"}, + String: {String, IsString, "string"}, + UnsafePointer: {UnsafePointer, 0, "Pointer"}, + + UntypedBool: {UntypedBool, IsBoolean | IsUntyped, "untyped bool"}, + UntypedInt: {UntypedInt, IsInteger | IsUntyped, "untyped int"}, + UntypedRune: {UntypedRune, IsInteger | IsUntyped, "untyped rune"}, + UntypedFloat: {UntypedFloat, IsFloat | IsUntyped, "untyped float"}, + UntypedComplex: {UntypedComplex, IsComplex | IsUntyped, "untyped complex"}, + UntypedString: {UntypedString, IsString | IsUntyped, "untyped string"}, + UntypedNil: {UntypedNil, IsUntyped, "untyped nil"}, +} + +// Identical reports whether x and y are identical. +func Identical(x, y Type) bool { + if x == y { + return true + } + + switch x := x.(type) { + case *Basic: + // Basic types are singletons except for the rune and byte + // aliases, thus we cannot solely rely on the x == y check + // above. + if y, ok := y.(*Basic); ok { + return x.kind == y.kind + } + default: + panic("can't handle yet") + } + return false +} + +// A Tuple represents an ordered list of variables; a nil *Tuple is a valid (empty) tuple. +// Tuples are used as components of signatures and to represent the type of multiple +// assignments; they are not first class types of Go. +type Tuple struct { + vars []*Var +} + +// NewTuple returns a new tuple for the given variables. +func NewTuple(x ...*Var) *Tuple { + if len(x) > 0 { + return &Tuple{x} + } + return nil +} + +// Len returns the number variables of tuple t. +func (t *Tuple) Len() int { + if t != nil { + return len(t.vars) + } + return 0 +} + +// At returns the i'th variable of tuple t. +func (t *Tuple) At(i int) *Var { return t.vars[i] } + +// A Signature represents a (non-builtin) function or method type. +type Signature struct { + recv *Var // nil if not a method + params *Tuple // (incoming) parameters from left to right; or nil + results *Tuple // (outgoing) results from left to right; or nil + variadic bool // true if the last parameter's type is of the form ...T (or string, for append built-in only) +} + +// NewSignature returns a new function type for the given receiver, parameters, +// and results, either of which may be nil. If variadic is set, the function +// is variadic, it must have at least one parameter, and the last parameter +// must be of unnamed slice type. +func NewSignature(scope *int, recv *Var, params, results *Tuple, variadic bool) *Signature { + // TODO(gri) Should we rely on the correct (non-nil) incoming scope + // or should this function allocate and populate a scope? + if variadic { + n := params.Len() + if n == 0 { + panic("types.NewSignature: variadic function must have at least one parameter") + } + if _, ok := params.At(n - 1).typ.(*Slice); !ok { + panic("types.NewSignature: variadic parameter must be of unnamed slice type") + } + } + return &Signature{recv, params, results, variadic} +} diff --git a/src/cmd/internal/ssa/value.go b/src/cmd/internal/ssa/value.go new file mode 100644 index 0000000000..740525a5f5 --- /dev/null +++ b/src/cmd/internal/ssa/value.go @@ -0,0 +1,117 @@ +// 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" + "strings" +) + +// 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 0. 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 (& type). + Aux interface{} + + // Arguments of this value + Args []*Value + + // Containing basic block + Block *Block + + // Storage for the first two args + argstorage [2]*Value +} + +// Examples: +// Opcode aux args +// OpAdd nil 2 +// OpConstStr string 0 +// OpConstInt int64 0 +// OpAddcq int64 1 amd64 op: v = arg[0] + constant + +// short form print. Just v#. +func (v *Value) String() string { + return fmt.Sprintf("v%d", v.ID) +} + +// long form print. v# = opcode [aux] args [: reg] +func (v *Value) LongString() string { + s := fmt.Sprintf("v%d = %s", v.ID, strings.TrimPrefix(v.Op.String(), "Op")) + s += " <" + v.Type.String() + ">" + if v.Aux != nil { + s += fmt.Sprintf(" [%v]", v.Aux) + } + for _, a := range v.Args { + s += fmt.Sprintf(" %v", a) + } + r := v.Block.Func.RegAlloc + if r != nil && r[v.ID] != nil { + s += " : " + r[v.ID].Name() + } + return s +} + +func (v *Value) AddArg(w *Value) { + v.Args = append(v.Args, w) +} +func (v *Value) AddArgs(a ...*Value) { + 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 = 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] +} + +// CopyFrom converts v to be the same value as w. v and w must +// have the same type. +func (v *Value) CopyFrom(w *Value) { + if !typeIdentical(v.Type, w.Type) { + panic("copyFrom with unequal types") + } + v.Op = w.Op + v.Aux = w.Aux + v.resetArgs() + v.AddArgs(w.Args...) +} + +// SetType sets the type of v. v must not have had its type +// set yet (it must be TypeInvalid). +func (v *Value) SetType() { + if v.Type != TypeInvalid { + panic("setting type when it is already set") + } + opcodeTable[v.Op].typer(v) +} -- cgit v1.3 From 7c2c0b4e533d3d75df8993eb87f6948c49c04cc8 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Mon, 16 Mar 2015 16:31:13 -0700 Subject: [dev.ssa] cmd/internal/ssa: minor cleanup These were review comments for CL 6681 that didn't get sent in time. Change-Id: If161af3655770487f3ba34535d3fb55dbfde7917 Reviewed-on: https://go-review.googlesource.com/7644 Reviewed-by: Keith Randall --- src/cmd/internal/ssa/deadcode.go | 13 ++++++++----- src/cmd/internal/ssa/op.go | 2 +- src/cmd/internal/ssa/type.go | 2 +- src/cmd/internal/ssa/value.go | 9 ++++++++- 4 files changed, 18 insertions(+), 8 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/internal/ssa/deadcode.go b/src/cmd/internal/ssa/deadcode.go index 1647ea955d..e8c8bfcc03 100644 --- a/src/cmd/internal/ssa/deadcode.go +++ b/src/cmd/internal/ssa/deadcode.go @@ -86,8 +86,10 @@ func deadcode(f *Func) { f.vid.put(v.ID) } } - for j := i; j < len(b.Values); j++ { - b.Values[j] = nil // aid GC + // aid GC + tail := b.Values[i:] + for j := range tail { + tail[j] = nil } b.Values = b.Values[:i] } @@ -105,9 +107,10 @@ func deadcode(f *Func) { f.bid.put(b.ID) } } - // zero remainder to help gc - for j := i; j < len(f.Blocks); j++ { - f.Blocks[j] = nil + // zero remainder to help GC + tail := f.Blocks[i:] + for j := range tail { + tail[j] = nil } f.Blocks = f.Blocks[:i] diff --git a/src/cmd/internal/ssa/op.go b/src/cmd/internal/ssa/op.go index a4364b1c5c..905d62b69c 100644 --- a/src/cmd/internal/ssa/op.go +++ b/src/cmd/internal/ssa/op.go @@ -82,7 +82,7 @@ const ( OpStoreFP OpStoreSP - // spill&restore ops for the register allocator. These are + // spill and 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 with that because // we know there is no aliasing to spill slots on the stack. diff --git a/src/cmd/internal/ssa/type.go b/src/cmd/internal/ssa/type.go index 3389622c74..e9c017d38a 100644 --- a/src/cmd/internal/ssa/type.go +++ b/src/cmd/internal/ssa/type.go @@ -34,7 +34,7 @@ var ( TypeFlags = &Flags{} ) -// typeIdentical returns whether it two arguments are the same type. +// typeIdentical reports whether its two arguments are the same type. func typeIdentical(t, u Type) bool { if t == TypeMem { return u == TypeMem diff --git a/src/cmd/internal/ssa/value.go b/src/cmd/internal/ssa/value.go index 740525a5f5..f6f099cd32 100644 --- a/src/cmd/internal/ssa/value.go +++ b/src/cmd/internal/ssa/value.go @@ -24,7 +24,7 @@ type Value struct { // 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 (& type). + // Auxiliary info for this value. The type of this information depends on the opcode and type. Aux interface{} // Arguments of this value @@ -67,9 +67,15 @@ func (v *Value) LongString() string { } 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) { @@ -77,6 +83,7 @@ func (v *Value) SetArg(i int, w *Value) { } 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) { -- cgit v1.3 From 7b9628429553b2bce59cd292c0894a2276c54245 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Mon, 23 Mar 2015 17:02:11 -0700 Subject: [dev.ssa] cmd/internal/ssa: implement more compiler passes opt: machine-independent optimization fuse: join basic blocks lower: convert to machine-dependent opcodes critical: remove critical edges for register alloc layout: order basic blocks schedule: order values in basic blocks cgen: generate assembly output opt and lower use machine-generated matching rules using the rule generator in rulegen/ cgen will probably change in the real compiler, as we want to generate binary directly instead of ascii assembly. Change-Id: Iedd7ca70f6f55a4cde30e27cfad6a7fa05691b83 Reviewed-on: https://go-review.googlesource.com/7981 Reviewed-by: Alan Donovan Reviewed-by: Keith Randall --- src/cmd/internal/ssa/cgen.go | 117 +++++++++ src/cmd/internal/ssa/compile.go | 58 ++++- src/cmd/internal/ssa/critical.go | 51 ++++ src/cmd/internal/ssa/fuse.go | 40 +++ src/cmd/internal/ssa/generic.go | 111 +++++++++ src/cmd/internal/ssa/layout.go | 88 +++++++ src/cmd/internal/ssa/lower.go | 43 ++++ src/cmd/internal/ssa/lowerAmd64.go | 307 +++++++++++++++++++++++ src/cmd/internal/ssa/op.go | 25 +- src/cmd/internal/ssa/op_string.go | 4 +- src/cmd/internal/ssa/opt.go | 13 + src/cmd/internal/ssa/rewrite.go | 70 ++++++ src/cmd/internal/ssa/rulegen/generic.rules | 16 ++ src/cmd/internal/ssa/rulegen/lower_amd64.rules | 46 ++++ src/cmd/internal/ssa/rulegen/rulegen.go | 328 +++++++++++++++++++++++++ src/cmd/internal/ssa/schedule.go | 69 ++++++ src/cmd/internal/ssa/ssac/fib.goir | 5 +- src/cmd/internal/ssa/ssac/fibiter.goir | 4 +- 18 files changed, 1372 insertions(+), 23 deletions(-) create mode 100644 src/cmd/internal/ssa/cgen.go create mode 100644 src/cmd/internal/ssa/critical.go create mode 100644 src/cmd/internal/ssa/fuse.go create mode 100644 src/cmd/internal/ssa/generic.go create mode 100644 src/cmd/internal/ssa/layout.go create mode 100644 src/cmd/internal/ssa/lower.go create mode 100644 src/cmd/internal/ssa/lowerAmd64.go create mode 100644 src/cmd/internal/ssa/opt.go create mode 100644 src/cmd/internal/ssa/rewrite.go create mode 100644 src/cmd/internal/ssa/rulegen/generic.rules create mode 100644 src/cmd/internal/ssa/rulegen/lower_amd64.rules create mode 100644 src/cmd/internal/ssa/rulegen/rulegen.go create mode 100644 src/cmd/internal/ssa/schedule.go (limited to 'src/cmd') diff --git a/src/cmd/internal/ssa/cgen.go b/src/cmd/internal/ssa/cgen.go new file mode 100644 index 0000000000..4b1a90b89d --- /dev/null +++ b/src/cmd/internal/ssa/cgen.go @@ -0,0 +1,117 @@ +// 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" + +// cgen selects machine instructions for the function. +// This pass generates assembly output for now, but should +// TODO(khr): generate binary output (via liblink?) instead of text. +func cgen(f *Func) { + fmt.Printf("TEXT %s(SB),0,$0\n", f.Name) // TODO: frame size / arg size + + // TODO: prolog, allocate stack frame + + // hack for now, until regalloc is done + f.RegAlloc = make([]Location, f.NumValues()) + + for idx, b := range f.Blocks { + fmt.Printf("%d:\n", b.ID) + for _, v := range b.Values { + asm := opcodeTable[v.Op].asm + fmt.Print("\t") + if asm == "" { + fmt.Print("\t") + } + for i := 0; i < len(asm); i++ { + switch asm[i] { + default: + fmt.Printf("%c", asm[i]) + case '%': + i++ + switch asm[i] { + case '%': + fmt.Print("%") + case 'I': + i++ + n := asm[i] - '0' + if f.RegAlloc[v.Args[n].ID] != nil { + fmt.Print(f.RegAlloc[v.Args[n].ID].Name()) + } else { + fmt.Printf("v%d", v.Args[n].ID) + } + case 'O': + i++ + n := asm[i] - '0' + if n != 0 { + panic("can only handle 1 output for now") + } + if f.RegAlloc[v.ID] != nil { + // TODO: output tuple + fmt.Print(f.RegAlloc[v.ID].Name()) + } else { + fmt.Printf("v%d", v.ID) + } + case 'A': + fmt.Print(v.Aux) + } + } + } + fmt.Println("\t; " + v.LongString()) + } + // find next block in layout sequence + var next *Block + if idx < len(f.Blocks)-1 { + next = f.Blocks[idx+1] + } + // emit end of block code + // TODO: this is machine specific + switch b.Kind { + case BlockPlain: + if b.Succs[0] != next { + fmt.Printf("\tJMP\t%d\n", b.Succs[0].ID) + } + case BlockExit: + // TODO: run defers (if any) + // TODO: deallocate frame + fmt.Println("\tRET") + case BlockCall: + // nothing to emit - call instruction already happened + case BlockEQ: + if b.Succs[0] == next { + fmt.Printf("\tJNE\t%d\n", b.Succs[1].ID) + } else if b.Succs[1] == next { + fmt.Printf("\tJEQ\t%d\n", b.Succs[0].ID) + } else { + fmt.Printf("\tJEQ\t%d\n", b.Succs[0].ID) + fmt.Printf("\tJMP\t%d\n", b.Succs[1].ID) + } + case BlockNE: + if b.Succs[0] == next { + fmt.Printf("\tJEQ\t%d\n", b.Succs[1].ID) + } else if b.Succs[1] == next { + fmt.Printf("\tJNE\t%d\n", b.Succs[0].ID) + } else { + fmt.Printf("\tJNE\t%d\n", b.Succs[0].ID) + fmt.Printf("\tJMP\t%d\n", b.Succs[1].ID) + } + case BlockLT: + if b.Succs[0] == next { + fmt.Printf("\tJGE\t%d\n", b.Succs[1].ID) + } else if b.Succs[1] == next { + fmt.Printf("\tJLT\t%d\n", b.Succs[0].ID) + } else { + fmt.Printf("\tJLT\t%d\n", b.Succs[0].ID) + fmt.Printf("\tJMP\t%d\n", b.Succs[1].ID) + } + default: + fmt.Printf("\t%s ->", b.Kind.String()) + for _, s := range b.Succs { + fmt.Printf(" %d", s.ID) + } + fmt.Printf("\n") + } + } +} diff --git a/src/cmd/internal/ssa/compile.go b/src/cmd/internal/ssa/compile.go index 5e21bdf6e1..b8f34c52fc 100644 --- a/src/cmd/internal/ssa/compile.go +++ b/src/cmd/internal/ssa/compile.go @@ -4,7 +4,10 @@ package ssa -import "fmt" +import ( + "fmt" + "log" +) // Compile is the main entry point for this package. // Compile modifies f so that on return: @@ -50,16 +53,55 @@ type pass struct { var passes = [...]pass{ {"phielim", phielim}, {"copyelim", copyelim}, - //{"opt", opt}, + {"opt", opt}, // cse {"deadcode", deadcode}, - //{"fuse", fuse}, - //{"lower", lower}, + {"fuse", fuse}, + {"lower", lower}, // cse - //{"critical", critical}, // remove critical edges - //{"layout", layout}, // schedule blocks - //{"schedule", schedule}, // schedule values + {"critical", critical}, // remove critical edges + {"layout", layout}, // schedule blocks + {"schedule", schedule}, // schedule values // regalloc // stack slot alloc (+size stack frame) - //{"cgen", cgen}, + {"cgen", cgen}, +} + +// 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. +var passOrder = map[string]string{ + // 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", + // code generation requires register allocation + //"cgen":"regalloc", +} + +func init() { + for a, b := range passOrder { + 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/internal/ssa/critical.go b/src/cmd/internal/ssa/critical.go new file mode 100644 index 0000000000..5bbad8f2f5 --- /dev/null +++ b/src/cmd/internal/ssa/critical.go @@ -0,0 +1,51 @@ +// 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 + } + + // decide if we need to split edges coming into b. + hasphi := false + for _, v := range b.Values { + if v.Op == OpPhi && v.Type != TypeMem { + hasphi = true + break + } + } + if !hasphi { + // no splitting needed + continue + } + + // split input edges coming from multi-output blocks. + for i, c := range b.Preds { + if c.Kind == BlockPlain { + continue + } + + // allocate a new block to place on the edge + d := f.NewBlock(BlockPlain) + + // 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/internal/ssa/fuse.go b/src/cmd/internal/ssa/fuse.go new file mode 100644 index 0000000000..bfce9ef970 --- /dev/null +++ b/src/cmd/internal/ssa/fuse.go @@ -0,0 +1,40 @@ +// 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 _, b := range f.Blocks { + if b.Kind != BlockPlain { + continue + } + c := b.Succs[0] + if len(c.Preds) != 1 { + continue + } + + // move all of b's 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.Preds = b.Preds + for _, p := range c.Preds { + for i, q := range p.Succs { + if q == b { + p.Succs[i] = c + } + } + } + + // trash b, just in case + b.Kind = BlockUnknown + b.Values = nil + b.Preds = nil + b.Succs = nil + } +} diff --git a/src/cmd/internal/ssa/generic.go b/src/cmd/internal/ssa/generic.go new file mode 100644 index 0000000000..f28633b19a --- /dev/null +++ b/src/cmd/internal/ssa/generic.go @@ -0,0 +1,111 @@ +// autogenerated from rulegen/generic.rules: do not edit! +// generated with: go run rulegen/rulegen.go rulegen/generic.rules genericRules generic.go +package ssa + +func genericRules(v *Value) bool { + switch v.Op { + case OpAdd: + // match: (Add (ConstInt [c]) (ConstInt [d])) + // cond: is64BitInt(t) + // result: (ConstInt [{c.(int64)+d.(int64)}]) + { + t := v.Type + if v.Args[0].Op != OpConstInt { + goto end0 + } + c := v.Args[0].Aux + if v.Args[1].Op != OpConstInt { + goto end0 + } + d := v.Args[1].Aux + if !(is64BitInt(t)) { + goto end0 + } + v.Op = OpConstInt + v.Aux = nil + v.Args = v.argstorage[:0] + v.Aux = c.(int64) + d.(int64) + return true + } + end0: + ; + case OpLoad: + // match: (Load (FPAddr [offset]) mem) + // cond: + // result: (LoadFP [offset] mem) + { + if v.Args[0].Op != OpFPAddr { + goto end1 + } + offset := v.Args[0].Aux + mem := v.Args[1] + v.Op = OpLoadFP + v.Aux = nil + v.Args = v.argstorage[:0] + v.Aux = offset + v.AddArg(mem) + return true + } + end1: + ; + // match: (Load (SPAddr [offset]) mem) + // cond: + // result: (LoadSP [offset] mem) + { + if v.Args[0].Op != OpSPAddr { + goto end2 + } + offset := v.Args[0].Aux + mem := v.Args[1] + v.Op = OpLoadSP + v.Aux = nil + v.Args = v.argstorage[:0] + v.Aux = offset + v.AddArg(mem) + return true + } + end2: + ; + case OpStore: + // match: (Store (FPAddr [offset]) val mem) + // cond: + // result: (StoreFP [offset] val mem) + { + if v.Args[0].Op != OpFPAddr { + goto end3 + } + offset := v.Args[0].Aux + val := v.Args[1] + mem := v.Args[2] + v.Op = OpStoreFP + v.Aux = nil + v.Args = v.argstorage[:0] + v.Aux = offset + v.AddArg(val) + v.AddArg(mem) + return true + } + end3: + ; + // match: (Store (SPAddr [offset]) val mem) + // cond: + // result: (StoreSP [offset] val mem) + { + if v.Args[0].Op != OpSPAddr { + goto end4 + } + offset := v.Args[0].Aux + val := v.Args[1] + mem := v.Args[2] + v.Op = OpStoreSP + v.Aux = nil + v.Args = v.argstorage[:0] + v.Aux = offset + v.AddArg(val) + v.AddArg(mem) + return true + } + end4: + } + return false +} diff --git a/src/cmd/internal/ssa/layout.go b/src/cmd/internal/ssa/layout.go new file mode 100644 index 0000000000..7123397c4c --- /dev/null +++ b/src/cmd/internal/ssa/layout.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 + +import "log" + +// 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 := newSparseSet(f.NumBlocks()) // blocks with positive remaining degree + zerodegree := newSparseSet(f.NumBlocks()) // blocks with zero remaining degree + + // 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. + // Just use degree for now. TODO(khr): use likely direction hints. + 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 + } + } + log.Panicf("no block available for layout") + } + f.Blocks = order +} diff --git a/src/cmd/internal/ssa/lower.go b/src/cmd/internal/ssa/lower.go new file mode 100644 index 0000000000..7d97b0b466 --- /dev/null +++ b/src/cmd/internal/ssa/lower.go @@ -0,0 +1,43 @@ +// 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 + +var ( + // TODO(khr): put arch configuration constants together somewhere + intSize = 8 + ptrSize = 8 +) + +//go:generate go run rulegen/rulegen.go rulegen/lower_amd64.rules lowerAmd64 lowerAmd64.go + +// convert to machine-dependent ops +func lower(f *Func) { + // repeat rewrites until we find no more rewrites + // TODO: pick the target arch from config + applyRewrite(f, lowerAmd64) + + // TODO: check for unlowered opcodes, fail if we find one + + // additional pass for 386/amd64, link condition codes directly to blocks + // TODO: do generically somehow? Special "block" rewrite rules? + for _, b := range f.Blocks { + switch b.Kind { + case BlockIf: + switch b.Control.Op { + case OpSETL: + b.Kind = BlockLT + b.Control = b.Control.Args[0] + // TODO: others + } + case BlockLT: + if b.Control.Op == OpInvertFlags { + b.Kind = BlockGE + b.Control = b.Control.Args[0] + } + // TODO: others + } + } + deadcode(f) // TODO: separate pass? +} diff --git a/src/cmd/internal/ssa/lowerAmd64.go b/src/cmd/internal/ssa/lowerAmd64.go new file mode 100644 index 0000000000..ab79ed09b1 --- /dev/null +++ b/src/cmd/internal/ssa/lowerAmd64.go @@ -0,0 +1,307 @@ +// autogenerated from rulegen/lower_amd64.rules: do not edit! +// generated with: go run rulegen/rulegen.go rulegen/lower_amd64.rules lowerAmd64 lowerAmd64.go +package ssa + +func lowerAmd64(v *Value) bool { + switch v.Op { + case OpADDQ: + // match: (ADDQ x (ConstInt [c])) + // cond: + // result: (ADDCQ [c] x) + { + x := v.Args[0] + if v.Args[1].Op != OpConstInt { + goto end0 + } + c := v.Args[1].Aux + v.Op = OpADDCQ + v.Aux = nil + v.Args = v.argstorage[:0] + v.Aux = c + v.AddArg(x) + return true + } + end0: + ; + // match: (ADDQ (ConstInt [c]) x) + // cond: + // result: (ADDCQ [c] x) + { + if v.Args[0].Op != OpConstInt { + goto end1 + } + c := v.Args[0].Aux + x := v.Args[1] + v.Op = OpADDCQ + v.Aux = nil + v.Args = v.argstorage[:0] + v.Aux = c + v.AddArg(x) + return true + } + end1: + ; + case OpAdd: + // match: (Add x y) + // cond: is64BitInt(t) + // result: (ADDQ x y) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + if !(is64BitInt(t)) { + goto end2 + } + v.Op = OpADDQ + v.Aux = nil + v.Args = v.argstorage[:0] + v.AddArg(x) + v.AddArg(y) + return true + } + end2: + ; + // match: (Add x y) + // cond: is32BitInt(t) + // result: (ADDL x y) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + if !(is32BitInt(t)) { + goto end3 + } + v.Op = OpADDL + v.Aux = nil + v.Args = v.argstorage[:0] + v.AddArg(x) + v.AddArg(y) + return true + } + end3: + ; + case OpCMPQ: + // match: (CMPQ x (ConstInt [c])) + // cond: + // result: (CMPCQ x [c]) + { + x := v.Args[0] + if v.Args[1].Op != OpConstInt { + goto end4 + } + c := v.Args[1].Aux + v.Op = OpCMPCQ + v.Aux = nil + v.Args = v.argstorage[:0] + v.AddArg(x) + v.Aux = c + return true + } + end4: + ; + // match: (CMPQ (ConstInt [c]) x) + // cond: + // result: (InvertFlags (CMPCQ x [c])) + { + if v.Args[0].Op != OpConstInt { + goto end5 + } + c := v.Args[0].Aux + x := v.Args[1] + v.Op = OpInvertFlags + v.Aux = nil + v.Args = v.argstorage[:0] + v0 := v.Block.NewValue(OpCMPCQ, TypeInvalid, nil) + v0.AddArg(x) + v0.Aux = c + v0.SetType() + v.AddArg(v0) + return true + } + end5: + ; + case OpLess: + // match: (Less x y) + // cond: is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type) + // result: (SETL (CMPQ x y)) + { + x := v.Args[0] + y := v.Args[1] + if !(is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type)) { + goto end6 + } + v.Op = OpSETL + v.Aux = nil + v.Args = v.argstorage[:0] + v0 := v.Block.NewValue(OpCMPQ, TypeInvalid, nil) + v0.AddArg(x) + v0.AddArg(y) + v0.SetType() + v.AddArg(v0) + return true + } + end6: + ; + case OpLoadFP: + // match: (LoadFP [offset] mem) + // cond: typeSize(t) == 8 + // result: (LoadFP8 [offset] mem) + { + t := v.Type + offset := v.Aux + mem := v.Args[0] + if !(typeSize(t) == 8) { + goto end7 + } + v.Op = OpLoadFP8 + v.Aux = nil + v.Args = v.argstorage[:0] + v.Type = t + v.Aux = offset + v.AddArg(mem) + return true + } + end7: + ; + case OpLoadSP: + // match: (LoadSP [offset] mem) + // cond: typeSize(t) == 8 + // result: (LoadSP8 [offset] mem) + { + t := v.Type + offset := v.Aux + mem := v.Args[0] + if !(typeSize(t) == 8) { + goto end8 + } + v.Op = OpLoadSP8 + v.Aux = nil + v.Args = v.argstorage[:0] + v.Type = t + v.Aux = offset + v.AddArg(mem) + return true + } + end8: + ; + case OpSETL: + // match: (SETL (InvertFlags x)) + // cond: + // result: (SETGE x) + { + if v.Args[0].Op != OpInvertFlags { + goto end9 + } + x := v.Args[0].Args[0] + v.Op = OpSETGE + v.Aux = nil + v.Args = v.argstorage[:0] + v.AddArg(x) + return true + } + end9: + ; + case OpSUBQ: + // match: (SUBQ x (ConstInt [c])) + // cond: + // result: (SUBCQ x [c]) + { + x := v.Args[0] + if v.Args[1].Op != OpConstInt { + goto end10 + } + c := v.Args[1].Aux + v.Op = OpSUBCQ + v.Aux = nil + v.Args = v.argstorage[:0] + v.AddArg(x) + v.Aux = c + return true + } + end10: + ; + // match: (SUBQ (ConstInt [c]) x) + // cond: + // result: (NEGQ (SUBCQ x [c])) + { + if v.Args[0].Op != OpConstInt { + goto end11 + } + c := v.Args[0].Aux + x := v.Args[1] + v.Op = OpNEGQ + v.Aux = nil + v.Args = v.argstorage[:0] + v0 := v.Block.NewValue(OpSUBCQ, TypeInvalid, nil) + v0.AddArg(x) + v0.Aux = c + v0.SetType() + v.AddArg(v0) + return true + } + end11: + ; + case OpStoreFP: + // match: (StoreFP [offset] val mem) + // cond: typeSize(val.Type) == 8 + // result: (StoreFP8 [offset] val mem) + { + offset := v.Aux + val := v.Args[0] + mem := v.Args[1] + if !(typeSize(val.Type) == 8) { + goto end12 + } + v.Op = OpStoreFP8 + v.Aux = nil + v.Args = v.argstorage[:0] + v.Aux = offset + v.AddArg(val) + v.AddArg(mem) + return true + } + end12: + ; + case OpStoreSP: + // match: (StoreSP [offset] val mem) + // cond: typeSize(val.Type) == 8 + // result: (StoreSP8 [offset] val mem) + { + offset := v.Aux + val := v.Args[0] + mem := v.Args[1] + if !(typeSize(val.Type) == 8) { + goto end13 + } + v.Op = OpStoreSP8 + v.Aux = nil + v.Args = v.argstorage[:0] + v.Aux = offset + v.AddArg(val) + v.AddArg(mem) + return true + } + end13: + ; + case OpSub: + // match: (Sub x y) + // cond: is64BitInt(t) + // result: (SUBQ x y) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + if !(is64BitInt(t)) { + goto end14 + } + v.Op = OpSUBQ + v.Aux = nil + v.Args = v.argstorage[:0] + v.AddArg(x) + v.AddArg(y) + return true + } + end14: + } + return false +} diff --git a/src/cmd/internal/ssa/op.go b/src/cmd/internal/ssa/op.go index 905d62b69c..da69657411 100644 --- a/src/cmd/internal/ssa/op.go +++ b/src/cmd/internal/ssa/op.go @@ -62,7 +62,9 @@ const ( OpCheckBound // 0 <= arg[0] < arg[1] // function calls. Arguments to the call have already been written to the stack. - // Return values appear on the stack. + // Return values appear on the stack. The method receiver, if any, is treated + // as a phantom first argument. + // TODO: closure pointer must be in a register. OpCall // args are function ptr, memory OpStaticCall // aux is function, arg is memory @@ -82,33 +84,38 @@ const ( OpStoreFP OpStoreSP - // spill and 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 with that because - // we know there is no aliasing to spill slots on the stack. + // 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. OpStoreReg8 OpLoadReg8 // machine-dependent opcodes go here - // x86 + // amd64 OpADDQ OpSUBQ - OpADDCQ // 1 input arg, add aux which is an int64 constant + OpADDCQ // 1 input arg. output = input + aux.(int64) OpSUBCQ // 1 input arg. output = input - aux.(int64) OpNEGQ OpCMPQ OpCMPCQ // 1 input arg. Compares input with aux.(int64) OpADDL - OpInvertFlags // inverts interpretation of the flags register (< to >=, etc.) - OpSETL // generate bool = "flags encode less than" + OpSETL // generate bool = "flags encode less than" OpSETGE + // InvertFlags reverses direction of flags register interpretation: + // (InvertFlags (OpCMPQ a b)) == (OpCMPQ b a) + // This is a pseudo-op which can't appear in assembly output. + OpInvertFlags + OpLEAQ // x+y OpLEAQ2 // x+2*y OpLEAQ4 // x+4*y OpLEAQ8 // x+8*y + // load/store 8-byte integer register from stack slot. OpLoadFP8 OpLoadSP8 OpStoreFP8 diff --git a/src/cmd/internal/ssa/op_string.go b/src/cmd/internal/ssa/op_string.go index 40051eb321..9aee7de43e 100644 --- a/src/cmd/internal/ssa/op_string.go +++ b/src/cmd/internal/ssa/op_string.go @@ -4,9 +4,9 @@ package ssa import "fmt" -const _Op_name = "OpUnknownOpNopOpThunkOpAddOpSubOpMulOpLessOpConstNilOpConstBoolOpConstStringOpConstIntOpConstFloatOpConstComplexOpArgOpGlobalOpFuncOpCopyOpPhiOpSliceMakeOpSlicePtrOpSliceLenOpSliceCapOpStringMakeOpStringPtrOpStringLenOpSliceOpIndexOpIndexAddrOpLoadOpStoreOpCheckNilOpCheckBoundOpCallOpStaticCallOpConvertOpConvNopOpFPAddrOpSPAddrOpLoadFPOpLoadSPOpStoreFPOpStoreSPOpStoreReg8OpLoadReg8OpADDQOpSUBQOpADDCQOpSUBCQOpNEGQOpCMPQOpCMPCQOpADDLOpInvertFlagsOpSETLOpSETGEOpLEAQOpLEAQ2OpLEAQ4OpLEAQ8OpLoadFP8OpLoadSP8OpStoreFP8OpStoreSP8OpMax" +const _Op_name = "OpUnknownOpNopOpThunkOpAddOpSubOpMulOpLessOpConstNilOpConstBoolOpConstStringOpConstIntOpConstFloatOpConstComplexOpArgOpGlobalOpFuncOpCopyOpPhiOpSliceMakeOpSlicePtrOpSliceLenOpSliceCapOpStringMakeOpStringPtrOpStringLenOpSliceOpIndexOpIndexAddrOpLoadOpStoreOpCheckNilOpCheckBoundOpCallOpStaticCallOpConvertOpConvNopOpFPAddrOpSPAddrOpLoadFPOpLoadSPOpStoreFPOpStoreSPOpStoreReg8OpLoadReg8OpADDQOpSUBQOpADDCQOpSUBCQOpNEGQOpCMPQOpCMPCQOpADDLOpSETLOpSETGEOpInvertFlagsOpLEAQOpLEAQ2OpLEAQ4OpLEAQ8OpLoadFP8OpLoadSP8OpStoreFP8OpStoreSP8OpMax" -var _Op_index = [...]uint16{0, 9, 14, 21, 26, 31, 36, 42, 52, 63, 76, 86, 98, 112, 117, 125, 131, 137, 142, 153, 163, 173, 183, 195, 206, 217, 224, 231, 242, 248, 255, 265, 277, 283, 295, 304, 313, 321, 329, 337, 345, 354, 363, 374, 384, 390, 396, 403, 410, 416, 422, 429, 435, 448, 454, 461, 467, 474, 481, 488, 497, 506, 516, 526, 531} +var _Op_index = [...]uint16{0, 9, 14, 21, 26, 31, 36, 42, 52, 63, 76, 86, 98, 112, 117, 125, 131, 137, 142, 153, 163, 173, 183, 195, 206, 217, 224, 231, 242, 248, 255, 265, 277, 283, 295, 304, 313, 321, 329, 337, 345, 354, 363, 374, 384, 390, 396, 403, 410, 416, 422, 429, 435, 441, 448, 461, 467, 474, 481, 488, 497, 506, 516, 526, 531} func (i Op) String() string { if i < 0 || i+1 >= Op(len(_Op_index)) { diff --git a/src/cmd/internal/ssa/opt.go b/src/cmd/internal/ssa/opt.go new file mode 100644 index 0000000000..ea2bcf0e98 --- /dev/null +++ b/src/cmd/internal/ssa/opt.go @@ -0,0 +1,13 @@ +// 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 + +//go:generate go run rulegen/rulegen.go rulegen/generic.rules genericRules generic.go + +func opt(f *Func) { + applyRewrite(f, genericRules) +} diff --git a/src/cmd/internal/ssa/rewrite.go b/src/cmd/internal/ssa/rewrite.go new file mode 100644 index 0000000000..0d7c0c1c64 --- /dev/null +++ b/src/cmd/internal/ssa/rewrite.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. + +package ssa + +import ( + "cmd/internal/ssa/types" // TODO: use golang.org/x/tools/go/types instead +) + +func applyRewrite(f *Func, r func(*Value) bool) { + // repeat rewrites until we find no more rewrites + for { + change := false + for _, b := range f.Blocks { + for _, v := range b.Values { + if r(v) { + change = true + } + } + } + if !change { + return + } + } +} + +// Common functions called from rewriting rules + +func is64BitInt(t Type) bool { + return typeIdentical(t, TypeInt64) || + typeIdentical(t, TypeUint64) || + (typeIdentical(t, TypeInt) && intSize == 8) || + (typeIdentical(t, TypeUint) && intSize == 8) || + (typeIdentical(t, TypeUintptr) && ptrSize == 8) +} + +func is32BitInt(t Type) bool { + return typeIdentical(t, TypeInt32) || + typeIdentical(t, TypeUint32) || + (typeIdentical(t, TypeInt) && intSize == 4) || + (typeIdentical(t, TypeUint) && intSize == 4) || + (typeIdentical(t, TypeUintptr) && ptrSize == 4) +} + +func isSigned(t Type) bool { + return typeIdentical(t, TypeInt) || + typeIdentical(t, TypeInt8) || + typeIdentical(t, TypeInt16) || + typeIdentical(t, TypeInt32) || + typeIdentical(t, TypeInt64) +} + +func typeSize(t Type) int { + switch t { + case TypeInt32, TypeUint32: + return 4 + case TypeInt64, TypeUint64: + return 8 + case TypeUintptr: + return ptrSize + case TypeInt, TypeUint: + return intSize + default: + if _, ok := t.(*types.Pointer); ok { + return ptrSize + } + panic("TODO: width of " + t.String()) + } +} diff --git a/src/cmd/internal/ssa/rulegen/generic.rules b/src/cmd/internal/ssa/rulegen/generic.rules new file mode 100644 index 0000000000..73e6e4a329 --- /dev/null +++ b/src/cmd/internal/ssa/rulegen/generic.rules @@ -0,0 +1,16 @@ +// 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. + +// constant folding +(Add (ConstInt [c]) (ConstInt [d])) && is64BitInt(t) -> (ConstInt [{c.(int64)+d.(int64)}]) + +// load/store to stack +(Load (FPAddr [offset]) mem) -> (LoadFP [offset] mem) +(Store (FPAddr [offset]) val mem) -> (StoreFP [offset] val mem) + +(Load (SPAddr [offset]) mem) -> (LoadSP [offset] mem) +(Store (SPAddr [offset]) val mem) -> (StoreSP [offset] val mem) + +// expand array indexing +// others? Depends on what is already done by frontend diff --git a/src/cmd/internal/ssa/rulegen/lower_amd64.rules b/src/cmd/internal/ssa/rulegen/lower_amd64.rules new file mode 100644 index 0000000000..525035b8c2 --- /dev/null +++ b/src/cmd/internal/ssa/rulegen/lower_amd64.rules @@ -0,0 +1,46 @@ +// 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 [aux] arg0 arg1 ...) +// the type and aux fields are optional +// on the matching side +// - the types and aux fields must match if they are specified. +// on the generated side +// - types will be computed by opcode typers if not specified explicitly. +// - aux will be nil if not specified. + +// 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. + +// These are the lowerings themselves +(Add x y) && is64BitInt(t) -> (ADDQ x y) +(Add x y) && is32BitInt(t) -> (ADDL x y) + +(Sub x y) && is64BitInt(t) -> (SUBQ x y) + +(Less x y) && is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type) -> (SETL (CMPQ x y)) + +// stack loads/stores +(LoadFP [offset] mem) && typeSize(t) == 8 -> (LoadFP8 [offset] mem) +(StoreFP [offset] val mem) && typeSize(val.Type) == 8 -> (StoreFP8 [offset] val mem) +(LoadSP [offset] mem) && typeSize(t) == 8 -> (LoadSP8 [offset] mem) +(StoreSP [offset] val mem) && typeSize(val.Type) == 8 -> (StoreSP8 [offset] val mem) + +// Rules below here apply some simple optimizations after lowering. +// TODO: Should this be a separate pass? + +(ADDQ x (ConstInt [c])) -> (ADDCQ [c] x) // TODO: restrict c to int32 range? +(ADDQ (ConstInt [c]) x) -> (ADDCQ [c] x) +(SUBQ x (ConstInt [c])) -> (SUBCQ x [c]) +(SUBQ (ConstInt [c]) x) -> (NEGQ (SUBCQ x [c])) +(CMPQ x (ConstInt [c])) -> (CMPCQ x [c]) +(CMPQ (ConstInt [c]) x) -> (InvertFlags (CMPCQ x [c])) + +// reverse ordering of compare instruction +(SETL (InvertFlags x)) -> (SETGE x) diff --git a/src/cmd/internal/ssa/rulegen/rulegen.go b/src/cmd/internal/ssa/rulegen/rulegen.go new file mode 100644 index 0000000000..f125828f64 --- /dev/null +++ b/src/cmd/internal/ssa/rulegen/rulegen.go @@ -0,0 +1,328 @@ +// 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 + +// Run with something like "go run rulegen.go lower_amd64.rules lowerAmd64 lowerAmd64.go" + +package main + +import ( + "bufio" + "bytes" + "fmt" + "go/format" + "io" + "log" + "os" + "sort" + "strings" +) + +// rule syntax: +// sexpr [&& extra conditions] -> sexpr +// +// sexpr are s-expressions (lisp-like parenthesized groupings) +// sexpr ::= (opcode sexpr*) +// | variable +// | [aux] +// | +// | {code} +// +// 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. + +func main() { + if len(os.Args) < 3 || len(os.Args) > 4 { + fmt.Printf("usage: go run rulegen.go []") + os.Exit(1) + } + rulefile := os.Args[1] + rulefn := os.Args[2] + + // Open input file. + text, err := os.Open(rulefile) + if err != nil { + log.Fatalf("can't read rule file: %v", err) + } + + // oprules contains a list of rules for each opcode + oprules := map[string][]string{} + + // read rule file + scanner := bufio.NewScanner(text) + for scanner.Scan() { + 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] + } + line = strings.TrimSpace(line) + if line == "" { + continue + } + op := strings.Split(line, " ")[0][1:] + oprules[op] = append(oprules[op], line) + } + if err := scanner.Err(); err != nil { + log.Fatalf("scanner failed: %v\n", err) + } + + // Start output buffer, write header. + w := new(bytes.Buffer) + fmt.Fprintf(w, "// autogenerated from %s: do not edit!\n", rulefile) + fmt.Fprintf(w, "// generated with: go run rulegen/rulegen.go %s\n", strings.Join(os.Args[1:], " ")) + fmt.Fprintln(w, "package ssa") + fmt.Fprintf(w, "func %s(v *Value) bool {\n", rulefn) + + // generate code for each rule + fmt.Fprintf(w, "switch v.Op {\n") + var ops []string + for op := range oprules { + ops = append(ops, op) + } + sort.Strings(ops) + rulenum := 0 + for _, op := range ops { + fmt.Fprintf(w, "case Op%s:\n", op) + for _, rule := range oprules[op] { + // split at -> + s := strings.Split(rule, "->") + if len(s) != 2 { + log.Fatalf("no arrow in rule %s", rule) + } + lhs := strings.Trim(s[0], " \t") + result := strings.Trim(s[1], " \t\n") + + // split match into matching part and additional condition + match := lhs + cond := "" + if i := strings.Index(match, "&&"); i >= 0 { + cond = strings.Trim(match[i+2:], " \t") + match = strings.Trim(match[:i], " \t") + } + + fmt.Fprintf(w, "// match: %s\n", match) + fmt.Fprintf(w, "// cond: %s\n", cond) + fmt.Fprintf(w, "// result: %s\n", result) + + fail := fmt.Sprintf("{\ngoto end%d\n}\n", rulenum) + + fmt.Fprintf(w, "{\n") + genMatch(w, match, fail) + + if cond != "" { + fmt.Fprintf(w, "if !(%s) %s", cond, fail) + } + + genResult(w, result) + fmt.Fprintf(w, "return true\n") + + fmt.Fprintf(w, "}\n") + fmt.Fprintf(w, "end%d:;\n", rulenum) + rulenum++ + } + } + fmt.Fprintf(w, "}\n") + fmt.Fprintf(w, "return false\n") + fmt.Fprintf(w, "}\n") + + // gofmt result + b := w.Bytes() + b, err = format.Source(b) + if err != nil { + panic(err) + } + + // Write to a file if given, otherwise stdout. + var out io.WriteCloser + if len(os.Args) >= 4 { + outfile := os.Args[3] + out, err = os.Create(outfile) + if err != nil { + log.Fatalf("can't open output file %s: %v\n", outfile, err) + } + } else { + out = os.Stdout + } + if _, err = out.Write(b); err != nil { + log.Fatalf("can't write output: %v\n", err) + } + if err = out.Close(); err != nil { + log.Fatalf("can't close output: %v\n", err) + } +} + +func genMatch(w io.Writer, match, fail string) { + genMatch0(w, match, "v", fail, map[string]string{}, true) +} + +func genMatch0(w io.Writer, match, v, fail string, m map[string]string, top bool) { + if match[0] != '(' { + if x, 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 %s", v, x, fail) + return + } + // remember that this variable references the given value + 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]) + + // check op + if !top { + fmt.Fprintf(w, "if %s.Op != Op%s %s", v, s[0], fail) + } + + // check type/aux/args + argnum := 0 + for _, a := range s[1:] { + if a[0] == '<' { + // type restriction + t := a[1 : len(a)-1] + if t[0] == '{' { + // code. We must match the results of this code. + fmt.Fprintf(w, "if %s.Type != %s %s", v, t[1:len(t)-1], fail) + } else { + // variable + if u, ok := m[t]; ok { + // must match previous variable + fmt.Fprintf(w, "if %s.Type != %s %s", v, u, fail) + } else { + m[t] = v + ".Type" + fmt.Fprintf(w, "%s := %s.Type\n", t, v) + } + } + } else if a[0] == '[' { + // aux restriction + x := a[1 : len(a)-1] + if x[0] == '{' { + // code + fmt.Fprintf(w, "if %s.Aux != %s %s", v, x[1:len(x)-1], fail) + } else { + // variable + if y, ok := m[x]; ok { + fmt.Fprintf(w, "if %s.Aux != %s %s", v, y, fail) + } else { + m[x] = v + ".Aux" + fmt.Fprintf(w, "%s := %s.Aux\n", x, v) + } + } + } else if a[0] == '{' { + fmt.Fprintf(w, "if %s.Args[%d] != %s %s", v, argnum, a[1:len(a)-1], fail) + argnum++ + } else { + // variable or sexpr + genMatch0(w, a, fmt.Sprintf("%s.Args[%d]", v, argnum), fail, m, false) + argnum++ + } + } +} + +func genResult(w io.Writer, result string) { + genResult0(w, result, new(int), true) +} +func genResult0(w io.Writer, result string, alloc *int, top bool) string { + if result[0] != '(' { + // variable + return result + } + + s := split(result[1 : len(result)-1]) + var v string + var needsType bool + if top { + v = "v" + fmt.Fprintf(w, "v.Op = Op%s\n", s[0]) + fmt.Fprintf(w, "v.Aux = nil\n") + fmt.Fprintf(w, "v.Args = v.argstorage[:0]\n") + } else { + v = fmt.Sprintf("v%d", *alloc) + *alloc++ + fmt.Fprintf(w, "%s := v.Block.NewValue(Op%s, TypeInvalid, nil)\n", v, s[0]) + needsType = true + } + for _, a := range s[1:] { + if a[0] == '<' { + // type restriction + t := a[1 : len(a)-1] + if t[0] == '{' { + t = t[1 : len(t)-1] + } + fmt.Fprintf(w, "%s.Type = %s\n", v, t) + needsType = false + } else if a[0] == '[' { + // aux restriction + x := a[1 : len(a)-1] + if x[0] == '{' { + x = x[1 : len(x)-1] + } + fmt.Fprintf(w, "%s.Aux = %s\n", v, x) + } else if a[0] == '{' { + fmt.Fprintf(w, "%s.AddArg(%s)\n", v, a[1:len(a)-1]) + } else { + // regular argument (sexpr or variable) + x := genResult0(w, a, alloc, false) + fmt.Fprintf(w, "%s.AddArg(%s)\n", v, x) + } + } + if needsType { + fmt.Fprintf(w, "%s.SetType()\n", v) + } + return v +} + +func split(s string) []string { + var r []string + +outer: + for s != "" { + d := 0 // depth of ({[< + nonsp := false // found a non-space char so far + for i := 0; i < len(s); i++ { + switch s[i] { + case '(', '{', '[', '<': + d++ + case ')', '}', ']', '>': + d-- + case ' ', '\t': + if d == 0 && nonsp { + r = append(r, strings.TrimSpace(s[:i])) + s = s[i:] + continue outer + } + default: + nonsp = true + } + } + if d != 0 { + panic("imbalanced expression: " + s) + } + if nonsp { + r = append(r, strings.TrimSpace(s)) + } + break + } + return r +} diff --git a/src/cmd/internal/ssa/schedule.go b/src/cmd/internal/ssa/schedule.go new file mode 100644 index 0000000000..0a89ac3773 --- /dev/null +++ b/src/cmd/internal/ssa/schedule.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 + +// 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 an +// arbitrary valid schedule using a topological sort. TODO(khr): +// schedule smarter. +func schedule(f *Func) { + const ( + unmarked = 0 + found = 1 + expanded = 2 + done = 3 + ) + state := make([]byte, f.NumValues()) + var queue []*Value //stack-like worklist. Contains found and expanded nodes. + var order []*Value + + for _, b := range f.Blocks { + // Topologically sort the values in b. + order = order[:0] + for _, v := range b.Values { + if v.Op == OpPhi { + // Phis all go first. We handle phis specially + // because they may have self edges "a = phi(a, b, c)" + order = append(order, v) + continue + } + if state[v.ID] != unmarked { + if state[v.ID] != done { + panic("bad state") + } + continue + } + state[v.ID] = found + queue = append(queue, v) + for len(queue) > 0 { + v = queue[len(queue)-1] + switch state[v.ID] { + case found: + state[v.ID] = expanded + // Note that v is not popped. We leave it in place + // until all its children have been explored. + for _, w := range v.Args { + if w.Block == b && w.Op != OpPhi && state[w.ID] == unmarked { + state[w.ID] = found + queue = append(queue, w) + } + } + case expanded: + queue = queue[:len(queue)-1] + state[v.ID] = done + order = append(order, v) + default: + panic("bad state") + } + } + } + copy(b.Values, order) + } + // TODO: only allow one live mem type and one live flags type (x86) + // This restriction will force any loads (and any flag uses) to appear + // before the next store (flag update). This "anti-dependence" is not + // recorded explicitly in ssa form. +} diff --git a/src/cmd/internal/ssa/ssac/fib.goir b/src/cmd/internal/ssa/ssac/fib.goir index b572cdaa3a..0875d63ca3 100644 --- a/src/cmd/internal/ssa/ssac/fib.goir +++ b/src/cmd/internal/ssa/ssac/fib.goir @@ -13,6 +13,7 @@ (TYPE T127bd68 int) (TYPE T127bd68 int) (DCL n T127bd68) + (AS n (LOAD (FP T127bd68 0))) (DCL ~r1 T127bd68) (DCL n T127bd68) (DCL autotmp_0000 T127bd68) @@ -29,7 +30,7 @@ (IF (LT n (CINT 2)) .then0 .else0) (LABEL .then0) (AS ~r1 n) - (AS (SP T127bd68 8) ~r1) + (AS (FP T127bd68 8) ~r1) (RETURN) (GOTO .end0) (LABEL .else0) @@ -42,5 +43,5 @@ (CALL fib) (AS autotmp_0001 (LOAD (SP T127bd68 8))) (AS ~r1 (ADD autotmp_0000 autotmp_0001)) - (AS (SP T127bd68 8) ~r1) + (AS (FP T127bd68 8) ~r1) (RETURN) diff --git a/src/cmd/internal/ssa/ssac/fibiter.goir b/src/cmd/internal/ssa/ssac/fibiter.goir index 43c7a3de91..98b2b2b576 100644 --- a/src/cmd/internal/ssa/ssac/fibiter.goir +++ b/src/cmd/internal/ssa/ssac/fibiter.goir @@ -43,7 +43,7 @@ (DCL autotmp_0003 Tf5dd68) (DCL ~r1 Tf5dd68) (DCL a Tf5dd68) - (AS n (LOAD (SP Tf5dd68 0))) + (AS n (LOAD (FP Tf5dd68 0))) (AS a (CINT 0)) (AS b (CINT 1)) (AS i (CINT 0)) @@ -58,5 +58,5 @@ (AS i (ADD autotmp_0002 (CINT 1))) (GOTO .top0) (LABEL .end0) - (AS (SP Tf5dd68 8) a) + (AS (FP Tf5dd68 8) a) (RETURN) -- cgit v1.3 From 2c9b491e01dbc5e06d7cf98deaf1b4f1779f5da9 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Thu, 26 Mar 2015 10:49:03 -0700 Subject: [dev.ssa] cmd/internal/ssa: SSA cleanups Mostly suggested by Alan. Convert Const* ops to just one Const op. Use more of go/types. Get rid of typers, all types must be specified explicitly. Change-Id: Id4758f2b887d8a6888e88a7e047d97af55e34b62 Reviewed-on: https://go-review.googlesource.com/8110 Reviewed-by: Alan Donovan --- src/cmd/internal/ssa/block.go | 1 + src/cmd/internal/ssa/compile.go | 2 +- src/cmd/internal/ssa/deadcode.go | 2 +- src/cmd/internal/ssa/func.go | 2 +- src/cmd/internal/ssa/generic.go | 54 ++++++++---- src/cmd/internal/ssa/lowerAmd64.go | 37 ++++---- src/cmd/internal/ssa/op.go | 76 +++++----------- src/cmd/internal/ssa/op_string.go | 4 +- src/cmd/internal/ssa/rewrite.go | 55 +++++------- src/cmd/internal/ssa/rulegen/generic.rules | 3 +- src/cmd/internal/ssa/rulegen/lower_amd64.rules | 17 ++-- src/cmd/internal/ssa/rulegen/rulegen.go | 25 ++---- src/cmd/internal/ssa/ssac/main.go | 3 +- src/cmd/internal/ssa/type.go | 34 ++++--- src/cmd/internal/ssa/types/sizes.go | 117 +++++++++++++++++++++++++ src/cmd/internal/ssa/value.go | 13 +-- 16 files changed, 271 insertions(+), 174 deletions(-) create mode 100644 src/cmd/internal/ssa/types/sizes.go (limited to 'src/cmd') diff --git a/src/cmd/internal/ssa/block.go b/src/cmd/internal/ssa/block.go index ff1cb1b30a..81b5594f38 100644 --- a/src/cmd/internal/ssa/block.go +++ b/src/cmd/internal/ssa/block.go @@ -54,6 +54,7 @@ const ( BlockPlain // a single successor BlockIf // 2 successors, if control goto Succs[0] else goto Succs[1] BlockCall // 2 successors, normal return and panic + // TODO(khr): BlockPanic for the built-in panic call, has 1 edge to the exit block BlockUnknown // 386/amd64 variants of BlockIf that take the flags register as an arg diff --git a/src/cmd/internal/ssa/compile.go b/src/cmd/internal/ssa/compile.go index b8f34c52fc..6103cc9557 100644 --- a/src/cmd/internal/ssa/compile.go +++ b/src/cmd/internal/ssa/compile.go @@ -79,7 +79,7 @@ var passOrder = map[string]string{ // regalloc requires all the values in a block to be scheduled //"schedule": "regalloc", // code generation requires register allocation - //"cgen":"regalloc", + //"regalloc": "cgen", } func init() { diff --git a/src/cmd/internal/ssa/deadcode.go b/src/cmd/internal/ssa/deadcode.go index e8c8bfcc03..f9e4b18d5f 100644 --- a/src/cmd/internal/ssa/deadcode.go +++ b/src/cmd/internal/ssa/deadcode.go @@ -20,7 +20,7 @@ func deadcode(f *Func) { // constant-fold conditionals // TODO: rewrite rules instead? - if b.Kind == BlockIf && b.Control.Op == OpConstBool { + if b.Kind == BlockIf && b.Control.Op == OpConst { cond := b.Control.Aux.(bool) var c *Block if cond { diff --git a/src/cmd/internal/ssa/func.go b/src/cmd/internal/ssa/func.go index 6868e3d1ed..b4677c97b3 100644 --- a/src/cmd/internal/ssa/func.go +++ b/src/cmd/internal/ssa/func.go @@ -57,5 +57,5 @@ func (b *Block) NewValue(op Op, t Type, aux interface{}) *Value { func (f *Func) ConstInt(c int64) *Value { // TODO: cache? // TODO: different types? - return f.Entry.NewValue(OpConstInt, TypeInt, c) + return f.Entry.NewValue(OpConst, TypeInt64, c) } diff --git a/src/cmd/internal/ssa/generic.go b/src/cmd/internal/ssa/generic.go index f28633b19a..3118b3af9d 100644 --- a/src/cmd/internal/ssa/generic.go +++ b/src/cmd/internal/ssa/generic.go @@ -5,23 +5,23 @@ package ssa func genericRules(v *Value) bool { switch v.Op { case OpAdd: - // match: (Add (ConstInt [c]) (ConstInt [d])) - // cond: is64BitInt(t) - // result: (ConstInt [{c.(int64)+d.(int64)}]) + // match: (Add (Const [c]) (Const [d])) + // cond: is64BitInt(t) && isSigned(t) + // result: (Const [{c.(int64)+d.(int64)}]) { t := v.Type - if v.Args[0].Op != OpConstInt { + if v.Args[0].Op != OpConst { goto end0 } c := v.Args[0].Aux - if v.Args[1].Op != OpConstInt { + if v.Args[1].Op != OpConst { goto end0 } d := v.Args[1].Aux - if !(is64BitInt(t)) { + if !(is64BitInt(t) && isSigned(t)) { goto end0 } - v.Op = OpConstInt + v.Op = OpConst v.Aux = nil v.Args = v.argstorage[:0] v.Aux = c.(int64) + d.(int64) @@ -29,13 +29,37 @@ func genericRules(v *Value) bool { } end0: ; + // match: (Add (Const [c]) (Const [d])) + // cond: is64BitInt(t) && !isSigned(t) + // result: (Const [{c.(uint64)+d.(uint64)}]) + { + t := v.Type + if v.Args[0].Op != OpConst { + goto end1 + } + c := v.Args[0].Aux + if v.Args[1].Op != OpConst { + goto end1 + } + d := v.Args[1].Aux + if !(is64BitInt(t) && !isSigned(t)) { + goto end1 + } + v.Op = OpConst + v.Aux = nil + v.Args = v.argstorage[:0] + v.Aux = c.(uint64) + d.(uint64) + return true + } + end1: + ; case OpLoad: // match: (Load (FPAddr [offset]) mem) // cond: // result: (LoadFP [offset] mem) { if v.Args[0].Op != OpFPAddr { - goto end1 + goto end2 } offset := v.Args[0].Aux mem := v.Args[1] @@ -46,14 +70,14 @@ func genericRules(v *Value) bool { v.AddArg(mem) return true } - end1: + end2: ; // match: (Load (SPAddr [offset]) mem) // cond: // result: (LoadSP [offset] mem) { if v.Args[0].Op != OpSPAddr { - goto end2 + goto end3 } offset := v.Args[0].Aux mem := v.Args[1] @@ -64,7 +88,7 @@ func genericRules(v *Value) bool { v.AddArg(mem) return true } - end2: + end3: ; case OpStore: // match: (Store (FPAddr [offset]) val mem) @@ -72,7 +96,7 @@ func genericRules(v *Value) bool { // result: (StoreFP [offset] val mem) { if v.Args[0].Op != OpFPAddr { - goto end3 + goto end4 } offset := v.Args[0].Aux val := v.Args[1] @@ -85,14 +109,14 @@ func genericRules(v *Value) bool { v.AddArg(mem) return true } - end3: + end4: ; // match: (Store (SPAddr [offset]) val mem) // cond: // result: (StoreSP [offset] val mem) { if v.Args[0].Op != OpSPAddr { - goto end4 + goto end5 } offset := v.Args[0].Aux val := v.Args[1] @@ -105,7 +129,7 @@ func genericRules(v *Value) bool { v.AddArg(mem) return true } - end4: + end5: } return false } diff --git a/src/cmd/internal/ssa/lowerAmd64.go b/src/cmd/internal/ssa/lowerAmd64.go index ab79ed09b1..88f0e43bd8 100644 --- a/src/cmd/internal/ssa/lowerAmd64.go +++ b/src/cmd/internal/ssa/lowerAmd64.go @@ -5,12 +5,12 @@ package ssa func lowerAmd64(v *Value) bool { switch v.Op { case OpADDQ: - // match: (ADDQ x (ConstInt [c])) + // match: (ADDQ x (Const [c])) // cond: // result: (ADDCQ [c] x) { x := v.Args[0] - if v.Args[1].Op != OpConstInt { + if v.Args[1].Op != OpConst { goto end0 } c := v.Args[1].Aux @@ -23,11 +23,11 @@ func lowerAmd64(v *Value) bool { } end0: ; - // match: (ADDQ (ConstInt [c]) x) + // match: (ADDQ (Const [c]) x) // cond: // result: (ADDCQ [c] x) { - if v.Args[0].Op != OpConstInt { + if v.Args[0].Op != OpConst { goto end1 } c := v.Args[0].Aux @@ -81,12 +81,12 @@ func lowerAmd64(v *Value) bool { end3: ; case OpCMPQ: - // match: (CMPQ x (ConstInt [c])) + // match: (CMPQ x (Const [c])) // cond: // result: (CMPCQ x [c]) { x := v.Args[0] - if v.Args[1].Op != OpConstInt { + if v.Args[1].Op != OpConst { goto end4 } c := v.Args[1].Aux @@ -99,11 +99,11 @@ func lowerAmd64(v *Value) bool { } end4: ; - // match: (CMPQ (ConstInt [c]) x) + // match: (CMPQ (Const [c]) x) // cond: - // result: (InvertFlags (CMPCQ x [c])) + // result: (InvertFlags (CMPCQ x [c])) { - if v.Args[0].Op != OpConstInt { + if v.Args[0].Op != OpConst { goto end5 } c := v.Args[0].Aux @@ -112,9 +112,9 @@ func lowerAmd64(v *Value) bool { v.Aux = nil v.Args = v.argstorage[:0] v0 := v.Block.NewValue(OpCMPCQ, TypeInvalid, nil) + v0.Type = TypeFlags v0.AddArg(x) v0.Aux = c - v0.SetType() v.AddArg(v0) return true } @@ -123,7 +123,7 @@ func lowerAmd64(v *Value) bool { case OpLess: // match: (Less x y) // cond: is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type) - // result: (SETL (CMPQ x y)) + // result: (SETL (CMPQ x y)) { x := v.Args[0] y := v.Args[1] @@ -134,9 +134,9 @@ func lowerAmd64(v *Value) bool { v.Aux = nil v.Args = v.argstorage[:0] v0 := v.Block.NewValue(OpCMPQ, TypeInvalid, nil) + v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) - v0.SetType() v.AddArg(v0) return true } @@ -202,12 +202,12 @@ func lowerAmd64(v *Value) bool { end9: ; case OpSUBQ: - // match: (SUBQ x (ConstInt [c])) + // match: (SUBQ x (Const [c])) // cond: // result: (SUBCQ x [c]) { x := v.Args[0] - if v.Args[1].Op != OpConstInt { + if v.Args[1].Op != OpConst { goto end10 } c := v.Args[1].Aux @@ -220,11 +220,12 @@ func lowerAmd64(v *Value) bool { } end10: ; - // match: (SUBQ (ConstInt [c]) x) + // match: (SUBQ (Const [c]) x) // cond: - // result: (NEGQ (SUBCQ x [c])) + // result: (NEGQ (SUBCQ x [c])) { - if v.Args[0].Op != OpConstInt { + t := v.Type + if v.Args[0].Op != OpConst { goto end11 } c := v.Args[0].Aux @@ -233,9 +234,9 @@ func lowerAmd64(v *Value) bool { v.Aux = nil v.Args = v.argstorage[:0] v0 := v.Block.NewValue(OpSUBCQ, TypeInvalid, nil) + v0.Type = t v0.AddArg(x) v0.Aux = c - v0.SetType() v.AddArg(v0) return true } diff --git a/src/cmd/internal/ssa/op.go b/src/cmd/internal/ssa/op.go index da69657411..19d973921c 100644 --- a/src/cmd/internal/ssa/op.go +++ b/src/cmd/internal/ssa/op.go @@ -29,14 +29,9 @@ const ( OpLess // constants - OpConstNil - OpConstBool // aux is type bool - OpConstString // aux is type string - OpConstInt // aux is type int64 - OpConstFloat // aux is type float64 - OpConstComplex // aux is type complex128 - - OpArg // address of a function parameter/result + OpConst + + OpArg // address of a function parameter/result. Memory input is an arg called ".mem". OpGlobal // address of a global variable OpFunc // entry address of a function OpCopy // output = input @@ -56,7 +51,7 @@ const ( OpIndexAddr OpLoad // args are ptr, memory - OpStore // args are ptr, memory, returns memory + OpStore // args are ptr, value, memory, returns memory OpCheckNil // arg[0] != nil OpCheckBound // 0 <= arg[0] < arg[1] @@ -135,9 +130,6 @@ type OpInfo struct { // %A: print aux with fmt.Print asm string - // computes type for values with this opcode - typer func(v *Value) - // returns a reg constraint for the instruction. [0] gives a reg constraint // for each input, [1] gives a reg constraint for each output. (Values have // exactly one output for now) @@ -178,28 +170,6 @@ const ( ArchArm ) -func firstArgTyper(v *Value) { - v.Type = v.Args[0].Type -} -func boolTyper(v *Value) { - v.Type = TypeBool -} -func stringTyper(v *Value) { - v.Type = TypeString -} -func flagsTyper(v *Value) { - v.Type = TypeFlags -} -func uint8Typer(v *Value) { - v.Type = TypeUint8 -} -func uint64Typer(v *Value) { - v.Type = TypeUint64 -} -func auxTyper(v *Value) { - v.Type = v.Aux.(Type) -} - // general purpose registers, 2 input, 1 output var gp21 = [2][]regMask{{gp, gp}, {gp}} var gp21_overwrite = [2][]regMask{{gp, gp}, {overwrite0}} @@ -221,21 +191,17 @@ var genericTable = [...]OpInfo{ // the unknown op is used only during building and should not appear in a // fully formed ssa representation. - OpAdd: {flags: OpFlagCommutative, typer: firstArgTyper}, - OpSub: {typer: firstArgTyper}, - OpMul: {flags: OpFlagCommutative, typer: firstArgTyper}, - OpLess: {typer: boolTyper}, - - OpConstBool: {typer: boolTyper}, // aux is a bool - OpConstString: {typer: stringTyper}, // aux is a string - OpConstInt: {}, // aux is an int64 - OpConstFloat: {}, // aux is a float64 - OpConstComplex: {}, - OpArg: {}, // aux is the name of the input variable TODO:? - OpGlobal: {}, // address of a global variable - OpFunc: {}, - OpCopy: {}, - OpPhi: {}, + OpAdd: {flags: OpFlagCommutative}, + OpSub: {}, + OpMul: {flags: OpFlagCommutative}, + OpLess: {}, + + OpConst: {}, // aux matches the type (e.g. bool, int64 float64) + OpArg: {}, // aux is the name of the input variable TODO:? + OpGlobal: {}, // address of a global variable + OpFunc: {}, + OpCopy: {}, + OpPhi: {}, OpConvNop: {}, // aux is the type to convert to @@ -281,12 +247,12 @@ var genericTable = [...]OpInfo{ // Opcodes that appear in an output amd64 program var amd64Table = [...]OpInfo{ - OpADDQ: {flags: OpFlagCommutative, asm: "ADDQ\t%I0,%I1,%O0", reg: gp21, typer: firstArgTyper}, // TODO: overwrite - OpADDCQ: {asm: "ADDQ\t$%A,%I0,%O0", reg: gp11_overwrite, typer: firstArgTyper}, // aux = int64 constant to add - OpSUBQ: {asm: "SUBQ\t%I0,%I1,%O0", reg: gp21, typer: firstArgTyper}, - OpSUBCQ: {asm: "SUBQ\t$%A,%I0,%O0", reg: gp11_overwrite, typer: firstArgTyper}, + OpADDQ: {flags: OpFlagCommutative, asm: "ADDQ\t%I0,%I1,%O0", reg: gp21}, // TODO: overwrite + OpADDCQ: {asm: "ADDQ\t$%A,%I0,%O0", reg: gp11_overwrite}, // aux = int64 constant to add + OpSUBQ: {asm: "SUBQ\t%I0,%I1,%O0", reg: gp21}, + OpSUBCQ: {asm: "SUBQ\t$%A,%I0,%O0", reg: gp11_overwrite}, - OpCMPQ: {asm: "CMPQ\t%I0,%I1", reg: gp2_flags, typer: flagsTyper}, // compute arg[0]-arg[1] and produce flags + OpCMPQ: {asm: "CMPQ\t%I0,%I1", reg: gp2_flags}, // compute arg[0]-arg[1] and produce flags OpCMPCQ: {asm: "CMPQ\t$%A,%I0", reg: gp1_flags}, OpLEAQ: {flags: OpFlagCommutative, asm: "LEAQ\t%A(%I0)(%I1*1),%O0", reg: gp21}, // aux = int64 constant to add @@ -302,7 +268,7 @@ var amd64Table = [...]OpInfo{ OpCopy: {asm: "MOVQ\t%I0,%O0", reg: gp11}, // convert from flags back to boolean - OpSETL: {typer: boolTyper}, + OpSETL: {}, // ops for load/store to stack OpLoadFP8: {asm: "MOVQ\t%A(FP),%O0"}, diff --git a/src/cmd/internal/ssa/op_string.go b/src/cmd/internal/ssa/op_string.go index 9aee7de43e..dba1725262 100644 --- a/src/cmd/internal/ssa/op_string.go +++ b/src/cmd/internal/ssa/op_string.go @@ -4,9 +4,9 @@ package ssa import "fmt" -const _Op_name = "OpUnknownOpNopOpThunkOpAddOpSubOpMulOpLessOpConstNilOpConstBoolOpConstStringOpConstIntOpConstFloatOpConstComplexOpArgOpGlobalOpFuncOpCopyOpPhiOpSliceMakeOpSlicePtrOpSliceLenOpSliceCapOpStringMakeOpStringPtrOpStringLenOpSliceOpIndexOpIndexAddrOpLoadOpStoreOpCheckNilOpCheckBoundOpCallOpStaticCallOpConvertOpConvNopOpFPAddrOpSPAddrOpLoadFPOpLoadSPOpStoreFPOpStoreSPOpStoreReg8OpLoadReg8OpADDQOpSUBQOpADDCQOpSUBCQOpNEGQOpCMPQOpCMPCQOpADDLOpSETLOpSETGEOpInvertFlagsOpLEAQOpLEAQ2OpLEAQ4OpLEAQ8OpLoadFP8OpLoadSP8OpStoreFP8OpStoreSP8OpMax" +const _Op_name = "OpUnknownOpNopOpThunkOpAddOpSubOpMulOpLessOpConstOpArgOpGlobalOpFuncOpCopyOpPhiOpSliceMakeOpSlicePtrOpSliceLenOpSliceCapOpStringMakeOpStringPtrOpStringLenOpSliceOpIndexOpIndexAddrOpLoadOpStoreOpCheckNilOpCheckBoundOpCallOpStaticCallOpConvertOpConvNopOpFPAddrOpSPAddrOpLoadFPOpLoadSPOpStoreFPOpStoreSPOpStoreReg8OpLoadReg8OpADDQOpSUBQOpADDCQOpSUBCQOpNEGQOpCMPQOpCMPCQOpADDLOpSETLOpSETGEOpInvertFlagsOpLEAQOpLEAQ2OpLEAQ4OpLEAQ8OpLoadFP8OpLoadSP8OpStoreFP8OpStoreSP8OpMax" -var _Op_index = [...]uint16{0, 9, 14, 21, 26, 31, 36, 42, 52, 63, 76, 86, 98, 112, 117, 125, 131, 137, 142, 153, 163, 173, 183, 195, 206, 217, 224, 231, 242, 248, 255, 265, 277, 283, 295, 304, 313, 321, 329, 337, 345, 354, 363, 374, 384, 390, 396, 403, 410, 416, 422, 429, 435, 441, 448, 461, 467, 474, 481, 488, 497, 506, 516, 526, 531} +var _Op_index = [...]uint16{0, 9, 14, 21, 26, 31, 36, 42, 49, 54, 62, 68, 74, 79, 90, 100, 110, 120, 132, 143, 154, 161, 168, 179, 185, 192, 202, 214, 220, 232, 241, 250, 258, 266, 274, 282, 291, 300, 311, 321, 327, 333, 340, 347, 353, 359, 366, 372, 378, 385, 398, 404, 411, 418, 425, 434, 443, 453, 463, 468} func (i Op) String() string { if i < 0 || i+1 >= Op(len(_Op_index)) { diff --git a/src/cmd/internal/ssa/rewrite.go b/src/cmd/internal/ssa/rewrite.go index 0d7c0c1c64..d22926e8f9 100644 --- a/src/cmd/internal/ssa/rewrite.go +++ b/src/cmd/internal/ssa/rewrite.go @@ -28,43 +28,36 @@ func applyRewrite(f *Func, r func(*Value) bool) { // Common functions called from rewriting rules func is64BitInt(t Type) bool { - return typeIdentical(t, TypeInt64) || - typeIdentical(t, TypeUint64) || - (typeIdentical(t, TypeInt) && intSize == 8) || - (typeIdentical(t, TypeUint) && intSize == 8) || - (typeIdentical(t, TypeUintptr) && ptrSize == 8) + if b, ok := t.Underlying().(*types.Basic); ok { + switch b.Kind() { + case types.Int64, types.Uint64: + return true + } + } + return false } func is32BitInt(t Type) bool { - return typeIdentical(t, TypeInt32) || - typeIdentical(t, TypeUint32) || - (typeIdentical(t, TypeInt) && intSize == 4) || - (typeIdentical(t, TypeUint) && intSize == 4) || - (typeIdentical(t, TypeUintptr) && ptrSize == 4) + if b, ok := t.Underlying().(*types.Basic); ok { + switch b.Kind() { + case types.Int32, types.Uint32: + return true + } + } + return false } func isSigned(t Type) bool { - return typeIdentical(t, TypeInt) || - typeIdentical(t, TypeInt8) || - typeIdentical(t, TypeInt16) || - typeIdentical(t, TypeInt32) || - typeIdentical(t, TypeInt64) -} - -func typeSize(t Type) int { - switch t { - case TypeInt32, TypeUint32: - return 4 - case TypeInt64, TypeUint64: - return 8 - case TypeUintptr: - return ptrSize - case TypeInt, TypeUint: - return intSize - default: - if _, ok := t.(*types.Pointer); ok { - return ptrSize + if b, ok := t.Underlying().(*types.Basic); ok { + switch b.Kind() { + case types.Int8, types.Int16, types.Int32, types.Int64: + return true } - panic("TODO: width of " + t.String()) } + return false +} + +var sizer types.Sizes = &types.StdSizes{int64(ptrSize), int64(ptrSize)} // TODO(khr): from config +func typeSize(t Type) int64 { + return sizer.Sizeof(t) } diff --git a/src/cmd/internal/ssa/rulegen/generic.rules b/src/cmd/internal/ssa/rulegen/generic.rules index 73e6e4a329..1fc1620c5c 100644 --- a/src/cmd/internal/ssa/rulegen/generic.rules +++ b/src/cmd/internal/ssa/rulegen/generic.rules @@ -3,7 +3,8 @@ // license that can be found in the LICENSE file. // constant folding -(Add (ConstInt [c]) (ConstInt [d])) && is64BitInt(t) -> (ConstInt [{c.(int64)+d.(int64)}]) +(Add (Const [c]) (Const [d])) && is64BitInt(t) && isSigned(t) -> (Const [{c.(int64)+d.(int64)}]) +(Add (Const [c]) (Const [d])) && is64BitInt(t) && !isSigned(t) -> (Const [{c.(uint64)+d.(uint64)}]) // load/store to stack (Load (FPAddr [offset]) mem) -> (LoadFP [offset] mem) diff --git a/src/cmd/internal/ssa/rulegen/lower_amd64.rules b/src/cmd/internal/ssa/rulegen/lower_amd64.rules index 525035b8c2..f60ac361ad 100644 --- a/src/cmd/internal/ssa/rulegen/lower_amd64.rules +++ b/src/cmd/internal/ssa/rulegen/lower_amd64.rules @@ -8,7 +8,8 @@ // on the matching side // - the types and aux fields must match if they are specified. // on the generated side -// - types will be computed by opcode typers if not specified explicitly. +// - 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. // - aux will be nil if not specified. // x86 register conventions: @@ -24,7 +25,7 @@ (Sub x y) && is64BitInt(t) -> (SUBQ x y) -(Less x y) && is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type) -> (SETL (CMPQ x y)) +(Less x y) && is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type) -> (SETL (CMPQ x y)) // stack loads/stores (LoadFP [offset] mem) && typeSize(t) == 8 -> (LoadFP8 [offset] mem) @@ -35,12 +36,12 @@ // Rules below here apply some simple optimizations after lowering. // TODO: Should this be a separate pass? -(ADDQ x (ConstInt [c])) -> (ADDCQ [c] x) // TODO: restrict c to int32 range? -(ADDQ (ConstInt [c]) x) -> (ADDCQ [c] x) -(SUBQ x (ConstInt [c])) -> (SUBCQ x [c]) -(SUBQ (ConstInt [c]) x) -> (NEGQ (SUBCQ x [c])) -(CMPQ x (ConstInt [c])) -> (CMPCQ x [c]) -(CMPQ (ConstInt [c]) x) -> (InvertFlags (CMPCQ x [c])) +(ADDQ x (Const [c])) -> (ADDCQ [c] x) // TODO: restrict c to int32 range? +(ADDQ (Const [c]) x) -> (ADDCQ [c] x) +(SUBQ x (Const [c])) -> (SUBCQ x [c]) +(SUBQ (Const [c]) x) -> (NEGQ (SUBCQ x [c])) +(CMPQ x (Const [c])) -> (CMPCQ x [c]) +(CMPQ (Const [c]) x) -> (InvertFlags (CMPCQ x [c])) // reverse ordering of compare instruction (SETL (InvertFlags x)) -> (SETGE x) diff --git a/src/cmd/internal/ssa/rulegen/rulegen.go b/src/cmd/internal/ssa/rulegen/rulegen.go index f125828f64..4038662ca8 100644 --- a/src/cmd/internal/ssa/rulegen/rulegen.go +++ b/src/cmd/internal/ssa/rulegen/rulegen.go @@ -17,6 +17,7 @@ import ( "fmt" "go/format" "io" + "io/ioutil" "log" "os" "sort" @@ -148,22 +149,14 @@ func main() { } // Write to a file if given, otherwise stdout. - var out io.WriteCloser if len(os.Args) >= 4 { - outfile := os.Args[3] - out, err = os.Create(outfile) - if err != nil { - log.Fatalf("can't open output file %s: %v\n", outfile, err) - } + err = ioutil.WriteFile(os.Args[3], b, 0666) } else { - out = os.Stdout + _, err = os.Stdout.Write(b) } - if _, err = out.Write(b); err != nil { + if err != nil { log.Fatalf("can't write output: %v\n", err) } - if err = out.Close(); err != nil { - log.Fatalf("can't close output: %v\n", err) - } } func genMatch(w io.Writer, match, fail string) { @@ -251,17 +244,17 @@ func genResult0(w io.Writer, result string, alloc *int, top bool) string { s := split(result[1 : len(result)-1]) var v string - var needsType bool + var hasType bool if top { v = "v" fmt.Fprintf(w, "v.Op = Op%s\n", s[0]) fmt.Fprintf(w, "v.Aux = nil\n") fmt.Fprintf(w, "v.Args = v.argstorage[:0]\n") + hasType = true } else { v = fmt.Sprintf("v%d", *alloc) *alloc++ fmt.Fprintf(w, "%s := v.Block.NewValue(Op%s, TypeInvalid, nil)\n", v, s[0]) - needsType = true } for _, a := range s[1:] { if a[0] == '<' { @@ -271,7 +264,7 @@ func genResult0(w io.Writer, result string, alloc *int, top bool) string { t = t[1 : len(t)-1] } fmt.Fprintf(w, "%s.Type = %s\n", v, t) - needsType = false + hasType = true } else if a[0] == '[' { // aux restriction x := a[1 : len(a)-1] @@ -287,8 +280,8 @@ func genResult0(w io.Writer, result string, alloc *int, top bool) string { fmt.Fprintf(w, "%s.AddArg(%s)\n", v, x) } } - if needsType { - fmt.Fprintf(w, "%s.SetType()\n", v) + if !hasType { + log.Fatalf("sub-expression %s must have a type", result) } return v } diff --git a/src/cmd/internal/ssa/ssac/main.go b/src/cmd/internal/ssa/ssac/main.go index 4975b50db4..361bc87bff 100644 --- a/src/cmd/internal/ssa/ssac/main.go +++ b/src/cmd/internal/ssa/ssac/main.go @@ -411,7 +411,8 @@ func parseSexprType(e sexpr) ssa.Type { if !e.compound { switch e.name { case "int": - return ssa.TypeInt + // TODO: pick correct width + return ssa.TypeInt64 default: fmt.Println(e.name) panic("unknown type") diff --git a/src/cmd/internal/ssa/type.go b/src/cmd/internal/ssa/type.go index e9c017d38a..98efe54133 100644 --- a/src/cmd/internal/ssa/type.go +++ b/src/cmd/internal/ssa/type.go @@ -13,25 +13,33 @@ type Type types.Type var ( // shortcuts for commonly used basic types - TypeInt = types.Typ[types.Int] - TypeUint = types.Typ[types.Uint] - TypeInt8 = types.Typ[types.Int8] - TypeInt16 = types.Typ[types.Int16] - TypeInt32 = types.Typ[types.Int32] - TypeInt64 = types.Typ[types.Int64] - TypeUint8 = types.Typ[types.Uint8] - TypeUint16 = types.Typ[types.Uint16] - TypeUint32 = types.Typ[types.Uint32] - TypeUint64 = types.Typ[types.Uint64] - TypeUintptr = types.Typ[types.Uintptr] - TypeBool = types.Typ[types.Bool] - TypeString = types.Typ[types.String] + //TypeInt = types.Typ[types.Int] + //TypeUint = types.Typ[types.Uint] + TypeInt8 = types.Typ[types.Int8] + TypeInt16 = types.Typ[types.Int16] + TypeInt32 = types.Typ[types.Int32] + TypeInt64 = types.Typ[types.Int64] + TypeUint8 = types.Typ[types.Uint8] + TypeUint16 = types.Typ[types.Uint16] + TypeUint32 = types.Typ[types.Uint32] + TypeUint64 = types.Typ[types.Uint64] + //TypeUintptr = types.Typ[types.Uintptr] + TypeBool = types.Typ[types.Bool] + TypeString = types.Typ[types.String] TypeInvalid = types.Typ[types.Invalid] // Additional compiler-only types go here. TypeMem = &Memory{} TypeFlags = &Flags{} + + // TODO(khr): we probably shouldn't use int/uint/uintptr as Value types in the compiler. + // In OpConst's case, their width is the compiler's width, not the to-be-compiled + // program's width. For now, we can translate int/uint/uintptr to their specific + // widths variants before SSA. + // However, we may need at some point to maintain all possible user types in the + // compiler to handle things like interface conversion. At that point, we may + // need to revisit this decision. ) // typeIdentical reports whether its two arguments are the same type. diff --git a/src/cmd/internal/ssa/types/sizes.go b/src/cmd/internal/ssa/types/sizes.go new file mode 100644 index 0000000000..b52f636fc5 --- /dev/null +++ b/src/cmd/internal/ssa/types/sizes.go @@ -0,0 +1,117 @@ +// 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. + +// This file implements Sizes. + +package types + +import "log" + +// Sizes defines the sizing functions for package unsafe. +type Sizes interface { + // Alignof returns the alignment of a variable of type T. + // Alignof must implement the alignment guarantees required by the spec. + Alignof(T Type) int64 + + // Offsetsof returns the offsets of the given struct fields, in bytes. + // Offsetsof must implement the offset guarantees required by the spec. + Offsetsof(fields []*Var) []int64 + + // Sizeof returns the size of a variable of type T. + // Sizeof must implement the size guarantees required by the spec. + Sizeof(T Type) int64 +} + +// StdSizes is a convenience type for creating commonly used Sizes. +// It makes the following simplifying assumptions: +// +// - The size of explicitly sized basic types (int16, etc.) is the +// specified size. +// - The size of strings and interfaces is 2*WordSize. +// - The size of slices is 3*WordSize. +// - The size of an array of n elements corresponds to the size of +// a struct of n consecutive fields of the array's element type. +// - The size of a struct is the offset of the last field plus that +// field's size. As with all element types, if the struct is used +// in an array its size must first be aligned to a multiple of the +// struct's alignment. +// - All other types have size WordSize. +// - Arrays and structs are aligned per spec definition; all other +// types are naturally aligned with a maximum alignment MaxAlign. +// +// *StdSizes implements Sizes. +// +type StdSizes struct { + WordSize int64 // word size in bytes - must be >= 4 (32bits) + MaxAlign int64 // maximum alignment in bytes - must be >= 1 +} + +func (s *StdSizes) Alignof(T Type) int64 { + a := s.Sizeof(T) // may be 0 + // spec: "For a variable x of any type: unsafe.Alignof(x) is at least 1." + if a < 1 { + return 1 + } + if a > s.MaxAlign { + return s.MaxAlign + } + return a +} + +func (s *StdSizes) Offsetsof(fields []*Var) []int64 { + offsets := make([]int64, len(fields)) + var o int64 + for i, f := range fields { + a := s.Alignof(f.typ) + o = align(o, a) + offsets[i] = o + o += s.Sizeof(f.typ) + } + return offsets +} + +var basicSizes = [...]byte{ + Bool: 1, + Int8: 1, + Int16: 2, + Int32: 4, + Int64: 8, + Uint8: 1, + Uint16: 2, + Uint32: 4, + Uint64: 8, + Float32: 4, + Float64: 8, + Complex64: 8, + Complex128: 16, +} + +func (s *StdSizes) Sizeof(T Type) int64 { + switch t := T.Underlying().(type) { + case *Basic: + k := t.kind + if int(k) < len(basicSizes) { + if s := basicSizes[k]; s > 0 { + return int64(s) + } + } + if k == String { + return s.WordSize * 2 + } + case *Slice: + return s.WordSize * 3 + default: + log.Fatalf("not implemented") + } + return s.WordSize // catch-all +} + +// stdSizes is used if Config.Sizes == nil. +var stdSizes = StdSizes{8, 8} + +// align returns the smallest y >= x such that y % a == 0. +func align(x, a int64) int64 { + y := x + a - 1 + return y - y%a +} diff --git a/src/cmd/internal/ssa/value.go b/src/cmd/internal/ssa/value.go index f6f099cd32..389ba1ff77 100644 --- a/src/cmd/internal/ssa/value.go +++ b/src/cmd/internal/ssa/value.go @@ -40,8 +40,8 @@ type Value struct { // Examples: // Opcode aux args // OpAdd nil 2 -// OpConstStr string 0 -// OpConstInt int64 0 +// OpConst string 0 string constant +// OpConst int64 0 int64 constant // OpAddcq int64 1 amd64 op: v = arg[0] + constant // short form print. Just v#. @@ -113,12 +113,3 @@ func (v *Value) CopyFrom(w *Value) { v.resetArgs() v.AddArgs(w.Args...) } - -// SetType sets the type of v. v must not have had its type -// set yet (it must be TypeInvalid). -func (v *Value) SetType() { - if v.Type != TypeInvalid { - panic("setting type when it is already set") - } - opcodeTable[v.Op].typer(v) -} -- cgit v1.3 From 149671dfc30889b72254a7a43ba515783b4c5bf7 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Fri, 27 Mar 2015 13:41:30 -0700 Subject: [dev.ssa] cmd/internal/ssa: add CSE pass Implement a simple common-subexpression elimination. It uses value numbering & a dominator tree to detect redundant computation. Change-Id: Id0ff775e439c22f4d41bdd5976176017dd2a2086 Reviewed-on: https://go-review.googlesource.com/8172 Reviewed-by: Alan Donovan --- src/cmd/internal/ssa/compile.go | 7 +- src/cmd/internal/ssa/cse.go | 163 ++++++++++++++++++++++++++++++++++++++++ src/cmd/internal/ssa/dom.go | 121 +++++++++++++++++++++++++++++ src/cmd/internal/ssa/lower.go | 1 - 4 files changed, 288 insertions(+), 4 deletions(-) create mode 100644 src/cmd/internal/ssa/cse.go create mode 100644 src/cmd/internal/ssa/dom.go (limited to 'src/cmd') diff --git a/src/cmd/internal/ssa/compile.go b/src/cmd/internal/ssa/compile.go index 6103cc9557..08477d470c 100644 --- a/src/cmd/internal/ssa/compile.go +++ b/src/cmd/internal/ssa/compile.go @@ -54,11 +54,12 @@ var passes = [...]pass{ {"phielim", phielim}, {"copyelim", copyelim}, {"opt", opt}, - // cse - {"deadcode", deadcode}, + {"generic cse", cse}, + {"generic deadcode", deadcode}, {"fuse", fuse}, {"lower", lower}, - // cse + {"lowered cse", cse}, + {"lowered deadcode", deadcode}, {"critical", critical}, // remove critical edges {"layout", layout}, // schedule blocks {"schedule", schedule}, // schedule values diff --git a/src/cmd/internal/ssa/cse.go b/src/cmd/internal/ssa/cse.go new file mode 100644 index 0000000000..71f23013cf --- /dev/null +++ b/src/cmd/internal/ssa/cse.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 + +import ( + "sort" +) + +// 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 + // len(v.args) == len(w.args) + // 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 partition based on opcode/type/aux/nargs + // TODO(khr): types are not canonical, so we may split unnecessarily. Fix that. + type key struct { + op Op + typ Type + aux interface{} + nargs int + } + m := map[key]eqclass{} + for _, b := range f.Blocks { + for _, v := range b.Values { + k := key{v.Op, v.Type, v.Aux, len(v.Args)} + m[k] = append(m[k], v) + } + } + + // A partition is a set of disjoint eqclasses. + var partition []eqclass + for _, v := range m { + partition = append(partition, v) + } + + // map from value id back to eqclass id + valueEqClass := make([]int, f.NumValues()) + for i, e := range partition { + for _, v := range e { + valueEqClass[v.ID] = i + } + } + + // Find an equivalence class where some members of the class have + // non-equvalent arguments. Split the equivalence class appropriately. + // Repeat until we can't find any more splits. + for { + changed := false + + for i, e := range partition { + v := e[0] + // all values in this equiv class that are not equivalent to v get moved + // into another equiv class q. + var q eqclass + eqloop: + for j := 1; j < len(e); { + w := e[j] + for i := 0; i < len(v.Args); i++ { + if valueEqClass[v.Args[i].ID] != valueEqClass[w.Args[i].ID] { + // w is not equivalent to v. + // remove w from e + e, e[j] = e[:len(e)-1], e[len(e)-1] + // add w to q + q = append(q, w) + valueEqClass[w.ID] = len(partition) + changed = true + continue eqloop + } + } + // v and w are equivalent. Keep w in e. + j++ + } + partition[i] = e + if q != nil { + partition = append(partition, q) + } + } + + if !changed { + break + } + } + + // Compute dominator tree + idom := dominators(f) + + // 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 { + sort.Sort(e) // ensure deterministic ordering + for len(e) > 1 { + // Find a maximal dominant element in e + v := e[0] + for _, w := range e[1:] { + if dom(w.Block, v.Block, idom) { + v = w + } + } + + // Replace all elements of e which v dominates + for i := 0; i < len(e); { + w := e[i] + if w != v && dom(v.Block, w.Block, idom) { + rewrite[w.ID] = v + e, e[i] = e[:len(e)-1], e[len(e)-1] + } else { + i++ + } + } + // TODO(khr): if value is a control value, do we need to keep it block-local? + } + } + + // 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) + } + } + } + } +} + +// returns true if b dominates c. +// TODO(khr): faster +func dom(b, c *Block, idom []*Block) bool { + // Walk up from c in the dominator tree looking for b. + for c != nil { + if c == b { + return true + } + c = idom[c.ID] + } + // Reached the entry block, never saw b. + return false +} + +// An eqclass approximates an equivalence class. During the +// algorithm it may represent the union of several of the +// final equivalence classes. +type eqclass []*Value + +// Sort an equivalence class by value ID. +func (e eqclass) Len() int { return len(e) } +func (e eqclass) Swap(i, j int) { e[i], e[j] = e[j], e[i] } +func (e eqclass) Less(i, j int) bool { return e[i].ID < e[j].ID } diff --git a/src/cmd/internal/ssa/dom.go b/src/cmd/internal/ssa/dom.go new file mode 100644 index 0000000000..aaf3ab3da1 --- /dev/null +++ b/src/cmd/internal/ssa/dom.go @@ -0,0 +1,121 @@ +// 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 + +// This file contains code to compute the dominator tree +// of a control-flow graph. + +import "log" + +// 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()) + // 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 + ) + + // 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: + log.Fatalf("bad stack state %v %d", b, mark[b.ID]) + } + } + return order +} + +// 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 { + // 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 { + log.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 { + 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/internal/ssa/lower.go b/src/cmd/internal/ssa/lower.go index 7d97b0b466..18fe9861a6 100644 --- a/src/cmd/internal/ssa/lower.go +++ b/src/cmd/internal/ssa/lower.go @@ -39,5 +39,4 @@ func lower(f *Func) { // TODO: others } } - deadcode(f) // TODO: separate pass? } -- cgit v1.3 From 412944484c775d86d677e1dce38b923e27b437b0 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Tue, 31 Mar 2015 15:37:25 -0700 Subject: [dev.ssa] cmd/internal/ssa: fix typo Change-Id: I2209da94f1fd76267847d8d599e17f9d9a296ed3 Reviewed-on: https://go-review.googlesource.com/8320 Reviewed-by: Alan Donovan --- src/cmd/internal/ssa/cse.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/internal/ssa/cse.go b/src/cmd/internal/ssa/cse.go index 71f23013cf..c44b08f61c 100644 --- a/src/cmd/internal/ssa/cse.go +++ b/src/cmd/internal/ssa/cse.go @@ -56,7 +56,7 @@ func cse(f *Func) { } // Find an equivalence class where some members of the class have - // non-equvalent arguments. Split the equivalence class appropriately. + // non-equivalent arguments. Split the equivalence class appropriately. // Repeat until we can't find any more splits. for { changed := false -- cgit v1.3 From d2fd43aa770094e579bc394946e2ce9c75a44417 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Wed, 15 Apr 2015 15:51:25 -0700 Subject: [dev.ssa] cmd/internal/gc: convert standard IR into SSA. Hook into the current compiler to convert the existing IR (after walk) into SSA. Any function ending in "_ssa" will take this path. The resulting assembly is printed and then discarded. Use gc.Type directly in ssa instead of a wrapper for go types. It makes the IR->SSA rewrite a lot simpler. Only a few opcodes are implemented in this change. It is enough to compile simple examples like func f(p *int) int { return *p } func g(a []int, i int) int { return a[i] } Change-Id: I5e18841b752a83ca0519aa1b2d36ef02ce1de6f9 Reviewed-on: https://go-review.googlesource.com/8971 Reviewed-by: Alan Donovan --- src/cmd/dist/buildtool.go | 1 + src/cmd/internal/gc/pgen.go | 9 + src/cmd/internal/gc/ssa.go | 450 ++++++++++++++++++++ src/cmd/internal/gc/type.go | 62 +++ src/cmd/internal/ssa/cgen.go | 49 ++- src/cmd/internal/ssa/check.go | 1 - src/cmd/internal/ssa/config.go | 48 +++ src/cmd/internal/ssa/cse.go | 8 +- src/cmd/internal/ssa/deadcode.go | 1 + src/cmd/internal/ssa/deadcode_test.go | 6 +- src/cmd/internal/ssa/func.go | 51 ++- src/cmd/internal/ssa/fuse.go | 3 + src/cmd/internal/ssa/generic.go | 144 ++++--- src/cmd/internal/ssa/id.go | 2 - src/cmd/internal/ssa/lower.go | 30 +- src/cmd/internal/ssa/lowerAmd64.go | 548 ++++++++++++++++++++----- src/cmd/internal/ssa/op.go | 79 ++-- src/cmd/internal/ssa/op_string.go | 4 +- src/cmd/internal/ssa/rewrite.go | 43 +- src/cmd/internal/ssa/rulegen/generic.rules | 14 +- src/cmd/internal/ssa/rulegen/lower_amd64.rules | 51 ++- src/cmd/internal/ssa/rulegen/rulegen.go | 16 +- src/cmd/internal/ssa/ssac/main.go | 90 ++-- src/cmd/internal/ssa/type.go | 128 +++--- src/cmd/internal/ssa/types/object.go | 39 -- src/cmd/internal/ssa/types/sizes.go | 117 ------ src/cmd/internal/ssa/types/type.go | 229 ----------- src/cmd/internal/ssa/value.go | 12 - 28 files changed, 1458 insertions(+), 777 deletions(-) create mode 100644 src/cmd/internal/gc/ssa.go create mode 100644 src/cmd/internal/gc/type.go create mode 100644 src/cmd/internal/ssa/config.go delete mode 100644 src/cmd/internal/ssa/types/object.go delete mode 100644 src/cmd/internal/ssa/types/sizes.go delete mode 100644 src/cmd/internal/ssa/types/type.go (limited to 'src/cmd') diff --git a/src/cmd/dist/buildtool.go b/src/cmd/dist/buildtool.go index 69e077c002..daaf66c596 100644 --- a/src/cmd/dist/buildtool.go +++ b/src/cmd/dist/buildtool.go @@ -46,6 +46,7 @@ var bootstrapDirs = []string{ "internal/obj/arm64", "internal/obj/ppc64", "internal/obj/x86", + "internal/ssa", "old5a", "old6a", "old8a", diff --git a/src/cmd/internal/gc/pgen.go b/src/cmd/internal/gc/pgen.go index b6c9f30b98..78b41eef4d 100644 --- a/src/cmd/internal/gc/pgen.go +++ b/src/cmd/internal/gc/pgen.go @@ -418,6 +418,15 @@ func compile(fn *Node) { goto ret } + // Build an SSA backend function + { + name := Curfn.Nname.Sym.Name + if len(name) > 4 && name[len(name)-4:] == "_ssa" { + buildssa(Curfn) + // TODO(khr): use result of buildssa + } + } + continpc = nil breakpc = nil diff --git a/src/cmd/internal/gc/ssa.go b/src/cmd/internal/gc/ssa.go new file mode 100644 index 0000000000..415e9dc639 --- /dev/null +++ b/src/cmd/internal/gc/ssa.go @@ -0,0 +1,450 @@ +// 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 ( + "log" + + "cmd/internal/ssa" +) + +func buildssa(fn *Node) { + dumplist("buildssa", Curfn.Nbody) + + var s ssaState + + // TODO(khr): build config just once at the start of the compiler binary + s.config = ssa.NewConfig(Thearch.Thestring) + s.f = s.config.NewFunc() + s.f.Name = fn.Nname.Sym.Name + + // We construct SSA using an algorithm similar to + // Brau, Buchwald, Hack, Leißa, Mallon, and Zwinkau + // http://pp.info.uni-karlsruhe.de/uploads/publikationen/braun13cc.pdf + // TODO: check this comment + + // Allocate starting block + s.f.Entry = s.f.NewBlock(ssa.BlockPlain) + + // Allocate exit block + s.exit = s.f.NewBlock(ssa.BlockExit) + + // TODO(khr): all args. Make a struct containing args/returnvals, declare + // an FP which contains a pointer to that struct. + + s.vars = map[string]*ssa.Value{} + s.labels = map[string]*ssa.Block{} + s.argOffsets = map[string]int64{} + + // Convert the AST-based IR to the SSA-based IR + s.startBlock(s.f.Entry) + s.stmtList(fn.Nbody) + + // Finish up exit block + s.startBlock(s.exit) + s.exit.Control = s.mem() + s.endBlock() + + // Link up variable uses to variable definitions + s.linkForwardReferences() + + ssa.Compile(s.f) + + // TODO(khr): Use the resulting s.f to generate code +} + +type ssaState struct { + // configuration (arch) information + config *ssa.Config + + // function we're building + f *ssa.Func + + // exit block that "return" jumps to (and panics jump to) + exit *ssa.Block + + // the target block for each label in f + labels map[string]*ssa.Block + + // current location where we're interpreting the AST + curBlock *ssa.Block + + // variable assignments in the current block (map from variable name to ssa value) + vars map[string]*ssa.Value + + // all defined variables at the end of each block. Indexed by block ID. + defvars []map[string]*ssa.Value + + // offsets of argument slots + // unnamed and unused args are not listed. + argOffsets map[string]int64 +} + +// startBlock sets the current block we're generating code in to b. +func (s *ssaState) startBlock(b *ssa.Block) { + s.curBlock = b + s.vars = map[string]*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 *ssaState) 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 + return b +} + +// ssaStmtList converts the statement n to SSA and adds it to s. +func (s *ssaState) 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 *ssaState) stmt(n *Node) { + s.stmtList(n.Ninit) + switch n.Op { + + case OBLOCK: + s.stmtList(n.List) + + case ODCL: + // TODO: ??? Assign 0? + + case OLABEL, OGOTO: + // get block at label, or make one + t := s.labels[n.Left.Sym.Name] + if t == nil { + t = s.f.NewBlock(ssa.BlockPlain) + s.labels[n.Left.Sym.Name] = t + } + // go to that label (we pretend "label:" is preceded by "goto label") + b := s.endBlock() + addEdge(b, t) + + if n.Op == OLABEL { + // next we work on the label's target block + s.startBlock(t) + } + + case OAS: + // TODO(khr): colas? + val := s.expr(n.Right) + if n.Left.Op == OINDREG { + // indirect off a register (TODO: always SP?) + // used for storing arguments to callees + addr := s.f.Entry.NewValue(ssa.OpSPAddr, Ptrto(n.Right.Type), n.Left.Xoffset) + s.vars[".mem"] = s.curBlock.NewValue3(ssa.OpStore, ssa.TypeMem, nil, addr, val, s.mem()) + } else if n.Left.Op != ONAME { + // some more complicated expression. Rewrite to a store. TODO + addr := s.expr(n.Left) // TODO: wrap in & + + // TODO(khr): nil check + s.vars[".mem"] = s.curBlock.NewValue3(ssa.OpStore, n.Right.Type, nil, addr, val, s.mem()) + } else if n.Left.Addable == 0 { + // TODO + log.Fatalf("assignment to non-addable value") + } else if n.Left.Class&PHEAP != 0 { + // TODO + log.Fatalf("assignment to heap value") + } else if n.Left.Class == PPARAMOUT { + // store to parameter slot + addr := s.f.Entry.NewValue(ssa.OpFPAddr, Ptrto(n.Right.Type), n.Left.Xoffset) + s.vars[".mem"] = s.curBlock.NewValue3(ssa.OpStore, ssa.TypeMem, nil, addr, val, s.mem()) + } else { + // normal variable + s.vars[n.Left.Sym.Name] = val + } + case OIF: + cond := s.expr(n.Ntest) + b := s.endBlock() + b.Kind = ssa.BlockIf + b.Control = cond + // TODO(khr): likely direction + + bThen := s.f.NewBlock(ssa.BlockPlain) + bEnd := s.f.NewBlock(ssa.BlockPlain) + var bElse *ssa.Block + + if n.Nelse == nil { + addEdge(b, bThen) + addEdge(b, bEnd) + } else { + bElse = s.f.NewBlock(ssa.BlockPlain) + addEdge(b, bThen) + addEdge(b, bElse) + } + + s.startBlock(bThen) + s.stmtList(n.Nbody) + b = s.endBlock() + if b != nil { + addEdge(b, bEnd) + } + + if n.Nelse != nil { + s.startBlock(bElse) + s.stmtList(n.Nelse) + b = s.endBlock() + if b != nil { + addEdge(b, bEnd) + } + } + s.startBlock(bEnd) + + case ORETURN: + s.stmtList(n.List) + b := s.endBlock() + addEdge(b, s.exit) + + case OFOR: + bCond := s.f.NewBlock(ssa.BlockPlain) + bBody := s.f.NewBlock(ssa.BlockPlain) + bEnd := s.f.NewBlock(ssa.BlockPlain) + + // first, jump to condition test + b := s.endBlock() + addEdge(b, bCond) + + // generate code to test condition + // TODO(khr): Ntest == nil exception + s.startBlock(bCond) + cond := s.expr(n.Ntest) + b = s.endBlock() + b.Kind = ssa.BlockIf + b.Control = cond + // TODO(khr): likely direction + addEdge(b, bBody) + addEdge(b, bEnd) + + // generate body + s.startBlock(bBody) + s.stmtList(n.Nbody) + s.stmt(n.Nincr) + b = s.endBlock() + addEdge(b, bCond) + + s.startBlock(bEnd) + + case OVARKILL: + // TODO(khr): ??? anything to do here? Only for addrtaken variables? + // Maybe just link it in the store chain? + default: + log.Fatalf("unhandled stmt %s", opnames[n.Op]) + } +} + +// expr converts the expression n to ssa, adds it to s and returns the ssa result. +func (s *ssaState) expr(n *Node) *ssa.Value { + if n == nil { + // TODO(khr): is this nil??? + return s.f.Entry.NewValue(ssa.OpConst, n.Type, nil) + } + switch n.Op { + case ONAME: + // remember offsets for PPARAM names + s.argOffsets[n.Sym.Name] = n.Xoffset + return s.variable(n.Sym.Name, n.Type) + // binary ops + case OLITERAL: + switch n.Val.Ctype { + case CTINT: + return s.f.ConstInt(n.Type, Mpgetfix(n.Val.U.Xval)) + default: + log.Fatalf("unhandled OLITERAL %v", n.Val.Ctype) + return nil + } + case OLT: + a := s.expr(n.Left) + b := s.expr(n.Right) + return s.curBlock.NewValue2(ssa.OpLess, ssa.TypeBool, nil, a, b) + case OADD: + a := s.expr(n.Left) + b := s.expr(n.Right) + return s.curBlock.NewValue2(ssa.OpAdd, a.Type, nil, a, b) + + case OSUB: + // TODO:(khr) fold code for all binary ops together somehow + a := s.expr(n.Left) + b := s.expr(n.Right) + return s.curBlock.NewValue2(ssa.OpSub, a.Type, nil, a, b) + + case OIND: + p := s.expr(n.Left) + c := s.curBlock.NewValue1(ssa.OpCheckNil, ssa.TypeBool, nil, p) + b := s.endBlock() + b.Kind = ssa.BlockIf + b.Control = c + bNext := s.f.NewBlock(ssa.BlockPlain) + addEdge(b, bNext) + addEdge(b, s.exit) + s.startBlock(bNext) + // TODO(khr): if ptr check fails, don't go directly to exit. + // Instead, go to a call to panicnil or something. + // TODO: implicit nil checks somehow? + + return s.curBlock.NewValue2(ssa.OpLoad, n.Type, nil, p, s.mem()) + case ODOTPTR: + p := s.expr(n.Left) + // TODO: nilcheck + p = s.curBlock.NewValue2(ssa.OpAdd, p.Type, nil, p, s.f.ConstInt(s.config.UIntPtr, n.Xoffset)) + return s.curBlock.NewValue2(ssa.OpLoad, n.Type, nil, p, s.mem()) + + case OINDEX: + // TODO: slice vs array? Map index is already reduced to a function call + a := s.expr(n.Left) + i := s.expr(n.Right) + // 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 (and use a low32 op instead of convnop here). + i = s.curBlock.NewValue1(ssa.OpConvNop, s.config.UIntPtr, nil, i) + + // bounds check + len := s.curBlock.NewValue1(ssa.OpSliceLen, s.config.UIntPtr, nil, a) + cmp := s.curBlock.NewValue2(ssa.OpCheckBound, ssa.TypeBool, nil, i, len) + b := s.endBlock() + b.Kind = ssa.BlockIf + b.Control = cmp + bNext := s.f.NewBlock(ssa.BlockPlain) + addEdge(b, bNext) + addEdge(b, s.exit) + s.startBlock(bNext) + // TODO: don't go directly to s.exit. Go to a stub that calls panicindex first. + + return s.curBlock.NewValue3(ssa.OpSliceIndex, n.Left.Type.Type, nil, a, i, s.mem()) + + case OCALLFUNC: + // run all argument assignments + // TODO(khr): do we need to evaluate function first? + // Or is it already side-effect-free and does not require a call? + s.stmtList(n.List) + + if n.Left.Op != ONAME { + // TODO(khr): closure calls? + log.Fatalf("can't handle CALLFUNC with non-ONAME fn %s", opnames[n.Left.Op]) + } + bNext := s.f.NewBlock(ssa.BlockPlain) + call := s.curBlock.NewValue1(ssa.OpStaticCall, ssa.TypeMem, n.Left.Sym.Name, s.mem()) + b := s.endBlock() + b.Kind = ssa.BlockCall + b.Control = call + addEdge(b, bNext) + addEdge(b, s.exit) + + // read result from stack at the start of the fallthrough block + s.startBlock(bNext) + var titer Iter + fp := Structfirst(&titer, Getoutarg(n.Left.Type)) + a := s.f.Entry.NewValue(ssa.OpSPAddr, Ptrto(fp.Type), fp.Width) + return s.curBlock.NewValue2(ssa.OpLoad, fp.Type, nil, a, call) + default: + log.Fatalf("unhandled expr %s", opnames[n.Op]) + return nil + } +} + +// variable returns the value of a variable at the current location. +func (s *ssaState) variable(name string, t ssa.Type) *ssa.Value { + if s.curBlock == nil { + log.Fatalf("nil curblock!") + } + v := s.vars[name] + if v == nil { + // TODO: get type? Take Sym as arg? + v = s.curBlock.NewValue(ssa.OpFwdRef, t, name) + s.vars[name] = v + } + return v +} + +func (s *ssaState) mem() *ssa.Value { + return s.variable(".mem", ssa.TypeMem) +} + +func (s *ssaState) 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 Brau, Buchwald, Hack, Leißa, Mallon, and Zwinkau: + // http://pp.info.uni-karlsruhe.de/uploads/publikationen/braun13cc.pdf + for _, b := range s.f.Blocks { + for _, v := range b.Values { + if v.Op != ssa.OpFwdRef { + continue + } + name := v.Aux.(string) + v.Op = ssa.OpCopy + v.Aux = nil + v.SetArgs1(s.lookupVarIncoming(b, v.Type, name)) + } + } +} + +// lookupVarIncoming finds the variable's value at the start of block b. +func (s *ssaState) lookupVarIncoming(b *ssa.Block, t ssa.Type, name string) *ssa.Value { + // TODO(khr): have lookupVarIncoming overwrite the fwdRef or copy it + // will be used in, instead of having the result used in a copy value. + if b == s.f.Entry { + if name == ".mem" { + return b.NewValue(ssa.OpArg, t, name) + } + // variable is live at the entry block. Load it. + a := s.f.Entry.NewValue(ssa.OpFPAddr, Ptrto(t.(*Type)), s.argOffsets[name]) + m := b.NewValue(ssa.OpArg, ssa.TypeMem, ".mem") // TODO: reuse mem starting value + return b.NewValue2(ssa.OpLoad, t, nil, a, m) + } + var vals []*ssa.Value + for _, p := range b.Preds { + vals = append(vals, s.lookupVarOutgoing(p, t, name)) + } + v0 := vals[0] + for i := 1; i < len(vals); i++ { + if vals[i] != v0 { + // need a phi value + v := b.NewValue(ssa.OpPhi, t, nil) + v.AddArgs(vals...) + return v + } + } + return v0 +} + +// lookupVarOutgoing finds the variable's value at the end of block b. +func (s *ssaState) lookupVarOutgoing(b *ssa.Block, t ssa.Type, name string) *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 v, a copy value which + // will be the outgoing value of the variable. Then + // look up w, the incoming value of the variable. + // Make v = copy(w). We need the extra copy to + // prevent infinite recursion when looking up the + // incoming value of the variable. + v := b.NewValue(ssa.OpCopy, t, nil) + m[name] = v + v.AddArg(s.lookupVarIncoming(b, t, name)) + return v +} + +// TODO: the above mutually recursive functions can lead to very deep stacks. Fix that. + +// addEdge adds an edge from b to c. +func addEdge(b, c *ssa.Block) { + b.Succs = append(b.Succs, c) + c.Preds = append(c.Preds, b) +} diff --git a/src/cmd/internal/gc/type.go b/src/cmd/internal/gc/type.go new file mode 100644 index 0000000000..e88ca7c898 --- /dev/null +++ b/src/cmd/internal/gc/type.go @@ -0,0 +1,62 @@ +// 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/internal/ssa" +) + +func (t *Type) Size() int64 { + dowidth(t) + return t.Width +} + +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) IsPtr() bool { + return t.Etype == TPTR32 || t.Etype == TPTR64 || + t.Etype == TMAP || t.Etype == TCHAN || t.Etype == TFUNC +} + +func (t *Type) Elem() ssa.Type { + return t.Type +} +func (t *Type) PtrTo() ssa.Type { + return Ptrto(t) +} + +func (t *Type) IsMemory() bool { return false } +func (t *Type) IsFlags() bool { return false } + +func (t *Type) String() string { + return typefmt(t, 0) +} diff --git a/src/cmd/internal/ssa/cgen.go b/src/cmd/internal/ssa/cgen.go index 4b1a90b89d..c13e715653 100644 --- a/src/cmd/internal/ssa/cgen.go +++ b/src/cmd/internal/ssa/cgen.go @@ -4,7 +4,11 @@ package ssa -import "fmt" +import ( + "bytes" + "fmt" + "os" +) // cgen selects machine instructions for the function. // This pass generates assembly output for now, but should @@ -20,27 +24,30 @@ func cgen(f *Func) { for idx, b := range f.Blocks { fmt.Printf("%d:\n", b.ID) for _, v := range b.Values { + var buf bytes.Buffer asm := opcodeTable[v.Op].asm - fmt.Print("\t") - if asm == "" { - fmt.Print("\t") - } + buf.WriteString(" ") for i := 0; i < len(asm); i++ { switch asm[i] { default: - fmt.Printf("%c", asm[i]) + buf.WriteByte(asm[i]) + case '\t': + buf.WriteByte(' ') + for buf.Len()%8 != 0 { + buf.WriteByte(' ') + } case '%': i++ switch asm[i] { case '%': - fmt.Print("%") + buf.WriteByte('%') case 'I': i++ n := asm[i] - '0' if f.RegAlloc[v.Args[n].ID] != nil { - fmt.Print(f.RegAlloc[v.Args[n].ID].Name()) + buf.WriteString(f.RegAlloc[v.Args[n].ID].Name()) } else { - fmt.Printf("v%d", v.Args[n].ID) + fmt.Fprintf(&buf, "v%d", v.Args[n].ID) } case 'O': i++ @@ -49,17 +56,22 @@ func cgen(f *Func) { panic("can only handle 1 output for now") } if f.RegAlloc[v.ID] != nil { - // TODO: output tuple - fmt.Print(f.RegAlloc[v.ID].Name()) + buf.WriteString(f.RegAlloc[v.ID].Name()) } else { - fmt.Printf("v%d", v.ID) + fmt.Fprintf(&buf, "v%d", v.ID) } case 'A': - fmt.Print(v.Aux) + fmt.Fprint(&buf, v.Aux) } } } - fmt.Println("\t; " + v.LongString()) + for buf.Len() < 40 { + buf.WriteByte(' ') + } + buf.WriteString("; ") + buf.WriteString(v.LongString()) + buf.WriteByte('\n') + os.Stdout.Write(buf.Bytes()) } // find next block in layout sequence var next *Block @@ -106,6 +118,15 @@ func cgen(f *Func) { fmt.Printf("\tJLT\t%d\n", b.Succs[0].ID) fmt.Printf("\tJMP\t%d\n", b.Succs[1].ID) } + case BlockULT: + if b.Succs[0] == next { + fmt.Printf("\tJAE\t%d\n", b.Succs[1].ID) + } else if b.Succs[1] == next { + fmt.Printf("\tJB\t%d\n", b.Succs[0].ID) + } else { + fmt.Printf("\tJB\t%d\n", b.Succs[0].ID) + fmt.Printf("\tJMP\t%d\n", b.Succs[1].ID) + } default: fmt.Printf("\t%s ->", b.Kind.String()) for _, s := range b.Succs { diff --git a/src/cmd/internal/ssa/check.go b/src/cmd/internal/ssa/check.go index b501cdb54c..453388a899 100644 --- a/src/cmd/internal/ssa/check.go +++ b/src/cmd/internal/ssa/check.go @@ -106,7 +106,6 @@ func checkFunc(f *Func) { log.Panicf("phi length %s does not match pred length %d for block %s", v.LongString(), len(b.Preds), b) } - // TODO: check idom // TODO: check for cycles in values // TODO: check type } diff --git a/src/cmd/internal/ssa/config.go b/src/cmd/internal/ssa/config.go new file mode 100644 index 0000000000..80acda4b23 --- /dev/null +++ b/src/cmd/internal/ssa/config.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 "log" + +type Config struct { + arch string // "amd64", etc. + ptrSize int64 // 4 or 8 + UIntPtr Type // pointer arithmetic type + lower func(*Value) bool // lowering function + + // TODO: more stuff. Compiler flags of interest, ... +} + +// NewConfig returns a new configuration object for the given architecture. +func NewConfig(arch string) *Config { + c := &Config{arch: arch} + switch arch { + case "amd64": + c.ptrSize = 8 + c.lower = lowerAmd64 + case "386": + c.ptrSize = 4 + c.lower = lowerAmd64 // TODO(khr): full 32-bit support + default: + log.Fatalf("arch %s not implemented", arch) + } + + // cache the intptr type in the config + c.UIntPtr = TypeUInt32 + if c.ptrSize == 8 { + c.UIntPtr = TypeUInt64 + } + + return c +} + +// NewFunc returns a new, empty function object +func (c *Config) NewFunc() *Func { + // TODO(khr): should this function take name, type, etc. as arguments? + return &Func{Config: c} +} + +// TODO(khr): do we really need a separate Config, or can we just +// store all its fields inside a Func? diff --git a/src/cmd/internal/ssa/cse.go b/src/cmd/internal/ssa/cse.go index c44b08f61c..aba24aeabc 100644 --- a/src/cmd/internal/ssa/cse.go +++ b/src/cmd/internal/ssa/cse.go @@ -4,9 +4,7 @@ package ssa -import ( - "sort" -) +import "sort" // cse does common-subexpression elimination on the Function. // Values are just relinked, nothing is deleted. A subsequent deadcode @@ -115,7 +113,9 @@ func cse(f *Func) { // Replace all elements of e which v dominates for i := 0; i < len(e); { w := e[i] - if w != v && dom(v.Block, w.Block, idom) { + if w == v { + e, e[i] = e[:len(e)-1], e[len(e)-1] + } else if dom(v.Block, w.Block, idom) { rewrite[w.ID] = v e, e[i] = e[:len(e)-1], e[len(e)-1] } else { diff --git a/src/cmd/internal/ssa/deadcode.go b/src/cmd/internal/ssa/deadcode.go index f9e4b18d5f..a805861489 100644 --- a/src/cmd/internal/ssa/deadcode.go +++ b/src/cmd/internal/ssa/deadcode.go @@ -115,6 +115,7 @@ func deadcode(f *Func) { f.Blocks = f.Blocks[:i] // TODO: renumber Blocks and Values densely? + // TODO: save dead Values and Blocks for reuse? Or should we just let GC handle it? } // There was an edge b->c. It has been removed from b's successors. diff --git a/src/cmd/internal/ssa/deadcode_test.go b/src/cmd/internal/ssa/deadcode_test.go index 94fc359af7..1b7c81c568 100644 --- a/src/cmd/internal/ssa/deadcode_test.go +++ b/src/cmd/internal/ssa/deadcode_test.go @@ -27,7 +27,7 @@ func TestDeadLoop(t *testing.T) { addEdge(deadblock, exit) // dead value in dead block - deadval := deadblock.NewValue(OpConstBool, TypeBool, true) + deadval := deadblock.NewValue(OpConst, TypeBool, true) deadblock.Control = deadval CheckFunc(f) @@ -55,7 +55,7 @@ func TestDeadValue(t *testing.T) { mem := entry.NewValue(OpArg, TypeMem, ".mem") exit.Control = mem - deadval := entry.NewValue(OpConstInt, TypeInt, 37) + deadval := entry.NewValue(OpConst, TypeInt64, int64(37)) CheckFunc(f) Deadcode(f) @@ -84,7 +84,7 @@ func TestNeverTaken(t *testing.T) { mem := entry.NewValue(OpArg, TypeMem, ".mem") exit.Control = mem - cond := entry.NewValue(OpConstBool, TypeBool, false) + cond := entry.NewValue(OpConst, TypeBool, false) entry.Control = cond CheckFunc(f) diff --git a/src/cmd/internal/ssa/func.go b/src/cmd/internal/ssa/func.go index b4677c97b3..bdc8815e1a 100644 --- a/src/cmd/internal/ssa/func.go +++ b/src/cmd/internal/ssa/func.go @@ -7,6 +7,7 @@ package ssa // 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 Name string // e.g. bytes·Compare Type Type // type signature of the function. Blocks []*Block // unordered set of all basic blocks (note: not indexable by ID) @@ -53,9 +54,53 @@ func (b *Block) NewValue(op Op, t Type, aux interface{}) *Value { return v } +// NewValue1 returns a new value in the block with one argument. +func (b *Block) NewValue1(op Op, t Type, aux interface{}, arg *Value) *Value { + v := &Value{ + ID: b.Func.vid.get(), + Op: op, + Type: t, + Aux: aux, + Block: b, + } + v.Args = v.argstorage[:1] + v.Args[0] = arg + b.Values = append(b.Values, v) + return v +} + +// NewValue2 returns a new value in the block with two arguments. +func (b *Block) NewValue2(op Op, t Type, aux interface{}, arg0, arg1 *Value) *Value { + v := &Value{ + ID: b.Func.vid.get(), + Op: op, + Type: t, + Aux: aux, + Block: b, + } + v.Args = v.argstorage[:2] + v.Args[0] = arg0 + v.Args[1] = arg1 + b.Values = append(b.Values, v) + return v +} + +// NewValue3 returns a new value in the block with three arguments. +func (b *Block) NewValue3(op Op, t Type, aux interface{}, arg0, arg1, arg2 *Value) *Value { + v := &Value{ + ID: b.Func.vid.get(), + Op: op, + Type: t, + Aux: aux, + Block: b, + } + v.Args = []*Value{arg0, arg1, arg2} + b.Values = append(b.Values, v) + return v +} + // ConstInt returns an int constant representing its argument. -func (f *Func) ConstInt(c int64) *Value { +func (f *Func) ConstInt(t Type, c int64) *Value { // TODO: cache? - // TODO: different types? - return f.Entry.NewValue(OpConst, TypeInt64, c) + return f.Entry.NewValue(OpConst, t, c) } diff --git a/src/cmd/internal/ssa/fuse.go b/src/cmd/internal/ssa/fuse.go index bfce9ef970..af3e8a8e14 100644 --- a/src/cmd/internal/ssa/fuse.go +++ b/src/cmd/internal/ssa/fuse.go @@ -30,6 +30,9 @@ func fuse(f *Func) { } } } + if f.Entry == b { + f.Entry = c + } // trash b, just in case b.Kind = BlockUnknown diff --git a/src/cmd/internal/ssa/generic.go b/src/cmd/internal/ssa/generic.go index 3118b3af9d..2a96793c61 100644 --- a/src/cmd/internal/ssa/generic.go +++ b/src/cmd/internal/ssa/generic.go @@ -11,23 +11,24 @@ func genericRules(v *Value) bool { { t := v.Type if v.Args[0].Op != OpConst { - goto end0 + goto endc86f5c160a87f6f5ec90b6551ec099d9 } c := v.Args[0].Aux if v.Args[1].Op != OpConst { - goto end0 + goto endc86f5c160a87f6f5ec90b6551ec099d9 } d := v.Args[1].Aux if !(is64BitInt(t) && isSigned(t)) { - goto end0 + goto endc86f5c160a87f6f5ec90b6551ec099d9 } v.Op = OpConst v.Aux = nil - v.Args = v.argstorage[:0] + v.resetArgs() v.Aux = c.(int64) + d.(int64) return true } - end0: + goto endc86f5c160a87f6f5ec90b6551ec099d9 + endc86f5c160a87f6f5ec90b6551ec099d9: ; // match: (Add (Const [c]) (Const [d])) // cond: is64BitInt(t) && !isSigned(t) @@ -35,101 +36,130 @@ func genericRules(v *Value) bool { { t := v.Type if v.Args[0].Op != OpConst { - goto end1 + goto end8941c2a515c1bd38530b7fd96862bac4 } c := v.Args[0].Aux if v.Args[1].Op != OpConst { - goto end1 + goto end8941c2a515c1bd38530b7fd96862bac4 } d := v.Args[1].Aux if !(is64BitInt(t) && !isSigned(t)) { - goto end1 + goto end8941c2a515c1bd38530b7fd96862bac4 } v.Op = OpConst v.Aux = nil - v.Args = v.argstorage[:0] + v.resetArgs() v.Aux = c.(uint64) + d.(uint64) return true } - end1: + goto end8941c2a515c1bd38530b7fd96862bac4 + end8941c2a515c1bd38530b7fd96862bac4: ; - case OpLoad: - // match: (Load (FPAddr [offset]) mem) + case OpSliceCap: + // match: (SliceCap (Load ptr mem)) // cond: - // result: (LoadFP [offset] mem) + // result: (Load (Add ptr (Const [int64(v.Block.Func.Config.ptrSize*2)])) mem) { - if v.Args[0].Op != OpFPAddr { - goto end2 + if v.Args[0].Op != OpLoad { + goto ende03f9b79848867df439b56889bb4e55d } - offset := v.Args[0].Aux - mem := v.Args[1] - v.Op = OpLoadFP + ptr := v.Args[0].Args[0] + mem := v.Args[0].Args[1] + v.Op = OpLoad v.Aux = nil - v.Args = v.argstorage[:0] - v.Aux = offset + v.resetArgs() + v0 := v.Block.NewValue(OpAdd, TypeInvalid, nil) + v0.Type = ptr.Type + v0.AddArg(ptr) + v1 := v.Block.NewValue(OpConst, TypeInvalid, nil) + v1.Type = v.Block.Func.Config.UIntPtr + v1.Aux = int64(v.Block.Func.Config.ptrSize * 2) + v0.AddArg(v1) + v.AddArg(v0) v.AddArg(mem) return true } - end2: + goto ende03f9b79848867df439b56889bb4e55d + ende03f9b79848867df439b56889bb4e55d: ; - // match: (Load (SPAddr [offset]) mem) + case OpSliceIndex: + // match: (SliceIndex s i mem) // cond: - // result: (LoadSP [offset] mem) + // result: (Load (Add (SlicePtr s) (Mul i (Const [s.Type.Elem().Size()]))) mem) { - if v.Args[0].Op != OpSPAddr { - goto end3 - } - offset := v.Args[0].Aux - mem := v.Args[1] - v.Op = OpLoadSP + s := v.Args[0] + i := v.Args[1] + mem := v.Args[2] + v.Op = OpLoad v.Aux = nil - v.Args = v.argstorage[:0] - v.Aux = offset + v.resetArgs() + v0 := v.Block.NewValue(OpAdd, TypeInvalid, nil) + v0.Type = s.Type.Elem().PtrTo() + v1 := v.Block.NewValue(OpSlicePtr, TypeInvalid, nil) + v1.Type = s.Type.Elem().PtrTo() + v1.AddArg(s) + v0.AddArg(v1) + v2 := v.Block.NewValue(OpMul, TypeInvalid, nil) + v2.Type = v.Block.Func.Config.UIntPtr + v2.AddArg(i) + v3 := v.Block.NewValue(OpConst, TypeInvalid, nil) + v3.Type = v.Block.Func.Config.UIntPtr + v3.Aux = s.Type.Elem().Size() + v2.AddArg(v3) + v0.AddArg(v2) + v.AddArg(v0) v.AddArg(mem) return true } - end3: + goto end733704831a61760840348f790b3ab045 + end733704831a61760840348f790b3ab045: ; - case OpStore: - // match: (Store (FPAddr [offset]) val mem) + case OpSliceLen: + // match: (SliceLen (Load ptr mem)) // cond: - // result: (StoreFP [offset] val mem) + // result: (Load (Add ptr (Const [int64(v.Block.Func.Config.ptrSize)])) mem) { - if v.Args[0].Op != OpFPAddr { - goto end4 + if v.Args[0].Op != OpLoad { + goto ende94950a57eca1871c93afdeaadb90223 } - offset := v.Args[0].Aux - val := v.Args[1] - mem := v.Args[2] - v.Op = OpStoreFP + ptr := v.Args[0].Args[0] + mem := v.Args[0].Args[1] + v.Op = OpLoad v.Aux = nil - v.Args = v.argstorage[:0] - v.Aux = offset - v.AddArg(val) + v.resetArgs() + v0 := v.Block.NewValue(OpAdd, TypeInvalid, nil) + v0.Type = ptr.Type + v0.AddArg(ptr) + v1 := v.Block.NewValue(OpConst, TypeInvalid, nil) + v1.Type = v.Block.Func.Config.UIntPtr + v1.Aux = int64(v.Block.Func.Config.ptrSize) + v0.AddArg(v1) + v.AddArg(v0) v.AddArg(mem) return true } - end4: + goto ende94950a57eca1871c93afdeaadb90223 + ende94950a57eca1871c93afdeaadb90223: ; - // match: (Store (SPAddr [offset]) val mem) + case OpSlicePtr: + // match: (SlicePtr (Load ptr mem)) // cond: - // result: (StoreSP [offset] val mem) + // result: (Load ptr mem) { - if v.Args[0].Op != OpSPAddr { - goto end5 + if v.Args[0].Op != OpLoad { + goto end459613b83f95b65729d45c2ed663a153 } - offset := v.Args[0].Aux - val := v.Args[1] - mem := v.Args[2] - v.Op = OpStoreSP + ptr := v.Args[0].Args[0] + mem := v.Args[0].Args[1] + v.Op = OpLoad v.Aux = nil - v.Args = v.argstorage[:0] - v.Aux = offset - v.AddArg(val) + v.resetArgs() + v.AddArg(ptr) v.AddArg(mem) return true } - end5: + goto end459613b83f95b65729d45c2ed663a153 + end459613b83f95b65729d45c2ed663a153: } return false } diff --git a/src/cmd/internal/ssa/id.go b/src/cmd/internal/ssa/id.go index 43f23c838c..3f53e1a434 100644 --- a/src/cmd/internal/ssa/id.go +++ b/src/cmd/internal/ssa/id.go @@ -31,8 +31,6 @@ func (a *idAlloc) get() ID { // put deallocates an ID. func (a *idAlloc) put(x ID) { a.free = append(a.free, x) - // TODO: IR check should make sure that the IR contains - // no IDs that are in the free list. } // num returns the maximum ID ever returned + 1. diff --git a/src/cmd/internal/ssa/lower.go b/src/cmd/internal/ssa/lower.go index 18fe9861a6..82e5d23241 100644 --- a/src/cmd/internal/ssa/lower.go +++ b/src/cmd/internal/ssa/lower.go @@ -4,19 +4,12 @@ package ssa -var ( - // TODO(khr): put arch configuration constants together somewhere - intSize = 8 - ptrSize = 8 -) - //go:generate go run rulegen/rulegen.go rulegen/lower_amd64.rules lowerAmd64 lowerAmd64.go // convert to machine-dependent ops func lower(f *Func) { // repeat rewrites until we find no more rewrites - // TODO: pick the target arch from config - applyRewrite(f, lowerAmd64) + applyRewrite(f, f.Config.lower) // TODO: check for unlowered opcodes, fail if we find one @@ -29,6 +22,12 @@ func lower(f *Func) { case OpSETL: b.Kind = BlockLT b.Control = b.Control.Args[0] + case OpSETNE: + b.Kind = BlockNE + b.Control = b.Control.Args[0] + case OpSETB: + b.Kind = BlockULT + b.Control = b.Control.Args[0] // TODO: others } case BlockLT: @@ -36,6 +35,21 @@ func lower(f *Func) { b.Kind = BlockGE b.Control = b.Control.Args[0] } + case BlockULT: + if b.Control.Op == OpInvertFlags { + b.Kind = BlockUGE + b.Control = b.Control.Args[0] + } + case BlockEQ: + if b.Control.Op == OpInvertFlags { + b.Kind = BlockNE + b.Control = b.Control.Args[0] + } + case BlockNE: + if b.Control.Op == OpInvertFlags { + b.Kind = BlockEQ + b.Control = b.Control.Args[0] + } // TODO: others } } diff --git a/src/cmd/internal/ssa/lowerAmd64.go b/src/cmd/internal/ssa/lowerAmd64.go index 88f0e43bd8..6c0a42d976 100644 --- a/src/cmd/internal/ssa/lowerAmd64.go +++ b/src/cmd/internal/ssa/lowerAmd64.go @@ -4,6 +4,65 @@ package ssa func lowerAmd64(v *Value) bool { switch v.Op { + case OpADDCQ: + // match: (ADDCQ [c] (LEAQ8 [d] x y)) + // cond: + // result: (LEAQ8 [c.(int64)+d.(int64)] x y) + { + c := v.Aux + if v.Args[0].Op != OpLEAQ8 { + goto end16348939e556e99e8447227ecb986f01 + } + d := v.Args[0].Aux + x := v.Args[0].Args[0] + y := v.Args[0].Args[1] + v.Op = OpLEAQ8 + v.Aux = nil + v.resetArgs() + v.Aux = c.(int64) + d.(int64) + v.AddArg(x) + v.AddArg(y) + return true + } + goto end16348939e556e99e8447227ecb986f01 + end16348939e556e99e8447227ecb986f01: + ; + // match: (ADDCQ [off1] (FPAddr [off2])) + // cond: + // result: (FPAddr [off1.(int64)+off2.(int64)]) + { + off1 := v.Aux + if v.Args[0].Op != OpFPAddr { + goto end28e093ab0618066e6b2609db7aaf309b + } + off2 := v.Args[0].Aux + v.Op = OpFPAddr + v.Aux = nil + v.resetArgs() + v.Aux = off1.(int64) + off2.(int64) + return true + } + goto end28e093ab0618066e6b2609db7aaf309b + end28e093ab0618066e6b2609db7aaf309b: + ; + // match: (ADDCQ [off1] (SPAddr [off2])) + // cond: + // result: (SPAddr [off1.(int64)+off2.(int64)]) + { + off1 := v.Aux + if v.Args[0].Op != OpSPAddr { + goto endd0c27c62d150b88168075c5ba113d1fa + } + off2 := v.Args[0].Aux + v.Op = OpSPAddr + v.Aux = nil + v.resetArgs() + v.Aux = off1.(int64) + off2.(int64) + return true + } + goto endd0c27c62d150b88168075c5ba113d1fa + endd0c27c62d150b88168075c5ba113d1fa: + ; case OpADDQ: // match: (ADDQ x (Const [c])) // cond: @@ -11,55 +70,82 @@ func lowerAmd64(v *Value) bool { { x := v.Args[0] if v.Args[1].Op != OpConst { - goto end0 + goto endef6908cfdf56e102cc327a3ddc14393d } c := v.Args[1].Aux v.Op = OpADDCQ v.Aux = nil - v.Args = v.argstorage[:0] + v.resetArgs() v.Aux = c v.AddArg(x) return true } - end0: + goto endef6908cfdf56e102cc327a3ddc14393d + endef6908cfdf56e102cc327a3ddc14393d: ; // match: (ADDQ (Const [c]) x) // cond: // result: (ADDCQ [c] x) { if v.Args[0].Op != OpConst { - goto end1 + goto endb54a32cf3147f424f08b46db62c69b23 } c := v.Args[0].Aux x := v.Args[1] v.Op = OpADDCQ v.Aux = nil - v.Args = v.argstorage[:0] + v.resetArgs() v.Aux = c v.AddArg(x) return true } - end1: + goto endb54a32cf3147f424f08b46db62c69b23 + endb54a32cf3147f424f08b46db62c69b23: + ; + // match: (ADDQ x (SHLCQ [shift] y)) + // cond: shift.(int64) == 3 + // result: (LEAQ8 [int64(0)] x y) + { + x := v.Args[0] + if v.Args[1].Op != OpSHLCQ { + goto end7fa0d837edd248748cef516853fd9475 + } + shift := v.Args[1].Aux + y := v.Args[1].Args[0] + if !(shift.(int64) == 3) { + goto end7fa0d837edd248748cef516853fd9475 + } + v.Op = OpLEAQ8 + v.Aux = nil + v.resetArgs() + v.Aux = int64(0) + v.AddArg(x) + v.AddArg(y) + return true + } + goto end7fa0d837edd248748cef516853fd9475 + end7fa0d837edd248748cef516853fd9475: ; case OpAdd: // match: (Add x y) - // cond: is64BitInt(t) + // cond: (is64BitInt(t) || isPtr(t)) // result: (ADDQ x y) { t := v.Type x := v.Args[0] y := v.Args[1] - if !(is64BitInt(t)) { - goto end2 + if !(is64BitInt(t) || isPtr(t)) { + goto endf031c523d7dd08e4b8e7010a94cd94c9 } v.Op = OpADDQ v.Aux = nil - v.Args = v.argstorage[:0] + v.resetArgs() v.AddArg(x) v.AddArg(y) return true } - end2: + goto endf031c523d7dd08e4b8e7010a94cd94c9 + endf031c523d7dd08e4b8e7010a94cd94c9: ; // match: (Add x y) // cond: is32BitInt(t) @@ -69,16 +155,17 @@ func lowerAmd64(v *Value) bool { x := v.Args[0] y := v.Args[1] if !(is32BitInt(t)) { - goto end3 + goto end35a02a1587264e40cf1055856ff8445a } v.Op = OpADDL v.Aux = nil - v.Args = v.argstorage[:0] + v.resetArgs() v.AddArg(x) v.AddArg(y) return true } - end3: + goto end35a02a1587264e40cf1055856ff8445a + end35a02a1587264e40cf1055856ff8445a: ; case OpCMPQ: // match: (CMPQ x (Const [c])) @@ -87,30 +174,31 @@ func lowerAmd64(v *Value) bool { { x := v.Args[0] if v.Args[1].Op != OpConst { - goto end4 + goto end1770a40e4253d9f669559a360514613e } c := v.Args[1].Aux v.Op = OpCMPCQ v.Aux = nil - v.Args = v.argstorage[:0] + v.resetArgs() v.AddArg(x) v.Aux = c return true } - end4: + goto end1770a40e4253d9f669559a360514613e + end1770a40e4253d9f669559a360514613e: ; // match: (CMPQ (Const [c]) x) // cond: // result: (InvertFlags (CMPCQ x [c])) { if v.Args[0].Op != OpConst { - goto end5 + goto enda4e64c7eaeda16c1c0db9dac409cd126 } c := v.Args[0].Aux x := v.Args[1] v.Op = OpInvertFlags v.Aux = nil - v.Args = v.argstorage[:0] + v.resetArgs() v0 := v.Block.NewValue(OpCMPCQ, TypeInvalid, nil) v0.Type = TypeFlags v0.AddArg(x) @@ -118,7 +206,47 @@ func lowerAmd64(v *Value) bool { v.AddArg(v0) return true } - end5: + goto enda4e64c7eaeda16c1c0db9dac409cd126 + enda4e64c7eaeda16c1c0db9dac409cd126: + ; + case OpCheckBound: + // match: (CheckBound idx len) + // cond: + // result: (SETB (CMPQ idx len)) + { + idx := v.Args[0] + len := v.Args[1] + v.Op = OpSETB + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue(OpCMPQ, TypeInvalid, nil) + v0.Type = TypeFlags + v0.AddArg(idx) + v0.AddArg(len) + v.AddArg(v0) + return true + } + goto end249426f6f996d45a62f89a591311a954 + end249426f6f996d45a62f89a591311a954: + ; + case OpCheckNil: + // match: (CheckNil p) + // cond: + // result: (SETNE (TESTQ p p)) + { + p := v.Args[0] + v.Op = OpSETNE + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue(OpTESTQ, TypeInvalid, nil) + v0.Type = TypeFlags + v0.AddArg(p) + v0.AddArg(p) + v.AddArg(v0) + return true + } + goto end90d3057824f74ef953074e473aa0b282 + end90d3057824f74ef953074e473aa0b282: ; case OpLess: // match: (Less x y) @@ -128,11 +256,11 @@ func lowerAmd64(v *Value) bool { x := v.Args[0] y := v.Args[1] if !(is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type)) { - goto end6 + goto endcecf13a952d4c6c2383561c7d68a3cf9 } v.Op = OpSETL v.Aux = nil - v.Args = v.argstorage[:0] + v.resetArgs() v0 := v.Block.NewValue(OpCMPQ, TypeInvalid, nil) v0.Type = TypeFlags v0.AddArg(x) @@ -140,49 +268,292 @@ func lowerAmd64(v *Value) bool { v.AddArg(v0) return true } - end6: + goto endcecf13a952d4c6c2383561c7d68a3cf9 + endcecf13a952d4c6c2383561c7d68a3cf9: ; - case OpLoadFP: - // match: (LoadFP [offset] mem) - // cond: typeSize(t) == 8 - // result: (LoadFP8 [offset] mem) + case OpLoad: + // match: (Load ptr mem) + // cond: (is64BitInt(t) || isPtr(t)) + // result: (MOVQload [int64(0)] ptr mem) { t := v.Type - offset := v.Aux - mem := v.Args[0] - if !(typeSize(t) == 8) { - goto end7 + ptr := v.Args[0] + mem := v.Args[1] + if !(is64BitInt(t) || isPtr(t)) { + goto end581ce5a20901df1b8143448ba031685b + } + v.Op = OpMOVQload + v.Aux = nil + v.resetArgs() + v.Aux = int64(0) + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto end581ce5a20901df1b8143448ba031685b + end581ce5a20901df1b8143448ba031685b: + ; + case OpMOVQload: + // match: (MOVQload [off1] (FPAddr [off2]) mem) + // cond: + // result: (MOVQloadFP [off1.(int64)+off2.(int64)] mem) + { + off1 := v.Aux + if v.Args[0].Op != OpFPAddr { + goto endce972b1aa84b56447978c43def87fa57 } - v.Op = OpLoadFP8 + off2 := v.Args[0].Aux + mem := v.Args[1] + v.Op = OpMOVQloadFP v.Aux = nil - v.Args = v.argstorage[:0] - v.Type = t - v.Aux = offset + v.resetArgs() + v.Aux = off1.(int64) + off2.(int64) v.AddArg(mem) return true } - end7: + goto endce972b1aa84b56447978c43def87fa57 + endce972b1aa84b56447978c43def87fa57: ; - case OpLoadSP: - // match: (LoadSP [offset] mem) - // cond: typeSize(t) == 8 - // result: (LoadSP8 [offset] mem) + // match: (MOVQload [off1] (SPAddr [off2]) mem) + // cond: + // result: (MOVQloadSP [off1.(int64)+off2.(int64)] mem) { - t := v.Type - offset := v.Aux - mem := v.Args[0] - if !(typeSize(t) == 8) { - goto end8 + off1 := v.Aux + if v.Args[0].Op != OpSPAddr { + goto end3d8628a6536350a123be81240b8a1376 + } + off2 := v.Args[0].Aux + mem := v.Args[1] + v.Op = OpMOVQloadSP + v.Aux = nil + v.resetArgs() + v.Aux = off1.(int64) + off2.(int64) + v.AddArg(mem) + return true + } + goto end3d8628a6536350a123be81240b8a1376 + end3d8628a6536350a123be81240b8a1376: + ; + // match: (MOVQload [off1] (ADDCQ [off2] ptr) mem) + // cond: + // result: (MOVQload [off1.(int64)+off2.(int64)] ptr mem) + { + off1 := v.Aux + if v.Args[0].Op != OpADDCQ { + goto enda68a39292ba2a05b3436191cb0bb0516 + } + off2 := v.Args[0].Aux + ptr := v.Args[0].Args[0] + mem := v.Args[1] + v.Op = OpMOVQload + v.Aux = nil + v.resetArgs() + v.Aux = off1.(int64) + off2.(int64) + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto enda68a39292ba2a05b3436191cb0bb0516 + enda68a39292ba2a05b3436191cb0bb0516: + ; + // match: (MOVQload [off1] (LEAQ8 [off2] ptr idx) mem) + // cond: + // result: (MOVQload8 [off1.(int64)+off2.(int64)] ptr idx mem) + { + off1 := v.Aux + if v.Args[0].Op != OpLEAQ8 { + goto end35060118a284c93323ab3fb827156638 } - v.Op = OpLoadSP8 + off2 := v.Args[0].Aux + ptr := v.Args[0].Args[0] + idx := v.Args[0].Args[1] + mem := v.Args[1] + v.Op = OpMOVQload8 v.Aux = nil - v.Args = v.argstorage[:0] - v.Type = t - v.Aux = offset + v.resetArgs() + v.Aux = off1.(int64) + off2.(int64) + v.AddArg(ptr) + v.AddArg(idx) v.AddArg(mem) return true } - end8: + goto end35060118a284c93323ab3fb827156638 + end35060118a284c93323ab3fb827156638: + ; + case OpMOVQstore: + // match: (MOVQstore [off1] (FPAddr [off2]) val mem) + // cond: + // result: (MOVQstoreFP [off1.(int64)+off2.(int64)] val mem) + { + off1 := v.Aux + if v.Args[0].Op != OpFPAddr { + goto end0a2a81a20558dfc93790aecb1e9cc81a + } + off2 := v.Args[0].Aux + val := v.Args[1] + mem := v.Args[2] + v.Op = OpMOVQstoreFP + v.Aux = nil + v.resetArgs() + v.Aux = off1.(int64) + off2.(int64) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto end0a2a81a20558dfc93790aecb1e9cc81a + end0a2a81a20558dfc93790aecb1e9cc81a: + ; + // match: (MOVQstore [off1] (SPAddr [off2]) val mem) + // cond: + // result: (MOVQstoreSP [off1.(int64)+off2.(int64)] val mem) + { + off1 := v.Aux + if v.Args[0].Op != OpSPAddr { + goto end1cb5b7e766f018270fa434c6f46f607f + } + off2 := v.Args[0].Aux + val := v.Args[1] + mem := v.Args[2] + v.Op = OpMOVQstoreSP + v.Aux = nil + v.resetArgs() + v.Aux = off1.(int64) + off2.(int64) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto end1cb5b7e766f018270fa434c6f46f607f + end1cb5b7e766f018270fa434c6f46f607f: + ; + // match: (MOVQstore [off1] (ADDCQ [off2] ptr) val mem) + // cond: + // result: (MOVQstore [off1.(int64)+off2.(int64)] ptr val mem) + { + off1 := v.Aux + if v.Args[0].Op != OpADDCQ { + goto end271e3052de832e22b1f07576af2854de + } + off2 := v.Args[0].Aux + ptr := v.Args[0].Args[0] + val := v.Args[1] + mem := v.Args[2] + v.Op = OpMOVQstore + v.Aux = nil + v.resetArgs() + v.Aux = off1.(int64) + off2.(int64) + v.AddArg(ptr) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto end271e3052de832e22b1f07576af2854de + end271e3052de832e22b1f07576af2854de: + ; + // match: (MOVQstore [off1] (LEAQ8 [off2] ptr idx) val mem) + // cond: + // result: (MOVQstore8 [off1.(int64)+off2.(int64)] ptr idx val mem) + { + off1 := v.Aux + if v.Args[0].Op != OpLEAQ8 { + goto endb5cba0ee3ba21d2bd8e5aa163d2b984e + } + off2 := v.Args[0].Aux + ptr := v.Args[0].Args[0] + idx := v.Args[0].Args[1] + val := v.Args[1] + mem := v.Args[2] + v.Op = OpMOVQstore8 + v.Aux = nil + v.resetArgs() + v.Aux = off1.(int64) + off2.(int64) + v.AddArg(ptr) + v.AddArg(idx) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto endb5cba0ee3ba21d2bd8e5aa163d2b984e + endb5cba0ee3ba21d2bd8e5aa163d2b984e: + ; + case OpMULCQ: + // match: (MULCQ [c] x) + // cond: c.(int64) == 8 + // result: (SHLCQ [int64(3)] x) + { + c := v.Aux + x := v.Args[0] + if !(c.(int64) == 8) { + goto end90a1c055d9658aecacce5e101c1848b4 + } + v.Op = OpSHLCQ + v.Aux = nil + v.resetArgs() + v.Aux = int64(3) + v.AddArg(x) + return true + } + goto end90a1c055d9658aecacce5e101c1848b4 + end90a1c055d9658aecacce5e101c1848b4: + ; + case OpMULQ: + // match: (MULQ x (Const [c])) + // cond: + // result: (MULCQ [c] x) + { + x := v.Args[0] + if v.Args[1].Op != OpConst { + goto endc427f4838d2e83c00cc097b20bd20a37 + } + c := v.Args[1].Aux + v.Op = OpMULCQ + v.Aux = nil + v.resetArgs() + v.Aux = c + v.AddArg(x) + return true + } + goto endc427f4838d2e83c00cc097b20bd20a37 + endc427f4838d2e83c00cc097b20bd20a37: + ; + // match: (MULQ (Const [c]) x) + // cond: + // result: (MULCQ [c] x) + { + if v.Args[0].Op != OpConst { + goto endd70de938e71150d1c9e8173c2a5b2d95 + } + c := v.Args[0].Aux + x := v.Args[1] + v.Op = OpMULCQ + v.Aux = nil + v.resetArgs() + v.Aux = c + v.AddArg(x) + return true + } + goto endd70de938e71150d1c9e8173c2a5b2d95 + endd70de938e71150d1c9e8173c2a5b2d95: + ; + case OpMul: + // match: (Mul x y) + // cond: is64BitInt(t) + // result: (MULQ x y) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + if !(is64BitInt(t)) { + goto endfab0d598f376ecba45a22587d50f7aff + } + v.Op = OpMULQ + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto endfab0d598f376ecba45a22587d50f7aff + endfab0d598f376ecba45a22587d50f7aff: ; case OpSETL: // match: (SETL (InvertFlags x)) @@ -190,16 +561,17 @@ func lowerAmd64(v *Value) bool { // result: (SETGE x) { if v.Args[0].Op != OpInvertFlags { - goto end9 + goto end456c7681d48305698c1ef462d244bdc6 } x := v.Args[0].Args[0] v.Op = OpSETGE v.Aux = nil - v.Args = v.argstorage[:0] + v.resetArgs() v.AddArg(x) return true } - end9: + goto end456c7681d48305698c1ef462d244bdc6 + end456c7681d48305698c1ef462d244bdc6: ; case OpSUBQ: // match: (SUBQ x (Const [c])) @@ -208,17 +580,18 @@ func lowerAmd64(v *Value) bool { { x := v.Args[0] if v.Args[1].Op != OpConst { - goto end10 + goto endb31e242f283867de4722665a5796008c } c := v.Args[1].Aux v.Op = OpSUBCQ v.Aux = nil - v.Args = v.argstorage[:0] + v.resetArgs() v.AddArg(x) v.Aux = c return true } - end10: + goto endb31e242f283867de4722665a5796008c + endb31e242f283867de4722665a5796008c: ; // match: (SUBQ (Const [c]) x) // cond: @@ -226,13 +599,13 @@ func lowerAmd64(v *Value) bool { { t := v.Type if v.Args[0].Op != OpConst { - goto end11 + goto end569cc755877d1f89a701378bec05c08d } c := v.Args[0].Aux x := v.Args[1] v.Op = OpNEGQ v.Aux = nil - v.Args = v.argstorage[:0] + v.resetArgs() v0 := v.Block.NewValue(OpSUBCQ, TypeInvalid, nil) v0.Type = t v0.AddArg(x) @@ -240,49 +613,31 @@ func lowerAmd64(v *Value) bool { v.AddArg(v0) return true } - end11: + goto end569cc755877d1f89a701378bec05c08d + end569cc755877d1f89a701378bec05c08d: ; - case OpStoreFP: - // match: (StoreFP [offset] val mem) - // cond: typeSize(val.Type) == 8 - // result: (StoreFP8 [offset] val mem) + case OpStore: + // match: (Store ptr val mem) + // cond: (is64BitInt(val.Type) || isPtr(val.Type)) + // result: (MOVQstore [int64(0)] ptr val mem) { - offset := v.Aux - val := v.Args[0] - mem := v.Args[1] - if !(typeSize(val.Type) == 8) { - goto end12 - } - v.Op = OpStoreFP8 - v.Aux = nil - v.Args = v.argstorage[:0] - v.Aux = offset - v.AddArg(val) - v.AddArg(mem) - return true - } - end12: - ; - case OpStoreSP: - // match: (StoreSP [offset] val mem) - // cond: typeSize(val.Type) == 8 - // result: (StoreSP8 [offset] val mem) - { - offset := v.Aux - val := v.Args[0] - mem := v.Args[1] - if !(typeSize(val.Type) == 8) { - goto end13 + ptr := v.Args[0] + val := v.Args[1] + mem := v.Args[2] + if !(is64BitInt(val.Type) || isPtr(val.Type)) { + goto end9680b43f504bc06f9fab000823ce471a } - v.Op = OpStoreSP8 + v.Op = OpMOVQstore v.Aux = nil - v.Args = v.argstorage[:0] - v.Aux = offset + v.resetArgs() + v.Aux = int64(0) + v.AddArg(ptr) v.AddArg(val) v.AddArg(mem) return true } - end13: + goto end9680b43f504bc06f9fab000823ce471a + end9680b43f504bc06f9fab000823ce471a: ; case OpSub: // match: (Sub x y) @@ -293,16 +648,17 @@ func lowerAmd64(v *Value) bool { x := v.Args[0] y := v.Args[1] if !(is64BitInt(t)) { - goto end14 + goto ende6ef29f885a8ecf3058212bb95917323 } v.Op = OpSUBQ v.Aux = nil - v.Args = v.argstorage[:0] + v.resetArgs() v.AddArg(x) v.AddArg(y) return true } - end14: + goto ende6ef29f885a8ecf3058212bb95917323 + ende6ef29f885a8ecf3058212bb95917323: } return false } diff --git a/src/cmd/internal/ssa/op.go b/src/cmd/internal/ssa/op.go index 19d973921c..600dc9faa6 100644 --- a/src/cmd/internal/ssa/op.go +++ b/src/cmd/internal/ssa/op.go @@ -17,8 +17,8 @@ const ( // machine-independent opcodes - OpNop // should never be used, appears only briefly during construction, Has type Void. - OpThunk // used during ssa construction. Like OpCopy, but the arg has not been specified yet. + OpNop // should never be used, appears only briefly during construction, Has type Void. + OpFwdRef // used during ssa construction. Like OpCopy, but the arg has not been specified yet. // 2-input arithmetic OpAdd @@ -28,7 +28,12 @@ const ( // 2-input comparisons OpLess - // constants + // constants. Constant values are stored in the aux field. + // booleans have a bool aux field, strings have a string aux + // field, and so on. All integer types store their value + // in the aux field as an int64 (including int, uint64, etc.). + // We could store int8 as an int8, but that won't work for int, + // as it may be different widths on the host and target. OpConst OpArg // address of a function parameter/result. Memory input is an arg called ".mem". @@ -46,12 +51,11 @@ const ( OpStringPtr OpStringLen - OpSlice - OpIndex - OpIndexAddr + OpSliceIndex + OpSliceIndexAddr - OpLoad // args are ptr, memory - OpStore // args are ptr, value, memory, returns memory + OpLoad // args are ptr, memory. Loads from ptr+aux.(int64) + OpStore // args are ptr, value, memory, returns memory. Stores to ptr+aux.(int64) OpCheckNil // arg[0] != nil OpCheckBound // 0 <= arg[0] < arg[1] @@ -71,14 +75,6 @@ const ( OpFPAddr // offset from FP (+ == args from caller, - == locals) OpSPAddr // offset from SP - // load/store from constant offsets from SP/FP - // The distinction between FP/SP needs to be maintained until after - // register allocation because we don't know the size of the frame yet. - OpLoadFP - OpLoadSP - OpStoreFP - OpStoreSP - // 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 @@ -93,12 +89,22 @@ const ( OpSUBQ OpADDCQ // 1 input arg. output = input + aux.(int64) OpSUBCQ // 1 input arg. output = input - aux.(int64) + OpMULQ + OpMULCQ // output = input * aux.(int64) + OpSHLQ // output = input0 << input1 + OpSHLCQ // output = input << aux.(int64) OpNEGQ OpCMPQ OpCMPCQ // 1 input arg. Compares input with aux.(int64) OpADDL - OpSETL // generate bool = "flags encode less than" - OpSETGE + OpTESTQ // compute flags of arg[0] & arg[1] + OpSETEQ + OpSETNE + + // generate boolean based on the flags setting + OpSETL // less than + OpSETGE // >= + OpSETB // "below" = unsigned less than // InvertFlags reverses direction of flags register interpretation: // (InvertFlags (OpCMPQ a b)) == (OpCMPQ b a) @@ -110,11 +116,16 @@ const ( OpLEAQ4 // x+4*y OpLEAQ8 // x+8*y + OpMOVQload // (ptr, mem): loads from ptr+aux.(int64) + OpMOVQstore // (ptr, val, mem): stores val to ptr+aux.(int64), returns mem + OpMOVQload8 // (ptr,idx,mem): loads from ptr+idx*8+aux.(int64) + OpMOVQstore8 // (ptr,idx,val,mem): stores to ptr+idx*8+aux.(int64), returns mem + // load/store 8-byte integer register from stack slot. - OpLoadFP8 - OpLoadSP8 - OpStoreFP8 - OpStoreSP8 + OpMOVQloadFP + OpMOVQloadSP + OpMOVQstoreFP + OpMOVQstoreSP OpMax // sentinel ) @@ -184,7 +195,9 @@ var shift = [2][]regMask{{gp, cx}, {overwrite0}} var gp2_flags = [2][]regMask{{gp, gp}, {flags}} var gp1_flags = [2][]regMask{{gp}, {flags}} var gpload = [2][]regMask{{gp, 0}, {gp}} +var gploadX = [2][]regMask{{gp, gp, 0}, {gp}} // indexed loads var gpstore = [2][]regMask{{gp, gp, 0}, {0}} +var gpstoreX = [2][]regMask{{gp, gp, gp, 0}, {0}} // indexed stores // Opcodes that represent the input Go program var genericTable = [...]OpInfo{ @@ -197,7 +210,7 @@ var genericTable = [...]OpInfo{ OpLess: {}, OpConst: {}, // aux matches the type (e.g. bool, int64 float64) - OpArg: {}, // aux is the name of the input variable TODO:? + OpArg: {}, // aux is the name of the input variable. Currently only ".mem" is used OpGlobal: {}, // address of a global variable OpFunc: {}, OpCopy: {}, @@ -251,17 +264,25 @@ var amd64Table = [...]OpInfo{ OpADDCQ: {asm: "ADDQ\t$%A,%I0,%O0", reg: gp11_overwrite}, // aux = int64 constant to add OpSUBQ: {asm: "SUBQ\t%I0,%I1,%O0", reg: gp21}, OpSUBCQ: {asm: "SUBQ\t$%A,%I0,%O0", reg: gp11_overwrite}, + OpMULQ: {asm: "MULQ\t%I0,%I1,%O0", reg: gp21}, + OpMULCQ: {asm: "MULQ\t$%A,%I0,%O0", reg: gp11_overwrite}, + OpSHLQ: {asm: "SHLQ\t%I0,%I1,%O0", reg: gp21}, + OpSHLCQ: {asm: "SHLQ\t$%A,%I0,%O0", reg: gp11_overwrite}, OpCMPQ: {asm: "CMPQ\t%I0,%I1", reg: gp2_flags}, // compute arg[0]-arg[1] and produce flags OpCMPCQ: {asm: "CMPQ\t$%A,%I0", reg: gp1_flags}, + OpTESTQ: {asm: "TESTQ\t%I0,%I1", reg: gp2_flags}, OpLEAQ: {flags: OpFlagCommutative, asm: "LEAQ\t%A(%I0)(%I1*1),%O0", reg: gp21}, // aux = int64 constant to add OpLEAQ2: {asm: "LEAQ\t%A(%I0)(%I1*2),%O0"}, OpLEAQ4: {asm: "LEAQ\t%A(%I0)(%I1*4),%O0"}, OpLEAQ8: {asm: "LEAQ\t%A(%I0)(%I1*8),%O0"}, - //OpLoad8: {asm: "MOVQ\t%A(%I0),%O0", reg: gpload}, - //OpStore8: {asm: "MOVQ\t%I1,%A(%I0)", reg: gpstore}, + // loads and stores + OpMOVQload: {asm: "MOVQ\t%A(%I0),%O0", reg: gpload}, + OpMOVQstore: {asm: "MOVQ\t%I1,%A(%I0)", reg: gpstore}, + OpMOVQload8: {asm: "MOVQ\t%A(%I0)(%I1*8),%O0", reg: gploadX}, + OpMOVQstore8: {asm: "MOVQ\t%I2,%A(%I0)(%I1*8)", reg: gpstoreX}, OpStaticCall: {asm: "CALL\t%A(SB)"}, @@ -271,10 +292,10 @@ var amd64Table = [...]OpInfo{ OpSETL: {}, // ops for load/store to stack - OpLoadFP8: {asm: "MOVQ\t%A(FP),%O0"}, - OpLoadSP8: {asm: "MOVQ\t%A(SP),%O0"}, - OpStoreFP8: {asm: "MOVQ\t%I0,%A(FP)"}, - OpStoreSP8: {asm: "MOVQ\t%I0,%A(SP)"}, + OpMOVQloadFP: {asm: "MOVQ\t%A(FP),%O0"}, + OpMOVQloadSP: {asm: "MOVQ\t%A(SP),%O0"}, + OpMOVQstoreFP: {asm: "MOVQ\t%I0,%A(FP)"}, + OpMOVQstoreSP: {asm: "MOVQ\t%I0,%A(SP)"}, // ops for spilling of registers // unlike regular loads & stores, these take no memory argument. diff --git a/src/cmd/internal/ssa/op_string.go b/src/cmd/internal/ssa/op_string.go index dba1725262..5c42d22439 100644 --- a/src/cmd/internal/ssa/op_string.go +++ b/src/cmd/internal/ssa/op_string.go @@ -4,9 +4,9 @@ package ssa import "fmt" -const _Op_name = "OpUnknownOpNopOpThunkOpAddOpSubOpMulOpLessOpConstOpArgOpGlobalOpFuncOpCopyOpPhiOpSliceMakeOpSlicePtrOpSliceLenOpSliceCapOpStringMakeOpStringPtrOpStringLenOpSliceOpIndexOpIndexAddrOpLoadOpStoreOpCheckNilOpCheckBoundOpCallOpStaticCallOpConvertOpConvNopOpFPAddrOpSPAddrOpLoadFPOpLoadSPOpStoreFPOpStoreSPOpStoreReg8OpLoadReg8OpADDQOpSUBQOpADDCQOpSUBCQOpNEGQOpCMPQOpCMPCQOpADDLOpSETLOpSETGEOpInvertFlagsOpLEAQOpLEAQ2OpLEAQ4OpLEAQ8OpLoadFP8OpLoadSP8OpStoreFP8OpStoreSP8OpMax" +const _Op_name = "OpUnknownOpNopOpFwdRefOpAddOpSubOpMulOpLessOpConstOpArgOpGlobalOpFuncOpCopyOpPhiOpSliceMakeOpSlicePtrOpSliceLenOpSliceCapOpStringMakeOpStringPtrOpStringLenOpSliceIndexOpSliceIndexAddrOpLoadOpStoreOpCheckNilOpCheckBoundOpCallOpStaticCallOpConvertOpConvNopOpFPAddrOpSPAddrOpStoreReg8OpLoadReg8OpADDQOpSUBQOpADDCQOpSUBCQOpMULQOpMULCQOpSHLQOpSHLCQOpNEGQOpCMPQOpCMPCQOpADDLOpTESTQOpSETEQOpSETNEOpSETLOpSETGEOpSETBOpInvertFlagsOpLEAQOpLEAQ2OpLEAQ4OpLEAQ8OpMOVQloadOpMOVQstoreOpMOVQload8OpMOVQstore8OpMOVQloadFPOpMOVQloadSPOpMOVQstoreFPOpMOVQstoreSPOpMax" -var _Op_index = [...]uint16{0, 9, 14, 21, 26, 31, 36, 42, 49, 54, 62, 68, 74, 79, 90, 100, 110, 120, 132, 143, 154, 161, 168, 179, 185, 192, 202, 214, 220, 232, 241, 250, 258, 266, 274, 282, 291, 300, 311, 321, 327, 333, 340, 347, 353, 359, 366, 372, 378, 385, 398, 404, 411, 418, 425, 434, 443, 453, 463, 468} +var _Op_index = [...]uint16{0, 9, 14, 22, 27, 32, 37, 43, 50, 55, 63, 69, 75, 80, 91, 101, 111, 121, 133, 144, 155, 167, 183, 189, 196, 206, 218, 224, 236, 245, 254, 262, 270, 281, 291, 297, 303, 310, 317, 323, 330, 336, 343, 349, 355, 362, 368, 375, 382, 389, 395, 402, 408, 421, 427, 434, 441, 448, 458, 469, 480, 492, 504, 516, 529, 542, 547} func (i Op) String() string { if i < 0 || i+1 >= Op(len(_Op_index)) { diff --git a/src/cmd/internal/ssa/rewrite.go b/src/cmd/internal/ssa/rewrite.go index d22926e8f9..855719a877 100644 --- a/src/cmd/internal/ssa/rewrite.go +++ b/src/cmd/internal/ssa/rewrite.go @@ -4,16 +4,22 @@ package ssa -import ( - "cmd/internal/ssa/types" // TODO: use golang.org/x/tools/go/types instead -) +import "fmt" func applyRewrite(f *Func, r func(*Value) bool) { // repeat rewrites until we find no more rewrites + var curv *Value + defer func() { + if curv != nil { + fmt.Printf("panic during rewrite of %s\n", curv.LongString()) + // TODO(khr): print source location also + } + }() for { change := false for _, b := range f.Blocks { for _, v := range b.Values { + curv = v if r(v) { change = true } @@ -28,36 +34,21 @@ func applyRewrite(f *Func, r func(*Value) bool) { // Common functions called from rewriting rules func is64BitInt(t Type) bool { - if b, ok := t.Underlying().(*types.Basic); ok { - switch b.Kind() { - case types.Int64, types.Uint64: - return true - } - } - return false + return t.Size() == 8 && t.IsInteger() } func is32BitInt(t Type) bool { - if b, ok := t.Underlying().(*types.Basic); ok { - switch b.Kind() { - case types.Int32, types.Uint32: - return true - } - } - return false + return t.Size() == 4 && t.IsInteger() +} + +func isPtr(t Type) bool { + return t.IsPtr() } func isSigned(t Type) bool { - if b, ok := t.Underlying().(*types.Basic); ok { - switch b.Kind() { - case types.Int8, types.Int16, types.Int32, types.Int64: - return true - } - } - return false + return t.IsSigned() } -var sizer types.Sizes = &types.StdSizes{int64(ptrSize), int64(ptrSize)} // TODO(khr): from config func typeSize(t Type) int64 { - return sizer.Sizeof(t) + return t.Size() } diff --git a/src/cmd/internal/ssa/rulegen/generic.rules b/src/cmd/internal/ssa/rulegen/generic.rules index 1fc1620c5c..d17449930f 100644 --- a/src/cmd/internal/ssa/rulegen/generic.rules +++ b/src/cmd/internal/ssa/rulegen/generic.rules @@ -6,12 +6,14 @@ (Add (Const [c]) (Const [d])) && is64BitInt(t) && isSigned(t) -> (Const [{c.(int64)+d.(int64)}]) (Add (Const [c]) (Const [d])) && is64BitInt(t) && !isSigned(t) -> (Const [{c.(uint64)+d.(uint64)}]) -// load/store to stack -(Load (FPAddr [offset]) mem) -> (LoadFP [offset] mem) -(Store (FPAddr [offset]) val mem) -> (StoreFP [offset] val mem) - -(Load (SPAddr [offset]) mem) -> (LoadSP [offset] mem) -(Store (SPAddr [offset]) val mem) -> (StoreSP [offset] val mem) +// tear apart slices +// TODO: anything that generates a slice needs to go in here. +(SlicePtr (Load ptr mem)) -> (Load ptr mem) +(SliceLen (Load ptr mem)) -> (Load (Add ptr (Const [int64(v.Block.Func.Config.ptrSize)])) mem) +(SliceCap (Load ptr mem)) -> (Load (Add ptr (Const [int64(v.Block.Func.Config.ptrSize*2)])) mem) // expand array indexing // others? Depends on what is already done by frontend + +// Note: bounds check has already been done +(SliceIndex s i mem) -> (Load (Add (SlicePtr s) (Mul i (Const [s.Type.Elem().Size()]))) mem) diff --git a/src/cmd/internal/ssa/rulegen/lower_amd64.rules b/src/cmd/internal/ssa/rulegen/lower_amd64.rules index f60ac361ad..10c8dcc50f 100644 --- a/src/cmd/internal/ssa/rulegen/lower_amd64.rules +++ b/src/cmd/internal/ssa/rulegen/lower_amd64.rules @@ -13,35 +13,72 @@ // - aux will be nil if not specified. // x86 register conventions: -// - Integer types live in the low portion of registers. Upper portions are junk. +// - Integer types live in the low portion of registers. +// Upper portions are correctly extended. // - 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. // These are the lowerings themselves -(Add x y) && is64BitInt(t) -> (ADDQ x y) +(Add x y) && (is64BitInt(t) || isPtr(t)) -> (ADDQ x y) (Add x y) && is32BitInt(t) -> (ADDL x y) (Sub x y) && is64BitInt(t) -> (SUBQ x y) +(Mul x y) && is64BitInt(t) -> (MULQ x y) + (Less x y) && is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type) -> (SETL (CMPQ x y)) -// stack loads/stores -(LoadFP [offset] mem) && typeSize(t) == 8 -> (LoadFP8 [offset] mem) -(StoreFP [offset] val mem) && typeSize(val.Type) == 8 -> (StoreFP8 [offset] val mem) -(LoadSP [offset] mem) && typeSize(t) == 8 -> (LoadSP8 [offset] mem) -(StoreSP [offset] val mem) && typeSize(val.Type) == 8 -> (StoreSP8 [offset] val mem) +(Load ptr mem) && (is64BitInt(t) || isPtr(t)) -> (MOVQload [int64(0)] ptr mem) +(Store ptr val mem) && (is64BitInt(val.Type) || isPtr(val.Type)) -> (MOVQstore [int64(0)] ptr val mem) + +// checks +(CheckNil p) -> (SETNE (TESTQ p p)) +(CheckBound idx len) -> (SETB (CMPQ idx len)) // Rules below here apply some simple optimizations after lowering. // TODO: Should this be a separate pass? +// stack loads/stores +(MOVQload [off1] (FPAddr [off2]) mem) -> (MOVQloadFP [off1.(int64)+off2.(int64)] mem) +(MOVQload [off1] (SPAddr [off2]) mem) -> (MOVQloadSP [off1.(int64)+off2.(int64)] mem) +(MOVQstore [off1] (FPAddr [off2]) val mem) -> (MOVQstoreFP [off1.(int64)+off2.(int64)] val mem) +(MOVQstore [off1] (SPAddr [off2]) val mem) -> (MOVQstoreSP [off1.(int64)+off2.(int64)] val mem) + +// fold constants into instructions (ADDQ x (Const [c])) -> (ADDCQ [c] x) // TODO: restrict c to int32 range? (ADDQ (Const [c]) x) -> (ADDCQ [c] x) (SUBQ x (Const [c])) -> (SUBCQ x [c]) (SUBQ (Const [c]) x) -> (NEGQ (SUBCQ x [c])) +(MULQ x (Const [c])) -> (MULCQ [c] x) +(MULQ (Const [c]) x) -> (MULCQ [c] x) (CMPQ x (Const [c])) -> (CMPCQ x [c]) (CMPQ (Const [c]) x) -> (InvertFlags (CMPCQ x [c])) +// strength reduction +// TODO: do this a lot more generically +(MULCQ [c] x) && c.(int64) == 8 -> (SHLCQ [int64(3)] x) + +// fold add/shift into leaq +(ADDQ x (SHLCQ [shift] y)) && shift.(int64) == 3 -> (LEAQ8 [int64(0)] x y) +(ADDCQ [c] (LEAQ8 [d] x y)) -> (LEAQ8 [c.(int64)+d.(int64)] x y) + // reverse ordering of compare instruction (SETL (InvertFlags x)) -> (SETGE x) + +// fold constants into memory operations +// Note that this is not always a good idea because if not all the uses of +// the ADDCQ get eliminated, we still have to compute the ADDCQ and we now +// have potentially two live values (ptr and (ADDCQ [off] ptr)) instead of one. +// Nevertheless, let's do it! +(MOVQload [off1] (ADDCQ [off2] ptr) mem) -> (MOVQload [off1.(int64)+off2.(int64)] ptr mem) +(MOVQstore [off1] (ADDCQ [off2] ptr) val mem) -> (MOVQstore [off1.(int64)+off2.(int64)] ptr val mem) + +// indexed loads and stores +(MOVQload [off1] (LEAQ8 [off2] ptr idx) mem) -> (MOVQload8 [off1.(int64)+off2.(int64)] ptr idx mem) +(MOVQstore [off1] (LEAQ8 [off2] ptr idx) val mem) -> (MOVQstore8 [off1.(int64)+off2.(int64)] ptr idx val mem) + +// Combine the offset of a stack object with the offset within a stack object +(ADDCQ [off1] (FPAddr [off2])) -> (FPAddr [off1.(int64)+off2.(int64)]) +(ADDCQ [off1] (SPAddr [off2])) -> (SPAddr [off1.(int64)+off2.(int64)]) diff --git a/src/cmd/internal/ssa/rulegen/rulegen.go b/src/cmd/internal/ssa/rulegen/rulegen.go index 4038662ca8..31f46f7cce 100644 --- a/src/cmd/internal/ssa/rulegen/rulegen.go +++ b/src/cmd/internal/ssa/rulegen/rulegen.go @@ -14,6 +14,7 @@ package main import ( "bufio" "bytes" + "crypto/md5" "fmt" "go/format" "io" @@ -96,10 +97,15 @@ func main() { ops = append(ops, op) } sort.Strings(ops) - rulenum := 0 for _, op := range ops { fmt.Fprintf(w, "case Op%s:\n", op) for _, rule := range oprules[op] { + // Note: we use a hash to identify the rule so that its + // identity is invariant to adding/removing rules elsewhere + // in the rules file. This is useful to squash spurious + // diffs that would occur if we used rule index. + rulehash := fmt.Sprintf("%02x", md5.Sum([]byte(rule))) + // split at -> s := strings.Split(rule, "->") if len(s) != 2 { @@ -120,7 +126,7 @@ func main() { fmt.Fprintf(w, "// cond: %s\n", cond) fmt.Fprintf(w, "// result: %s\n", result) - fail := fmt.Sprintf("{\ngoto end%d\n}\n", rulenum) + fail := fmt.Sprintf("{\ngoto end%s\n}\n", rulehash) fmt.Fprintf(w, "{\n") genMatch(w, match, fail) @@ -133,8 +139,8 @@ func main() { fmt.Fprintf(w, "return true\n") fmt.Fprintf(w, "}\n") - fmt.Fprintf(w, "end%d:;\n", rulenum) - rulenum++ + fmt.Fprintf(w, "goto end%s\n", rulehash) // use label + fmt.Fprintf(w, "end%s:;\n", rulehash) } } fmt.Fprintf(w, "}\n") @@ -249,7 +255,7 @@ func genResult0(w io.Writer, result string, alloc *int, top bool) string { v = "v" fmt.Fprintf(w, "v.Op = Op%s\n", s[0]) fmt.Fprintf(w, "v.Aux = nil\n") - fmt.Fprintf(w, "v.Args = v.argstorage[:0]\n") + fmt.Fprintf(w, "v.resetArgs()\n") hasType = true } else { v = fmt.Sprintf("v%d", *alloc) diff --git a/src/cmd/internal/ssa/ssac/main.go b/src/cmd/internal/ssa/ssac/main.go index 361bc87bff..2afa7c6aa9 100644 --- a/src/cmd/internal/ssa/ssac/main.go +++ b/src/cmd/internal/ssa/ssac/main.go @@ -16,8 +16,6 @@ import ( "strconv" "strings" - "cmd/internal/ssa/types" - "cmd/internal/ssa" ) @@ -227,9 +225,9 @@ func buildFunc(lines []sexpr) *ssa.Func { b.Control = v } } - // link up thunks to their actual values + // link up forward references to their actual values for _, v := range b.Values { - if v.Op != ssa.OpThunk { + if v.Op != ssa.OpFwdRef { continue } varid := v.Aux.(int) @@ -302,7 +300,7 @@ func genExpr(state *ssaFuncState, b *ssa.Block, e sexpr) *ssa.Value { if err != nil { panic("bad cint value") } - return b.Func.ConstInt(c) + return b.Func.ConstInt(ssa.TypeInt64, c) case "LT": x := genExpr(state, b, e.parts[1]) y := genExpr(state, b, e.parts[2]) @@ -310,28 +308,30 @@ func genExpr(state *ssaFuncState, b *ssa.Block, e sexpr) *ssa.Value { v.AddArg(x) v.AddArg(y) return v - case "FP": - typ := state.types[e.parts[1].name] - offset, err := strconv.ParseInt(e.parts[2].name, 10, 64) - if err != nil { - panic(err) - } - v := b.NewValue(ssa.OpFPAddr, types.NewPointer(typ), offset) - return v - case "SP": - typ := state.types[e.parts[1].name] - offset, err := strconv.ParseInt(e.parts[2].name, 10, 64) - if err != nil { - panic(err) - } - v := b.NewValue(ssa.OpSPAddr, types.NewPointer(typ), offset) - return v - case "LOAD": - p := genExpr(state, b, e.parts[1]) - v := b.NewValue(ssa.OpLoad, p.Type.(*types.Pointer).Elem(), nil) - v.AddArg(p) - v.AddArg(genVar(state, b, state.memID)) - return v + /* + case "FP": + typ := state.types[e.parts[1].name] + offset, err := strconv.ParseInt(e.parts[2].name, 10, 64) + if err != nil { + panic(err) + } + v := b.NewValue(ssa.OpFPAddr, types.NewPointer(typ), offset) + return v + case "SP": + typ := state.types[e.parts[1].name] + offset, err := strconv.ParseInt(e.parts[2].name, 10, 64) + if err != nil { + panic(err) + } + v := b.NewValue(ssa.OpSPAddr, types.NewPointer(typ), offset) + return v + case "LOAD": + p := genExpr(state, b, e.parts[1]) + v := b.NewValue(ssa.OpLoad, p.Type.(*types.Pointer).Elem(), nil) + v.AddArg(p) + v.AddArg(genVar(state, b, state.memID)) + return v + */ default: fmt.Println(e.parts[0].name) panic("unknown op") @@ -372,9 +372,9 @@ func lookupVarOutgoing(state *ssaFuncState, b *ssa.Block, id int) *ssa.Value { return v } // We don't know about defined variables in this block (yet). - // Make a thunk for this variable. - fmt.Printf("making thunk for var=%d in block=%d\n", id, b.ID) - v = b.NewValue(ssa.OpThunk, state.vartypes[id], id) + // Make a forward reference for this variable. + fmt.Printf("making fwdRef for var=%d in block=%d\n", id, b.ID) + v = b.NewValue(ssa.OpFwdRef, state.vartypes[id], id) // memoize result state.defs[blockvar{b.ID, id}] = v @@ -400,7 +400,7 @@ func lookupVarIncoming(state *ssaFuncState, b *ssa.Block, id int) *ssa.Value { args[i] = lookupVarOutgoing(state, p, id) } - // if <=1 value that isn't this variable's thunk, don't make phi + // if <=1 value that isn't this variable's fwdRef, don't make phi v.Op = ssa.OpPhi v.AddArgs(args...) // note: order corresponding to b.Pred } @@ -418,20 +418,22 @@ func parseSexprType(e sexpr) ssa.Type { panic("unknown type") } } - if e.parts[0].name == "FUNC" { - // TODO: receiver? Already folded into args? Variadic? - var args, rets []*types.Var - for _, s := range e.parts[1].parts { - t := parseSexprType(s) - args = append(args, types.NewParam(0, nil, "noname", t)) - } - for _, s := range e.parts[2].parts { - t := parseSexprType(s) - rets = append(rets, types.NewParam(0, nil, "noname", t)) + /* + if e.parts[0].name == "FUNC" { + // TODO: receiver? Already folded into args? Variadic? + var args, rets []*types.Var + for _, s := range e.parts[1].parts { + t := parseSexprType(s) + args = append(args, types.NewParam(0, nil, "noname", t)) + } + for _, s := range e.parts[2].parts { + t := parseSexprType(s) + rets = append(rets, types.NewParam(0, nil, "noname", t)) + } + sig := types.NewSignature(nil, nil, types.NewTuple(args...), types.NewTuple(rets...), false) + return ssa.Type(sig) } - sig := types.NewSignature(nil, nil, types.NewTuple(args...), types.NewTuple(rets...), false) - return ssa.Type(sig) - } + */ // TODO: array/struct/... panic("compound type") } diff --git a/src/cmd/internal/ssa/type.go b/src/cmd/internal/ssa/type.go index 98efe54133..611c85834a 100644 --- a/src/cmd/internal/ssa/type.go +++ b/src/cmd/internal/ssa/type.go @@ -4,89 +4,71 @@ package ssa -import ( - "cmd/internal/ssa/types" // TODO: use golang.org/x/tools/go/types instead -) - -// We just inherit types from go/types -type Type types.Type - -var ( - // shortcuts for commonly used basic types - //TypeInt = types.Typ[types.Int] - //TypeUint = types.Typ[types.Uint] - TypeInt8 = types.Typ[types.Int8] - TypeInt16 = types.Typ[types.Int16] - TypeInt32 = types.Typ[types.Int32] - TypeInt64 = types.Typ[types.Int64] - TypeUint8 = types.Typ[types.Uint8] - TypeUint16 = types.Typ[types.Uint16] - TypeUint32 = types.Typ[types.Uint32] - TypeUint64 = types.Typ[types.Uint64] - //TypeUintptr = types.Typ[types.Uintptr] - TypeBool = types.Typ[types.Bool] - TypeString = types.Typ[types.String] +// TODO: use go/types instead? - TypeInvalid = types.Typ[types.Invalid] - - // Additional compiler-only types go here. - TypeMem = &Memory{} - TypeFlags = &Flags{} - - // TODO(khr): we probably shouldn't use int/uint/uintptr as Value types in the compiler. - // In OpConst's case, their width is the compiler's width, not the to-be-compiled - // program's width. For now, we can translate int/uint/uintptr to their specific - // widths variants before SSA. - // However, we may need at some point to maintain all possible user types in the - // compiler to handle things like interface conversion. At that point, we may - // need to revisit this decision. -) +// 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 -// typeIdentical reports whether its two arguments are the same type. -func typeIdentical(t, u Type) bool { - if t == TypeMem { - return u == TypeMem - } - if t == TypeFlags { - return u == TypeFlags - } - return types.Identical(t, u) -} + IsBoolean() bool // is a named or unnamed boolean type + IsInteger() bool // ... ditto for the others + IsSigned() bool + IsFloat() bool + IsPtr() bool -// A type representing all of memory -type Memory struct { -} + IsMemory() bool // special ssa-package-only types + IsFlags() bool -func (t *Memory) Underlying() types.Type { panic("Underlying of Memory") } -func (t *Memory) String() string { return "mem" } + Elem() Type // given []T or *T, return T + PtrTo() Type // given T, return *T -// A type representing the unknown type -type Unknown struct { + String() string } -func (t *Unknown) Underlying() types.Type { panic("Underlying of Unknown") } -func (t *Unknown) String() string { return "unk" } +// Stub implementation for now, until we are completely using ../gc:Type +type TypeImpl struct { + Size_ int64 + Boolean bool + Integer bool + Signed bool + Float bool + Ptr bool -// A type representing the void type. Used during building, should always -// be eliminated by the first deadcode pass. -type Void struct { -} + Memory bool + Flags bool -func (t *Void) Underlying() types.Type { panic("Underlying of Void") } -func (t *Void) String() string { return "void" } - -// A type representing the results of a nil check or bounds check. -// TODO: or type check? -// TODO: just use bool? -type Check struct { + Name string } -func (t *Check) Underlying() types.Type { panic("Underlying of Check") } -func (t *Check) String() string { return "check" } +func (t *TypeImpl) Size() int64 { return t.Size_ } +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) IsPtr() bool { return t.Ptr } +func (t *TypeImpl) IsMemory() bool { return t.Memory } +func (t *TypeImpl) IsFlags() bool { return t.Flags } +func (t *TypeImpl) String() string { return t.Name } +func (t *TypeImpl) Elem() Type { panic("not implemented"); return nil } +func (t *TypeImpl) PtrTo() Type { panic("not implemented"); return nil } -// x86 flags type -type Flags struct { -} +var ( + // shortcuts for commonly used basic types + TypeInt8 = &TypeImpl{Size_: 1, Integer: true, Signed: true, Name: "int8"} + TypeInt16 = &TypeImpl{Size_: 2, Integer: true, Signed: true, Name: "int16"} + TypeInt32 = &TypeImpl{Size_: 4, Integer: true, Signed: true, Name: "int32"} + TypeInt64 = &TypeImpl{Size_: 8, Integer: true, Signed: true, Name: "int64"} + TypeUInt8 = &TypeImpl{Size_: 1, Integer: true, Name: "uint8"} + TypeUInt16 = &TypeImpl{Size_: 2, Integer: true, Name: "uint16"} + TypeUInt32 = &TypeImpl{Size_: 4, Integer: true, Name: "uint32"} + TypeUInt64 = &TypeImpl{Size_: 8, Integer: true, Name: "uint64"} + TypeBool = &TypeImpl{Size_: 1, Boolean: true, Name: "bool"} + //TypeString = types.Typ[types.String] + + TypeInvalid = &TypeImpl{Name: "invalid"} -func (t *Flags) Underlying() types.Type { panic("Underlying of Flags") } -func (t *Flags) String() string { return "flags" } + // Additional compiler-only types go here. + TypeMem = &TypeImpl{Memory: true, Name: "mem"} + TypeFlags = &TypeImpl{Flags: true, Name: "flags"} +) diff --git a/src/cmd/internal/ssa/types/object.go b/src/cmd/internal/ssa/types/object.go deleted file mode 100644 index cd0be163b7..0000000000 --- a/src/cmd/internal/ssa/types/object.go +++ /dev/null @@ -1,39 +0,0 @@ -// 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 is a drop-in replacement for go/types -// for use until go/types is included in the main repo. - -package types - -// An Object describes a named language entity such as a package, -// constant, type, variable, function (incl. methods), or label. -// All objects implement the Object interface. -// -type Object interface { - Name() string // package local object name - Type() Type // object type -} - -// An object implements the common parts of an Object. -type object struct { - name string - typ Type -} - -func (obj *object) Name() string { return obj.name } -func (obj *object) Type() Type { return obj.typ } - -// A Variable represents a declared variable (including function parameters and results, and struct fields). -type Var struct { - object - anonymous bool // if set, the variable is an anonymous struct field, and name is the type name - visited bool // for initialization cycle detection - isField bool // var is struct field - used bool // set if the variable was used -} - -func NewParam(pos int, pkg *int, name string, typ Type) *Var { - return &Var{object: object{name, typ}, used: true} // parameters are always 'used' -} diff --git a/src/cmd/internal/ssa/types/sizes.go b/src/cmd/internal/ssa/types/sizes.go deleted file mode 100644 index b52f636fc5..0000000000 --- a/src/cmd/internal/ssa/types/sizes.go +++ /dev/null @@ -1,117 +0,0 @@ -// 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. - -// This file implements Sizes. - -package types - -import "log" - -// Sizes defines the sizing functions for package unsafe. -type Sizes interface { - // Alignof returns the alignment of a variable of type T. - // Alignof must implement the alignment guarantees required by the spec. - Alignof(T Type) int64 - - // Offsetsof returns the offsets of the given struct fields, in bytes. - // Offsetsof must implement the offset guarantees required by the spec. - Offsetsof(fields []*Var) []int64 - - // Sizeof returns the size of a variable of type T. - // Sizeof must implement the size guarantees required by the spec. - Sizeof(T Type) int64 -} - -// StdSizes is a convenience type for creating commonly used Sizes. -// It makes the following simplifying assumptions: -// -// - The size of explicitly sized basic types (int16, etc.) is the -// specified size. -// - The size of strings and interfaces is 2*WordSize. -// - The size of slices is 3*WordSize. -// - The size of an array of n elements corresponds to the size of -// a struct of n consecutive fields of the array's element type. -// - The size of a struct is the offset of the last field plus that -// field's size. As with all element types, if the struct is used -// in an array its size must first be aligned to a multiple of the -// struct's alignment. -// - All other types have size WordSize. -// - Arrays and structs are aligned per spec definition; all other -// types are naturally aligned with a maximum alignment MaxAlign. -// -// *StdSizes implements Sizes. -// -type StdSizes struct { - WordSize int64 // word size in bytes - must be >= 4 (32bits) - MaxAlign int64 // maximum alignment in bytes - must be >= 1 -} - -func (s *StdSizes) Alignof(T Type) int64 { - a := s.Sizeof(T) // may be 0 - // spec: "For a variable x of any type: unsafe.Alignof(x) is at least 1." - if a < 1 { - return 1 - } - if a > s.MaxAlign { - return s.MaxAlign - } - return a -} - -func (s *StdSizes) Offsetsof(fields []*Var) []int64 { - offsets := make([]int64, len(fields)) - var o int64 - for i, f := range fields { - a := s.Alignof(f.typ) - o = align(o, a) - offsets[i] = o - o += s.Sizeof(f.typ) - } - return offsets -} - -var basicSizes = [...]byte{ - Bool: 1, - Int8: 1, - Int16: 2, - Int32: 4, - Int64: 8, - Uint8: 1, - Uint16: 2, - Uint32: 4, - Uint64: 8, - Float32: 4, - Float64: 8, - Complex64: 8, - Complex128: 16, -} - -func (s *StdSizes) Sizeof(T Type) int64 { - switch t := T.Underlying().(type) { - case *Basic: - k := t.kind - if int(k) < len(basicSizes) { - if s := basicSizes[k]; s > 0 { - return int64(s) - } - } - if k == String { - return s.WordSize * 2 - } - case *Slice: - return s.WordSize * 3 - default: - log.Fatalf("not implemented") - } - return s.WordSize // catch-all -} - -// stdSizes is used if Config.Sizes == nil. -var stdSizes = StdSizes{8, 8} - -// align returns the smallest y >= x such that y % a == 0. -func align(x, a int64) int64 { - y := x + a - 1 - return y - y%a -} diff --git a/src/cmd/internal/ssa/types/type.go b/src/cmd/internal/ssa/types/type.go deleted file mode 100644 index e01de5c1e4..0000000000 --- a/src/cmd/internal/ssa/types/type.go +++ /dev/null @@ -1,229 +0,0 @@ -// 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 is a drop-in replacement for go/types -// for use until go/types is included in the main repo. - -package types - -// A Type represents a type of Go. -// All types implement the Type interface. -type Type interface { - // Underlying returns the underlying type of a type. - Underlying() Type - - // String returns a string representation of a type. - String() string -} - -// BasicKind describes the kind of basic type. -type BasicKind int - -const ( - Invalid BasicKind = iota // type is invalid - - // predeclared types - Bool - Int - Int8 - Int16 - Int32 - Int64 - Uint - Uint8 - Uint16 - Uint32 - Uint64 - Uintptr - Float32 - Float64 - Complex64 - Complex128 - String - UnsafePointer - - // types for untyped values - UntypedBool - UntypedInt - UntypedRune - UntypedFloat - UntypedComplex - UntypedString - UntypedNil - - // aliases - Byte = Uint8 - Rune = Int32 -) - -// BasicInfo is a set of flags describing properties of a basic type. -type BasicInfo int - -// Properties of basic types. -const ( - IsBoolean BasicInfo = 1 << iota - IsInteger - IsUnsigned - IsFloat - IsComplex - IsString - IsUntyped - - IsOrdered = IsInteger | IsFloat | IsString - IsNumeric = IsInteger | IsFloat | IsComplex - IsConstType = IsBoolean | IsNumeric | IsString -) - -// A Basic represents a basic type. -type Basic struct { - kind BasicKind - info BasicInfo - name string -} - -// Kind returns the kind of basic type b. -func (b *Basic) Kind() BasicKind { return b.kind } - -// Info returns information about properties of basic type b. -func (b *Basic) Info() BasicInfo { return b.info } - -// Name returns the name of basic type b. -func (b *Basic) Name() string { return b.name } - -// A Pointer represents a pointer type. -type Pointer struct { - base Type // element type -} - -// NewPointer returns a new pointer type for the given element (base) type. -func NewPointer(elem Type) *Pointer { return &Pointer{base: elem} } - -// Elem returns the element type for the given pointer p. -func (p *Pointer) Elem() Type { return p.base } - -// A Slice represents a slice type. -type Slice struct { - elem Type -} - -// NewSlice returns a new slice type for the given element type. -func NewSlice(elem Type) *Slice { return &Slice{elem} } - -// Elem returns the element type of slice s. -func (s *Slice) Elem() Type { return s.elem } - -// Implementations for Type methods. -func (t *Basic) Underlying() Type { return t } -func (t *Slice) Underlying() Type { return t } -func (t *Pointer) Underlying() Type { return t } -func (t *Signature) Underlying() Type { return t } - -func (b *Basic) String() string { return b.name } -func (t *Slice) String() string { return "[]" + t.elem.String() } -func (t *Pointer) String() string { return "*" + t.base.String() } -func (t *Signature) String() string { return "sig" /* TODO */ } - -var Typ = [...]*Basic{ - Invalid: {Invalid, 0, "invalid type"}, - - Bool: {Bool, IsBoolean, "bool"}, - Int: {Int, IsInteger, "int"}, - Int8: {Int8, IsInteger, "int8"}, - Int16: {Int16, IsInteger, "int16"}, - Int32: {Int32, IsInteger, "int32"}, - Int64: {Int64, IsInteger, "int64"}, - Uint: {Uint, IsInteger | IsUnsigned, "uint"}, - Uint8: {Uint8, IsInteger | IsUnsigned, "uint8"}, - Uint16: {Uint16, IsInteger | IsUnsigned, "uint16"}, - Uint32: {Uint32, IsInteger | IsUnsigned, "uint32"}, - Uint64: {Uint64, IsInteger | IsUnsigned, "uint64"}, - Uintptr: {Uintptr, IsInteger | IsUnsigned, "uintptr"}, - Float32: {Float32, IsFloat, "float32"}, - Float64: {Float64, IsFloat, "float64"}, - Complex64: {Complex64, IsComplex, "complex64"}, - Complex128: {Complex128, IsComplex, "complex128"}, - String: {String, IsString, "string"}, - UnsafePointer: {UnsafePointer, 0, "Pointer"}, - - UntypedBool: {UntypedBool, IsBoolean | IsUntyped, "untyped bool"}, - UntypedInt: {UntypedInt, IsInteger | IsUntyped, "untyped int"}, - UntypedRune: {UntypedRune, IsInteger | IsUntyped, "untyped rune"}, - UntypedFloat: {UntypedFloat, IsFloat | IsUntyped, "untyped float"}, - UntypedComplex: {UntypedComplex, IsComplex | IsUntyped, "untyped complex"}, - UntypedString: {UntypedString, IsString | IsUntyped, "untyped string"}, - UntypedNil: {UntypedNil, IsUntyped, "untyped nil"}, -} - -// Identical reports whether x and y are identical. -func Identical(x, y Type) bool { - if x == y { - return true - } - - switch x := x.(type) { - case *Basic: - // Basic types are singletons except for the rune and byte - // aliases, thus we cannot solely rely on the x == y check - // above. - if y, ok := y.(*Basic); ok { - return x.kind == y.kind - } - default: - panic("can't handle yet") - } - return false -} - -// A Tuple represents an ordered list of variables; a nil *Tuple is a valid (empty) tuple. -// Tuples are used as components of signatures and to represent the type of multiple -// assignments; they are not first class types of Go. -type Tuple struct { - vars []*Var -} - -// NewTuple returns a new tuple for the given variables. -func NewTuple(x ...*Var) *Tuple { - if len(x) > 0 { - return &Tuple{x} - } - return nil -} - -// Len returns the number variables of tuple t. -func (t *Tuple) Len() int { - if t != nil { - return len(t.vars) - } - return 0 -} - -// At returns the i'th variable of tuple t. -func (t *Tuple) At(i int) *Var { return t.vars[i] } - -// A Signature represents a (non-builtin) function or method type. -type Signature struct { - recv *Var // nil if not a method - params *Tuple // (incoming) parameters from left to right; or nil - results *Tuple // (outgoing) results from left to right; or nil - variadic bool // true if the last parameter's type is of the form ...T (or string, for append built-in only) -} - -// NewSignature returns a new function type for the given receiver, parameters, -// and results, either of which may be nil. If variadic is set, the function -// is variadic, it must have at least one parameter, and the last parameter -// must be of unnamed slice type. -func NewSignature(scope *int, recv *Var, params, results *Tuple, variadic bool) *Signature { - // TODO(gri) Should we rely on the correct (non-nil) incoming scope - // or should this function allocate and populate a scope? - if variadic { - n := params.Len() - if n == 0 { - panic("types.NewSignature: variadic function must have at least one parameter") - } - if _, ok := params.At(n - 1).typ.(*Slice); !ok { - panic("types.NewSignature: variadic parameter must be of unnamed slice type") - } - } - return &Signature{recv, params, results, variadic} -} diff --git a/src/cmd/internal/ssa/value.go b/src/cmd/internal/ssa/value.go index 389ba1ff77..dab6239dee 100644 --- a/src/cmd/internal/ssa/value.go +++ b/src/cmd/internal/ssa/value.go @@ -101,15 +101,3 @@ func (v *Value) resetArgs() { v.argstorage[1] = nil v.Args = v.argstorage[:0] } - -// CopyFrom converts v to be the same value as w. v and w must -// have the same type. -func (v *Value) CopyFrom(w *Value) { - if !typeIdentical(v.Type, w.Type) { - panic("copyFrom with unequal types") - } - v.Op = w.Op - v.Aux = w.Aux - v.resetArgs() - v.AddArgs(w.Args...) -} -- cgit v1.3 From a9a37dab4ac3b16cfeb865bd1ced940bc1d2004b Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Tue, 5 May 2015 16:19:12 -0700 Subject: [dev.ssa] cmd/internal/ssa: Add register allocation Add a simple register allocator. It does only intra-basicblock allocation. It uses a greedy one-pass allocation treating the register file as a cache. Change-Id: Ib6b52f48270e08dfda98f2dd842b05afc3ab01ce Reviewed-on: https://go-review.googlesource.com/9761 Reviewed-by: Alan Donovan --- src/cmd/internal/ssa/block.go | 5 +- src/cmd/internal/ssa/cgen.go | 3 - src/cmd/internal/ssa/compile.go | 25 ++- src/cmd/internal/ssa/critical.go | 2 +- src/cmd/internal/ssa/location.go | 2 +- src/cmd/internal/ssa/op.go | 50 +++-- src/cmd/internal/ssa/op_string.go | 4 +- src/cmd/internal/ssa/regalloc.go | 421 +++++++++++++++++++++++++++++++++++++ src/cmd/internal/ssa/sparseset.go | 19 +- src/cmd/internal/ssa/stackalloc.go | 51 +++++ 10 files changed, 542 insertions(+), 40 deletions(-) create mode 100644 src/cmd/internal/ssa/regalloc.go create mode 100644 src/cmd/internal/ssa/stackalloc.go (limited to 'src/cmd') diff --git a/src/cmd/internal/ssa/block.go b/src/cmd/internal/ssa/block.go index 81b5594f38..dcf3676bc2 100644 --- a/src/cmd/internal/ssa/block.go +++ b/src/cmd/internal/ssa/block.go @@ -19,7 +19,7 @@ type Block struct { Kind BlockKind // Subsequent blocks, if any. The number and order depend on the block kind. - // All blocks must be distinct (to make phi values in successors unambiguous). + // All successors must be distinct (to make phi values in successors unambiguous). Succs []*Block // Inverse of successors. @@ -33,8 +33,9 @@ type Block struct { // has a memory control value. Control *Value - // The unordered set of Values contained in this block. + // 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 diff --git a/src/cmd/internal/ssa/cgen.go b/src/cmd/internal/ssa/cgen.go index c13e715653..51c72aacd9 100644 --- a/src/cmd/internal/ssa/cgen.go +++ b/src/cmd/internal/ssa/cgen.go @@ -18,9 +18,6 @@ func cgen(f *Func) { // TODO: prolog, allocate stack frame - // hack for now, until regalloc is done - f.RegAlloc = make([]Location, f.NumValues()) - for idx, b := range f.Blocks { fmt.Printf("%d:\n", b.ID) for _, v := range b.Values { diff --git a/src/cmd/internal/ssa/compile.go b/src/cmd/internal/ssa/compile.go index 08477d470c..c1f7956791 100644 --- a/src/cmd/internal/ssa/compile.go +++ b/src/cmd/internal/ssa/compile.go @@ -63,8 +63,8 @@ var passes = [...]pass{ {"critical", critical}, // remove critical edges {"layout", layout}, // schedule blocks {"schedule", schedule}, // schedule values - // regalloc - // stack slot alloc (+size stack frame) + {"regalloc", regalloc}, + {"stackalloc", stackalloc}, {"cgen", cgen}, } @@ -72,19 +72,26 @@ var passes = [...]pass{ // This code is intended to document the ordering requirements // between different phases. It does not override the passes // list above. -var passOrder = map[string]string{ +type constraint struct { + a, b string // a must come before b +} + +var passOrder = [...]constraint{ // don't layout blocks until critical edges have been removed - "critical": "layout", + {"critical", "layout"}, // regalloc requires the removal of all critical edges - //"critical": "regalloc", + {"critical", "regalloc"}, // regalloc requires all the values in a block to be scheduled - //"schedule": "regalloc", - // code generation requires register allocation - //"regalloc": "cgen", + {"schedule", "regalloc"}, + // stack allocation requires register allocation + {"regalloc", "stackalloc"}, + // code generation requires stack allocation + {"stackalloc", "cgen"}, } func init() { - for a, b := range passOrder { + for _, c := range passOrder { + a, b := c.a, c.b i := -1 j := -1 for k, p := range passes { diff --git a/src/cmd/internal/ssa/critical.go b/src/cmd/internal/ssa/critical.go index 5bbad8f2f5..503681ffd3 100644 --- a/src/cmd/internal/ssa/critical.go +++ b/src/cmd/internal/ssa/critical.go @@ -29,7 +29,7 @@ func critical(f *Func) { // split input edges coming from multi-output blocks. for i, c := range b.Preds { if c.Kind == BlockPlain { - continue + continue // only single output block } // allocate a new block to place on the edge diff --git a/src/cmd/internal/ssa/location.go b/src/cmd/internal/ssa/location.go index 94c1b426a2..5fc2c5c934 100644 --- a/src/cmd/internal/ssa/location.go +++ b/src/cmd/internal/ssa/location.go @@ -28,7 +28,7 @@ type LocalSlot struct { } func (s *LocalSlot) Name() string { - return fmt.Sprintf("loc%d", s.idx) + return fmt.Sprintf("-%d(FP)", s.idx) } // An ArgSlot is a location in the parents' stack frame where it passed us an argument. diff --git a/src/cmd/internal/ssa/op.go b/src/cmd/internal/ssa/op.go index 600dc9faa6..2d60b92939 100644 --- a/src/cmd/internal/ssa/op.go +++ b/src/cmd/internal/ssa/op.go @@ -127,6 +127,9 @@ const ( OpMOVQstoreFP OpMOVQstoreSP + // materialize a constant into a register + OpMOVQconst + OpMax // sentinel ) @@ -151,14 +154,13 @@ type regMask uint64 var regs386 = [...]string{ "AX", - "BX", "CX", "DX", - "SI", - "DI", + "BX", "SP", "BP", - "X0", + "SI", + "DI", // pseudo registers "FLAGS", @@ -166,10 +168,10 @@ var regs386 = [...]string{ } // TODO: match up these with regs386 above -var gp regMask = 0xff -var cx regMask = 0x4 -var flags regMask = 1 << 9 -var overwrite0 regMask = 1 << 10 +var gp regMask = 0xef +var cx regMask = 0x2 +var flags regMask = 1 << 8 +var overwrite0 regMask = 1 << 9 const ( // possible properties of opcodes @@ -177,20 +179,23 @@ const ( // architecture constants Arch386 - ArchAmd64 - ArchArm + ArchAMD64 + ArchARM ) // general purpose registers, 2 input, 1 output var gp21 = [2][]regMask{{gp, gp}, {gp}} -var gp21_overwrite = [2][]regMask{{gp, gp}, {overwrite0}} +var gp21_overwrite = [2][]regMask{{gp, gp}, {gp}} // general purpose registers, 1 input, 1 output var gp11 = [2][]regMask{{gp}, {gp}} -var gp11_overwrite = [2][]regMask{{gp}, {overwrite0}} +var gp11_overwrite = [2][]regMask{{gp}, {gp}} + +// general purpose registers, 0 input, 1 output +var gp01 = [2][]regMask{{}, {gp}} // shift operations -var shift = [2][]regMask{{gp, cx}, {overwrite0}} +var shift = [2][]regMask{{gp, cx}, {gp}} var gp2_flags = [2][]regMask{{gp, gp}, {flags}} var gp1_flags = [2][]regMask{{gp}, {flags}} @@ -199,6 +204,9 @@ var gploadX = [2][]regMask{{gp, gp, 0}, {gp}} // indexed loads var gpstore = [2][]regMask{{gp, gp, 0}, {0}} var gpstoreX = [2][]regMask{{gp, gp, gp, 0}, {0}} // indexed stores +var gpload_stack = [2][]regMask{{0}, {gp}} +var gpstore_stack = [2][]regMask{{gp, 0}, {0}} + // Opcodes that represent the input Go program var genericTable = [...]OpInfo{ // the unknown op is used only during building and should not appear in a @@ -284,6 +292,8 @@ var amd64Table = [...]OpInfo{ OpMOVQload8: {asm: "MOVQ\t%A(%I0)(%I1*8),%O0", reg: gploadX}, OpMOVQstore8: {asm: "MOVQ\t%I2,%A(%I0)(%I1*8)", reg: gpstoreX}, + OpMOVQconst: {asm: "MOVQ\t$%A,%O0", reg: gp01}, + OpStaticCall: {asm: "CALL\t%A(SB)"}, OpCopy: {asm: "MOVQ\t%I0,%O0", reg: gp11}, @@ -292,17 +302,17 @@ var amd64Table = [...]OpInfo{ OpSETL: {}, // ops for load/store to stack - OpMOVQloadFP: {asm: "MOVQ\t%A(FP),%O0"}, - OpMOVQloadSP: {asm: "MOVQ\t%A(SP),%O0"}, - OpMOVQstoreFP: {asm: "MOVQ\t%I0,%A(FP)"}, - OpMOVQstoreSP: {asm: "MOVQ\t%I0,%A(SP)"}, + OpMOVQloadFP: {asm: "MOVQ\t%A(FP),%O0", reg: gpload_stack}, // mem -> value + OpMOVQloadSP: {asm: "MOVQ\t%A(SP),%O0", reg: gpload_stack}, // mem -> value + OpMOVQstoreFP: {asm: "MOVQ\t%I0,%A(FP)", reg: gpstore_stack}, // mem, value -> mem + OpMOVQstoreSP: {asm: "MOVQ\t%I0,%A(SP)", reg: gpstore_stack}, // mem, value -> mem // ops for spilling of registers // unlike regular loads & stores, these take no memory argument. // They are just like OpCopy but we use them during register allocation. // TODO: different widths, float - OpLoadReg8: {asm: "MOVQ\t%I0,%O0", reg: gp11}, - OpStoreReg8: {asm: "MOVQ\t%I0,%O0", reg: gp11}, + OpLoadReg8: {asm: "MOVQ\t%I0,%O0"}, + OpStoreReg8: {asm: "MOVQ\t%I0,%O0"}, } // A Table is a list of opcodes with a common set of flags. @@ -313,7 +323,7 @@ type Table struct { var tables = []Table{ {genericTable[:], 0}, - {amd64Table[:], ArchAmd64}, // TODO: pick this dynamically + {amd64Table[:], ArchAMD64}, // TODO: pick this dynamically } // table of opcodes, indexed by opcode ID diff --git a/src/cmd/internal/ssa/op_string.go b/src/cmd/internal/ssa/op_string.go index 5c42d22439..c095fba52b 100644 --- a/src/cmd/internal/ssa/op_string.go +++ b/src/cmd/internal/ssa/op_string.go @@ -4,9 +4,9 @@ package ssa import "fmt" -const _Op_name = "OpUnknownOpNopOpFwdRefOpAddOpSubOpMulOpLessOpConstOpArgOpGlobalOpFuncOpCopyOpPhiOpSliceMakeOpSlicePtrOpSliceLenOpSliceCapOpStringMakeOpStringPtrOpStringLenOpSliceIndexOpSliceIndexAddrOpLoadOpStoreOpCheckNilOpCheckBoundOpCallOpStaticCallOpConvertOpConvNopOpFPAddrOpSPAddrOpStoreReg8OpLoadReg8OpADDQOpSUBQOpADDCQOpSUBCQOpMULQOpMULCQOpSHLQOpSHLCQOpNEGQOpCMPQOpCMPCQOpADDLOpTESTQOpSETEQOpSETNEOpSETLOpSETGEOpSETBOpInvertFlagsOpLEAQOpLEAQ2OpLEAQ4OpLEAQ8OpMOVQloadOpMOVQstoreOpMOVQload8OpMOVQstore8OpMOVQloadFPOpMOVQloadSPOpMOVQstoreFPOpMOVQstoreSPOpMax" +const _Op_name = "OpUnknownOpNopOpFwdRefOpAddOpSubOpMulOpLessOpConstOpArgOpGlobalOpFuncOpCopyOpPhiOpSliceMakeOpSlicePtrOpSliceLenOpSliceCapOpStringMakeOpStringPtrOpStringLenOpSliceIndexOpSliceIndexAddrOpLoadOpStoreOpCheckNilOpCheckBoundOpCallOpStaticCallOpConvertOpConvNopOpFPAddrOpSPAddrOpStoreReg8OpLoadReg8OpADDQOpSUBQOpADDCQOpSUBCQOpMULQOpMULCQOpSHLQOpSHLCQOpNEGQOpCMPQOpCMPCQOpADDLOpTESTQOpSETEQOpSETNEOpSETLOpSETGEOpSETBOpInvertFlagsOpLEAQOpLEAQ2OpLEAQ4OpLEAQ8OpMOVQloadOpMOVQstoreOpMOVQload8OpMOVQstore8OpMOVQloadFPOpMOVQloadSPOpMOVQstoreFPOpMOVQstoreSPOpMOVQconstOpMax" -var _Op_index = [...]uint16{0, 9, 14, 22, 27, 32, 37, 43, 50, 55, 63, 69, 75, 80, 91, 101, 111, 121, 133, 144, 155, 167, 183, 189, 196, 206, 218, 224, 236, 245, 254, 262, 270, 281, 291, 297, 303, 310, 317, 323, 330, 336, 343, 349, 355, 362, 368, 375, 382, 389, 395, 402, 408, 421, 427, 434, 441, 448, 458, 469, 480, 492, 504, 516, 529, 542, 547} +var _Op_index = [...]uint16{0, 9, 14, 22, 27, 32, 37, 43, 50, 55, 63, 69, 75, 80, 91, 101, 111, 121, 133, 144, 155, 167, 183, 189, 196, 206, 218, 224, 236, 245, 254, 262, 270, 281, 291, 297, 303, 310, 317, 323, 330, 336, 343, 349, 355, 362, 368, 375, 382, 389, 395, 402, 408, 421, 427, 434, 441, 448, 458, 469, 480, 492, 504, 516, 529, 542, 553, 558} func (i Op) String() string { if i < 0 || i+1 >= Op(len(_Op_index)) { diff --git a/src/cmd/internal/ssa/regalloc.go b/src/cmd/internal/ssa/regalloc.go new file mode 100644 index 0000000000..724a0557d5 --- /dev/null +++ b/src/cmd/internal/ssa/regalloc.go @@ -0,0 +1,421 @@ +package ssa + +import ( + "fmt" + "log" + "sort" +) + +func setloc(home []Location, v *Value, loc Location) []Location { + for v.ID >= ID(len(home)) { + home = append(home, nil) + } + home[v.ID] = loc + return home +} + +type register uint + +// TODO: make arch-dependent +var numRegs register = 32 + +var registers = [...]Register{ + Register{"AX"}, + Register{"CX"}, + Register{"DX"}, + Register{"BX"}, + Register{"SP"}, + Register{"BP"}, + Register{"SI"}, + Register{"DI"}, + + // TODO R8, X0, ... + // TODO: make arch-dependent + Register{"FLAGS"}, + Register{"OVERWRITE"}, +} + +// 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 + } +} + +// regalloc performs register allocation on f. It sets f.RegAlloc +// to the resulting allocation. +func regalloc(f *Func) { + // For now, a very simple allocator. Everything has a home + // location on the stack (TBD as a subsequent stackalloc pass). + // Values live in the home locations at basic block boundaries. + // We use a simple greedy allocator within a basic block. + home := make([]Location, f.NumValues()) + + addPhiCopies(f) // add copies of phi inputs in preceeding blocks + + // Compute live values at the end of each block. + live := live(f) + lastUse := make([]int, f.NumValues()) + + var oldSched []*Value + + // Register allocate each block separately. All live values will live + // in home locations (stack slots) between blocks. + for _, b := range f.Blocks { + + // Compute the index of the last use of each Value in the Block. + // Scheduling has already happened, so Values are totally ordered. + // lastUse[x] = max(i) where b.Value[i] uses Value x. + for i, v := range b.Values { + lastUse[v.ID] = -1 + for _, w := range v.Args { + // could condition this store on w.Block == b, but no need + lastUse[w.ID] = i + } + } + // Values which are live at block exit have a lastUse of len(b.Values). + if b.Control != nil { + lastUse[b.Control.ID] = len(b.Values) + } + // Values live after block exit have a lastUse of len(b.Values)+1. + for _, vid := range live[b.ID] { + lastUse[vid] = len(b.Values) + 1 + } + + // For each register, store which value it contains + type regInfo struct { + v *Value // stack-homed original value (or nil if empty) + c *Value // the register copy of v + dirty bool // if the stack-homed copy is out of date + } + regs := make([]regInfo, numRegs) + + var used regMask // has a 1 for each non-nil entry in regs + var dirty regMask // has a 1 for each dirty entry in regs + + oldSched = append(oldSched[:0], b.Values...) + b.Values = b.Values[:0] + + for idx, v := range oldSched { + // For each instruction, do: + // set up inputs to v in registers + // pick output register + // run insn + // mark output register as dirty + // Note that v represents the Value at "home" (on the stack), and c + // is its register equivalent. There are two ways to establish c: + // - use of v. c will be a load from v's home. + // - definition of v. c will be identical to v but will live in + // a register. v will be modified into a spill of c. + regspec := opcodeTable[v.Op].reg + if v.Op == OpConvNop { + regspec = opcodeTable[v.Args[0].Op].reg + } + inputs := regspec[0] + outputs := regspec[1] + if len(inputs) == 0 && len(outputs) == 0 { + // No register allocation required (or none specified yet) + b.Values = append(b.Values, v) + continue + } + + // Compute a good input ordering. Start with the most constrained input. + order := make([]intPair, len(inputs)) + for i, input := range inputs { + order[i] = intPair{countRegs(input), i} + } + sort.Sort(byKey(order)) + + // nospill contains registers that we can't spill because + // we already set them up for use by the current instruction. + var nospill regMask + + // Move inputs into registers + for _, o := range order { + w := v.Args[o.val] + mask := inputs[o.val] + if mask == 0 { + // Input doesn't need a register + continue + } + // TODO: 2-address overwrite instructions + + // Find registers that w is already in + var wreg regMask + for r := register(0); r < numRegs; r++ { + if regs[r].v == w { + wreg |= regMask(1) << r + } + } + + var r register + if mask&wreg != 0 { + // w is already in an allowed register. We're done. + r = pickReg(mask & wreg) + } else { + // Pick a register for w + // Priorities (in order) + // - an unused register + // - a clean register + // - a dirty register + // TODO: for used registers, pick the one whose next use is the + // farthest in the future. + mask &^= nospill + if mask & ^dirty != 0 { + mask &^= dirty + } + if mask & ^used != 0 { + mask &^= used + } + r = pickReg(mask) + + // Kick out whomever is using this register. + if regs[r].v != nil { + x := regs[r].v + c := regs[r].c + if regs[r].dirty && lastUse[x.ID] > idx { + // Write x back to home. Its value is currently held in c. + x.Op = OpStoreReg8 + x.Aux = nil + x.resetArgs() + x.AddArg(c) + b.Values = append(b.Values, x) + regs[r].dirty = false + dirty &^= regMask(1) << r + } + regs[r].v = nil + regs[r].c = nil + used &^= regMask(1) << r + } + + // Load w into this register + var c *Value + if w.Op == OpConst { + // Materialize w + // TODO: arch-specific MOV op + c = b.NewValue(OpMOVQconst, w.Type, w.Aux) + } else if wreg != 0 { + // Copy from another register. + // Typically just an optimization, but this is + // required if w is dirty. + s := pickReg(wreg) + // inv: s != r + c = b.NewValue(OpCopy, w.Type, nil) + c.AddArg(regs[s].c) + } else { + // Load from home location + c = b.NewValue(OpLoadReg8, w.Type, nil) + c.AddArg(w) + } + home = setloc(home, c, ®isters[r]) + // Remember what we did + regs[r].v = w + regs[r].c = c + regs[r].dirty = false + used |= regMask(1) << r + } + + // Replace w with its in-register copy. + v.SetArg(o.val, regs[r].c) + + // Remember not to undo this register assignment until after + // the instruction is issued. + nospill |= regMask(1) << r + } + + // pick a register for v itself. + if len(outputs) > 1 { + panic("can't do multi-output yet") + } + if len(outputs) == 0 || outputs[0] == 0 { + // output doesn't need a register + b.Values = append(b.Values, v) + } else { + mask := outputs[0] + if mask & ^dirty != 0 { + mask &^= dirty + } + if mask & ^used != 0 { + mask &^= used + } + r := pickReg(mask) + + // Kick out whomever is using this register. + if regs[r].v != nil { + x := regs[r].v + c := regs[r].c + if regs[r].dirty && lastUse[x.ID] > idx { + // Write x back to home. Its value is currently held in c. + x.Op = OpStoreReg8 + x.Aux = nil + x.resetArgs() + x.AddArg(c) + b.Values = append(b.Values, x) + regs[r].dirty = false + dirty &^= regMask(1) << r + } + regs[r].v = nil + regs[r].c = nil + used &^= regMask(1) << r + } + + // Reissue v with new op, with r as its home. + c := b.NewValue(v.Op, v.Type, v.Aux) + c.AddArgs(v.Args...) + home = setloc(home, c, ®isters[r]) + + // Remember what we did + regs[r].v = v + regs[r].c = c + regs[r].dirty = true + used |= regMask(1) << r + dirty |= regMask(1) << r + } + } + + // If the block ends in a call, we must put the call after the spill code. + var call *Value + if b.Kind == BlockCall { + call = b.Control + if call != b.Values[len(b.Values)-1] { + log.Fatalf("call not at end of block %b %v", b, call) + } + b.Values = b.Values[:len(b.Values)-1] + // TODO: do this for all control types? + } + + // at the end of the block, spill any remaining dirty, live values + for r := register(0); r < numRegs; r++ { + if !regs[r].dirty { + continue + } + v := regs[r].v + c := regs[r].c + if lastUse[v.ID] <= len(oldSched) { + continue // not live after block + } + + // change v to be a copy of c + v.Op = OpStoreReg8 + v.Aux = nil + v.resetArgs() + v.AddArg(c) + b.Values = append(b.Values, v) + } + + // add call back after spills + if b.Kind == BlockCall { + b.Values = append(b.Values, call) + } + } + f.RegAlloc = home +} + +// addPhiCopies adds copies of phi inputs in the blocks +// immediately preceding the phi's block. +func addPhiCopies(f *Func) { + for _, b := range f.Blocks { + for _, v := range b.Values { + if v.Op != OpPhi { + break // all phis should appear first + } + if v.Type.IsMemory() { // TODO: only "regallocable" types + continue + } + for i, w := range v.Args { + c := b.Preds[i] + cpy := c.NewValue1(OpCopy, v.Type, nil, w) + v.Args[i] = cpy + } + } + } +} + +// live returns a map from block ID to a list of 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 live(f *Func) [][]ID { + live := make([][]ID, f.NumBlocks()) + var phis []*Value + + s := newSparseSet(f.NumValues()) + t := newSparseSet(f.NumValues()) + for { + for _, b := range f.Blocks { + fmt.Printf("live %s %v\n", b, live[b.ID]) + } + changed := false + + for _, b := range f.Blocks { + // Start with known live values at the end of the block + s.clear() + s.addAll(live[b.ID]) + + // 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] + s.remove(v.ID) + if v.Op == OpPhi { + // save phi ops for later + phis = append(phis, v) + continue + } + s.addAllValues(v.Args) + } + + // for each predecessor of b, expand its list of live-at-end values + // inv: s contains the values live at the start of b (excluding phi inputs) + for i, p := range b.Preds { + t.clear() + t.addAll(live[p.ID]) + t.addAll(s.contents()) + for _, v := range phis { + t.add(v.Args[i].ID) + } + if t.size() == len(live[p.ID]) { + continue + } + // grow p's live set + c := make([]ID, t.size()) + copy(c, t.contents()) + live[p.ID] = c + changed = true + } + } + + if !changed { + break + } + } + return live +} + +// 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/internal/ssa/sparseset.go b/src/cmd/internal/ssa/sparseset.go index e1f9a9a81d..b79aee8497 100644 --- a/src/cmd/internal/ssa/sparseset.go +++ b/src/cmd/internal/ssa/sparseset.go @@ -28,9 +28,24 @@ func (s *sparseSet) contains(x ID) bool { } func (s *sparseSet) add(x ID) { - i := len(s.dense) + i := s.sparse[x] + if i < len(s.dense) && s.dense[i] == x { + return + } s.dense = append(s.dense, x) - s.sparse[x] = i + 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) { diff --git a/src/cmd/internal/ssa/stackalloc.go b/src/cmd/internal/ssa/stackalloc.go new file mode 100644 index 0000000000..aa6d829fa2 --- /dev/null +++ b/src/cmd/internal/ssa/stackalloc.go @@ -0,0 +1,51 @@ +package ssa + +// stackalloc allocates storage in the stack frame for +// all Values that did not get a register. +func stackalloc(f *Func) { + home := f.RegAlloc + + var n int64 = 8 // 8 = space for return address. TODO: arch-dependent + + // Assign stack locations to phis first, because we + // must also assign the same locations to the phi copies + // introduced during regalloc. + for _, b := range f.Blocks { + for _, v := range b.Values { + if v.Op != OpPhi { + continue + } + n += v.Type.Size() + // a := v.Type.Align() + // n = (n + a - 1) / a * a TODO + loc := &LocalSlot{n} + home = setloc(home, v, loc) + for _, w := range v.Args { + home = setloc(home, w, loc) + } + } + } + + // Now do all other unassigned values. + for _, b := range f.Blocks { + for _, v := range b.Values { + if v.ID < ID(len(home)) && home[v.ID] != nil { + continue + } + if v.Type.IsMemory() { // TODO: only "regallocable" types + continue + } + // a := v.Type.Align() + // n = (n + a - 1) / a * a TODO + n += v.Type.Size() + loc := &LocalSlot{n} + home = setloc(home, v, loc) + } + } + f.RegAlloc = home + + // TODO: share stack slots among noninterfering (& gc type compatible) values + // TODO: align final n + // TODO: compute total frame size: n + max paramout space + // TODO: save total size somewhere +} -- cgit v1.3 From 23df95b9b509c80a2ebef2fe91a90c32d242005a Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Tue, 12 May 2015 15:16:52 -0700 Subject: [dev.ssa] cmd/internal/ssa: implement global variables Fix a few compilation errors due to previous merge from tip. Change-Id: I826ad5a9d602a8f8be2762ad00b030dea6f41bcc Reviewed-on: https://go-review.googlesource.com/9967 Reviewed-by: Alan Donovan --- src/cmd/internal/gc/ssa.go | 13 ++++++-- src/cmd/internal/gc/type.go | 4 --- src/cmd/internal/ssa/lowerAmd64.go | 42 ++++++++++++++++++++++++++ src/cmd/internal/ssa/op.go | 17 ++++++++++- src/cmd/internal/ssa/op_string.go | 4 +-- src/cmd/internal/ssa/rulegen/lower_amd64.rules | 4 +++ 6 files changed, 75 insertions(+), 9 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/internal/gc/ssa.go b/src/cmd/internal/gc/ssa.go index 415e9dc639..ec747e970b 100644 --- a/src/cmd/internal/gc/ssa.go +++ b/src/cmd/internal/gc/ssa.go @@ -153,12 +153,16 @@ func (s *ssaState) stmt(n *Node) { // TODO(khr): nil check s.vars[".mem"] = s.curBlock.NewValue3(ssa.OpStore, n.Right.Type, nil, addr, val, s.mem()) - } else if n.Left.Addable == 0 { + } else if !n.Left.Addable { // TODO log.Fatalf("assignment to non-addable value") } else if n.Left.Class&PHEAP != 0 { // TODO log.Fatalf("assignment to heap value") + } else if n.Left.Class == PEXTERN { + // assign to global variable + addr := s.f.Entry.NewValue(ssa.OpGlobal, Ptrto(n.Left.Type), n.Left.Sym) + s.vars[".mem"] = s.curBlock.NewValue3(ssa.OpStore, ssa.TypeMem, nil, addr, val, s.mem()) } else if n.Left.Class == PPARAMOUT { // store to parameter slot addr := s.f.Entry.NewValue(ssa.OpFPAddr, Ptrto(n.Right.Type), n.Left.Xoffset) @@ -254,7 +258,12 @@ func (s *ssaState) expr(n *Node) *ssa.Value { } switch n.Op { case ONAME: - // remember offsets for PPARAM names + // TODO: remember offsets for PPARAM names + if n.Class == PEXTERN { + // global variable + addr := s.f.Entry.NewValue(ssa.OpGlobal, Ptrto(n.Type), n.Sym) + return s.curBlock.NewValue2(ssa.OpLoad, n.Type, nil, addr, s.mem()) + } s.argOffsets[n.Sym.Name] = n.Xoffset return s.variable(n.Sym.Name, n.Type) // binary ops diff --git a/src/cmd/internal/gc/type.go b/src/cmd/internal/gc/type.go index e88ca7c898..6f7830d70a 100644 --- a/src/cmd/internal/gc/type.go +++ b/src/cmd/internal/gc/type.go @@ -56,7 +56,3 @@ func (t *Type) PtrTo() ssa.Type { func (t *Type) IsMemory() bool { return false } func (t *Type) IsFlags() bool { return false } - -func (t *Type) String() string { - return typefmt(t, 0) -} diff --git a/src/cmd/internal/ssa/lowerAmd64.go b/src/cmd/internal/ssa/lowerAmd64.go index 6c0a42d976..842822bda4 100644 --- a/src/cmd/internal/ssa/lowerAmd64.go +++ b/src/cmd/internal/ssa/lowerAmd64.go @@ -333,6 +333,26 @@ func lowerAmd64(v *Value) bool { } goto end3d8628a6536350a123be81240b8a1376 end3d8628a6536350a123be81240b8a1376: + ; + // match: (MOVQload [off] (Global [sym]) mem) + // cond: + // result: (MOVQloadglobal [GlobalOffset{sym,off.(int64)}] mem) + { + off := v.Aux + if v.Args[0].Op != OpGlobal { + goto end20693899317f3f8d1b47fefa64087654 + } + sym := v.Args[0].Aux + mem := v.Args[1] + v.Op = OpMOVQloadglobal + v.Aux = nil + v.resetArgs() + v.Aux = GlobalOffset{sym, off.(int64)} + v.AddArg(mem) + return true + } + goto end20693899317f3f8d1b47fefa64087654 + end20693899317f3f8d1b47fefa64087654: ; // match: (MOVQload [off1] (ADDCQ [off2] ptr) mem) // cond: @@ -424,6 +444,28 @@ func lowerAmd64(v *Value) bool { } goto end1cb5b7e766f018270fa434c6f46f607f end1cb5b7e766f018270fa434c6f46f607f: + ; + // match: (MOVQstore [off] (Global [sym]) val mem) + // cond: + // result: (MOVQstoreglobal [GlobalOffset{sym,off.(int64)}] val mem) + { + off := v.Aux + if v.Args[0].Op != OpGlobal { + goto end657d07e37c720a8fbb108a31bb48090d + } + sym := v.Args[0].Aux + val := v.Args[1] + mem := v.Args[2] + v.Op = OpMOVQstoreglobal + v.Aux = nil + v.resetArgs() + v.Aux = GlobalOffset{sym, off.(int64)} + v.AddArg(val) + v.AddArg(mem) + return true + } + goto end657d07e37c720a8fbb108a31bb48090d + end657d07e37c720a8fbb108a31bb48090d: ; // match: (MOVQstore [off1] (ADDCQ [off2] ptr) val mem) // cond: diff --git a/src/cmd/internal/ssa/op.go b/src/cmd/internal/ssa/op.go index 2d60b92939..1d374db61d 100644 --- a/src/cmd/internal/ssa/op.go +++ b/src/cmd/internal/ssa/op.go @@ -37,7 +37,7 @@ const ( OpConst OpArg // address of a function parameter/result. Memory input is an arg called ".mem". - OpGlobal // address of a global variable + OpGlobal // address of a global variable (aux is a *gc.Sym) OpFunc // entry address of a function OpCopy // output = input OpPhi // select an input based on which predecessor we came from @@ -121,6 +121,10 @@ const ( OpMOVQload8 // (ptr,idx,mem): loads from ptr+idx*8+aux.(int64) OpMOVQstore8 // (ptr,idx,val,mem): stores to ptr+idx*8+aux.(int64), returns mem + // load/store from global. aux = GlobalOffset + OpMOVQloadglobal // (mem) -> value + OpMOVQstoreglobal // (val, mem) -> mem + // load/store 8-byte integer register from stack slot. OpMOVQloadFP OpMOVQloadSP @@ -133,6 +137,12 @@ const ( OpMax // sentinel ) +// GlobalOffset represents a fixed offset within a global variable +type GlobalOffset struct { + Global interface{} // holds a *cmd/internal/gc.Sym + Offset int64 +} + //go:generate stringer -type=Op type OpInfo struct { @@ -203,6 +213,8 @@ var gpload = [2][]regMask{{gp, 0}, {gp}} var gploadX = [2][]regMask{{gp, gp, 0}, {gp}} // indexed loads var gpstore = [2][]regMask{{gp, gp, 0}, {0}} var gpstoreX = [2][]regMask{{gp, gp, gp, 0}, {0}} // indexed stores +var gploadglobal = [2][]regMask{{0}, {gp}} +var gpstoreglobal = [2][]regMask{{gp, 0}, {0}} var gpload_stack = [2][]regMask{{0}, {gp}} var gpstore_stack = [2][]regMask{{gp, 0}, {0}} @@ -292,6 +304,9 @@ var amd64Table = [...]OpInfo{ OpMOVQload8: {asm: "MOVQ\t%A(%I0)(%I1*8),%O0", reg: gploadX}, OpMOVQstore8: {asm: "MOVQ\t%I2,%A(%I0)(%I1*8)", reg: gpstoreX}, + OpMOVQloadglobal: {reg: gploadglobal}, + OpMOVQstoreglobal: {reg: gpstoreglobal}, + OpMOVQconst: {asm: "MOVQ\t$%A,%O0", reg: gp01}, OpStaticCall: {asm: "CALL\t%A(SB)"}, diff --git a/src/cmd/internal/ssa/op_string.go b/src/cmd/internal/ssa/op_string.go index c095fba52b..adce17a1f2 100644 --- a/src/cmd/internal/ssa/op_string.go +++ b/src/cmd/internal/ssa/op_string.go @@ -4,9 +4,9 @@ package ssa import "fmt" -const _Op_name = "OpUnknownOpNopOpFwdRefOpAddOpSubOpMulOpLessOpConstOpArgOpGlobalOpFuncOpCopyOpPhiOpSliceMakeOpSlicePtrOpSliceLenOpSliceCapOpStringMakeOpStringPtrOpStringLenOpSliceIndexOpSliceIndexAddrOpLoadOpStoreOpCheckNilOpCheckBoundOpCallOpStaticCallOpConvertOpConvNopOpFPAddrOpSPAddrOpStoreReg8OpLoadReg8OpADDQOpSUBQOpADDCQOpSUBCQOpMULQOpMULCQOpSHLQOpSHLCQOpNEGQOpCMPQOpCMPCQOpADDLOpTESTQOpSETEQOpSETNEOpSETLOpSETGEOpSETBOpInvertFlagsOpLEAQOpLEAQ2OpLEAQ4OpLEAQ8OpMOVQloadOpMOVQstoreOpMOVQload8OpMOVQstore8OpMOVQloadFPOpMOVQloadSPOpMOVQstoreFPOpMOVQstoreSPOpMOVQconstOpMax" +const _Op_name = "OpUnknownOpNopOpFwdRefOpAddOpSubOpMulOpLessOpConstOpArgOpGlobalOpFuncOpCopyOpPhiOpSliceMakeOpSlicePtrOpSliceLenOpSliceCapOpStringMakeOpStringPtrOpStringLenOpSliceIndexOpSliceIndexAddrOpLoadOpStoreOpCheckNilOpCheckBoundOpCallOpStaticCallOpConvertOpConvNopOpFPAddrOpSPAddrOpStoreReg8OpLoadReg8OpADDQOpSUBQOpADDCQOpSUBCQOpMULQOpMULCQOpSHLQOpSHLCQOpNEGQOpCMPQOpCMPCQOpADDLOpTESTQOpSETEQOpSETNEOpSETLOpSETGEOpSETBOpInvertFlagsOpLEAQOpLEAQ2OpLEAQ4OpLEAQ8OpMOVQloadOpMOVQstoreOpMOVQload8OpMOVQstore8OpMOVQloadglobalOpMOVQstoreglobalOpMOVQloadFPOpMOVQloadSPOpMOVQstoreFPOpMOVQstoreSPOpMOVQconstOpMax" -var _Op_index = [...]uint16{0, 9, 14, 22, 27, 32, 37, 43, 50, 55, 63, 69, 75, 80, 91, 101, 111, 121, 133, 144, 155, 167, 183, 189, 196, 206, 218, 224, 236, 245, 254, 262, 270, 281, 291, 297, 303, 310, 317, 323, 330, 336, 343, 349, 355, 362, 368, 375, 382, 389, 395, 402, 408, 421, 427, 434, 441, 448, 458, 469, 480, 492, 504, 516, 529, 542, 553, 558} +var _Op_index = [...]uint16{0, 9, 14, 22, 27, 32, 37, 43, 50, 55, 63, 69, 75, 80, 91, 101, 111, 121, 133, 144, 155, 167, 183, 189, 196, 206, 218, 224, 236, 245, 254, 262, 270, 281, 291, 297, 303, 310, 317, 323, 330, 336, 343, 349, 355, 362, 368, 375, 382, 389, 395, 402, 408, 421, 427, 434, 441, 448, 458, 469, 480, 492, 508, 525, 537, 549, 562, 575, 586, 591} func (i Op) String() string { if i < 0 || i+1 >= Op(len(_Op_index)) { diff --git a/src/cmd/internal/ssa/rulegen/lower_amd64.rules b/src/cmd/internal/ssa/rulegen/lower_amd64.rules index 10c8dcc50f..8882e3c253 100644 --- a/src/cmd/internal/ssa/rulegen/lower_amd64.rules +++ b/src/cmd/internal/ssa/rulegen/lower_amd64.rules @@ -46,6 +46,10 @@ (MOVQstore [off1] (FPAddr [off2]) val mem) -> (MOVQstoreFP [off1.(int64)+off2.(int64)] val mem) (MOVQstore [off1] (SPAddr [off2]) val mem) -> (MOVQstoreSP [off1.(int64)+off2.(int64)] val mem) +// global loads/stores +(MOVQload [off] (Global [sym]) mem) -> (MOVQloadglobal [GlobalOffset{sym,off.(int64)}] mem) +(MOVQstore [off] (Global [sym]) val mem) -> (MOVQstoreglobal [GlobalOffset{sym,off.(int64)}] val mem) + // fold constants into instructions (ADDQ x (Const [c])) -> (ADDCQ [c] x) // TODO: restrict c to int32 range? (ADDQ (Const [c]) x) -> (ADDCQ [c] x) -- cgit v1.3 From 12f980bc85c1ded76ba8b861b5ec4a50146f868f Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Wed, 13 May 2015 14:18:12 -0700 Subject: [dev.ssa] cmd/internal/ssa: delete ssac We don't need this standalone tool any more. We can now feed the ssa compiler directly from the Go frontend. Change-Id: I922f1e061c2d3db6bf77acc137d4d1fc7dc86c0d Reviewed-on: https://go-review.googlesource.com/10034 Reviewed-by: Alan Donovan --- src/cmd/internal/ssa/ssac/.gitignore | 1 - src/cmd/internal/ssa/ssac/fib.goir | 47 ---- src/cmd/internal/ssa/ssac/fibiter.goir | 62 ----- src/cmd/internal/ssa/ssac/main.go | 439 --------------------------------- src/cmd/internal/ssa/ssac/sexpr.go | 82 ------ src/cmd/internal/ssa/ssac/sparsemap.go | 69 ------ 6 files changed, 700 deletions(-) delete mode 100644 src/cmd/internal/ssa/ssac/.gitignore delete mode 100644 src/cmd/internal/ssa/ssac/fib.goir delete mode 100644 src/cmd/internal/ssa/ssac/fibiter.goir delete mode 100644 src/cmd/internal/ssa/ssac/main.go delete mode 100644 src/cmd/internal/ssa/ssac/sexpr.go delete mode 100644 src/cmd/internal/ssa/ssac/sparsemap.go (limited to 'src/cmd') diff --git a/src/cmd/internal/ssa/ssac/.gitignore b/src/cmd/internal/ssa/ssac/.gitignore deleted file mode 100644 index ab17b9d28e..0000000000 --- a/src/cmd/internal/ssa/ssac/.gitignore +++ /dev/null @@ -1 +0,0 @@ -ssac diff --git a/src/cmd/internal/ssa/ssac/fib.goir b/src/cmd/internal/ssa/ssac/fib.goir deleted file mode 100644 index 0875d63ca3..0000000000 --- a/src/cmd/internal/ssa/ssac/fib.goir +++ /dev/null @@ -1,47 +0,0 @@ - (TYPE T127bd68 int) - (TYPE T127bd68 int) - (TYPE T127bd68 int) - (TYPE T127bd68 int) - (TYPE T7faedc523360 (FUNC (int) (int))) - (TYPE T127bd68 int) - (TYPE T127bd68 int) - (TYPE T7faedc523360 (FUNC (int) (int))) - (TYPE T127bd68 int) - (TYPE T127bd68 int) - (TYPE T127bd68 int) - (TYPE T127bd68 int) - (TYPE T127bd68 int) - (TYPE T127bd68 int) - (DCL n T127bd68) - (AS n (LOAD (FP T127bd68 0))) - (DCL ~r1 T127bd68) - (DCL n T127bd68) - (DCL autotmp_0000 T127bd68) - (DCL fib T7faedc523360) - (DCL n T127bd68) - (DCL autotmp_0001 T127bd68) - (DCL fib T7faedc523360) - (DCL n T127bd68) - (DCL ~r1 T127bd68) - (DCL autotmp_0000 T127bd68) - (DCL autotmp_0001 T127bd68) - (DCL autotmp_0001 T127bd68) - (DCL autotmp_0000 T127bd68) - (IF (LT n (CINT 2)) .then0 .else0) - (LABEL .then0) - (AS ~r1 n) - (AS (FP T127bd68 8) ~r1) - (RETURN) - (GOTO .end0) - (LABEL .else0) - (GOTO .end0) - (LABEL .end0) - (AS (SP T127bd68 0) (SUB n (CINT 1))) - (CALL fib) - (AS autotmp_0000 (LOAD (SP T127bd68 8))) - (AS (SP T127bd68 0) (SUB n (CINT 2))) - (CALL fib) - (AS autotmp_0001 (LOAD (SP T127bd68 8))) - (AS ~r1 (ADD autotmp_0000 autotmp_0001)) - (AS (FP T127bd68 8) ~r1) - (RETURN) diff --git a/src/cmd/internal/ssa/ssac/fibiter.goir b/src/cmd/internal/ssa/ssac/fibiter.goir deleted file mode 100644 index 98b2b2b576..0000000000 --- a/src/cmd/internal/ssa/ssac/fibiter.goir +++ /dev/null @@ -1,62 +0,0 @@ - (NAME runtime·fibiter) - (TYPE Tf5dd68 int) - (TYPE Tf5dd68 int) - (TYPE Tf5dd68 int) - (TYPE Tf5dd68 int) - (TYPE Tf5dd68 int) - (TYPE Tf5dd68 int) - (TYPE Tf5dd68 int) - (TYPE Tf5dd68 int) - (TYPE Tf5dd68 int) - (TYPE Tf5dd68 int) - (TYPE Tf5dd68 int) - (TYPE Tf5dd68 int) - (TYPE Tf5dd68 int) - (TYPE Tf5dd68 int) - (TYPE Tf5dd68 int) - (TYPE Tf5dd68 int) - (TYPE Tf5dd68 int) - (TYPE Tf5dd68 int) - (TYPE Tf5dd68 int) - (TYPE Tf5dd68 int) - (TYPE Tf5dd68 int) - (TYPE Tf5dd68 int) - (DCL a Tf5dd68) - (DCL a Tf5dd68) - (DCL b Tf5dd68) - (DCL b Tf5dd68) - (DCL i Tf5dd68) - (DCL i Tf5dd68) - (DCL i Tf5dd68) - (DCL n Tf5dd68) - (DCL autotmp_0002 Tf5dd68) - (DCL i Tf5dd68) - (DCL i Tf5dd68) - (DCL autotmp_0002 Tf5dd68) - (DCL autotmp_0002 Tf5dd68) - (DCL autotmp_0003 Tf5dd68) - (DCL a Tf5dd68) - (DCL b Tf5dd68) - (DCL a Tf5dd68) - (DCL b Tf5dd68) - (DCL b Tf5dd68) - (DCL autotmp_0003 Tf5dd68) - (DCL ~r1 Tf5dd68) - (DCL a Tf5dd68) - (AS n (LOAD (FP Tf5dd68 0))) - (AS a (CINT 0)) - (AS b (CINT 1)) - (AS i (CINT 0)) - (GOTO .top0) - (LABEL .top0) - (IF (LT i n) .body0 .end0) - (LABEL .body0) - (AS autotmp_0003 (ADD a b)) - (AS a b) - (AS b autotmp_0003) - (AS autotmp_0002 i) - (AS i (ADD autotmp_0002 (CINT 1))) - (GOTO .top0) - (LABEL .end0) - (AS (FP Tf5dd68 8) a) - (RETURN) diff --git a/src/cmd/internal/ssa/ssac/main.go b/src/cmd/internal/ssa/ssac/main.go deleted file mode 100644 index 2afa7c6aa9..0000000000 --- a/src/cmd/internal/ssa/ssac/main.go +++ /dev/null @@ -1,439 +0,0 @@ -// 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 - -// Stub package for testing ssa compiler backend. Will eventually -// be deleted when ssa is called directly from the main compiler. - -import ( - "bufio" - "flag" - "fmt" - "io" - "os" - "strconv" - "strings" - - "cmd/internal/ssa" -) - -// testing harness which runs the compiler using an IR read from a file -func main() { - flag.Parse() - file := flag.Arg(0) - r, err := os.Open(file) - if err != nil { - panic(err) - } - f := buildFunc(readFunc(r)) - ssa.Compile(f) - // TODO: output f -} - -// readFunc reads the intermediate representation generated by the -// compiler frontend and returns it as a list of sexpressions. -func readFunc(r io.Reader) []sexpr { - var lines []sexpr - s := bufio.NewScanner(r) - for s.Scan() { - line := s.Text() - e := parseSexpr(strings.Trim(line, " ")) - - if !e.compound { - panic("bad stmt: " + line) - } - if e.parts[0].compound { - panic("bad op: " + line) - } - lines = append(lines, e) - } - return lines -} - -// buildFunc converts from the 6g IR dump format to the internal -// form. Builds SSA and all that. -func buildFunc(lines []sexpr) *ssa.Func { - f := new(ssa.Func) - - // We construct SSA using an algorithm similar to - // Brau, Buchwald, Hack, Leißa, Mallon, and Zwinkau - // http://pp.info.uni-karlsruhe.de/uploads/publikationen/braun13cc.pdf - - // allocate starting block - f.Entry = f.NewBlock(ssa.BlockPlain) - // TODO: all args. Make a struct containing args/returnvals, declare - // an FP which contains a pointer to that struct. - - var exit *ssa.Block // all returns (if any) branch to here TODO: defers & panics? - - // add a block for each label - // Also a few other preprocessing steps, all in one pass. - labels := map[string]*ssa.Block{} - types := map[string]ssa.Type{} - callFallthrough := map[int]*ssa.Block{} - for i, e := range lines { - switch e.parts[0].name { - case "LABEL": - labels[e.parts[1].name] = f.NewBlock(ssa.BlockPlain) - case "NAME": - f.Name = e.parts[1].name - case "RETURN": - if exit == nil { - exit = f.NewBlock(ssa.BlockExit) - } - case "TYPE": - types[e.parts[1].name] = parseSexprType(e.parts[2]) - case "CALL": - // allocate a new block for fallthrough - callFallthrough[i] = f.NewBlock(ssa.BlockPlain) - if exit == nil { - exit = f.NewBlock(ssa.BlockExit) - } - } - } - - // map from block id to sexprs in that block - blocklines := make([][]sexpr, f.NumBlocks()) - - // Add sexprs to the correct block. Add edges between blocks. - b := f.Entry - var i int - for j, e := range lines { - if b == nil && e.parts[0].name != "LABEL" { - // dead code (e.g. return in "if" branch makes the "goto end" statement dead) - continue - } - switch e.parts[0].name { - case "IF": - if b.Kind != ssa.BlockPlain { - panic("bad b state") - } - b.Kind = ssa.BlockIf - edge(b, labels[e.parts[2].name]) - edge(b, labels[e.parts[3].name]) - blocklines[b.ID] = lines[i : j+1] - b = nil - case "GOTO": - edge(b, labels[e.parts[1].name]) - blocklines[b.ID] = lines[i:j] - b = nil - case "LABEL": - b = labels[e.parts[1].name] - i = j + 1 - case "RETURN": - if b.Kind != ssa.BlockPlain { - panic("bad b state") - } - edge(b, exit) - blocklines[b.ID] = lines[i:j] - b = nil - case "CALL": - if b.Kind != ssa.BlockPlain { - panic("bad b state") - } - b.Kind = ssa.BlockCall - c := callFallthrough[j] - edge(b, c) - edge(b, exit) - blocklines[b.ID] = lines[i : j+1] - b = c - i = j + 1 - } - // note that we don't keep goto/label/return sexprs - } - if b != nil { - panic("control flow falls off end of function") - } - - // Read types for each variable - // Number the variables densely - varids := map[string]int{} // map from variable name to id - var varnames []string // map from id to variable name - var vartypes []ssa.Type // map from variable id to type - for _, e := range lines { - if e.parts[0].name != "DCL" { - continue - } - name := e.parts[1].name - if _, ok := varids[name]; ok { - continue - } - id := len(varids) - if id == 1<<31-1 { - panic("too many variables") - } - fmt.Printf("var %d = %s\n", id, name) - varids[name] = id - varnames = append(varnames, name) - vartypes = append(vartypes, types[e.parts[2].name]) - } - memID := len(varids) - fmt.Printf("var %d = .mem\n", memID) - varids[".mem"] = memID // TODO: need .mem here? - varnames = append(varnames, ".mem") - vartypes = append(vartypes, ssa.TypeMem) - - // map from variable ID to current Value of that variable - curBlock := NewSparseMap(len(varids)) - - var state ssaFuncState - state.types = types - state.varids = varids - state.varnames = varnames - state.vartypes = vartypes - state.curBlock = curBlock - state.done = make([]bool, f.NumBlocks()) - state.defs = map[blockvar]*ssa.Value{} - state.memID = memID - - // Convert each block to ssa - // TODO: order blocks for maximum happiness - we want to process - // all the predecessors of a block before processing the block itself, - // if at all possible. - for _, b := range f.Blocks { - fmt.Printf("processing block %d\n", b.ID) - curBlock.Clear() - for _, e := range blocklines[b.ID] { - switch e.parts[0].name { - case "AS": - if e.parts[1].compound { - // store expression - lhs := genExpr(&state, b, e.parts[1]) - rhs := genExpr(&state, b, e.parts[2]) - mem := genVar(&state, b, memID) - v := b.NewValue(ssa.OpStore, ssa.TypeMem, nil) - v.AddArg(lhs) - v.AddArg(rhs) - v.AddArg(mem) - curBlock.Put(memID, v) - } else { - // variable assignment - v := genExpr(&state, b, e.parts[2]) - curBlock.Put(varids[e.parts[1].name], v) - } - case "DCL": - // nothing to do - case "IF": - b.Control = genExpr(&state, b, e.parts[1]) - case "CALL": - // only direct call for now - indirect call takes addr value as well - v := b.NewValue(ssa.OpStaticCall, ssa.TypeMem, e.parts[1].name) - v.AddArg(genVar(&state, b, memID)) - curBlock.Put(memID, v) - b.Control = v - } - } - // link up forward references to their actual values - for _, v := range b.Values { - if v.Op != ssa.OpFwdRef { - continue - } - varid := v.Aux.(int) - w := genVar(&state, b, varid) - v.Op = ssa.OpCopy - v.Aux = nil - v.AddArg(w) - } - - // record final values at the end of the block - for _, e := range curBlock.Contents() { - state.defs[blockvar{b.ID, e.Key}] = e.Val - // TODO: somehow avoid storing dead values to this map. - } - curBlock.Clear() - state.done[b.ID] = true - } - - // the final store value is returned - if exit != nil { - exit.Control = genVar(&state, exit, memID) - } - - return f -} - -func edge(a, b *ssa.Block) { - a.Succs = append(a.Succs, b) - b.Preds = append(b.Preds, a) -} - -func genVar(state *ssaFuncState, b *ssa.Block, id int) *ssa.Value { - // look up variable - v := state.curBlock.Get(id) - if v != nil { - // variable was defined previously in this block - // (or we memoized the result) - return v - } - - // Variable comes in from outside of basic block. - v = lookupVarIncoming(state, b, id) - - // memoize result so future callers will not look it up again - state.curBlock.Put(id, v) - return v -} - -func genExpr(state *ssaFuncState, b *ssa.Block, e sexpr) *ssa.Value { - if !e.compound { - return genVar(state, b, state.varids[e.name]) - } - switch e.parts[0].name { - case "ADD": - x := genExpr(state, b, e.parts[1]) - y := genExpr(state, b, e.parts[2]) - v := b.NewValue(ssa.OpAdd, x.Type, nil) - v.AddArg(x) - v.AddArg(y) - return v - case "SUB": - x := genExpr(state, b, e.parts[1]) - y := genExpr(state, b, e.parts[2]) - v := b.NewValue(ssa.OpSub, x.Type, nil) - v.AddArg(x) - v.AddArg(y) - return v - case "CINT": - c, err := strconv.ParseInt(e.parts[1].name, 10, 64) - if err != nil { - panic("bad cint value") - } - return b.Func.ConstInt(ssa.TypeInt64, c) - case "LT": - x := genExpr(state, b, e.parts[1]) - y := genExpr(state, b, e.parts[2]) - v := b.NewValue(ssa.OpLess, ssa.TypeBool, nil) - v.AddArg(x) - v.AddArg(y) - return v - /* - case "FP": - typ := state.types[e.parts[1].name] - offset, err := strconv.ParseInt(e.parts[2].name, 10, 64) - if err != nil { - panic(err) - } - v := b.NewValue(ssa.OpFPAddr, types.NewPointer(typ), offset) - return v - case "SP": - typ := state.types[e.parts[1].name] - offset, err := strconv.ParseInt(e.parts[2].name, 10, 64) - if err != nil { - panic(err) - } - v := b.NewValue(ssa.OpSPAddr, types.NewPointer(typ), offset) - return v - case "LOAD": - p := genExpr(state, b, e.parts[1]) - v := b.NewValue(ssa.OpLoad, p.Type.(*types.Pointer).Elem(), nil) - v.AddArg(p) - v.AddArg(genVar(state, b, state.memID)) - return v - */ - default: - fmt.Println(e.parts[0].name) - panic("unknown op") - } -} - -// map key combining block id and variable id -type blockvar struct { - bid ssa.ID - varid int -} - -type ssaFuncState struct { - types map[string]ssa.Type - varnames []string - varids map[string]int - vartypes []ssa.Type - curBlock *SparseMap // value of each variable in block we're working on - defs map[blockvar]*ssa.Value // values for variables at the end of blocks - done []bool - memID int -} - -// Find the value of the variable with the given id leaving block b. -func lookupVarOutgoing(state *ssaFuncState, b *ssa.Block, id int) *ssa.Value { - fmt.Printf("lookupOutgoing var=%d block=%d\n", id, b.ID) - v := state.defs[blockvar{b.ID, id}] - if v != nil { - return v - } - if state.done[b.ID] { - // The variable was not defined in this block, and we haven't - // memoized the answer yet. Look it up recursively. This might - // cause infinite recursion, so add a copy first. - v = b.NewValue(ssa.OpCopy, state.vartypes[id], nil) - state.defs[blockvar{b.ID, id}] = v - v.AddArg(lookupVarIncoming(state, b, id)) - return v - } - // We don't know about defined variables in this block (yet). - // Make a forward reference for this variable. - fmt.Printf("making fwdRef for var=%d in block=%d\n", id, b.ID) - v = b.NewValue(ssa.OpFwdRef, state.vartypes[id], id) - - // memoize result - state.defs[blockvar{b.ID, id}] = v - return v -} - -// Find the Value of the variable coming into block b. -func lookupVarIncoming(state *ssaFuncState, b *ssa.Block, id int) *ssa.Value { - fmt.Printf("lookupIncoming var=%d block=%d\n", id, b.ID) - var v *ssa.Value - switch len(b.Preds) { - case 0: - // TODO: handle function args some other way (assignments in starting block?) - // TODO: error if variable isn't a function arg (including mem input) - v = b.NewValue(ssa.OpArg, state.vartypes[id], state.varnames[id]) - case 1: - v = lookupVarOutgoing(state, b.Preds[0], id) - default: - v = b.NewValue(ssa.OpCopy, state.vartypes[id], nil) - - args := make([]*ssa.Value, len(b.Preds)) - for i, p := range b.Preds { - args[i] = lookupVarOutgoing(state, p, id) - } - - // if <=1 value that isn't this variable's fwdRef, don't make phi - v.Op = ssa.OpPhi - v.AddArgs(args...) // note: order corresponding to b.Pred - } - return v -} - -func parseSexprType(e sexpr) ssa.Type { - if !e.compound { - switch e.name { - case "int": - // TODO: pick correct width - return ssa.TypeInt64 - default: - fmt.Println(e.name) - panic("unknown type") - } - } - /* - if e.parts[0].name == "FUNC" { - // TODO: receiver? Already folded into args? Variadic? - var args, rets []*types.Var - for _, s := range e.parts[1].parts { - t := parseSexprType(s) - args = append(args, types.NewParam(0, nil, "noname", t)) - } - for _, s := range e.parts[2].parts { - t := parseSexprType(s) - rets = append(rets, types.NewParam(0, nil, "noname", t)) - } - sig := types.NewSignature(nil, nil, types.NewTuple(args...), types.NewTuple(rets...), false) - return ssa.Type(sig) - } - */ - // TODO: array/struct/... - panic("compound type") -} diff --git a/src/cmd/internal/ssa/ssac/sexpr.go b/src/cmd/internal/ssa/ssac/sexpr.go deleted file mode 100644 index 77e8923dd0..0000000000 --- a/src/cmd/internal/ssa/ssac/sexpr.go +++ /dev/null @@ -1,82 +0,0 @@ -// 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" - -// an sexpr is an s-expression. It is either a token or a -// parenthesized list of s-expressions. -// -// Used just for initial development. Should we keep it for testing, or -// ditch it once we've plugged into the main compiler output? - -type sexpr struct { - compound bool - name string // !compound - parts []sexpr // compound -} - -func (s *sexpr) String() string { - if !s.compound { - return s.name - } - x := "(" - for i, p := range s.parts { - if i != 0 { - x += " " - } - x += p.String() - } - return x + ")" -} - -func parseSexpr(s string) sexpr { - var e string - e, s = grabOne(s) - if len(e) > 0 && e[0] == '(' { - e = e[1 : len(e)-1] - var parts []sexpr - for e != "" { - var p string - p, e = grabOne(e) - parts = append(parts, parseSexpr(p)) - } - return sexpr{true, "", parts} - } - return sexpr{false, e, nil} -} - -// grabOne peels off first token or parenthesized string from s. -// returns first thing and the remainder of s. -func grabOne(s string) (string, string) { - for len(s) > 0 && s[0] == ' ' { - s = s[1:] - } - if len(s) == 0 || s[0] != '(' { - i := strings.Index(s, " ") - if i < 0 { - return s, "" - } - return s[:i], s[i:] - } - d := 0 - i := 0 - for { - if len(s) == i { - panic("unterminated s-expression: " + s) - } - if s[i] == '(' { - d++ - } - if s[i] == ')' { - d-- - if d == 0 { - i++ - return s[:i], s[i:] - } - } - i++ - } -} diff --git a/src/cmd/internal/ssa/ssac/sparsemap.go b/src/cmd/internal/ssa/ssac/sparsemap.go deleted file mode 100644 index b7a0fb0fde..0000000000 --- a/src/cmd/internal/ssa/ssac/sparsemap.go +++ /dev/null @@ -1,69 +0,0 @@ -// 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 - -// Maintains a map[int]*ssa.Value, but cheaper. - -// from http://research.swtch.com/sparse -// in turn, from Briggs and Torczon - -import ( - "cmd/internal/ssa" -) - -type SparseMap struct { - dense []SparseMapEntry - sparse []int -} -type SparseMapEntry struct { - Key int - Val *ssa.Value -} - -// NewSparseMap returns a SparseMap that can have -// integers between 0 and n-1 as keys. -func NewSparseMap(n int) *SparseMap { - return &SparseMap{nil, make([]int, n)} -} - -func (s *SparseMap) Get(x int) *ssa.Value { - i := s.sparse[x] - if i < len(s.dense) && s.dense[i].Key == x { - return s.dense[i].Val - } - return nil -} - -func (s *SparseMap) Put(x int, v *ssa.Value) { - i := s.sparse[x] - if i < len(s.dense) && s.dense[i].Key == x { - s.dense[i].Val = v - return - } - i = len(s.dense) - s.dense = append(s.dense, SparseMapEntry{x, v}) - s.sparse[x] = i -} - -func (s *SparseMap) Remove(x int) { - i := s.sparse[x] - if i < len(s.dense) && s.dense[i].Key == x { - 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] -} - -// Contents returns a slice of key/value pairs. -// Caller must not modify any returned entries. -// The return value is invalid after the SparseMap is modified in any way. -func (s *SparseMap) Contents() []SparseMapEntry { - return s.dense -} -- cgit v1.3 From b3137966db7c000d2edd8d2f9d6fd10ebbb4da9c Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Wed, 13 May 2015 14:11:39 -0700 Subject: [dev.ssa] cmd/internal/ssa: reorganize opcode tables Separate out opcode tables into separate ranges for each architecture. Put architecture-specific opcodes into separate files. Comment each opcode in a consistent format. Change-Id: Iddf03c062bc8a88ad2bcebbf6528088c01a75779 Reviewed-on: https://go-review.googlesource.com/10033 Reviewed-by: Alan Donovan --- src/cmd/internal/gc/ssa.go | 6 +- src/cmd/internal/ssa/lowerAmd64.go | 36 ++-- src/cmd/internal/ssa/op.go | 273 +++++-------------------- src/cmd/internal/ssa/op_string.go | 32 ++- src/cmd/internal/ssa/opamd64.go | 171 ++++++++++++++++ src/cmd/internal/ssa/regalloc.go | 12 +- src/cmd/internal/ssa/rulegen/lower_amd64.rules | 8 +- 7 files changed, 282 insertions(+), 256 deletions(-) create mode 100644 src/cmd/internal/ssa/opamd64.go (limited to 'src/cmd') diff --git a/src/cmd/internal/gc/ssa.go b/src/cmd/internal/gc/ssa.go index ec747e970b..1d3abb3f37 100644 --- a/src/cmd/internal/gc/ssa.go +++ b/src/cmd/internal/gc/ssa.go @@ -292,7 +292,7 @@ func (s *ssaState) expr(n *Node) *ssa.Value { case OIND: p := s.expr(n.Left) - c := s.curBlock.NewValue1(ssa.OpCheckNil, ssa.TypeBool, nil, p) + c := s.curBlock.NewValue1(ssa.OpIsNonNil, ssa.TypeBool, nil, p) b := s.endBlock() b.Kind = ssa.BlockIf b.Control = c @@ -322,7 +322,7 @@ func (s *ssaState) expr(n *Node) *ssa.Value { // bounds check len := s.curBlock.NewValue1(ssa.OpSliceLen, s.config.UIntPtr, nil, a) - cmp := s.curBlock.NewValue2(ssa.OpCheckBound, ssa.TypeBool, nil, i, len) + cmp := s.curBlock.NewValue2(ssa.OpIsInBounds, ssa.TypeBool, nil, i, len) b := s.endBlock() b.Kind = ssa.BlockIf b.Control = cmp @@ -345,7 +345,7 @@ func (s *ssaState) expr(n *Node) *ssa.Value { log.Fatalf("can't handle CALLFUNC with non-ONAME fn %s", opnames[n.Left.Op]) } bNext := s.f.NewBlock(ssa.BlockPlain) - call := s.curBlock.NewValue1(ssa.OpStaticCall, ssa.TypeMem, n.Left.Sym.Name, s.mem()) + call := s.curBlock.NewValue1(ssa.OpStaticCall, ssa.TypeMem, n.Left.Sym, s.mem()) b := s.endBlock() b.Kind = ssa.BlockCall b.Control = call diff --git a/src/cmd/internal/ssa/lowerAmd64.go b/src/cmd/internal/ssa/lowerAmd64.go index 842822bda4..ef891c37d9 100644 --- a/src/cmd/internal/ssa/lowerAmd64.go +++ b/src/cmd/internal/ssa/lowerAmd64.go @@ -209,8 +209,8 @@ func lowerAmd64(v *Value) bool { goto enda4e64c7eaeda16c1c0db9dac409cd126 enda4e64c7eaeda16c1c0db9dac409cd126: ; - case OpCheckBound: - // match: (CheckBound idx len) + case OpIsInBounds: + // match: (IsInBounds idx len) // cond: // result: (SETB (CMPQ idx len)) { @@ -226,11 +226,11 @@ func lowerAmd64(v *Value) bool { v.AddArg(v0) return true } - goto end249426f6f996d45a62f89a591311a954 - end249426f6f996d45a62f89a591311a954: + goto endb51d371171154c0f1613b687757e0576 + endb51d371171154c0f1613b687757e0576: ; - case OpCheckNil: - // match: (CheckNil p) + case OpIsNonNil: + // match: (IsNonNil p) // cond: // result: (SETNE (TESTQ p p)) { @@ -245,8 +245,8 @@ func lowerAmd64(v *Value) bool { v.AddArg(v0) return true } - goto end90d3057824f74ef953074e473aa0b282 - end90d3057824f74ef953074e473aa0b282: + goto endff508c3726edfb573abc6128c177e76c + endff508c3726edfb573abc6128c177e76c: ; case OpLess: // match: (Less x y) @@ -378,17 +378,17 @@ func lowerAmd64(v *Value) bool { ; // match: (MOVQload [off1] (LEAQ8 [off2] ptr idx) mem) // cond: - // result: (MOVQload8 [off1.(int64)+off2.(int64)] ptr idx mem) + // result: (MOVQloadidx8 [off1.(int64)+off2.(int64)] ptr idx mem) { off1 := v.Aux if v.Args[0].Op != OpLEAQ8 { - goto end35060118a284c93323ab3fb827156638 + goto endba0e5cee85021614041016b1a2709ab8 } off2 := v.Args[0].Aux ptr := v.Args[0].Args[0] idx := v.Args[0].Args[1] mem := v.Args[1] - v.Op = OpMOVQload8 + v.Op = OpMOVQloadidx8 v.Aux = nil v.resetArgs() v.Aux = off1.(int64) + off2.(int64) @@ -397,8 +397,8 @@ func lowerAmd64(v *Value) bool { v.AddArg(mem) return true } - goto end35060118a284c93323ab3fb827156638 - end35060118a284c93323ab3fb827156638: + goto endba0e5cee85021614041016b1a2709ab8 + endba0e5cee85021614041016b1a2709ab8: ; case OpMOVQstore: // match: (MOVQstore [off1] (FPAddr [off2]) val mem) @@ -493,18 +493,18 @@ func lowerAmd64(v *Value) bool { ; // match: (MOVQstore [off1] (LEAQ8 [off2] ptr idx) val mem) // cond: - // result: (MOVQstore8 [off1.(int64)+off2.(int64)] ptr idx val mem) + // result: (MOVQstoreidx8 [off1.(int64)+off2.(int64)] ptr idx val mem) { off1 := v.Aux if v.Args[0].Op != OpLEAQ8 { - goto endb5cba0ee3ba21d2bd8e5aa163d2b984e + goto end4ad469f534c7369f6ac36bdace3462ad } off2 := v.Args[0].Aux ptr := v.Args[0].Args[0] idx := v.Args[0].Args[1] val := v.Args[1] mem := v.Args[2] - v.Op = OpMOVQstore8 + v.Op = OpMOVQstoreidx8 v.Aux = nil v.resetArgs() v.Aux = off1.(int64) + off2.(int64) @@ -514,8 +514,8 @@ func lowerAmd64(v *Value) bool { v.AddArg(mem) return true } - goto endb5cba0ee3ba21d2bd8e5aa163d2b984e - endb5cba0ee3ba21d2bd8e5aa163d2b984e: + goto end4ad469f534c7369f6ac36bdace3462ad + end4ad469f534c7369f6ac36bdace3462ad: ; case OpMULCQ: // match: (MULCQ [c] x) diff --git a/src/cmd/internal/ssa/op.go b/src/cmd/internal/ssa/op.go index 1d374db61d..ebe4a8e747 100644 --- a/src/cmd/internal/ssa/op.go +++ b/src/cmd/internal/ssa/op.go @@ -8,25 +8,33 @@ package ssa // 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 below. +// // Ops come in two flavors, architecture-independent and architecture-dependent. +// Architecture-independent opcodes appear in this file. +// Architecture-dependent opcodes appear in op{arch}.go files. type Op int32 -// All the opcodes +// Opcode ranges, a generic one and one for each architecture. const ( - OpUnknown Op = iota + opInvalid Op = 0 + opGenericBase Op = 1 + 1000*iota + opAMD64Base + op386Base - // machine-independent opcodes + opMax // sentinel +) - OpNop // should never be used, appears only briefly during construction, Has type Void. - OpFwdRef // used during ssa construction. Like OpCopy, but the arg has not been specified yet. +// Generic opcodes +const ( + opGenericStart Op = opGenericBase + iota // 2-input arithmetic - OpAdd - OpSub - OpMul + OpAdd // arg0 + arg1 + OpSub // arg0 - arg1 + OpMul // arg0 * arg1 // 2-input comparisons - OpLess + OpLess // arg0 < arg1 // constants. Constant values are stored in the aux field. // booleans have a bool aux field, strings have a string aux @@ -36,44 +44,40 @@ const ( // as it may be different widths on the host and target. OpConst - OpArg // address of a function parameter/result. Memory input is an arg called ".mem". - OpGlobal // address of a global variable (aux is a *gc.Sym) + OpArg // address of a function parameter/result. Memory input is an arg called ".mem". aux is a string (TODO: make it something other than a string?) + OpGlobal // the address of a global variable aux.(*gc.Sym) OpFunc // entry address of a function - OpCopy // output = input - OpPhi // select an input based on which predecessor we came from - - OpSliceMake // args are ptr/len/cap - OpSlicePtr - OpSliceLen - OpSliceCap - OpStringMake // args are ptr/len - OpStringPtr - OpStringLen + OpCopy // output = arg0 + OpPhi // select an argument based on which predecessor block we came from - OpSliceIndex - OpSliceIndexAddr + OpSliceMake // arg0=ptr, arg1=len, arg2=cap + OpSlicePtr // ptr(arg0) + OpSliceLen // len(arg0) + OpSliceCap // cap(arg0) - OpLoad // args are ptr, memory. Loads from ptr+aux.(int64) - OpStore // args are ptr, value, memory, returns memory. Stores to ptr+aux.(int64) + OpStringMake // arg0=ptr, arg1=len + OpStringPtr // ptr(arg0) + OpStringLen // len(arg0) - OpCheckNil // arg[0] != nil - OpCheckBound // 0 <= arg[0] < arg[1] + OpLoad // Load from arg0+aux.(int64). arg1=memory + OpStore // Store arg1 to arg0+aux.(int64). arg2=memory. Returns memory. + OpSliceIndex // arg0=slice, arg1=index, arg2=memory + OpIsNonNil // arg0 != nil + OpIsInBounds // 0 <= arg0 < arg1 // 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. - // TODO: closure pointer must be in a register. - OpCall // args are function ptr, memory - OpStaticCall // aux is function, arg is memory + OpCall // arg0=code pointer, arg1=context ptr, arg2=memory. Returns memory. + OpStaticCall // call function aux.(*gc.Sym), arg0=memory. Returns memory. - OpConvert - OpConvNop + OpConvert // convert arg0 to another type + OpConvNop // interpret arg0 as another type - // These ops return a pointer to a location on the stack. Aux contains an int64 - // indicating an offset from the base pointer. - OpFPAddr // offset from FP (+ == args from caller, - == locals) - OpSPAddr // offset from SP + // These ops return a pointer to a location on the stack. + OpFPAddr // FP + aux.(int64) (+ == args from caller, - == locals) + OpSPAddr // SP + aux.(int64) // spill&restore ops for the register allocator. These are // semantically identical to OpCopy; they do not take/return @@ -82,70 +86,19 @@ const ( OpStoreReg8 OpLoadReg8 - // machine-dependent opcodes go here - - // amd64 - OpADDQ - OpSUBQ - OpADDCQ // 1 input arg. output = input + aux.(int64) - OpSUBCQ // 1 input arg. output = input - aux.(int64) - OpMULQ - OpMULCQ // output = input * aux.(int64) - OpSHLQ // output = input0 << input1 - OpSHLCQ // output = input << aux.(int64) - OpNEGQ - OpCMPQ - OpCMPCQ // 1 input arg. Compares input with aux.(int64) - OpADDL - OpTESTQ // compute flags of arg[0] & arg[1] - OpSETEQ - OpSETNE - - // generate boolean based on the flags setting - OpSETL // less than - OpSETGE // >= - OpSETB // "below" = unsigned less than - - // InvertFlags reverses direction of flags register interpretation: - // (InvertFlags (OpCMPQ a b)) == (OpCMPQ b a) - // This is a pseudo-op which can't appear in assembly output. - OpInvertFlags - - OpLEAQ // x+y - OpLEAQ2 // x+2*y - OpLEAQ4 // x+4*y - OpLEAQ8 // x+8*y - - OpMOVQload // (ptr, mem): loads from ptr+aux.(int64) - OpMOVQstore // (ptr, val, mem): stores val to ptr+aux.(int64), returns mem - OpMOVQload8 // (ptr,idx,mem): loads from ptr+idx*8+aux.(int64) - OpMOVQstore8 // (ptr,idx,val,mem): stores to ptr+idx*8+aux.(int64), returns mem - - // load/store from global. aux = GlobalOffset - OpMOVQloadglobal // (mem) -> value - OpMOVQstoreglobal // (val, mem) -> mem - - // load/store 8-byte integer register from stack slot. - OpMOVQloadFP - OpMOVQloadSP - OpMOVQstoreFP - OpMOVQstoreSP - - // materialize a constant into a register - OpMOVQconst - - OpMax // sentinel + // used during ssa construction. Like OpCopy, but the arg has not been specified yet. + OpFwdRef ) // GlobalOffset represents a fixed offset within a global variable type GlobalOffset struct { - Global interface{} // holds a *cmd/internal/gc.Sym + Global interface{} // holds a *gc.Sym Offset int64 } //go:generate stringer -type=Op -type OpInfo struct { +type opInfo struct { flags int32 // assembly template @@ -160,67 +113,13 @@ type OpInfo struct { reg [2][]regMask } -type regMask uint64 - -var regs386 = [...]string{ - "AX", - "CX", - "DX", - "BX", - "SP", - "BP", - "SI", - "DI", - - // pseudo registers - "FLAGS", - "OVERWRITE0", // the same register as the first input -} - -// TODO: match up these with regs386 above -var gp regMask = 0xef -var cx regMask = 0x2 -var flags regMask = 1 << 8 -var overwrite0 regMask = 1 << 9 - const ( // possible properties of opcodes OpFlagCommutative int32 = 1 << iota - - // architecture constants - Arch386 - ArchAMD64 - ArchARM ) -// general purpose registers, 2 input, 1 output -var gp21 = [2][]regMask{{gp, gp}, {gp}} -var gp21_overwrite = [2][]regMask{{gp, gp}, {gp}} - -// general purpose registers, 1 input, 1 output -var gp11 = [2][]regMask{{gp}, {gp}} -var gp11_overwrite = [2][]regMask{{gp}, {gp}} - -// general purpose registers, 0 input, 1 output -var gp01 = [2][]regMask{{}, {gp}} - -// shift operations -var shift = [2][]regMask{{gp, cx}, {gp}} - -var gp2_flags = [2][]regMask{{gp, gp}, {flags}} -var gp1_flags = [2][]regMask{{gp}, {flags}} -var gpload = [2][]regMask{{gp, 0}, {gp}} -var gploadX = [2][]regMask{{gp, gp, 0}, {gp}} // indexed loads -var gpstore = [2][]regMask{{gp, gp, 0}, {0}} -var gpstoreX = [2][]regMask{{gp, gp, gp, 0}, {0}} // indexed stores -var gploadglobal = [2][]regMask{{0}, {gp}} -var gpstoreglobal = [2][]regMask{{gp, 0}, {0}} - -var gpload_stack = [2][]regMask{{0}, {gp}} -var gpstore_stack = [2][]regMask{{gp, 0}, {0}} - // Opcodes that represent the input Go program -var genericTable = [...]OpInfo{ +var genericTable = map[Op]opInfo{ // the unknown op is used only during building and should not appear in a // fully formed ssa representation. @@ -278,87 +177,11 @@ var genericTable = [...]OpInfo{ */ } -// Opcodes that appear in an output amd64 program -var amd64Table = [...]OpInfo{ - OpADDQ: {flags: OpFlagCommutative, asm: "ADDQ\t%I0,%I1,%O0", reg: gp21}, // TODO: overwrite - OpADDCQ: {asm: "ADDQ\t$%A,%I0,%O0", reg: gp11_overwrite}, // aux = int64 constant to add - OpSUBQ: {asm: "SUBQ\t%I0,%I1,%O0", reg: gp21}, - OpSUBCQ: {asm: "SUBQ\t$%A,%I0,%O0", reg: gp11_overwrite}, - OpMULQ: {asm: "MULQ\t%I0,%I1,%O0", reg: gp21}, - OpMULCQ: {asm: "MULQ\t$%A,%I0,%O0", reg: gp11_overwrite}, - OpSHLQ: {asm: "SHLQ\t%I0,%I1,%O0", reg: gp21}, - OpSHLCQ: {asm: "SHLQ\t$%A,%I0,%O0", reg: gp11_overwrite}, - - OpCMPQ: {asm: "CMPQ\t%I0,%I1", reg: gp2_flags}, // compute arg[0]-arg[1] and produce flags - OpCMPCQ: {asm: "CMPQ\t$%A,%I0", reg: gp1_flags}, - OpTESTQ: {asm: "TESTQ\t%I0,%I1", reg: gp2_flags}, - - OpLEAQ: {flags: OpFlagCommutative, asm: "LEAQ\t%A(%I0)(%I1*1),%O0", reg: gp21}, // aux = int64 constant to add - OpLEAQ2: {asm: "LEAQ\t%A(%I0)(%I1*2),%O0"}, - OpLEAQ4: {asm: "LEAQ\t%A(%I0)(%I1*4),%O0"}, - OpLEAQ8: {asm: "LEAQ\t%A(%I0)(%I1*8),%O0"}, - - // loads and stores - OpMOVQload: {asm: "MOVQ\t%A(%I0),%O0", reg: gpload}, - OpMOVQstore: {asm: "MOVQ\t%I1,%A(%I0)", reg: gpstore}, - OpMOVQload8: {asm: "MOVQ\t%A(%I0)(%I1*8),%O0", reg: gploadX}, - OpMOVQstore8: {asm: "MOVQ\t%I2,%A(%I0)(%I1*8)", reg: gpstoreX}, - - OpMOVQloadglobal: {reg: gploadglobal}, - OpMOVQstoreglobal: {reg: gpstoreglobal}, - - OpMOVQconst: {asm: "MOVQ\t$%A,%O0", reg: gp01}, - - OpStaticCall: {asm: "CALL\t%A(SB)"}, - - OpCopy: {asm: "MOVQ\t%I0,%O0", reg: gp11}, - - // convert from flags back to boolean - OpSETL: {}, - - // ops for load/store to stack - OpMOVQloadFP: {asm: "MOVQ\t%A(FP),%O0", reg: gpload_stack}, // mem -> value - OpMOVQloadSP: {asm: "MOVQ\t%A(SP),%O0", reg: gpload_stack}, // mem -> value - OpMOVQstoreFP: {asm: "MOVQ\t%I0,%A(FP)", reg: gpstore_stack}, // mem, value -> mem - OpMOVQstoreSP: {asm: "MOVQ\t%I0,%A(SP)", reg: gpstore_stack}, // mem, value -> mem - - // ops for spilling of registers - // unlike regular loads & stores, these take no memory argument. - // They are just like OpCopy but we use them during register allocation. - // TODO: different widths, float - OpLoadReg8: {asm: "MOVQ\t%I0,%O0"}, - OpStoreReg8: {asm: "MOVQ\t%I0,%O0"}, -} - -// A Table is a list of opcodes with a common set of flags. -type Table struct { - t []OpInfo - flags int32 -} - -var tables = []Table{ - {genericTable[:], 0}, - {amd64Table[:], ArchAMD64}, // TODO: pick this dynamically -} - // table of opcodes, indexed by opcode ID -var opcodeTable [OpMax]OpInfo - -// map from opcode names to opcode IDs -var nameToOp map[string]Op +var opcodeTable [opMax]opInfo func init() { - // build full opcode table - // Note that the arch-specific table overwrites the generic table - for _, t := range tables { - for op, entry := range t.t { - entry.flags |= t.flags - opcodeTable[op] = entry - } - } - // build name to opcode mapping - nameToOp = make(map[string]Op) - for op := range opcodeTable { - nameToOp[Op(op).String()] = Op(op) + for op, info := range genericTable { + opcodeTable[op] = info } } diff --git a/src/cmd/internal/ssa/op_string.go b/src/cmd/internal/ssa/op_string.go index adce17a1f2..0851cfe0fb 100644 --- a/src/cmd/internal/ssa/op_string.go +++ b/src/cmd/internal/ssa/op_string.go @@ -4,13 +4,37 @@ package ssa import "fmt" -const _Op_name = "OpUnknownOpNopOpFwdRefOpAddOpSubOpMulOpLessOpConstOpArgOpGlobalOpFuncOpCopyOpPhiOpSliceMakeOpSlicePtrOpSliceLenOpSliceCapOpStringMakeOpStringPtrOpStringLenOpSliceIndexOpSliceIndexAddrOpLoadOpStoreOpCheckNilOpCheckBoundOpCallOpStaticCallOpConvertOpConvNopOpFPAddrOpSPAddrOpStoreReg8OpLoadReg8OpADDQOpSUBQOpADDCQOpSUBCQOpMULQOpMULCQOpSHLQOpSHLCQOpNEGQOpCMPQOpCMPCQOpADDLOpTESTQOpSETEQOpSETNEOpSETLOpSETGEOpSETBOpInvertFlagsOpLEAQOpLEAQ2OpLEAQ4OpLEAQ8OpMOVQloadOpMOVQstoreOpMOVQload8OpMOVQstore8OpMOVQloadglobalOpMOVQstoreglobalOpMOVQloadFPOpMOVQloadSPOpMOVQstoreFPOpMOVQstoreSPOpMOVQconstOpMax" +const ( + _Op_name_0 = "opInvalid" + _Op_name_1 = "opGenericBaseOpAddOpSubOpMulOpLessOpConstOpArgOpGlobalOpFuncOpCopyOpPhiOpSliceMakeOpSlicePtrOpSliceLenOpSliceCapOpStringMakeOpStringPtrOpStringLenOpLoadOpStoreOpSliceIndexOpIsNonNilOpIsInBoundsOpCallOpStaticCallOpConvertOpConvNopOpFPAddrOpSPAddrOpStoreReg8OpLoadReg8OpFwdRef" + _Op_name_2 = "opAMD64BaseOpADDQOpSUBQOpADDCQOpSUBCQOpMULQOpMULCQOpSHLQOpSHLCQOpNEGQOpADDLOpCMPQOpCMPCQOpTESTQOpSETEQOpSETNEOpSETLOpSETGEOpSETBOpInvertFlagsOpLEAQOpLEAQ2OpLEAQ4OpLEAQ8OpMOVQloadOpMOVQstoreOpMOVQloadidx8OpMOVQstoreidx8OpMOVQloadglobalOpMOVQstoreglobalOpMOVQloadFPOpMOVQloadSPOpMOVQstoreFPOpMOVQstoreSPOpMOVQconst" + _Op_name_3 = "op386Base" + _Op_name_4 = "opMax" +) -var _Op_index = [...]uint16{0, 9, 14, 22, 27, 32, 37, 43, 50, 55, 63, 69, 75, 80, 91, 101, 111, 121, 133, 144, 155, 167, 183, 189, 196, 206, 218, 224, 236, 245, 254, 262, 270, 281, 291, 297, 303, 310, 317, 323, 330, 336, 343, 349, 355, 362, 368, 375, 382, 389, 395, 402, 408, 421, 427, 434, 441, 448, 458, 469, 480, 492, 508, 525, 537, 549, 562, 575, 586, 591} +var ( + _Op_index_0 = [...]uint8{0, 9} + _Op_index_1 = [...]uint16{0, 13, 18, 23, 28, 34, 41, 46, 54, 60, 66, 71, 82, 92, 102, 112, 124, 135, 146, 152, 159, 171, 181, 193, 199, 211, 220, 229, 237, 245, 256, 266, 274} + _Op_index_2 = [...]uint16{0, 11, 17, 23, 30, 37, 43, 50, 56, 63, 69, 75, 81, 88, 95, 102, 109, 115, 122, 128, 141, 147, 154, 161, 168, 178, 189, 203, 218, 234, 251, 263, 275, 288, 301, 312} + _Op_index_3 = [...]uint8{0, 9} + _Op_index_4 = [...]uint8{0, 5} +) func (i Op) String() string { - if i < 0 || i+1 >= Op(len(_Op_index)) { + switch { + case i == 0: + return _Op_name_0 + case 1001 <= i && i <= 1032: + i -= 1001 + return _Op_name_1[_Op_index_1[i]:_Op_index_1[i+1]] + case 2001 <= i && i <= 2035: + i -= 2001 + return _Op_name_2[_Op_index_2[i]:_Op_index_2[i+1]] + case i == 3001: + return _Op_name_3 + case i == 4001: + return _Op_name_4 + default: return fmt.Sprintf("Op(%d)", i) } - return _Op_name[_Op_index[i]:_Op_index[i+1]] } diff --git a/src/cmd/internal/ssa/opamd64.go b/src/cmd/internal/ssa/opamd64.go new file mode 100644 index 0000000000..8bdd19f713 --- /dev/null +++ b/src/cmd/internal/ssa/opamd64.go @@ -0,0 +1,171 @@ +// 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 + +// amd64-specific opcodes + +const ( + opAMD64start Op = opAMD64Base + iota + + // Suffixes encode the bit width of various instructions. + // Q = 64 bit, L = 32 bit, W = 16 bit, B = 8 bit + + // arithmetic + OpADDQ // arg0 + arg1 + OpSUBQ // arg0 - arg1 + OpADDCQ // arg + aux.(int64) + OpSUBCQ // arg - aux.(int64) + OpMULQ // arg0 * arg1 + OpMULCQ // arg * aux.(int64) + OpSHLQ // arg0 << arg1 + OpSHLCQ // arg << aux.(int64) + OpNEGQ // -arg + OpADDL // arg0 + arg1 + + // Flags value generation. + // We pretend the flags type is an opaque thing that comparisons generate + // and from which we can extract boolean conditions like <, ==, etc. + OpCMPQ // arg0 compare to arg1 + OpCMPCQ // arg0 compare to aux.(int64) + OpTESTQ // (arg0 & arg1) compare to 0 + + // These opcodes extract a particular boolean condition from a flags value. + OpSETEQ // extract == condition from arg0 + OpSETNE // extract != condition from arg0 + OpSETL // extract signed < condition from arg0 + OpSETGE // extract signed >= condition from arg0 + OpSETB // extract unsigned < condition from arg0 + + // InvertFlags reverses the direction of a flags type interpretation: + // (InvertFlags (OpCMPQ a b)) == (OpCMPQ b a) + // This is a pseudo-op which can't appear in assembly output. + OpInvertFlags // reverse direction of arg0 + + OpLEAQ // arg0 + arg1 + aux.(int64) + OpLEAQ2 // arg0 + 2*arg1 + aux.(int64) + OpLEAQ4 // arg0 + 4*arg1 + aux.(int64) + OpLEAQ8 // arg0 + 8*arg1 + aux.(int64) + + // Load/store from general address + OpMOVQload // Load from arg0+aux.(int64). arg1=memory + OpMOVQstore // Store arg1 to arg0+aux.(int64). arg2=memory, returns memory. + OpMOVQloadidx8 // Load from arg0+arg1*8+aux.(int64). arg2=memory + OpMOVQstoreidx8 // Store arg2 to arg0+arg1*8+aux.(int64). arg3=memory, returns memory. + + // Load/store from global. aux.(GlobalOffset) encodes the global location. + OpMOVQloadglobal // arg0 = memory + OpMOVQstoreglobal // store arg0. arg1=memory, returns memory. + + // Load/store from stack slot. + OpMOVQloadFP // load from FP+aux.(int64). arg0=memory + OpMOVQloadSP // load from SP+aux.(int64). arg0=memory + OpMOVQstoreFP // store arg0 to FP+aux.(int64). arg1=memory, returns memory. + OpMOVQstoreSP // store arg0 to SP+aux.(int64). arg1=memory, returns memory. + + // materialize a constant into a register + OpMOVQconst // (takes no arguments) +) + +type regMask uint64 + +var regsAMD64 = [...]string{ + "AX", + "CX", + "DX", + "BX", + "SP", + "BP", + "SI", + "DI", + "R8", + "R9", + "R10", + "R11", + "R12", + "R13", + "R14", + "R15", + + // pseudo registers + "FLAGS", + "OVERWRITE0", // the same register as the first input +} + +var gp regMask = 0xef // all integer registers except SP +var cx regMask = 0x2 +var flags regMask = 1 << 16 + +var ( + // gp = general purpose (integer) registers + gp21 = [2][]regMask{{gp, gp}, {gp}} // 2 input, 1 output + gp11 = [2][]regMask{{gp}, {gp}} // 1 input, 1 output + gp01 = [2][]regMask{{}, {gp}} // 0 input, 1 output + shift = [2][]regMask{{gp, cx}, {gp}} // shift operations + gp2_flags = [2][]regMask{{gp, gp}, {flags}} // generate flags from 2 gp regs + gp1_flags = [2][]regMask{{gp}, {flags}} // generate flags from 1 gp reg + + gpload = [2][]regMask{{gp, 0}, {gp}} + gploadidx = [2][]regMask{{gp, gp, 0}, {gp}} + gpstore = [2][]regMask{{gp, gp, 0}, {0}} + gpstoreidx = [2][]regMask{{gp, gp, gp, 0}, {0}} + + gpload_stack = [2][]regMask{{0}, {gp}} + gpstore_stack = [2][]regMask{{gp, 0}, {0}} +) + +// Opcodes that appear in an output amd64 program +var amd64Table = map[Op]opInfo{ + OpADDQ: {flags: OpFlagCommutative, asm: "ADDQ\t%I0,%I1,%O0", reg: gp21}, // TODO: overwrite + OpADDCQ: {asm: "ADDQ\t$%A,%I0,%O0", reg: gp11}, // aux = int64 constant to add + OpSUBQ: {asm: "SUBQ\t%I0,%I1,%O0", reg: gp21}, + OpSUBCQ: {asm: "SUBQ\t$%A,%I0,%O0", reg: gp11}, + OpMULQ: {asm: "MULQ\t%I0,%I1,%O0", reg: gp21}, + OpMULCQ: {asm: "MULQ\t$%A,%I0,%O0", reg: gp11}, + OpSHLQ: {asm: "SHLQ\t%I0,%I1,%O0", reg: gp21}, + OpSHLCQ: {asm: "SHLQ\t$%A,%I0,%O0", reg: gp11}, + + OpCMPQ: {asm: "CMPQ\t%I0,%I1", reg: gp2_flags}, // compute arg[0]-arg[1] and produce flags + OpCMPCQ: {asm: "CMPQ\t$%A,%I0", reg: gp1_flags}, + OpTESTQ: {asm: "TESTQ\t%I0,%I1", reg: gp2_flags}, + + OpLEAQ: {flags: OpFlagCommutative, asm: "LEAQ\t%A(%I0)(%I1*1),%O0", reg: gp21}, // aux = int64 constant to add + OpLEAQ2: {asm: "LEAQ\t%A(%I0)(%I1*2),%O0"}, + OpLEAQ4: {asm: "LEAQ\t%A(%I0)(%I1*4),%O0"}, + OpLEAQ8: {asm: "LEAQ\t%A(%I0)(%I1*8),%O0"}, + + // loads and stores + OpMOVQload: {asm: "MOVQ\t%A(%I0),%O0", reg: gpload}, + OpMOVQstore: {asm: "MOVQ\t%I1,%A(%I0)", reg: gpstore}, + OpMOVQloadidx8: {asm: "MOVQ\t%A(%I0)(%I1*8),%O0", reg: gploadidx}, + OpMOVQstoreidx8: {asm: "MOVQ\t%I2,%A(%I0)(%I1*8)", reg: gpstoreidx}, + + OpMOVQconst: {asm: "MOVQ\t$%A,%O0", reg: gp01}, + + OpStaticCall: {asm: "CALL\t%A(SB)"}, + + OpCopy: {asm: "MOVQ\t%I0,%O0", reg: gp11}, + + // convert from flags back to boolean + OpSETL: {}, + + // ops for load/store to stack + OpMOVQloadFP: {asm: "MOVQ\t%A(FP),%O0", reg: gpload_stack}, // mem -> value + OpMOVQloadSP: {asm: "MOVQ\t%A(SP),%O0", reg: gpload_stack}, // mem -> value + OpMOVQstoreFP: {asm: "MOVQ\t%I0,%A(FP)", reg: gpstore_stack}, // mem, value -> mem + OpMOVQstoreSP: {asm: "MOVQ\t%I0,%A(SP)", reg: gpstore_stack}, // mem, value -> mem + + // ops for spilling of registers + // unlike regular loads & stores, these take no memory argument. + // They are just like OpCopy but we use them during register allocation. + // TODO: different widths, float + OpLoadReg8: {asm: "MOVQ\t%I0,%O0"}, + OpStoreReg8: {asm: "MOVQ\t%I0,%O0"}, +} + +func init() { + for op, info := range amd64Table { + opcodeTable[op] = info + } +} diff --git a/src/cmd/internal/ssa/regalloc.go b/src/cmd/internal/ssa/regalloc.go index 724a0557d5..bc397f323f 100644 --- a/src/cmd/internal/ssa/regalloc.go +++ b/src/cmd/internal/ssa/regalloc.go @@ -28,8 +28,16 @@ var registers = [...]Register{ Register{"BP"}, Register{"SI"}, Register{"DI"}, - - // TODO R8, X0, ... + Register{"R8"}, + Register{"R9"}, + Register{"R10"}, + Register{"R11"}, + Register{"R12"}, + Register{"R13"}, + Register{"R14"}, + Register{"R15"}, + + // TODO X0, ... // TODO: make arch-dependent Register{"FLAGS"}, Register{"OVERWRITE"}, diff --git a/src/cmd/internal/ssa/rulegen/lower_amd64.rules b/src/cmd/internal/ssa/rulegen/lower_amd64.rules index 8882e3c253..55267d6842 100644 --- a/src/cmd/internal/ssa/rulegen/lower_amd64.rules +++ b/src/cmd/internal/ssa/rulegen/lower_amd64.rules @@ -34,8 +34,8 @@ (Store ptr val mem) && (is64BitInt(val.Type) || isPtr(val.Type)) -> (MOVQstore [int64(0)] ptr val mem) // checks -(CheckNil p) -> (SETNE (TESTQ p p)) -(CheckBound idx len) -> (SETB (CMPQ idx len)) +(IsNonNil p) -> (SETNE (TESTQ p p)) +(IsInBounds idx len) -> (SETB (CMPQ idx len)) // Rules below here apply some simple optimizations after lowering. // TODO: Should this be a separate pass? @@ -80,8 +80,8 @@ (MOVQstore [off1] (ADDCQ [off2] ptr) val mem) -> (MOVQstore [off1.(int64)+off2.(int64)] ptr val mem) // indexed loads and stores -(MOVQload [off1] (LEAQ8 [off2] ptr idx) mem) -> (MOVQload8 [off1.(int64)+off2.(int64)] ptr idx mem) -(MOVQstore [off1] (LEAQ8 [off2] ptr idx) val mem) -> (MOVQstore8 [off1.(int64)+off2.(int64)] ptr idx val mem) +(MOVQload [off1] (LEAQ8 [off2] ptr idx) mem) -> (MOVQloadidx8 [off1.(int64)+off2.(int64)] ptr idx mem) +(MOVQstore [off1] (LEAQ8 [off2] ptr idx) val mem) -> (MOVQstoreidx8 [off1.(int64)+off2.(int64)] ptr idx val mem) // Combine the offset of a stack object with the offset within a stack object (ADDCQ [off1] (FPAddr [off2])) -> (FPAddr [off1.(int64)+off2.(int64)]) -- cgit v1.3 From 310d09bf73c2063626cd824b8df809595d6f0392 Mon Sep 17 00:00:00 2001 From: Michael Matloob Date: Tue, 12 May 2015 12:06:45 -0400 Subject: cmd/internal/ssa: utility functions to make Funcs Adds a more convenient way to define Funcs for testing. For instance, b1: v1 = Arg [.mem] Plain -> b2 b2: Exit v1 b3: v2 = Const [true] If v2 -> b3 b2 can be defined as fun :=Fun("entry", Bloc("entry", Valu("mem", OpArg, TypeMem, ".mem"), Goto("exit")), Bloc("exit", Exit("mem")), Bloc("deadblock", Valu("deadval", OpConst, TypeBool, true), If("deadval", "deadblock", "exit"))) Also add an Equiv function to test two Funcs for equivalence. Change-Id: If1633865aeefb8e765e772b6dad19250d93a413a Reviewed-on: https://go-review.googlesource.com/9992 Reviewed-by: Keith Randall --- src/cmd/internal/ssa/deadcode_test.go | 127 +++++------ src/cmd/internal/ssa/func_test.go | 401 ++++++++++++++++++++++++++++++++++ 2 files changed, 455 insertions(+), 73 deletions(-) create mode 100644 src/cmd/internal/ssa/func_test.go (limited to 'src/cmd') diff --git a/src/cmd/internal/ssa/deadcode_test.go b/src/cmd/internal/ssa/deadcode_test.go index 1b7c81c568..ced46e524b 100644 --- a/src/cmd/internal/ssa/deadcode_test.go +++ b/src/cmd/internal/ssa/deadcode_test.go @@ -2,44 +2,35 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -// TODO: these tests are pretty verbose. Is there a way to simplify -// building a small Func for testing? - -package ssa_test +package ssa import ( - . "cmd/internal/ssa" "testing" ) func TestDeadLoop(t *testing.T) { - f := new(Func) - entry := f.NewBlock(BlockPlain) - exit := f.NewBlock(BlockExit) - f.Entry = entry - addEdge(entry, exit) - mem := entry.NewValue(OpArg, TypeMem, ".mem") - exit.Control = mem - - // dead loop - deadblock := f.NewBlock(BlockIf) - addEdge(deadblock, deadblock) - addEdge(deadblock, exit) - - // dead value in dead block - deadval := deadblock.NewValue(OpConst, TypeBool, true) - deadblock.Control = deadval - - CheckFunc(f) - Deadcode(f) - CheckFunc(f) - - for _, b := range f.Blocks { - if b == deadblock { + fun := Fun("entry", + Bloc("entry", + Valu("mem", OpArg, TypeMem, ".mem"), + Goto("exit")), + Bloc("exit", + Exit("mem")), + // dead loop + Bloc("deadblock", + // dead value in dead block + Valu("deadval", OpConst, TypeBool, true), + 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 == deadval { + if v == fun.values["deadval"] { t.Errorf("control value of dead block not removed") } } @@ -47,23 +38,21 @@ func TestDeadLoop(t *testing.T) { } func TestDeadValue(t *testing.T) { - f := new(Func) - entry := f.NewBlock(BlockPlain) - exit := f.NewBlock(BlockExit) - f.Entry = entry - addEdge(entry, exit) - mem := entry.NewValue(OpArg, TypeMem, ".mem") - exit.Control = mem - - deadval := entry.NewValue(OpConst, TypeInt64, int64(37)) - - CheckFunc(f) - Deadcode(f) - CheckFunc(f) - - for _, b := range f.Blocks { + fun := Fun("entry", + Bloc("entry", + Valu("mem", OpArg, TypeMem, ".mem"), + Valu("deadval", OpConst, TypeInt64, int64(37)), + 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 == deadval { + if v == fun.values["deadval"] { t.Errorf("dead value not removed") } } @@ -71,42 +60,34 @@ func TestDeadValue(t *testing.T) { } func TestNeverTaken(t *testing.T) { - f := new(Func) - entry := f.NewBlock(BlockIf) - exit := f.NewBlock(BlockExit) - then := f.NewBlock(BlockPlain) - else_ := f.NewBlock(BlockPlain) - f.Entry = entry - addEdge(entry, then) - addEdge(entry, else_) - addEdge(then, exit) - addEdge(else_, exit) - mem := entry.NewValue(OpArg, TypeMem, ".mem") - exit.Control = mem - - cond := entry.NewValue(OpConst, TypeBool, false) - entry.Control = cond - - CheckFunc(f) - Deadcode(f) - CheckFunc(f) - - if entry.Kind != BlockPlain { + fun := Fun("entry", + Bloc("entry", + Valu("cond", OpConst, TypeBool, false), + Valu("mem", OpArg, TypeMem, ".mem"), + If("cond", "then", "else")), + Bloc("then", + Goto("exit")), + Bloc("else", + Goto("exit")), + Bloc("exit", + Exit("mem"))) + + CheckFunc(fun.f) + Deadcode(fun.f) + CheckFunc(fun.f) + + if fun.blocks["entry"].Kind != BlockPlain { t.Errorf("if(false) not simplified") } - for _, b := range f.Blocks { - if b == then { + for _, b := range fun.f.Blocks { + if b == fun.blocks["then"] { t.Errorf("then block still present") } for _, v := range b.Values { - if v == cond { + if v == fun.values["cond"] { t.Errorf("constant condition still present") } } } -} -func addEdge(b, c *Block) { - b.Succs = append(b.Succs, c) - c.Preds = append(c.Preds, b) } diff --git a/src/cmd/internal/ssa/func_test.go b/src/cmd/internal/ssa/func_test.go new file mode 100644 index 0000000000..e7619ca4f8 --- /dev/null +++ b/src/cmd/internal/ssa/func_test.go @@ -0,0 +1,401 @@ +// This file contains some utility functions to help define Funcs for testing. +// As an example, the following func +// +// b1: +// v1 = Arg [.mem] +// Plain -> b2 +// b2: +// Exit v1 +// b3: +// v2 = Const [true] +// If v2 -> b3 b2 +// +// can be defined as +// +// fun := Fun("entry", +// Bloc("entry", +// Valu("mem", OpArg, TypeMem, ".mem"), +// Goto("exit")), +// Bloc("exit", +// Exit("mem")), +// Bloc("deadblock", +// Valu("deadval", OpConst, TypeBool, 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 ( + "log" + "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 { + 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 +} + +// 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(entry string, blocs ...bloc) fun { + f := new(Func) + 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.NewValue(valu.op, valu.t, 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 { + log.Panicf("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 { + log.Panicf("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 { + addEdge(b, 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 { + log.Panicf("already seen control for block %s", name) + } + b.control = v + seenCtrl = true + case valu: + b.valus = append(b.valus, v) + } + } + if !seenCtrl { + log.Panicf("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, aux interface{}, args ...string) valu { + return valu{name, op, t, 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{}} +} + +// 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 + aux interface{} + args []string +} + +func addEdge(b, c *Block) { + b.Succs = append(b.Succs, c) + c.Preds = append(c.Preds, b) +} + +func TestArgs(t *testing.T) { + fun := Fun("entry", + Bloc("entry", + Valu("a", OpConst, TypeInt64, 14), + Valu("b", OpConst, TypeInt64, 26), + Valu("sum", OpAdd, TypeInt64, nil, "a", "b"), + Valu("mem", OpArg, TypeMem, ".mem"), + 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("entry", + Bloc("entry", + Valu("a", OpConst, TypeInt64, 14), + Valu("b", OpConst, TypeInt64, 26), + Valu("sum", OpAdd, TypeInt64, nil, "a", "b"), + Valu("mem", OpArg, TypeMem, ".mem"), + Goto("exit")), + Bloc("exit", + Exit("mem"))), + Fun("entry", + Bloc("entry", + Valu("a", OpConst, TypeInt64, 14), + Valu("b", OpConst, TypeInt64, 26), + Valu("sum", OpAdd, TypeInt64, nil, "a", "b"), + Valu("mem", OpArg, TypeMem, ".mem"), + Goto("exit")), + Bloc("exit", + Exit("mem"))), + }, + // block order changed + { + Fun("entry", + Bloc("entry", + Valu("a", OpConst, TypeInt64, 14), + Valu("b", OpConst, TypeInt64, 26), + Valu("sum", OpAdd, TypeInt64, nil, "a", "b"), + Valu("mem", OpArg, TypeMem, ".mem"), + Goto("exit")), + Bloc("exit", + Exit("mem"))), + Fun("entry", + Bloc("exit", + Exit("mem")), + Bloc("entry", + Valu("a", OpConst, TypeInt64, 14), + Valu("b", OpConst, TypeInt64, 26), + Valu("sum", OpAdd, TypeInt64, nil, "a", "b"), + Valu("mem", OpArg, TypeMem, ".mem"), + Goto("exit"))), + }, + } + for _, c := range equivalentCases { + if !Equiv(c.f.f, c.g.f) { + t.Errorf("expected equivalence. Func definitions:") + // TODO(matloob): Rewrite PrintFunc to output to a string or writer, + // so the functions can be written to the error log. + PrintFunc(c.f.f) + PrintFunc(c.g.f) + } + } + + differentCases := []struct{ f, g fun }{ + // different shape + { + Fun("entry", + Bloc("entry", + Valu("mem", OpArg, TypeMem, ".mem"), + Goto("exit")), + Bloc("exit", + Exit("mem"))), + Fun("entry", + Bloc("entry", + Valu("mem", OpArg, TypeMem, ".mem"), + Exit("mem"))), + }, + // value order changed + { + Fun("entry", + Bloc("entry", + Valu("mem", OpArg, TypeMem, ".mem"), + Valu("b", OpConst, TypeInt64, 26), + Valu("a", OpConst, TypeInt64, 14), + Exit("mem"))), + Fun("entry", + Bloc("entry", + Valu("mem", OpArg, TypeMem, ".mem"), + Valu("a", OpConst, TypeInt64, 14), + Valu("b", OpConst, TypeInt64, 26), + Exit("mem"))), + }, + // value aux different + { + Fun("entry", + Bloc("entry", + Valu("mem", OpArg, TypeMem, ".mem"), + Valu("a", OpConst, TypeInt64, 14), + Exit("mem"))), + Fun("entry", + Bloc("entry", + Valu("mem", OpArg, TypeMem, ".mem"), + Valu("a", OpConst, TypeInt64, 26), + Exit("mem"))), + }, + // value args different + { + Fun("entry", + Bloc("entry", + Valu("mem", OpArg, TypeMem, ".mem"), + Valu("a", OpConst, TypeInt64, 14), + Valu("b", OpConst, TypeInt64, 26), + Valu("sum", OpAdd, TypeInt64, nil, "a", "b"), + Exit("mem"))), + Fun("entry", + Bloc("entry", + Valu("mem", OpArg, TypeMem, ".mem"), + Valu("a", OpConst, TypeInt64, 0), + Valu("b", OpConst, TypeInt64, 14), + Valu("sum", OpAdd, TypeInt64, nil, "b", "a"), + Exit("mem"))), + }, + } + for _, c := range differentCases { + if Equiv(c.f.f, c.g.f) { + t.Errorf("expected difference. Func definitions:") + // TODO(matloob): Rewrite PrintFunc to output to a string or writer, + // so the functions can be written to the error log. + PrintFunc(c.f.f) + PrintFunc(c.g.f) + } + } +} -- cgit v1.3 From 083a646f63055427c203d5600ef65f05f55783bf Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Tue, 12 May 2015 11:06:44 -0700 Subject: [dev.ssa] cmd/internal/gc: Generate code from ssa form After the ssa compiler finishes, extract a cmd/internal/obj program from the result. Can compile and run iterative Fibonacci. The code is awful, but it runs. Change-Id: I19fa27ffe69863950a8cb594f33a5e9a671a7663 Reviewed-on: https://go-review.googlesource.com/9971 Reviewed-by: Russ Cox --- src/cmd/internal/gc/pgen.go | 9 +- src/cmd/internal/gc/ssa.go | 258 ++++++++++++++++++++++++++++++++++++- src/cmd/internal/ssa/location.go | 6 +- src/cmd/internal/ssa/regalloc.go | 36 +++--- src/cmd/internal/ssa/stackalloc.go | 6 + 5 files changed, 291 insertions(+), 24 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/internal/gc/pgen.go b/src/cmd/internal/gc/pgen.go index ae7fcce1ba..2c225c8778 100644 --- a/src/cmd/internal/gc/pgen.go +++ b/src/cmd/internal/gc/pgen.go @@ -6,6 +6,7 @@ package gc import ( "cmd/internal/obj" + "cmd/internal/ssa" "crypto/md5" "fmt" "strings" @@ -367,6 +368,7 @@ func compile(fn *Node) { var nam *Node var gcargs *Sym var gclocals *Sym + var ssafn *ssa.Func if fn.Nbody == nil { if pure_go != 0 || strings.HasPrefix(fn.Nname.Sym.Name, "init.") { Yyerror("missing function body for %q", fn.Nname.Sym.Name) @@ -422,8 +424,7 @@ func compile(fn *Node) { { name := Curfn.Nname.Sym.Name if len(name) > 4 && name[len(name)-4:] == "_ssa" { - buildssa(Curfn) - // TODO(khr): use result of buildssa + ssafn = buildssa(Curfn) } } @@ -488,6 +489,10 @@ func compile(fn *Node) { } Genlist(Curfn.Func.Enter) + if ssafn != nil { + genssa(ssafn, ptxt, gcargs, gclocals) + return + } Genlist(Curfn.Nbody) gclean() checklabels() diff --git a/src/cmd/internal/gc/ssa.go b/src/cmd/internal/gc/ssa.go index 1d3abb3f37..ec6ad8abcb 100644 --- a/src/cmd/internal/gc/ssa.go +++ b/src/cmd/internal/gc/ssa.go @@ -7,10 +7,12 @@ package gc import ( "log" + "cmd/internal/obj" + "cmd/internal/obj/x86" // TODO: remove "cmd/internal/ssa" ) -func buildssa(fn *Node) { +func buildssa(fn *Node) *ssa.Func { dumplist("buildssa", Curfn.Nbody) var s ssaState @@ -50,9 +52,10 @@ func buildssa(fn *Node) { // Link up variable uses to variable definitions s.linkForwardReferences() + // Main call to ssa package to compile function ssa.Compile(s.f) - // TODO(khr): Use the resulting s.f to generate code + return s.f } type ssaState struct { @@ -457,3 +460,254 @@ func addEdge(b, c *ssa.Block) { b.Succs = append(b.Succs, c) c.Preds = append(c.Preds, b) } + +// an unresolved branch +type branch struct { + p *obj.Prog // branch instruction + b *ssa.Block // target +} + +// 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) { + // TODO: line numbers + // TODO: layout frame + stkSize := int64(64) + + if Hasdefer != 0 { + // deferreturn pretends to have one uintptr argument. + // Reserve space for it so stack scanner is happy. + if Maxarg < int64(Widthptr) { + Maxarg = int64(Widthptr) + } + } + if stkSize+Maxarg > 1<<31 { + Yyerror("stack frame too large (>2GB)") + return + } + frameSize := stkSize + Maxarg + + ptxt.To.Type = obj.TYPE_TEXTSIZE + ptxt.To.Val = int32(Rnd(Curfn.Type.Argwid, int64(Widthptr))) // arg size + ptxt.To.Offset = frameSize - 8 // TODO: arch-dependent + + // Remember where each block starts. + bstart := make([]*obj.Prog, f.NumBlocks()) + + // Remember all the branch instructions we've seen + // and where they would like to go + var branches []branch + + // Emit basic blocks + for i, b := range f.Blocks { + bstart[b.ID] = Pc + // Emit values in block + for _, v := range b.Values { + genValue(v, frameSize) + } + // Emit control flow instructions for block + var next *ssa.Block + if i < len(f.Blocks)-1 { + next = f.Blocks[i+1] + } + branches = genBlock(b, next, branches) + } + + // Resolve branches + for _, br := range branches { + br.p.To.Val = bstart[br.b.ID] + } + + Pc.As = obj.ARET // overwrite AEND + + // TODO: liveness + // TODO: gcargs + // TODO: gclocals + + // TODO: dump frame if -f + + // Emit garbage collection symbols. TODO: put something in them + liveness(Curfn, ptxt, gcargs, gclocals) +} + +func genValue(v *ssa.Value, frameSize int64) { + switch v.Op { + case ssa.OpADDQ: + // TODO: use addq instead of leaq if target is in the right register. + p := Prog(x86.ALEAQ) + p.From.Type = obj.TYPE_MEM + p.From.Reg = regnum(v.Args[0]) + p.From.Scale = 1 + p.From.Index = regnum(v.Args[1]) + p.To.Type = obj.TYPE_REG + p.To.Reg = regnum(v) + case ssa.OpADDCQ: + // TODO: use addq instead of leaq if target is in the right register. + p := Prog(x86.ALEAQ) + p.From.Type = obj.TYPE_MEM + p.From.Reg = regnum(v.Args[0]) + p.From.Offset = v.Aux.(int64) + p.To.Type = obj.TYPE_REG + p.To.Reg = regnum(v) + case ssa.OpSUBCQ: + // 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(x86.AMOVQ) + p.From.Type = obj.TYPE_REG + p.From.Reg = x + p.To.Type = obj.TYPE_REG + p.To.Reg = r + x = r + } + p := Prog(x86.ASUBQ) + p.From.Type = obj.TYPE_CONST + p.From.Offset = v.Aux.(int64) + p.To.Type = obj.TYPE_REG + p.To.Reg = r + case ssa.OpCMPQ: + x := regnum(v.Args[0]) + y := regnum(v.Args[1]) + p := Prog(x86.ACMPQ) + p.From.Type = obj.TYPE_REG + p.From.Reg = x + p.To.Type = obj.TYPE_REG + p.To.Reg = y + case ssa.OpMOVQconst: + x := regnum(v) + p := Prog(x86.AMOVQ) + p.From.Type = obj.TYPE_CONST + p.From.Offset = v.Aux.(int64) + p.To.Type = obj.TYPE_REG + p.To.Reg = x + case ssa.OpMOVQloadFP: + x := regnum(v) + p := Prog(x86.AMOVQ) + p.From.Type = obj.TYPE_MEM + p.From.Reg = x86.REG_SP + p.From.Offset = v.Aux.(int64) + frameSize + p.To.Type = obj.TYPE_REG + p.To.Reg = x + case ssa.OpMOVQstoreFP: + x := regnum(v.Args[0]) + p := Prog(x86.AMOVQ) + p.From.Type = obj.TYPE_REG + p.From.Reg = x + p.To.Type = obj.TYPE_MEM + p.To.Reg = x86.REG_SP + p.To.Offset = v.Aux.(int64) + frameSize + case ssa.OpCopy: + x := regnum(v.Args[0]) + y := regnum(v) + if x != y { + p := Prog(x86.AMOVQ) + p.From.Type = obj.TYPE_REG + p.From.Reg = x + p.To.Type = obj.TYPE_REG + p.To.Reg = y + } + case ssa.OpLoadReg8: + p := Prog(x86.AMOVQ) + p.From.Type = obj.TYPE_MEM + p.From.Reg = x86.REG_SP + p.From.Offset = frameSize - localOffset(v.Args[0]) + p.To.Type = obj.TYPE_REG + p.To.Reg = regnum(v) + case ssa.OpStoreReg8: + p := Prog(x86.AMOVQ) + p.From.Type = obj.TYPE_REG + p.From.Reg = regnum(v.Args[0]) + p.To.Type = obj.TYPE_MEM + p.To.Reg = x86.REG_SP + p.To.Offset = frameSize - localOffset(v) + case ssa.OpPhi: + // just check to make sure regalloc did it right + f := v.Block.Func + loc := f.RegAlloc[v.ID] + for _, a := range v.Args { + if f.RegAlloc[a.ID] != loc { // TODO: .Equal() instead? + log.Fatalf("phi arg at different location than phi %v %v %v %v", v, loc, a, f.RegAlloc[a.ID]) + } + } + case ssa.OpConst: + if v.Block.Func.RegAlloc[v.ID] != nil { + log.Fatalf("const value %v shouldn't have a location", v) + } + case ssa.OpArg: + // memory arg needs no code + // TODO: only mem arg goes here. + default: + log.Fatalf("value %v not implemented yet", v) + } +} + +func genBlock(b, next *ssa.Block, branches []branch) []branch { + switch b.Kind { + case ssa.BlockPlain: + if b.Succs[0] != next { + p := Prog(obj.AJMP) + p.To.Type = obj.TYPE_BRANCH + branches = append(branches, branch{p, b.Succs[0]}) + } + case ssa.BlockExit: + Prog(obj.ARET) + case ssa.BlockLT: + if b.Succs[0] == next { + p := Prog(x86.AJGE) + p.To.Type = obj.TYPE_BRANCH + branches = append(branches, branch{p, b.Succs[1]}) + } else if b.Succs[1] == next { + p := Prog(x86.AJLT) + p.To.Type = obj.TYPE_BRANCH + branches = append(branches, branch{p, b.Succs[0]}) + } else { + p := Prog(x86.AJLT) + p.To.Type = obj.TYPE_BRANCH + branches = append(branches, branch{p, b.Succs[0]}) + q := Prog(obj.AJMP) + q.To.Type = obj.TYPE_BRANCH + branches = append(branches, branch{q, b.Succs[1]}) + } + default: + log.Fatalf("branch at %v not implemented yet", b) + } + return branches +} + +// 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, + // TODO: more + // TODO: arch-dependent +} + +// regnum returns the register (in cmd/internal/obj numbering) to +// which v has been allocated. Panics if v is not assigned to a +// register. +func regnum(v *ssa.Value) int16 { + return ssaRegToReg[v.Block.Func.RegAlloc[v.ID].(*ssa.Register).Num] +} + +// localOffset returns the offset below the frame pointer where +// a stack-allocated local has been allocated. Panics if v +// is not assigned to a local slot. +func localOffset(v *ssa.Value) int64 { + return v.Block.Func.RegAlloc[v.ID].(*ssa.LocalSlot).Idx +} diff --git a/src/cmd/internal/ssa/location.go b/src/cmd/internal/ssa/location.go index 5fc2c5c934..528956e681 100644 --- a/src/cmd/internal/ssa/location.go +++ b/src/cmd/internal/ssa/location.go @@ -14,7 +14,9 @@ type Location interface { } // A Register is a machine register, like %rax. +// They are numbered densely from 0 (for each architecture). type Register struct { + Num int32 name string } @@ -24,11 +26,11 @@ func (r *Register) Name() string { // A LocalSlot is a location in the stack frame. type LocalSlot struct { - idx int64 // offset in locals area (distance down from FP == caller's SP) + Idx int64 // offset in locals area (distance down from FP == caller's SP) } func (s *LocalSlot) Name() string { - return fmt.Sprintf("-%d(FP)", s.idx) + return fmt.Sprintf("-%d(FP)", s.Idx) } // An ArgSlot is a location in the parents' stack frame where it passed us an argument. diff --git a/src/cmd/internal/ssa/regalloc.go b/src/cmd/internal/ssa/regalloc.go index bc397f323f..e2de10896e 100644 --- a/src/cmd/internal/ssa/regalloc.go +++ b/src/cmd/internal/ssa/regalloc.go @@ -20,27 +20,27 @@ type register uint var numRegs register = 32 var registers = [...]Register{ - Register{"AX"}, - Register{"CX"}, - Register{"DX"}, - Register{"BX"}, - Register{"SP"}, - Register{"BP"}, - Register{"SI"}, - Register{"DI"}, - Register{"R8"}, - Register{"R9"}, - Register{"R10"}, - Register{"R11"}, - Register{"R12"}, - Register{"R13"}, - Register{"R14"}, - Register{"R15"}, + 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"}, // TODO X0, ... // TODO: make arch-dependent - Register{"FLAGS"}, - Register{"OVERWRITE"}, + Register{16, "FLAGS"}, + Register{17, "OVERWRITE"}, } // countRegs returns the number of set bits in the register mask. diff --git a/src/cmd/internal/ssa/stackalloc.go b/src/cmd/internal/ssa/stackalloc.go index aa6d829fa2..4d0359ed81 100644 --- a/src/cmd/internal/ssa/stackalloc.go +++ b/src/cmd/internal/ssa/stackalloc.go @@ -35,6 +35,12 @@ func stackalloc(f *Func) { if v.Type.IsMemory() { // TODO: only "regallocable" types continue } + if v.Op == OpConst { + // don't allocate space for OpConsts. They should + // have been rematerialized everywhere. + // TODO: is this the right thing to do? + continue + } // a := v.Type.Align() // n = (n + a - 1) / a * a TODO n += v.Type.Size() -- cgit v1.3 From cfc2aa56b0bf6b7dfb8f38cd2cfbe8799fc5a31a Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Mon, 18 May 2015 16:44:20 -0700 Subject: [dev.ssa] cmd/internal/ssa: Handle more instructions + some cleanup Add & as an input op. Add several output ops (loads & stores, TESTB, LEAQglobal, branches, memcopy) Some other small things: - Add exprAddr to builder to generate addresses of expressions. Use it in various places that had ad-hoc code. - Separate out nil & bounds check generation to separate functions. - Add explicit FP and SP ops so we dont need specialized *FP and *SP opcodes. - Fix fallthrough at end of functions with no return values. - rematerialization of more opcodes. Change-Id: I781decfcef9770fb15f0cd6b061547f7824a2d5e Reviewed-on: https://go-review.googlesource.com/10213 Reviewed-by: Alan Donovan --- src/cmd/internal/gc/ssa.go | 371 ++++++++++++++++------ src/cmd/internal/obj/x86/6.out.go | 32 +- src/cmd/internal/ssa/check.go | 6 +- src/cmd/internal/ssa/config.go | 6 +- src/cmd/internal/ssa/generic.go | 189 ++++++++---- src/cmd/internal/ssa/lower.go | 115 ++++--- src/cmd/internal/ssa/lowerAmd64.go | 408 +++++++++++++------------ src/cmd/internal/ssa/op.go | 19 +- src/cmd/internal/ssa/op_string.go | 12 +- src/cmd/internal/ssa/opamd64.go | 57 ++-- src/cmd/internal/ssa/regalloc.go | 43 ++- src/cmd/internal/ssa/rewrite.go | 33 +- src/cmd/internal/ssa/rulegen/generic.rules | 21 +- src/cmd/internal/ssa/rulegen/lower_amd64.rules | 49 +-- src/cmd/internal/ssa/rulegen/rulegen.go | 35 ++- src/cmd/internal/ssa/stackalloc.go | 12 +- 16 files changed, 905 insertions(+), 503 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/internal/gc/ssa.go b/src/cmd/internal/gc/ssa.go index ec6ad8abcb..8e81163ad4 100644 --- a/src/cmd/internal/gc/ssa.go +++ b/src/cmd/internal/gc/ssa.go @@ -15,7 +15,7 @@ import ( func buildssa(fn *Node) *ssa.Func { dumplist("buildssa", Curfn.Nbody) - var s ssaState + var s state // TODO(khr): build config just once at the start of the compiler binary s.config = ssa.NewConfig(Thearch.Thestring) @@ -33,8 +33,10 @@ func buildssa(fn *Node) *ssa.Func { // Allocate exit block s.exit = s.f.NewBlock(ssa.BlockExit) - // TODO(khr): all args. Make a struct containing args/returnvals, declare - // an FP which contains a pointer to that struct. + // Allocate starting values + s.startmem = s.f.Entry.NewValue(ssa.OpArg, ssa.TypeMem, ".mem") + s.fp = s.f.Entry.NewValue(ssa.OpFP, s.config.Uintptr, nil) // TODO: use generic pointer type (unsafe.Pointer?) instead + s.sp = s.f.Entry.NewValue(ssa.OpSP, s.config.Uintptr, nil) s.vars = map[string]*ssa.Value{} s.labels = map[string]*ssa.Block{} @@ -44,6 +46,11 @@ func buildssa(fn *Node) *ssa.Func { s.startBlock(s.f.Entry) s.stmtList(fn.Nbody) + // fallthrough to exit + if b := s.endBlock(); b != nil { + addEdge(b, s.exit) + } + // Finish up exit block s.startBlock(s.exit) s.exit.Control = s.mem() @@ -58,7 +65,7 @@ func buildssa(fn *Node) *ssa.Func { return s.f } -type ssaState struct { +type state struct { // configuration (arch) information config *ssa.Config @@ -83,10 +90,18 @@ type ssaState struct { // offsets of argument slots // unnamed and unused args are not listed. argOffsets map[string]int64 + + // starting values. Memory, frame pointer, and stack pointer + startmem *ssa.Value + fp *ssa.Value + sp *ssa.Value } // startBlock sets the current block we're generating code in to b. -func (s *ssaState) startBlock(b *ssa.Block) { +func (s *state) startBlock(b *ssa.Block) { + if s.curBlock != nil { + log.Fatalf("starting block %v when block %v has not ended", b, s.curBlock) + } s.curBlock = b s.vars = map[string]*ssa.Value{} } @@ -94,7 +109,7 @@ func (s *ssaState) startBlock(b *ssa.Block) { // 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 *ssaState) endBlock() *ssa.Block { +func (s *state) endBlock() *ssa.Block { b := s.curBlock if b == nil { return nil @@ -109,14 +124,14 @@ func (s *ssaState) endBlock() *ssa.Block { } // ssaStmtList converts the statement n to SSA and adds it to s. -func (s *ssaState) stmtList(l *NodeList) { +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 *ssaState) stmt(n *Node) { +func (s *state) stmt(n *Node) { s.stmtList(n.Ninit) switch n.Op { @@ -145,35 +160,15 @@ func (s *ssaState) stmt(n *Node) { case OAS: // TODO(khr): colas? val := s.expr(n.Right) - if n.Left.Op == OINDREG { - // indirect off a register (TODO: always SP?) - // used for storing arguments to callees - addr := s.f.Entry.NewValue(ssa.OpSPAddr, Ptrto(n.Right.Type), n.Left.Xoffset) - s.vars[".mem"] = s.curBlock.NewValue3(ssa.OpStore, ssa.TypeMem, nil, addr, val, s.mem()) - } else if n.Left.Op != ONAME { - // some more complicated expression. Rewrite to a store. TODO - addr := s.expr(n.Left) // TODO: wrap in & - - // TODO(khr): nil check - s.vars[".mem"] = s.curBlock.NewValue3(ssa.OpStore, n.Right.Type, nil, addr, val, s.mem()) - } else if !n.Left.Addable { - // TODO - log.Fatalf("assignment to non-addable value") - } else if n.Left.Class&PHEAP != 0 { - // TODO - log.Fatalf("assignment to heap value") - } else if n.Left.Class == PEXTERN { - // assign to global variable - addr := s.f.Entry.NewValue(ssa.OpGlobal, Ptrto(n.Left.Type), n.Left.Sym) - s.vars[".mem"] = s.curBlock.NewValue3(ssa.OpStore, ssa.TypeMem, nil, addr, val, s.mem()) - } else if n.Left.Class == PPARAMOUT { - // store to parameter slot - addr := s.f.Entry.NewValue(ssa.OpFPAddr, Ptrto(n.Right.Type), n.Left.Xoffset) - s.vars[".mem"] = s.curBlock.NewValue3(ssa.OpStore, ssa.TypeMem, nil, addr, val, s.mem()) - } else { - // normal variable + if n.Left.Op == ONAME && !n.Left.Addrtaken && n.Left.Class&PHEAP == 0 && n.Left.Class != PEXTERN && n.Left.Class != PPARAMOUT { + // ssa-able variable. s.vars[n.Left.Sym.Name] = val + return } + // not ssa-able. Treat as a store. + addr := s.addr(n.Left) + s.vars[".mem"] = s.curBlock.NewValue3(ssa.OpStore, ssa.TypeMem, nil, addr, val, s.mem()) + // TODO: try to make more variables registerizeable. case OIF: cond := s.expr(n.Ntest) b := s.endBlock() @@ -254,7 +249,7 @@ func (s *ssaState) stmt(n *Node) { } // expr converts the expression n to ssa, adds it to s and returns the ssa result. -func (s *ssaState) expr(n *Node) *ssa.Value { +func (s *state) expr(n *Node) *ssa.Value { if n == nil { // TODO(khr): is this nil??? return s.f.Entry.NewValue(ssa.OpConst, n.Type, nil) @@ -269,7 +264,6 @@ func (s *ssaState) expr(n *Node) *ssa.Value { } s.argOffsets[n.Sym.Name] = n.Xoffset return s.variable(n.Sym.Name, n.Type) - // binary ops case OLITERAL: switch n.Val.Ctype { case CTINT: @@ -278,6 +272,8 @@ func (s *ssaState) expr(n *Node) *ssa.Value { log.Fatalf("unhandled OLITERAL %v", n.Val.Ctype) return nil } + + // binary ops case OLT: a := s.expr(n.Left) b := s.expr(n.Right) @@ -286,56 +282,36 @@ func (s *ssaState) expr(n *Node) *ssa.Value { a := s.expr(n.Left) b := s.expr(n.Right) return s.curBlock.NewValue2(ssa.OpAdd, a.Type, nil, a, b) - case OSUB: // TODO:(khr) fold code for all binary ops together somehow a := s.expr(n.Left) b := s.expr(n.Right) return s.curBlock.NewValue2(ssa.OpSub, a.Type, nil, a, b) + case OADDR: + return s.addr(n.Left) + case OIND: p := s.expr(n.Left) - c := s.curBlock.NewValue1(ssa.OpIsNonNil, ssa.TypeBool, nil, p) - b := s.endBlock() - b.Kind = ssa.BlockIf - b.Control = c - bNext := s.f.NewBlock(ssa.BlockPlain) - addEdge(b, bNext) - addEdge(b, s.exit) - s.startBlock(bNext) - // TODO(khr): if ptr check fails, don't go directly to exit. - // Instead, go to a call to panicnil or something. - // TODO: implicit nil checks somehow? - + s.nilCheck(p) return s.curBlock.NewValue2(ssa.OpLoad, n.Type, nil, p, s.mem()) + case ODOTPTR: p := s.expr(n.Left) - // TODO: nilcheck - p = s.curBlock.NewValue2(ssa.OpAdd, p.Type, nil, p, s.f.ConstInt(s.config.UIntPtr, n.Xoffset)) + s.nilCheck(p) + p = s.curBlock.NewValue2(ssa.OpAdd, p.Type, nil, p, s.f.ConstInt(s.config.Uintptr, n.Xoffset)) return s.curBlock.NewValue2(ssa.OpLoad, n.Type, nil, p, s.mem()) case OINDEX: - // TODO: slice vs array? Map index is already reduced to a function call - a := s.expr(n.Left) - i := s.expr(n.Right) - // 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 (and use a low32 op instead of convnop here). - i = s.curBlock.NewValue1(ssa.OpConvNop, s.config.UIntPtr, nil, i) - - // bounds check - len := s.curBlock.NewValue1(ssa.OpSliceLen, s.config.UIntPtr, nil, a) - cmp := s.curBlock.NewValue2(ssa.OpIsInBounds, ssa.TypeBool, nil, i, len) - b := s.endBlock() - b.Kind = ssa.BlockIf - b.Control = cmp - bNext := s.f.NewBlock(ssa.BlockPlain) - addEdge(b, bNext) - addEdge(b, s.exit) - s.startBlock(bNext) - // TODO: don't go directly to s.exit. Go to a stub that calls panicindex first. - - return s.curBlock.NewValue3(ssa.OpSliceIndex, n.Left.Type.Type, nil, a, i, s.mem()) + if n.Left.Type.Bound >= 0 { // array + a := s.expr(n.Left) + i := s.expr(n.Right) + s.boundsCheck(i, s.f.ConstInt(s.config.Uintptr, n.Left.Type.Bound)) + return s.curBlock.NewValue2(ssa.OpArrayIndex, n.Left.Type.Type, nil, a, i) + } else { // slice + p := s.addr(n) + return s.curBlock.NewValue2(ssa.OpLoad, n.Left.Type.Type, nil, p, s.mem()) + } case OCALLFUNC: // run all argument assignments @@ -359,7 +335,7 @@ func (s *ssaState) expr(n *Node) *ssa.Value { s.startBlock(bNext) var titer Iter fp := Structfirst(&titer, Getoutarg(n.Left.Type)) - a := s.f.Entry.NewValue(ssa.OpSPAddr, Ptrto(fp.Type), fp.Width) + a := s.f.Entry.NewValue1(ssa.OpOffPtr, Ptrto(fp.Type), fp.Width, s.sp) return s.curBlock.NewValue2(ssa.OpLoad, fp.Type, nil, a, call) default: log.Fatalf("unhandled expr %s", opnames[n.Op]) @@ -367,8 +343,81 @@ func (s *ssaState) expr(n *Node) *ssa.Value { } } +// expr converts the address of the expression n to SSA, adds it to s and returns the SSA result. +func (s *state) addr(n *Node) *ssa.Value { + switch n.Op { + case ONAME: + if n.Class == PEXTERN { + // global variable + return s.f.Entry.NewValue(ssa.OpGlobal, Ptrto(n.Type), n.Sym) + } + if n.Class == PPARAMOUT { + // store to parameter slot + return s.f.Entry.NewValue1(ssa.OpOffPtr, Ptrto(n.Type), n.Xoffset, s.fp) + } + // TODO: address of locals + log.Fatalf("variable address of %v not implemented", n) + return nil + case OINDREG: + // indirect off a register (TODO: always SP?) + // used for storing/loading arguments/returns to/from callees + return s.f.Entry.NewValue1(ssa.OpOffPtr, Ptrto(n.Type), n.Xoffset, s.sp) + case OINDEX: + if n.Left.Type.Bound >= 0 { // array + a := s.addr(n.Left) + i := s.expr(n.Right) + len := s.f.ConstInt(s.config.Uintptr, n.Left.Type.Bound) + s.boundsCheck(i, len) + return s.curBlock.NewValue2(ssa.OpPtrIndex, Ptrto(n.Left.Type.Type), nil, a, i) + } else { // slice + a := s.expr(n.Left) + i := s.expr(n.Right) + len := s.curBlock.NewValue1(ssa.OpSliceLen, s.config.Uintptr, nil, a) + s.boundsCheck(i, len) + p := s.curBlock.NewValue1(ssa.OpSlicePtr, Ptrto(n.Left.Type.Type), nil, a) + return s.curBlock.NewValue2(ssa.OpPtrIndex, Ptrto(n.Left.Type.Type), nil, p, i) + } + default: + log.Fatalf("addr: bad op %v", n.Op) + return nil + } +} + +// nilCheck generates nil pointer checking code. +// Starts a new block on return. +func (s *state) nilCheck(ptr *ssa.Value) { + c := s.curBlock.NewValue1(ssa.OpIsNonNil, ssa.TypeBool, nil, ptr) + b := s.endBlock() + b.Kind = ssa.BlockIf + b.Control = c + bNext := s.f.NewBlock(ssa.BlockPlain) + addEdge(b, bNext) + addEdge(b, s.exit) + s.startBlock(bNext) + // TODO(khr): Don't go directly to exit. Go to a stub that calls panicmem first. + // TODO: implicit nil checks somehow? +} + +// 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) { + // 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.curBlock.NewValue2(ssa.OpIsInBounds, ssa.TypeBool, nil, idx, len) + b := s.endBlock() + b.Kind = ssa.BlockIf + b.Control = cmp + bNext := s.f.NewBlock(ssa.BlockPlain) + addEdge(b, bNext) + addEdge(b, s.exit) + // TODO: don't go directly to s.exit. Go to a stub that calls panicindex first. + s.startBlock(bNext) +} + // variable returns the value of a variable at the current location. -func (s *ssaState) variable(name string, t ssa.Type) *ssa.Value { +func (s *state) variable(name string, t ssa.Type) *ssa.Value { if s.curBlock == nil { log.Fatalf("nil curblock!") } @@ -381,11 +430,11 @@ func (s *ssaState) variable(name string, t ssa.Type) *ssa.Value { return v } -func (s *ssaState) mem() *ssa.Value { +func (s *state) mem() *ssa.Value { return s.variable(".mem", ssa.TypeMem) } -func (s *ssaState) linkForwardReferences() { +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, @@ -406,17 +455,16 @@ func (s *ssaState) linkForwardReferences() { } // lookupVarIncoming finds the variable's value at the start of block b. -func (s *ssaState) lookupVarIncoming(b *ssa.Block, t ssa.Type, name string) *ssa.Value { +func (s *state) lookupVarIncoming(b *ssa.Block, t ssa.Type, name string) *ssa.Value { // TODO(khr): have lookupVarIncoming overwrite the fwdRef or copy it // will be used in, instead of having the result used in a copy value. if b == s.f.Entry { if name == ".mem" { - return b.NewValue(ssa.OpArg, t, name) + return s.startmem } // variable is live at the entry block. Load it. - a := s.f.Entry.NewValue(ssa.OpFPAddr, Ptrto(t.(*Type)), s.argOffsets[name]) - m := b.NewValue(ssa.OpArg, ssa.TypeMem, ".mem") // TODO: reuse mem starting value - return b.NewValue2(ssa.OpLoad, t, nil, a, m) + addr := s.f.Entry.NewValue1(ssa.OpOffPtr, Ptrto(t.(*Type)), s.argOffsets[name], s.fp) + return b.NewValue2(ssa.OpLoad, t, nil, addr, s.startmem) } var vals []*ssa.Value for _, p := range b.Preds { @@ -435,7 +483,7 @@ func (s *ssaState) lookupVarIncoming(b *ssa.Block, t ssa.Type, name string) *ssa } // lookupVarOutgoing finds the variable's value at the end of block b. -func (s *ssaState) lookupVarOutgoing(b *ssa.Block, t ssa.Type, name string) *ssa.Value { +func (s *state) lookupVarOutgoing(b *ssa.Block, t ssa.Type, name string) *ssa.Value { m := s.defvars[b.ID] if v, ok := m[name]; ok { return v @@ -568,13 +616,23 @@ func genValue(v *ssa.Value, frameSize int64) { p.To.Type = obj.TYPE_REG p.To.Reg = r case ssa.OpCMPQ: - x := regnum(v.Args[0]) - y := regnum(v.Args[1]) p := Prog(x86.ACMPQ) p.From.Type = obj.TYPE_REG - p.From.Reg = x + p.From.Reg = regnum(v.Args[0]) + p.To.Type = obj.TYPE_REG + p.To.Reg = regnum(v.Args[1]) + case ssa.OpCMPCQ: + p := Prog(x86.ACMPQ) + p.From.Type = obj.TYPE_REG + p.From.Reg = regnum(v.Args[0]) + p.To.Type = obj.TYPE_CONST + p.To.Offset = v.Aux.(int64) + case ssa.OpTESTB: + p := Prog(x86.ATESTB) + p.From.Type = obj.TYPE_REG + p.From.Reg = regnum(v.Args[0]) p.To.Type = obj.TYPE_REG - p.To.Reg = y + p.To.Reg = regnum(v.Args[1]) case ssa.OpMOVQconst: x := regnum(v) p := Prog(x86.AMOVQ) @@ -582,22 +640,57 @@ func genValue(v *ssa.Value, frameSize int64) { p.From.Offset = v.Aux.(int64) p.To.Type = obj.TYPE_REG p.To.Reg = x - case ssa.OpMOVQloadFP: - x := regnum(v) + case ssa.OpMOVQload: p := Prog(x86.AMOVQ) p.From.Type = obj.TYPE_MEM - p.From.Reg = x86.REG_SP - p.From.Offset = v.Aux.(int64) + frameSize + if v.Block.Func.RegAlloc[v.Args[0].ID].Name() == "FP" { + // TODO: do the fp/sp adjustment somewhere else? + p.From.Reg = x86.REG_SP + p.From.Offset = v.Aux.(int64) + frameSize + } else { + p.From.Reg = regnum(v.Args[0]) + p.From.Offset = v.Aux.(int64) + } p.To.Type = obj.TYPE_REG - p.To.Reg = x - case ssa.OpMOVQstoreFP: - x := regnum(v.Args[0]) + p.To.Reg = regnum(v) + case ssa.OpMOVBload: + p := Prog(x86.AMOVB) + p.From.Type = obj.TYPE_MEM + if v.Block.Func.RegAlloc[v.Args[0].ID].Name() == "FP" { + p.From.Reg = x86.REG_SP + p.From.Offset = v.Aux.(int64) + frameSize + } else { + p.From.Reg = regnum(v.Args[0]) + p.From.Offset = v.Aux.(int64) + } + p.To.Type = obj.TYPE_REG + p.To.Reg = regnum(v) + case ssa.OpMOVQloadidx8: + p := Prog(x86.AMOVQ) + p.From.Type = obj.TYPE_MEM + if v.Block.Func.RegAlloc[v.Args[0].ID].Name() == "FP" { + p.From.Reg = x86.REG_SP + p.From.Offset = v.Aux.(int64) + frameSize + } else { + p.From.Reg = regnum(v.Args[0]) + p.From.Offset = v.Aux.(int64) + } + p.From.Scale = 8 + p.From.Index = regnum(v.Args[1]) + p.To.Type = obj.TYPE_REG + p.To.Reg = regnum(v) + case ssa.OpMOVQstore: p := Prog(x86.AMOVQ) p.From.Type = obj.TYPE_REG - p.From.Reg = x + p.From.Reg = regnum(v.Args[1]) p.To.Type = obj.TYPE_MEM - p.To.Reg = x86.REG_SP - p.To.Offset = v.Aux.(int64) + frameSize + if v.Block.Func.RegAlloc[v.Args[0].ID].Name() == "FP" { + p.To.Reg = x86.REG_SP + p.To.Offset = v.Aux.(int64) + frameSize + } else { + p.To.Reg = regnum(v.Args[0]) + p.To.Offset = v.Aux.(int64) + } case ssa.OpCopy: x := regnum(v.Args[0]) y := regnum(v) @@ -638,8 +731,19 @@ func genValue(v *ssa.Value, frameSize int64) { case ssa.OpArg: // memory arg needs no code // TODO: only mem arg goes here. + case ssa.OpLEAQglobal: + g := v.Aux.(ssa.GlobalOffset) + p := Prog(x86.ALEAQ) + p.From.Type = obj.TYPE_MEM + p.From.Name = obj.NAME_EXTERN + p.From.Sym = Linksym(g.Global.(*Sym)) + p.From.Offset = g.Offset + p.To.Type = obj.TYPE_REG + p.To.Reg = regnum(v) + case ssa.OpFP, ssa.OpSP: + // nothing to do default: - log.Fatalf("value %v not implemented yet", v) + log.Fatalf("value %s not implemented yet", v.LongString()) } } @@ -653,6 +757,40 @@ func genBlock(b, next *ssa.Block, branches []branch) []branch { } case ssa.BlockExit: Prog(obj.ARET) + case ssa.BlockEQ: + if b.Succs[0] == next { + p := Prog(x86.AJNE) + p.To.Type = obj.TYPE_BRANCH + branches = append(branches, branch{p, b.Succs[1]}) + } else if b.Succs[1] == next { + p := Prog(x86.AJEQ) + p.To.Type = obj.TYPE_BRANCH + branches = append(branches, branch{p, b.Succs[0]}) + } else { + p := Prog(x86.AJEQ) + p.To.Type = obj.TYPE_BRANCH + branches = append(branches, branch{p, b.Succs[0]}) + q := Prog(obj.AJMP) + q.To.Type = obj.TYPE_BRANCH + branches = append(branches, branch{q, b.Succs[1]}) + } + case ssa.BlockNE: + if b.Succs[0] == next { + p := Prog(x86.AJEQ) + p.To.Type = obj.TYPE_BRANCH + branches = append(branches, branch{p, b.Succs[1]}) + } else if b.Succs[1] == next { + p := Prog(x86.AJNE) + p.To.Type = obj.TYPE_BRANCH + branches = append(branches, branch{p, b.Succs[0]}) + } else { + p := Prog(x86.AJNE) + p.To.Type = obj.TYPE_BRANCH + branches = append(branches, branch{p, b.Succs[0]}) + q := Prog(obj.AJMP) + q.To.Type = obj.TYPE_BRANCH + branches = append(branches, branch{q, b.Succs[1]}) + } case ssa.BlockLT: if b.Succs[0] == next { p := Prog(x86.AJGE) @@ -670,8 +808,43 @@ func genBlock(b, next *ssa.Block, branches []branch) []branch { q.To.Type = obj.TYPE_BRANCH branches = append(branches, branch{q, b.Succs[1]}) } + case ssa.BlockULT: + if b.Succs[0] == next { + p := Prog(x86.AJCC) + p.To.Type = obj.TYPE_BRANCH + branches = append(branches, branch{p, b.Succs[1]}) + } else if b.Succs[1] == next { + p := Prog(x86.AJCS) + p.To.Type = obj.TYPE_BRANCH + branches = append(branches, branch{p, b.Succs[0]}) + } else { + p := Prog(x86.AJCS) + p.To.Type = obj.TYPE_BRANCH + branches = append(branches, branch{p, b.Succs[0]}) + q := Prog(obj.AJMP) + q.To.Type = obj.TYPE_BRANCH + branches = append(branches, branch{q, b.Succs[1]}) + } + case ssa.BlockUGT: + if b.Succs[0] == next { + p := Prog(x86.AJLS) + p.To.Type = obj.TYPE_BRANCH + branches = append(branches, branch{p, b.Succs[1]}) + } else if b.Succs[1] == next { + p := Prog(x86.AJHI) + p.To.Type = obj.TYPE_BRANCH + branches = append(branches, branch{p, b.Succs[0]}) + } else { + p := Prog(x86.AJHI) + p.To.Type = obj.TYPE_BRANCH + branches = append(branches, branch{p, b.Succs[0]}) + q := Prog(obj.AJMP) + q.To.Type = obj.TYPE_BRANCH + branches = append(branches, branch{q, b.Succs[1]}) + } + default: - log.Fatalf("branch at %v not implemented yet", b) + log.Fatalf("branch %s not implemented yet", b.LongString()) } return branches } diff --git a/src/cmd/internal/obj/x86/6.out.go b/src/cmd/internal/obj/x86/6.out.go index c7f46e1801..e36cb9e7a3 100644 --- a/src/cmd/internal/obj/x86/6.out.go +++ b/src/cmd/internal/obj/x86/6.out.go @@ -110,23 +110,23 @@ const ( 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/ssa/check.go b/src/cmd/internal/ssa/check.go index 453388a899..667313ad9f 100644 --- a/src/cmd/internal/ssa/check.go +++ b/src/cmd/internal/ssa/check.go @@ -58,7 +58,7 @@ func checkFunc(f *Func) { if b.Control == nil { log.Panicf("exit block %s has no control value", b) } - if b.Control.Type != TypeMem { + if !b.Control.Type.IsMemory() { log.Panicf("exit block %s has non-memory control value %s", b, b.Control.LongString()) } case BlockPlain: @@ -75,7 +75,7 @@ func checkFunc(f *Func) { if b.Control == nil { log.Panicf("if block %s has no control value", b) } - if b.Control.Type != TypeBool { + if !b.Control.Type.IsBoolean() { log.Panicf("if block %s has non-bool control value %s", b, b.Control.LongString()) } case BlockCall: @@ -85,7 +85,7 @@ func checkFunc(f *Func) { if b.Control == nil { log.Panicf("call block %s has no control value", b) } - if b.Control.Type != TypeMem { + if !b.Control.Type.IsMemory() { log.Panicf("call block %s has non-memory control value %s", b, b.Control.LongString()) } if b.Succs[1].Kind != BlockExit { diff --git a/src/cmd/internal/ssa/config.go b/src/cmd/internal/ssa/config.go index 80acda4b23..9f1d2a8593 100644 --- a/src/cmd/internal/ssa/config.go +++ b/src/cmd/internal/ssa/config.go @@ -9,7 +9,7 @@ import "log" type Config struct { arch string // "amd64", etc. ptrSize int64 // 4 or 8 - UIntPtr Type // pointer arithmetic type + Uintptr Type // pointer arithmetic type lower func(*Value) bool // lowering function // TODO: more stuff. Compiler flags of interest, ... @@ -30,9 +30,9 @@ func NewConfig(arch string) *Config { } // cache the intptr type in the config - c.UIntPtr = TypeUInt32 + c.Uintptr = TypeUInt32 if c.ptrSize == 8 { - c.UIntPtr = TypeUInt64 + c.Uintptr = TypeUInt64 } return c diff --git a/src/cmd/internal/ssa/generic.go b/src/cmd/internal/ssa/generic.go index 2a96793c61..91f9c17d11 100644 --- a/src/cmd/internal/ssa/generic.go +++ b/src/cmd/internal/ssa/generic.go @@ -6,20 +6,20 @@ func genericRules(v *Value) bool { switch v.Op { case OpAdd: // match: (Add (Const [c]) (Const [d])) - // cond: is64BitInt(t) && isSigned(t) + // cond: is64BitInt(t) // result: (Const [{c.(int64)+d.(int64)}]) { t := v.Type if v.Args[0].Op != OpConst { - goto endc86f5c160a87f6f5ec90b6551ec099d9 + goto end8d047ed0ae9537b840adc79ea82c6e05 } c := v.Args[0].Aux if v.Args[1].Op != OpConst { - goto endc86f5c160a87f6f5ec90b6551ec099d9 + goto end8d047ed0ae9537b840adc79ea82c6e05 } d := v.Args[1].Aux - if !(is64BitInt(t) && isSigned(t)) { - goto endc86f5c160a87f6f5ec90b6551ec099d9 + if !(is64BitInt(t)) { + goto end8d047ed0ae9537b840adc79ea82c6e05 } v.Op = OpConst v.Aux = nil @@ -27,100 +27,141 @@ func genericRules(v *Value) bool { v.Aux = c.(int64) + d.(int64) return true } - goto endc86f5c160a87f6f5ec90b6551ec099d9 - endc86f5c160a87f6f5ec90b6551ec099d9: + goto end8d047ed0ae9537b840adc79ea82c6e05 + end8d047ed0ae9537b840adc79ea82c6e05: ; - // match: (Add (Const [c]) (Const [d])) - // cond: is64BitInt(t) && !isSigned(t) - // result: (Const [{c.(uint64)+d.(uint64)}]) + case OpArrayIndex: + // match: (ArrayIndex (Load ptr mem) idx) + // cond: + // result: (Load (PtrIndex ptr idx) mem) + { + if v.Args[0].Op != OpLoad { + goto end3809f4c52270a76313e4ea26e6f0b753 + } + ptr := v.Args[0].Args[0] + mem := v.Args[0].Args[1] + idx := v.Args[1] + v.Op = OpLoad + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue(OpPtrIndex, TypeInvalid, nil) + v0.Type = ptr.Type.Elem().Elem().PtrTo() + v0.AddArg(ptr) + v0.AddArg(idx) + v.AddArg(v0) + v.AddArg(mem) + return true + } + goto end3809f4c52270a76313e4ea26e6f0b753 + end3809f4c52270a76313e4ea26e6f0b753: + ; + case OpIsInBounds: + // match: (IsInBounds (Const [c]) (Const [d])) + // cond: + // result: (Const [inBounds(c.(int64),d.(int64))]) + { + if v.Args[0].Op != OpConst { + goto enddbd1a394d9b71ee64335361b8384865c + } + c := v.Args[0].Aux + if v.Args[1].Op != OpConst { + goto enddbd1a394d9b71ee64335361b8384865c + } + d := v.Args[1].Aux + v.Op = OpConst + v.Aux = nil + v.resetArgs() + v.Aux = inBounds(c.(int64), d.(int64)) + return true + } + goto enddbd1a394d9b71ee64335361b8384865c + enddbd1a394d9b71ee64335361b8384865c: + ; + case OpMul: + // match: (Mul (Const [c]) (Const [d])) + // cond: is64BitInt(t) + // result: (Const [{c.(int64)*d.(int64)}]) { t := v.Type if v.Args[0].Op != OpConst { - goto end8941c2a515c1bd38530b7fd96862bac4 + goto end776610f88cf04f438242d76ed2b14f1c } c := v.Args[0].Aux if v.Args[1].Op != OpConst { - goto end8941c2a515c1bd38530b7fd96862bac4 + goto end776610f88cf04f438242d76ed2b14f1c } d := v.Args[1].Aux - if !(is64BitInt(t) && !isSigned(t)) { - goto end8941c2a515c1bd38530b7fd96862bac4 + if !(is64BitInt(t)) { + goto end776610f88cf04f438242d76ed2b14f1c } v.Op = OpConst v.Aux = nil v.resetArgs() - v.Aux = c.(uint64) + d.(uint64) + v.Aux = c.(int64) * d.(int64) return true } - goto end8941c2a515c1bd38530b7fd96862bac4 - end8941c2a515c1bd38530b7fd96862bac4: + goto end776610f88cf04f438242d76ed2b14f1c + end776610f88cf04f438242d76ed2b14f1c: ; - case OpSliceCap: - // match: (SliceCap (Load ptr mem)) + case OpPtrIndex: + // match: (PtrIndex ptr idx) // cond: - // result: (Load (Add ptr (Const [int64(v.Block.Func.Config.ptrSize*2)])) mem) + // result: (Add ptr (Mul idx (Const [t.Elem().Size()]))) { - if v.Args[0].Op != OpLoad { - goto ende03f9b79848867df439b56889bb4e55d - } - ptr := v.Args[0].Args[0] - mem := v.Args[0].Args[1] - v.Op = OpLoad + t := v.Type + ptr := v.Args[0] + idx := v.Args[1] + v.Op = OpAdd v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue(OpAdd, TypeInvalid, nil) - v0.Type = ptr.Type - v0.AddArg(ptr) + v.AddArg(ptr) + v0 := v.Block.NewValue(OpMul, TypeInvalid, nil) + v0.Type = v.Block.Func.Config.Uintptr + v0.AddArg(idx) v1 := v.Block.NewValue(OpConst, TypeInvalid, nil) - v1.Type = v.Block.Func.Config.UIntPtr - v1.Aux = int64(v.Block.Func.Config.ptrSize * 2) + v1.Type = v.Block.Func.Config.Uintptr + v1.Aux = t.Elem().Size() v0.AddArg(v1) v.AddArg(v0) - v.AddArg(mem) return true } - goto ende03f9b79848867df439b56889bb4e55d - ende03f9b79848867df439b56889bb4e55d: + goto end383c68c41e72d22ef00c4b7b0fddcbb8 + end383c68c41e72d22ef00c4b7b0fddcbb8: ; - case OpSliceIndex: - // match: (SliceIndex s i mem) + case OpSliceCap: + // match: (SliceCap (Load ptr mem)) // cond: - // result: (Load (Add (SlicePtr s) (Mul i (Const [s.Type.Elem().Size()]))) mem) + // result: (Load (Add ptr (Const [int64(v.Block.Func.Config.ptrSize*2)])) mem) { - s := v.Args[0] - i := v.Args[1] - mem := v.Args[2] + if v.Args[0].Op != OpLoad { + goto endbf1d4db93c4664ed43be3f73afb4dfa3 + } + ptr := v.Args[0].Args[0] + mem := v.Args[0].Args[1] v.Op = OpLoad v.Aux = nil v.resetArgs() v0 := v.Block.NewValue(OpAdd, TypeInvalid, nil) - v0.Type = s.Type.Elem().PtrTo() - v1 := v.Block.NewValue(OpSlicePtr, TypeInvalid, nil) - v1.Type = s.Type.Elem().PtrTo() - v1.AddArg(s) + v0.Type = ptr.Type + v0.AddArg(ptr) + v1 := v.Block.NewValue(OpConst, TypeInvalid, nil) + v1.Type = v.Block.Func.Config.Uintptr + v1.Aux = int64(v.Block.Func.Config.ptrSize * 2) v0.AddArg(v1) - v2 := v.Block.NewValue(OpMul, TypeInvalid, nil) - v2.Type = v.Block.Func.Config.UIntPtr - v2.AddArg(i) - v3 := v.Block.NewValue(OpConst, TypeInvalid, nil) - v3.Type = v.Block.Func.Config.UIntPtr - v3.Aux = s.Type.Elem().Size() - v2.AddArg(v3) - v0.AddArg(v2) v.AddArg(v0) v.AddArg(mem) return true } - goto end733704831a61760840348f790b3ab045 - end733704831a61760840348f790b3ab045: + goto endbf1d4db93c4664ed43be3f73afb4dfa3 + endbf1d4db93c4664ed43be3f73afb4dfa3: ; case OpSliceLen: // match: (SliceLen (Load ptr mem)) // cond: - // result: (Load (Add ptr (Const [int64(v.Block.Func.Config.ptrSize)])) mem) + // result: (Load (Add ptr (Const [int64(v.Block.Func.Config.ptrSize)])) mem) { if v.Args[0].Op != OpLoad { - goto ende94950a57eca1871c93afdeaadb90223 + goto end9190b1ecbda4c5dd6d3e05d2495fb297 } ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] @@ -131,15 +172,15 @@ func genericRules(v *Value) bool { v0.Type = ptr.Type v0.AddArg(ptr) v1 := v.Block.NewValue(OpConst, TypeInvalid, nil) - v1.Type = v.Block.Func.Config.UIntPtr + v1.Type = v.Block.Func.Config.Uintptr v1.Aux = int64(v.Block.Func.Config.ptrSize) v0.AddArg(v1) v.AddArg(v0) v.AddArg(mem) return true } - goto ende94950a57eca1871c93afdeaadb90223 - ende94950a57eca1871c93afdeaadb90223: + goto end9190b1ecbda4c5dd6d3e05d2495fb297 + end9190b1ecbda4c5dd6d3e05d2495fb297: ; case OpSlicePtr: // match: (SlicePtr (Load ptr mem)) @@ -160,6 +201,36 @@ func genericRules(v *Value) bool { } goto end459613b83f95b65729d45c2ed663a153 end459613b83f95b65729d45c2ed663a153: + ; + case OpStore: + // match: (Store dst (Load src mem) mem) + // cond: t.Size() > 8 + // result: (Move [t.Size()] dst src mem) + { + dst := v.Args[0] + if v.Args[1].Op != OpLoad { + goto end324ffb6d2771808da4267f62c854e9c8 + } + t := v.Args[1].Type + src := v.Args[1].Args[0] + mem := v.Args[1].Args[1] + if v.Args[2] != v.Args[1].Args[1] { + goto end324ffb6d2771808da4267f62c854e9c8 + } + if !(t.Size() > 8) { + goto end324ffb6d2771808da4267f62c854e9c8 + } + v.Op = OpMove + v.Aux = nil + v.resetArgs() + v.Aux = t.Size() + v.AddArg(dst) + v.AddArg(src) + v.AddArg(mem) + return true + } + goto end324ffb6d2771808da4267f62c854e9c8 + end324ffb6d2771808da4267f62c854e9c8: } return false } diff --git a/src/cmd/internal/ssa/lower.go b/src/cmd/internal/ssa/lower.go index 82e5d23241..84379c00de 100644 --- a/src/cmd/internal/ssa/lower.go +++ b/src/cmd/internal/ssa/lower.go @@ -16,41 +16,88 @@ func lower(f *Func) { // additional pass for 386/amd64, link condition codes directly to blocks // TODO: do generically somehow? Special "block" rewrite rules? for _, b := range f.Blocks { - switch b.Kind { - case BlockIf: - switch b.Control.Op { - case OpSETL: - b.Kind = BlockLT - b.Control = b.Control.Args[0] - case OpSETNE: - b.Kind = BlockNE - b.Control = b.Control.Args[0] - case OpSETB: - b.Kind = BlockULT - b.Control = b.Control.Args[0] - // TODO: others + for { + switch b.Kind { + case BlockIf: + switch b.Control.Op { + case OpSETL: + b.Kind = BlockLT + b.Control = b.Control.Args[0] + continue + case OpSETNE: + b.Kind = BlockNE + b.Control = b.Control.Args[0] + continue + case OpSETB: + b.Kind = BlockULT + b.Control = b.Control.Args[0] + continue + case OpMOVBload: + b.Kind = BlockNE + b.Control = b.NewValue2(OpTESTB, TypeFlags, nil, b.Control, b.Control) + continue + // TODO: others + } + case BlockLT: + if b.Control.Op == OpInvertFlags { + b.Kind = BlockGT + b.Control = b.Control.Args[0] + continue + } + case BlockGT: + if b.Control.Op == OpInvertFlags { + b.Kind = BlockLT + b.Control = b.Control.Args[0] + continue + } + case BlockLE: + if b.Control.Op == OpInvertFlags { + b.Kind = BlockGE + b.Control = b.Control.Args[0] + continue + } + case BlockGE: + if b.Control.Op == OpInvertFlags { + b.Kind = BlockLE + b.Control = b.Control.Args[0] + continue + } + case BlockULT: + if b.Control.Op == OpInvertFlags { + b.Kind = BlockUGT + b.Control = b.Control.Args[0] + continue + } + case BlockUGT: + if b.Control.Op == OpInvertFlags { + b.Kind = BlockULT + b.Control = b.Control.Args[0] + continue + } + case BlockULE: + if b.Control.Op == OpInvertFlags { + b.Kind = BlockUGE + b.Control = b.Control.Args[0] + continue + } + case BlockUGE: + if b.Control.Op == OpInvertFlags { + b.Kind = BlockULE + b.Control = b.Control.Args[0] + continue + } + case BlockEQ: + if b.Control.Op == OpInvertFlags { + b.Control = b.Control.Args[0] + continue + } + case BlockNE: + if b.Control.Op == OpInvertFlags { + b.Control = b.Control.Args[0] + continue + } } - case BlockLT: - if b.Control.Op == OpInvertFlags { - b.Kind = BlockGE - b.Control = b.Control.Args[0] - } - case BlockULT: - if b.Control.Op == OpInvertFlags { - b.Kind = BlockUGE - b.Control = b.Control.Args[0] - } - case BlockEQ: - if b.Control.Op == OpInvertFlags { - b.Kind = BlockNE - b.Control = b.Control.Args[0] - } - case BlockNE: - if b.Control.Op == OpInvertFlags { - b.Kind = BlockEQ - b.Control = b.Control.Args[0] - } - // TODO: others + break } } } diff --git a/src/cmd/internal/ssa/lowerAmd64.go b/src/cmd/internal/ssa/lowerAmd64.go index ef891c37d9..356f646dcc 100644 --- a/src/cmd/internal/ssa/lowerAmd64.go +++ b/src/cmd/internal/ssa/lowerAmd64.go @@ -7,11 +7,11 @@ func lowerAmd64(v *Value) bool { case OpADDCQ: // match: (ADDCQ [c] (LEAQ8 [d] x y)) // cond: - // result: (LEAQ8 [c.(int64)+d.(int64)] x y) + // result: (LEAQ8 [addOff(c, d)] x y) { c := v.Aux if v.Args[0].Op != OpLEAQ8 { - goto end16348939e556e99e8447227ecb986f01 + goto end3bc1457811adc0cb81ad6b88a7461c60 } d := v.Args[0].Aux x := v.Args[0].Args[0] @@ -19,58 +19,40 @@ func lowerAmd64(v *Value) bool { v.Op = OpLEAQ8 v.Aux = nil v.resetArgs() - v.Aux = c.(int64) + d.(int64) + v.Aux = addOff(c, d) v.AddArg(x) v.AddArg(y) return true } - goto end16348939e556e99e8447227ecb986f01 - end16348939e556e99e8447227ecb986f01: + goto end3bc1457811adc0cb81ad6b88a7461c60 + end3bc1457811adc0cb81ad6b88a7461c60: ; - // match: (ADDCQ [off1] (FPAddr [off2])) - // cond: - // result: (FPAddr [off1.(int64)+off2.(int64)]) - { - off1 := v.Aux - if v.Args[0].Op != OpFPAddr { - goto end28e093ab0618066e6b2609db7aaf309b - } - off2 := v.Args[0].Aux - v.Op = OpFPAddr - v.Aux = nil - v.resetArgs() - v.Aux = off1.(int64) + off2.(int64) - return true - } - goto end28e093ab0618066e6b2609db7aaf309b - end28e093ab0618066e6b2609db7aaf309b: - ; - // match: (ADDCQ [off1] (SPAddr [off2])) - // cond: - // result: (SPAddr [off1.(int64)+off2.(int64)]) + // match: (ADDCQ [off] x) + // cond: off.(int64) == 0 + // result: (Copy x) { - off1 := v.Aux - if v.Args[0].Op != OpSPAddr { - goto endd0c27c62d150b88168075c5ba113d1fa + off := v.Aux + x := v.Args[0] + if !(off.(int64) == 0) { + goto end6710a6679c47b70577ecea7ad00dae87 } - off2 := v.Args[0].Aux - v.Op = OpSPAddr + v.Op = OpCopy v.Aux = nil v.resetArgs() - v.Aux = off1.(int64) + off2.(int64) + v.AddArg(x) return true } - goto endd0c27c62d150b88168075c5ba113d1fa - endd0c27c62d150b88168075c5ba113d1fa: + goto end6710a6679c47b70577ecea7ad00dae87 + end6710a6679c47b70577ecea7ad00dae87: ; case OpADDQ: - // match: (ADDQ x (Const [c])) + // match: (ADDQ x (MOVQconst [c])) // cond: // result: (ADDCQ [c] x) { x := v.Args[0] - if v.Args[1].Op != OpConst { - goto endef6908cfdf56e102cc327a3ddc14393d + if v.Args[1].Op != OpMOVQconst { + goto end39b79e84f20a6d44b5c4136aae220ac2 } c := v.Args[1].Aux v.Op = OpADDCQ @@ -80,15 +62,15 @@ func lowerAmd64(v *Value) bool { v.AddArg(x) return true } - goto endef6908cfdf56e102cc327a3ddc14393d - endef6908cfdf56e102cc327a3ddc14393d: + goto end39b79e84f20a6d44b5c4136aae220ac2 + end39b79e84f20a6d44b5c4136aae220ac2: ; - // match: (ADDQ (Const [c]) x) + // match: (ADDQ (MOVQconst [c]) x) // cond: // result: (ADDCQ [c] x) { - if v.Args[0].Op != OpConst { - goto endb54a32cf3147f424f08b46db62c69b23 + if v.Args[0].Op != OpMOVQconst { + goto endc05ff5a2a132241b69d00c852001d820 } c := v.Args[0].Aux x := v.Args[1] @@ -99,8 +81,8 @@ func lowerAmd64(v *Value) bool { v.AddArg(x) return true } - goto endb54a32cf3147f424f08b46db62c69b23 - endb54a32cf3147f424f08b46db62c69b23: + goto endc05ff5a2a132241b69d00c852001d820 + endc05ff5a2a132241b69d00c852001d820: ; // match: (ADDQ x (SHLCQ [shift] y)) // cond: shift.(int64) == 3 @@ -168,13 +150,13 @@ func lowerAmd64(v *Value) bool { end35a02a1587264e40cf1055856ff8445a: ; case OpCMPQ: - // match: (CMPQ x (Const [c])) + // match: (CMPQ x (MOVQconst [c])) // cond: // result: (CMPCQ x [c]) { x := v.Args[0] - if v.Args[1].Op != OpConst { - goto end1770a40e4253d9f669559a360514613e + if v.Args[1].Op != OpMOVQconst { + goto endf180bae15b3d24c0213520d7f7aa98b4 } c := v.Args[1].Aux v.Op = OpCMPCQ @@ -184,15 +166,15 @@ func lowerAmd64(v *Value) bool { v.Aux = c return true } - goto end1770a40e4253d9f669559a360514613e - end1770a40e4253d9f669559a360514613e: + goto endf180bae15b3d24c0213520d7f7aa98b4 + endf180bae15b3d24c0213520d7f7aa98b4: ; - // match: (CMPQ (Const [c]) x) + // match: (CMPQ (MOVQconst [c]) x) // cond: // result: (InvertFlags (CMPCQ x [c])) { - if v.Args[0].Op != OpConst { - goto enda4e64c7eaeda16c1c0db9dac409cd126 + if v.Args[0].Op != OpMOVQconst { + goto end8fc58bffa73b3df80b3de72c91844884 } c := v.Args[0].Aux x := v.Args[1] @@ -206,8 +188,42 @@ func lowerAmd64(v *Value) bool { v.AddArg(v0) return true } - goto enda4e64c7eaeda16c1c0db9dac409cd126 - enda4e64c7eaeda16c1c0db9dac409cd126: + goto end8fc58bffa73b3df80b3de72c91844884 + end8fc58bffa73b3df80b3de72c91844884: + ; + case OpConst: + // match: (Const [val]) + // cond: is64BitInt(t) + // result: (MOVQconst [val]) + { + t := v.Type + val := v.Aux + if !(is64BitInt(t)) { + goto end7f5c5b34093fbc6860524cb803ee51bf + } + v.Op = OpMOVQconst + v.Aux = nil + v.resetArgs() + v.Aux = val + return true + } + goto end7f5c5b34093fbc6860524cb803ee51bf + end7f5c5b34093fbc6860524cb803ee51bf: + ; + case OpGlobal: + // match: (Global [sym]) + // cond: + // result: (LEAQglobal [GlobalOffset{sym,0}]) + { + sym := v.Aux + v.Op = OpLEAQglobal + v.Aux = nil + v.resetArgs() + v.Aux = GlobalOffset{sym, 0} + return true + } + goto end3a3c76fac0e2e53c0e1c60b9524e6f1c + end3a3c76fac0e2e53c0e1c60b9524e6f1c: ; case OpIsInBounds: // match: (IsInBounds idx len) @@ -273,16 +289,16 @@ func lowerAmd64(v *Value) bool { ; case OpLoad: // match: (Load ptr mem) - // cond: (is64BitInt(t) || isPtr(t)) - // result: (MOVQload [int64(0)] ptr mem) + // cond: t.IsBoolean() + // result: (MOVBload [int64(0)] ptr mem) { t := v.Type ptr := v.Args[0] mem := v.Args[1] - if !(is64BitInt(t) || isPtr(t)) { - goto end581ce5a20901df1b8143448ba031685b + if !(t.IsBoolean()) { + goto end73f21632e56c3614902d3c29c82dc4ea } - v.Op = OpMOVQload + v.Op = OpMOVBload v.Aux = nil v.resetArgs() v.Aux = int64(0) @@ -290,77 +306,38 @@ func lowerAmd64(v *Value) bool { v.AddArg(mem) return true } - goto end581ce5a20901df1b8143448ba031685b - end581ce5a20901df1b8143448ba031685b: - ; - case OpMOVQload: - // match: (MOVQload [off1] (FPAddr [off2]) mem) - // cond: - // result: (MOVQloadFP [off1.(int64)+off2.(int64)] mem) - { - off1 := v.Aux - if v.Args[0].Op != OpFPAddr { - goto endce972b1aa84b56447978c43def87fa57 - } - off2 := v.Args[0].Aux - mem := v.Args[1] - v.Op = OpMOVQloadFP - v.Aux = nil - v.resetArgs() - v.Aux = off1.(int64) + off2.(int64) - v.AddArg(mem) - return true - } - goto endce972b1aa84b56447978c43def87fa57 - endce972b1aa84b56447978c43def87fa57: + goto end73f21632e56c3614902d3c29c82dc4ea + end73f21632e56c3614902d3c29c82dc4ea: ; - // match: (MOVQload [off1] (SPAddr [off2]) mem) - // cond: - // result: (MOVQloadSP [off1.(int64)+off2.(int64)] mem) + // match: (Load ptr mem) + // cond: (is64BitInt(t) || isPtr(t)) + // result: (MOVQload [int64(0)] ptr mem) { - off1 := v.Aux - if v.Args[0].Op != OpSPAddr { - goto end3d8628a6536350a123be81240b8a1376 - } - off2 := v.Args[0].Aux + t := v.Type + ptr := v.Args[0] mem := v.Args[1] - v.Op = OpMOVQloadSP - v.Aux = nil - v.resetArgs() - v.Aux = off1.(int64) + off2.(int64) - v.AddArg(mem) - return true - } - goto end3d8628a6536350a123be81240b8a1376 - end3d8628a6536350a123be81240b8a1376: - ; - // match: (MOVQload [off] (Global [sym]) mem) - // cond: - // result: (MOVQloadglobal [GlobalOffset{sym,off.(int64)}] mem) - { - off := v.Aux - if v.Args[0].Op != OpGlobal { - goto end20693899317f3f8d1b47fefa64087654 + if !(is64BitInt(t) || isPtr(t)) { + goto end581ce5a20901df1b8143448ba031685b } - sym := v.Args[0].Aux - mem := v.Args[1] - v.Op = OpMOVQloadglobal + v.Op = OpMOVQload v.Aux = nil v.resetArgs() - v.Aux = GlobalOffset{sym, off.(int64)} + v.Aux = int64(0) + v.AddArg(ptr) v.AddArg(mem) return true } - goto end20693899317f3f8d1b47fefa64087654 - end20693899317f3f8d1b47fefa64087654: + goto end581ce5a20901df1b8143448ba031685b + end581ce5a20901df1b8143448ba031685b: ; + case OpMOVQload: // match: (MOVQload [off1] (ADDCQ [off2] ptr) mem) // cond: - // result: (MOVQload [off1.(int64)+off2.(int64)] ptr mem) + // result: (MOVQload [addOff(off1, off2)] ptr mem) { off1 := v.Aux if v.Args[0].Op != OpADDCQ { - goto enda68a39292ba2a05b3436191cb0bb0516 + goto end218ceec16b8299d573d3c9ccaa69b086 } off2 := v.Args[0].Aux ptr := v.Args[0].Args[0] @@ -368,21 +345,21 @@ func lowerAmd64(v *Value) bool { v.Op = OpMOVQload v.Aux = nil v.resetArgs() - v.Aux = off1.(int64) + off2.(int64) + v.Aux = addOff(off1, off2) v.AddArg(ptr) v.AddArg(mem) return true } - goto enda68a39292ba2a05b3436191cb0bb0516 - enda68a39292ba2a05b3436191cb0bb0516: + goto end218ceec16b8299d573d3c9ccaa69b086 + end218ceec16b8299d573d3c9ccaa69b086: ; // match: (MOVQload [off1] (LEAQ8 [off2] ptr idx) mem) // cond: - // result: (MOVQloadidx8 [off1.(int64)+off2.(int64)] ptr idx mem) + // result: (MOVQloadidx8 [addOff(off1, off2)] ptr idx mem) { off1 := v.Aux if v.Args[0].Op != OpLEAQ8 { - goto endba0e5cee85021614041016b1a2709ab8 + goto end02f5ad148292c46463e7c20d3b821735 } off2 := v.Args[0].Aux ptr := v.Args[0].Args[0] @@ -391,131 +368,117 @@ func lowerAmd64(v *Value) bool { v.Op = OpMOVQloadidx8 v.Aux = nil v.resetArgs() - v.Aux = off1.(int64) + off2.(int64) + v.Aux = addOff(off1, off2) v.AddArg(ptr) v.AddArg(idx) v.AddArg(mem) return true } - goto endba0e5cee85021614041016b1a2709ab8 - endba0e5cee85021614041016b1a2709ab8: + goto end02f5ad148292c46463e7c20d3b821735 + end02f5ad148292c46463e7c20d3b821735: ; - case OpMOVQstore: - // match: (MOVQstore [off1] (FPAddr [off2]) val mem) + case OpMOVQloadidx8: + // match: (MOVQloadidx8 [off1] (ADDCQ [off2] ptr) idx mem) // cond: - // result: (MOVQstoreFP [off1.(int64)+off2.(int64)] val mem) + // result: (MOVQloadidx8 [addOff(off1, off2)] ptr idx mem) { off1 := v.Aux - if v.Args[0].Op != OpFPAddr { - goto end0a2a81a20558dfc93790aecb1e9cc81a + if v.Args[0].Op != OpADDCQ { + goto ende47e8d742e2615f39fb6509a5749e414 } off2 := v.Args[0].Aux - val := v.Args[1] + ptr := v.Args[0].Args[0] + idx := v.Args[1] mem := v.Args[2] - v.Op = OpMOVQstoreFP + v.Op = OpMOVQloadidx8 v.Aux = nil v.resetArgs() - v.Aux = off1.(int64) + off2.(int64) - v.AddArg(val) + v.Aux = addOff(off1, off2) + v.AddArg(ptr) + v.AddArg(idx) v.AddArg(mem) return true } - goto end0a2a81a20558dfc93790aecb1e9cc81a - end0a2a81a20558dfc93790aecb1e9cc81a: + goto ende47e8d742e2615f39fb6509a5749e414 + ende47e8d742e2615f39fb6509a5749e414: ; - // match: (MOVQstore [off1] (SPAddr [off2]) val mem) + case OpMOVQstore: + // match: (MOVQstore [off1] (ADDCQ [off2] ptr) val mem) // cond: - // result: (MOVQstoreSP [off1.(int64)+off2.(int64)] val mem) + // result: (MOVQstore [addOff(off1, off2)] ptr val mem) { off1 := v.Aux - if v.Args[0].Op != OpSPAddr { - goto end1cb5b7e766f018270fa434c6f46f607f + if v.Args[0].Op != OpADDCQ { + goto enddfd4c7a20fd3b84eb9dcf84b98c661fc } off2 := v.Args[0].Aux + ptr := v.Args[0].Args[0] val := v.Args[1] mem := v.Args[2] - v.Op = OpMOVQstoreSP - v.Aux = nil - v.resetArgs() - v.Aux = off1.(int64) + off2.(int64) - v.AddArg(val) - v.AddArg(mem) - return true - } - goto end1cb5b7e766f018270fa434c6f46f607f - end1cb5b7e766f018270fa434c6f46f607f: - ; - // match: (MOVQstore [off] (Global [sym]) val mem) - // cond: - // result: (MOVQstoreglobal [GlobalOffset{sym,off.(int64)}] val mem) - { - off := v.Aux - if v.Args[0].Op != OpGlobal { - goto end657d07e37c720a8fbb108a31bb48090d - } - sym := v.Args[0].Aux - val := v.Args[1] - mem := v.Args[2] - v.Op = OpMOVQstoreglobal + v.Op = OpMOVQstore v.Aux = nil v.resetArgs() - v.Aux = GlobalOffset{sym, off.(int64)} + v.Aux = addOff(off1, off2) + v.AddArg(ptr) v.AddArg(val) v.AddArg(mem) return true } - goto end657d07e37c720a8fbb108a31bb48090d - end657d07e37c720a8fbb108a31bb48090d: + goto enddfd4c7a20fd3b84eb9dcf84b98c661fc + enddfd4c7a20fd3b84eb9dcf84b98c661fc: ; - // match: (MOVQstore [off1] (ADDCQ [off2] ptr) val mem) + // match: (MOVQstore [off1] (LEAQ8 [off2] ptr idx) val mem) // cond: - // result: (MOVQstore [off1.(int64)+off2.(int64)] ptr val mem) + // result: (MOVQstoreidx8 [addOff(off1, off2)] ptr idx val mem) { off1 := v.Aux - if v.Args[0].Op != OpADDCQ { - goto end271e3052de832e22b1f07576af2854de + if v.Args[0].Op != OpLEAQ8 { + goto endce1db8c8d37c8397c500a2068a65c215 } off2 := v.Args[0].Aux ptr := v.Args[0].Args[0] + idx := v.Args[0].Args[1] val := v.Args[1] mem := v.Args[2] - v.Op = OpMOVQstore + v.Op = OpMOVQstoreidx8 v.Aux = nil v.resetArgs() - v.Aux = off1.(int64) + off2.(int64) + v.Aux = addOff(off1, off2) v.AddArg(ptr) + v.AddArg(idx) v.AddArg(val) v.AddArg(mem) return true } - goto end271e3052de832e22b1f07576af2854de - end271e3052de832e22b1f07576af2854de: + goto endce1db8c8d37c8397c500a2068a65c215 + endce1db8c8d37c8397c500a2068a65c215: ; - // match: (MOVQstore [off1] (LEAQ8 [off2] ptr idx) val mem) + case OpMOVQstoreidx8: + // match: (MOVQstoreidx8 [off1] (ADDCQ [off2] ptr) idx val mem) // cond: - // result: (MOVQstoreidx8 [off1.(int64)+off2.(int64)] ptr idx val mem) + // result: (MOVQstoreidx8 [addOff(off1, off2)] ptr idx val mem) { off1 := v.Aux - if v.Args[0].Op != OpLEAQ8 { - goto end4ad469f534c7369f6ac36bdace3462ad + if v.Args[0].Op != OpADDCQ { + goto endcdb222707a568ad468f7fff2fc42fc39 } off2 := v.Args[0].Aux ptr := v.Args[0].Args[0] - idx := v.Args[0].Args[1] - val := v.Args[1] - mem := v.Args[2] + idx := v.Args[1] + val := v.Args[2] + mem := v.Args[3] v.Op = OpMOVQstoreidx8 v.Aux = nil v.resetArgs() - v.Aux = off1.(int64) + off2.(int64) + v.Aux = addOff(off1, off2) v.AddArg(ptr) v.AddArg(idx) v.AddArg(val) v.AddArg(mem) return true } - goto end4ad469f534c7369f6ac36bdace3462ad - end4ad469f534c7369f6ac36bdace3462ad: + goto endcdb222707a568ad468f7fff2fc42fc39 + endcdb222707a568ad468f7fff2fc42fc39: ; case OpMULCQ: // match: (MULCQ [c] x) @@ -538,13 +501,13 @@ func lowerAmd64(v *Value) bool { end90a1c055d9658aecacce5e101c1848b4: ; case OpMULQ: - // match: (MULQ x (Const [c])) + // match: (MULQ x (MOVQconst [c])) // cond: // result: (MULCQ [c] x) { x := v.Args[0] - if v.Args[1].Op != OpConst { - goto endc427f4838d2e83c00cc097b20bd20a37 + if v.Args[1].Op != OpMOVQconst { + goto endce35d001482ea209e62e9394bd07c7cb } c := v.Args[1].Aux v.Op = OpMULCQ @@ -554,15 +517,15 @@ func lowerAmd64(v *Value) bool { v.AddArg(x) return true } - goto endc427f4838d2e83c00cc097b20bd20a37 - endc427f4838d2e83c00cc097b20bd20a37: + goto endce35d001482ea209e62e9394bd07c7cb + endce35d001482ea209e62e9394bd07c7cb: ; - // match: (MULQ (Const [c]) x) + // match: (MULQ (MOVQconst [c]) x) // cond: // result: (MULCQ [c] x) { - if v.Args[0].Op != OpConst { - goto endd70de938e71150d1c9e8173c2a5b2d95 + if v.Args[0].Op != OpMOVQconst { + goto end804f58b1f6a7cce19d48379999ec03f1 } c := v.Args[0].Aux x := v.Args[1] @@ -573,8 +536,32 @@ func lowerAmd64(v *Value) bool { v.AddArg(x) return true } - goto endd70de938e71150d1c9e8173c2a5b2d95 - endd70de938e71150d1c9e8173c2a5b2d95: + goto end804f58b1f6a7cce19d48379999ec03f1 + end804f58b1f6a7cce19d48379999ec03f1: + ; + case OpMove: + // match: (Move [size] dst src mem) + // cond: + // result: (REPMOVSB dst src (Const [size.(int64)]) mem) + { + size := v.Aux + dst := v.Args[0] + src := v.Args[1] + mem := v.Args[2] + v.Op = OpREPMOVSB + v.Aux = nil + v.resetArgs() + v.AddArg(dst) + v.AddArg(src) + v0 := v.Block.NewValue(OpConst, TypeInvalid, nil) + v0.Type = TypeUInt64 + v0.Aux = size.(int64) + v.AddArg(v0) + v.AddArg(mem) + return true + } + goto end48909259b265a6bb2a076bc2c2dc7d1f + end48909259b265a6bb2a076bc2c2dc7d1f: ; case OpMul: // match: (Mul x y) @@ -597,6 +584,23 @@ func lowerAmd64(v *Value) bool { goto endfab0d598f376ecba45a22587d50f7aff endfab0d598f376ecba45a22587d50f7aff: ; + case OpOffPtr: + // match: (OffPtr [off] ptr) + // cond: + // result: (ADDCQ [off] ptr) + { + off := v.Aux + ptr := v.Args[0] + v.Op = OpADDCQ + v.Aux = nil + v.resetArgs() + v.Aux = off + v.AddArg(ptr) + return true + } + goto endfe8f713b1d237a23311fb721ee46bedb + endfe8f713b1d237a23311fb721ee46bedb: + ; case OpSETL: // match: (SETL (InvertFlags x)) // cond: @@ -616,13 +620,13 @@ func lowerAmd64(v *Value) bool { end456c7681d48305698c1ef462d244bdc6: ; case OpSUBQ: - // match: (SUBQ x (Const [c])) + // match: (SUBQ x (MOVQconst [c])) // cond: // result: (SUBCQ x [c]) { x := v.Args[0] - if v.Args[1].Op != OpConst { - goto endb31e242f283867de4722665a5796008c + if v.Args[1].Op != OpMOVQconst { + goto endc96cd1cb2dd98427c34fb9543feca4fe } c := v.Args[1].Aux v.Op = OpSUBCQ @@ -632,16 +636,16 @@ func lowerAmd64(v *Value) bool { v.Aux = c return true } - goto endb31e242f283867de4722665a5796008c - endb31e242f283867de4722665a5796008c: + goto endc96cd1cb2dd98427c34fb9543feca4fe + endc96cd1cb2dd98427c34fb9543feca4fe: ; - // match: (SUBQ (Const [c]) x) + // match: (SUBQ (MOVQconst [c]) x) // cond: // result: (NEGQ (SUBCQ x [c])) { t := v.Type - if v.Args[0].Op != OpConst { - goto end569cc755877d1f89a701378bec05c08d + if v.Args[0].Op != OpMOVQconst { + goto end900aaaf28cefac6bb62e76b5151611cf } c := v.Args[0].Aux x := v.Args[1] @@ -655,8 +659,8 @@ func lowerAmd64(v *Value) bool { v.AddArg(v0) return true } - goto end569cc755877d1f89a701378bec05c08d - end569cc755877d1f89a701378bec05c08d: + goto end900aaaf28cefac6bb62e76b5151611cf + end900aaaf28cefac6bb62e76b5151611cf: ; case OpStore: // match: (Store ptr val mem) diff --git a/src/cmd/internal/ssa/op.go b/src/cmd/internal/ssa/op.go index ebe4a8e747..e0dc531fc9 100644 --- a/src/cmd/internal/ssa/op.go +++ b/src/cmd/internal/ssa/op.go @@ -4,6 +4,8 @@ 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. @@ -47,8 +49,11 @@ const ( OpArg // address of a function parameter/result. Memory input is an arg called ".mem". aux is a string (TODO: make it something other than a string?) OpGlobal // the address of a global variable aux.(*gc.Sym) OpFunc // entry address of a function + OpFP // frame pointer + OpSP // stack pointer OpCopy // output = arg0 + OpMove // arg0=destptr, arg1=srcptr, arg2=mem, aux.(int64)=size. Returns memory. OpPhi // select an argument based on which predecessor block we came from OpSliceMake // arg0=ptr, arg1=len, arg2=cap @@ -62,7 +67,8 @@ const ( OpLoad // Load from arg0+aux.(int64). arg1=memory OpStore // Store arg1 to arg0+aux.(int64). arg2=memory. Returns memory. - OpSliceIndex // arg0=slice, arg1=index, arg2=memory + OpArrayIndex // arg0=array, arg1=index. Returns a[i] + OpPtrIndex // arg0=ptr, arg1=index. Computes ptr+sizeof(*v.type)*index, where index is extended to ptrwidth type OpIsNonNil // arg0 != nil OpIsInBounds // 0 <= arg0 < arg1 @@ -75,6 +81,8 @@ const ( OpConvert // convert arg0 to another type OpConvNop // interpret arg0 as another type + OpOffPtr // arg0 + aux.(int64) (arg0 and result are pointers) + // These ops return a pointer to a location on the stack. OpFPAddr // FP + aux.(int64) (+ == args from caller, - == locals) OpSPAddr // SP + aux.(int64) @@ -96,6 +104,15 @@ type GlobalOffset struct { Offset int64 } +// offset adds x to the location specified by g and returns it. +func (g GlobalOffset) offset(x int64) GlobalOffset { + return GlobalOffset{g.Global, g.Offset + x} +} + +func (g GlobalOffset) String() string { + return fmt.Sprintf("%v+%d", g.Global, g.Offset) +} + //go:generate stringer -type=Op type opInfo struct { diff --git a/src/cmd/internal/ssa/op_string.go b/src/cmd/internal/ssa/op_string.go index 0851cfe0fb..9b22f664ef 100644 --- a/src/cmd/internal/ssa/op_string.go +++ b/src/cmd/internal/ssa/op_string.go @@ -6,16 +6,16 @@ import "fmt" const ( _Op_name_0 = "opInvalid" - _Op_name_1 = "opGenericBaseOpAddOpSubOpMulOpLessOpConstOpArgOpGlobalOpFuncOpCopyOpPhiOpSliceMakeOpSlicePtrOpSliceLenOpSliceCapOpStringMakeOpStringPtrOpStringLenOpLoadOpStoreOpSliceIndexOpIsNonNilOpIsInBoundsOpCallOpStaticCallOpConvertOpConvNopOpFPAddrOpSPAddrOpStoreReg8OpLoadReg8OpFwdRef" - _Op_name_2 = "opAMD64BaseOpADDQOpSUBQOpADDCQOpSUBCQOpMULQOpMULCQOpSHLQOpSHLCQOpNEGQOpADDLOpCMPQOpCMPCQOpTESTQOpSETEQOpSETNEOpSETLOpSETGEOpSETBOpInvertFlagsOpLEAQOpLEAQ2OpLEAQ4OpLEAQ8OpMOVQloadOpMOVQstoreOpMOVQloadidx8OpMOVQstoreidx8OpMOVQloadglobalOpMOVQstoreglobalOpMOVQloadFPOpMOVQloadSPOpMOVQstoreFPOpMOVQstoreSPOpMOVQconst" + _Op_name_1 = "opGenericBaseOpAddOpSubOpMulOpLessOpConstOpArgOpGlobalOpFuncOpFPOpSPOpCopyOpMoveOpPhiOpSliceMakeOpSlicePtrOpSliceLenOpSliceCapOpStringMakeOpStringPtrOpStringLenOpLoadOpStoreOpArrayIndexOpPtrIndexOpIsNonNilOpIsInBoundsOpCallOpStaticCallOpConvertOpConvNopOpOffPtrOpFPAddrOpSPAddrOpStoreReg8OpLoadReg8OpFwdRef" + _Op_name_2 = "opAMD64BaseOpADDQOpSUBQOpADDCQOpSUBCQOpMULQOpMULCQOpSHLQOpSHLCQOpNEGQOpADDLOpCMPQOpCMPCQOpTESTQOpTESTBOpSETEQOpSETNEOpSETLOpSETGEOpSETBOpInvertFlagsOpLEAQOpLEAQ2OpLEAQ4OpLEAQ8OpLEAQglobalOpMOVBloadOpMOVBQZXloadOpMOVBQSXloadOpMOVQloadOpMOVQstoreOpMOVQloadidx8OpMOVQstoreidx8OpMOVQloadglobalOpMOVQstoreglobalOpMOVQconstOpREPMOVSB" _Op_name_3 = "op386Base" _Op_name_4 = "opMax" ) var ( _Op_index_0 = [...]uint8{0, 9} - _Op_index_1 = [...]uint16{0, 13, 18, 23, 28, 34, 41, 46, 54, 60, 66, 71, 82, 92, 102, 112, 124, 135, 146, 152, 159, 171, 181, 193, 199, 211, 220, 229, 237, 245, 256, 266, 274} - _Op_index_2 = [...]uint16{0, 11, 17, 23, 30, 37, 43, 50, 56, 63, 69, 75, 81, 88, 95, 102, 109, 115, 122, 128, 141, 147, 154, 161, 168, 178, 189, 203, 218, 234, 251, 263, 275, 288, 301, 312} + _Op_index_1 = [...]uint16{0, 13, 18, 23, 28, 34, 41, 46, 54, 60, 64, 68, 74, 80, 85, 96, 106, 116, 126, 138, 149, 160, 166, 173, 185, 195, 205, 217, 223, 235, 244, 253, 261, 269, 277, 288, 298, 306} + _Op_index_2 = [...]uint16{0, 11, 17, 23, 30, 37, 43, 50, 56, 63, 69, 75, 81, 88, 95, 102, 109, 116, 122, 129, 135, 148, 154, 161, 168, 175, 187, 197, 210, 223, 233, 244, 258, 273, 289, 306, 317, 327} _Op_index_3 = [...]uint8{0, 9} _Op_index_4 = [...]uint8{0, 5} ) @@ -24,10 +24,10 @@ func (i Op) String() string { switch { case i == 0: return _Op_name_0 - case 1001 <= i && i <= 1032: + case 1001 <= i && i <= 1037: i -= 1001 return _Op_name_1[_Op_index_1[i]:_Op_index_1[i+1]] - case 2001 <= i && i <= 2035: + case 2001 <= i && i <= 2037: i -= 2001 return _Op_name_2[_Op_index_2[i]:_Op_index_2[i+1]] case i == 3001: diff --git a/src/cmd/internal/ssa/opamd64.go b/src/cmd/internal/ssa/opamd64.go index 8bdd19f713..46f0a69dfb 100644 --- a/src/cmd/internal/ssa/opamd64.go +++ b/src/cmd/internal/ssa/opamd64.go @@ -30,6 +30,7 @@ const ( OpCMPQ // arg0 compare to arg1 OpCMPCQ // arg0 compare to aux.(int64) OpTESTQ // (arg0 & arg1) compare to 0 + OpTESTB // (arg0 & arg1) compare to 0 // These opcodes extract a particular boolean condition from a flags value. OpSETEQ // extract == condition from arg0 @@ -43,29 +44,30 @@ const ( // This is a pseudo-op which can't appear in assembly output. OpInvertFlags // reverse direction of arg0 - OpLEAQ // arg0 + arg1 + aux.(int64) - OpLEAQ2 // arg0 + 2*arg1 + aux.(int64) - OpLEAQ4 // arg0 + 4*arg1 + aux.(int64) - OpLEAQ8 // arg0 + 8*arg1 + aux.(int64) + OpLEAQ // arg0 + arg1 + aux.(int64) + OpLEAQ2 // arg0 + 2*arg1 + aux.(int64) + OpLEAQ4 // arg0 + 4*arg1 + aux.(int64) + OpLEAQ8 // arg0 + 8*arg1 + aux.(int64) + OpLEAQglobal // no args. address of aux.(GlobalOffset) // Load/store from general address - OpMOVQload // Load from arg0+aux.(int64). arg1=memory + OpMOVBload // Load from arg0+aux.(int64). arg1=memory + OpMOVBQZXload + OpMOVBQSXload + OpMOVQload OpMOVQstore // Store arg1 to arg0+aux.(int64). arg2=memory, returns memory. OpMOVQloadidx8 // Load from arg0+arg1*8+aux.(int64). arg2=memory OpMOVQstoreidx8 // Store arg2 to arg0+arg1*8+aux.(int64). arg3=memory, returns memory. - // Load/store from global. aux.(GlobalOffset) encodes the global location. + // Load/store from global. Same as the above loads, but arg0 is missing and aux is a GlobalOffset instead of an int64. OpMOVQloadglobal // arg0 = memory OpMOVQstoreglobal // store arg0. arg1=memory, returns memory. - // Load/store from stack slot. - OpMOVQloadFP // load from FP+aux.(int64). arg0=memory - OpMOVQloadSP // load from SP+aux.(int64). arg0=memory - OpMOVQstoreFP // store arg0 to FP+aux.(int64). arg1=memory, returns memory. - OpMOVQstoreSP // store arg0 to SP+aux.(int64). arg1=memory, returns memory. - // materialize a constant into a register OpMOVQconst // (takes no arguments) + + // move memory + OpREPMOVSB // arg0=destptr, arg1=srcptr, arg2=len, arg3=mem ) type regMask uint64 @@ -89,13 +91,16 @@ var regsAMD64 = [...]string{ "R15", // pseudo registers + "FP", "FLAGS", "OVERWRITE0", // the same register as the first input } -var gp regMask = 0xef // all integer registers except SP -var cx regMask = 0x2 -var flags regMask = 1 << 16 +var gp regMask = 0x1ffff // all integer registers (including SP&FP) +var cx regMask = 1 << 1 +var si regMask = 1 << 6 +var di regMask = 1 << 7 +var flags regMask = 1 << 17 var ( // gp = general purpose (integer) registers @@ -129,13 +134,16 @@ var amd64Table = map[Op]opInfo{ OpCMPQ: {asm: "CMPQ\t%I0,%I1", reg: gp2_flags}, // compute arg[0]-arg[1] and produce flags OpCMPCQ: {asm: "CMPQ\t$%A,%I0", reg: gp1_flags}, OpTESTQ: {asm: "TESTQ\t%I0,%I1", reg: gp2_flags}, + OpTESTB: {asm: "TESTB\t%I0,%I1", reg: gp2_flags}, - OpLEAQ: {flags: OpFlagCommutative, asm: "LEAQ\t%A(%I0)(%I1*1),%O0", reg: gp21}, // aux = int64 constant to add - OpLEAQ2: {asm: "LEAQ\t%A(%I0)(%I1*2),%O0"}, - OpLEAQ4: {asm: "LEAQ\t%A(%I0)(%I1*4),%O0"}, - OpLEAQ8: {asm: "LEAQ\t%A(%I0)(%I1*8),%O0"}, + OpLEAQ: {flags: OpFlagCommutative, asm: "LEAQ\t%A(%I0)(%I1*1),%O0", reg: gp21}, // aux = int64 constant to add + OpLEAQ2: {asm: "LEAQ\t%A(%I0)(%I1*2),%O0"}, + OpLEAQ4: {asm: "LEAQ\t%A(%I0)(%I1*4),%O0"}, + OpLEAQ8: {asm: "LEAQ\t%A(%I0)(%I1*8),%O0"}, + OpLEAQglobal: {asm: "LEAQ\t%A(SB),%O0", reg: gp01}, // loads and stores + OpMOVBload: {asm: "MOVB\t%A(%I0),%O0", reg: gpload}, OpMOVQload: {asm: "MOVQ\t%A(%I0),%O0", reg: gpload}, OpMOVQstore: {asm: "MOVQ\t%I1,%A(%I0)", reg: gpstore}, OpMOVQloadidx8: {asm: "MOVQ\t%A(%I0)(%I1*8),%O0", reg: gploadidx}, @@ -145,23 +153,20 @@ var amd64Table = map[Op]opInfo{ OpStaticCall: {asm: "CALL\t%A(SB)"}, - OpCopy: {asm: "MOVQ\t%I0,%O0", reg: gp11}, + OpCopy: {asm: "MOVQ\t%I0,%O0", reg: gp11}, // TODO: make arch-specific + OpConvNop: {asm: "MOVQ\t%I0,%O0", reg: gp11}, // TODO: make arch-specific. Or get rid of this altogether. // convert from flags back to boolean OpSETL: {}, - // ops for load/store to stack - OpMOVQloadFP: {asm: "MOVQ\t%A(FP),%O0", reg: gpload_stack}, // mem -> value - OpMOVQloadSP: {asm: "MOVQ\t%A(SP),%O0", reg: gpload_stack}, // mem -> value - OpMOVQstoreFP: {asm: "MOVQ\t%I0,%A(FP)", reg: gpstore_stack}, // mem, value -> mem - OpMOVQstoreSP: {asm: "MOVQ\t%I0,%A(SP)", reg: gpstore_stack}, // mem, value -> mem - // ops for spilling of registers // unlike regular loads & stores, these take no memory argument. // They are just like OpCopy but we use them during register allocation. // TODO: different widths, float OpLoadReg8: {asm: "MOVQ\t%I0,%O0"}, OpStoreReg8: {asm: "MOVQ\t%I0,%O0"}, + + OpREPMOVSB: {asm: "REP MOVSB", reg: [2][]regMask{{di, si, cx, 0}, {0}}}, // TODO: record that si/di/cx are clobbered } func init() { diff --git a/src/cmd/internal/ssa/regalloc.go b/src/cmd/internal/ssa/regalloc.go index e2de10896e..c798d2e936 100644 --- a/src/cmd/internal/ssa/regalloc.go +++ b/src/cmd/internal/ssa/regalloc.go @@ -39,8 +39,9 @@ var registers = [...]Register{ // TODO X0, ... // TODO: make arch-dependent - Register{16, "FLAGS"}, - Register{17, "OVERWRITE"}, + Register{16, "FP"}, // pseudo-register, actually a constant offset from SP + Register{17, "FLAGS"}, + Register{18, "OVERWRITE"}, } // countRegs returns the number of set bits in the register mask. @@ -84,6 +85,19 @@ func regalloc(f *Func) { var oldSched []*Value + // Hack to find fp, sp Values and assign them a register. (TODO: make not so hacky) + var fp, sp *Value + for _, v := range f.Entry.Values { + switch v.Op { + case OpSP: + sp = v + home = setloc(home, v, ®isters[4]) // TODO: arch-dependent + case OpFP: + fp = v + home = setloc(home, v, ®isters[16]) // TODO: arch-dependent + } + } + // Register allocate each block separately. All live values will live // in home locations (stack slots) between blocks. for _, b := range f.Blocks { @@ -115,6 +129,10 @@ func regalloc(f *Func) { } regs := make([]regInfo, numRegs) + // TODO: hack: initialize fixed registers + regs[4] = regInfo{sp, sp, false} + regs[16] = regInfo{fp, fp, false} + var used regMask // has a 1 for each non-nil entry in regs var dirty regMask // has a 1 for each dirty entry in regs @@ -133,9 +151,6 @@ func regalloc(f *Func) { // - definition of v. c will be identical to v but will live in // a register. v will be modified into a spill of c. regspec := opcodeTable[v.Op].reg - if v.Op == OpConvNop { - regspec = opcodeTable[v.Args[0].Op].reg - } inputs := regspec[0] outputs := regspec[1] if len(inputs) == 0 && len(outputs) == 0 { @@ -154,6 +169,7 @@ func regalloc(f *Func) { // nospill contains registers that we can't spill because // we already set them up for use by the current instruction. var nospill regMask + nospill |= 0x10010 // SP and FP can't be spilled (TODO: arch-specific) // Move inputs into registers for _, o := range order { @@ -215,10 +231,16 @@ func regalloc(f *Func) { // Load w into this register var c *Value - if w.Op == OpConst { + if len(w.Args) == 0 { // Materialize w - // TODO: arch-specific MOV op - c = b.NewValue(OpMOVQconst, w.Type, w.Aux) + if w.Op == OpFP || w.Op == OpSP || w.Op == OpGlobal { + c = b.NewValue1(OpCopy, w.Type, nil, w) + } else { + c = b.NewValue(w.Op, w.Type, w.Aux) + } + } else if len(w.Args) == 1 && (w.Args[0].Op == OpFP || w.Args[0].Op == OpSP || w.Args[0].Op == OpGlobal) { + // Materialize offsets from SP/FP/Global + c = b.NewValue1(w.Op, w.Type, w.Aux, w.Args[0]) } else if wreg != 0 { // Copy from another register. // Typically just an optimization, but this is @@ -317,6 +339,10 @@ func regalloc(f *Func) { v := regs[r].v c := regs[r].c if lastUse[v.ID] <= len(oldSched) { + if v == v.Block.Control { + // link control value to register version + v.Block.Control = c + } continue // not live after block } @@ -334,6 +360,7 @@ func regalloc(f *Func) { } } f.RegAlloc = home + deadcode(f) // remove values that had all of their uses rematerialized. TODO: separate pass? } // addPhiCopies adds copies of phi inputs in the blocks diff --git a/src/cmd/internal/ssa/rewrite.go b/src/cmd/internal/ssa/rewrite.go index 855719a877..75e910d690 100644 --- a/src/cmd/internal/ssa/rewrite.go +++ b/src/cmd/internal/ssa/rewrite.go @@ -4,14 +4,14 @@ package ssa -import "fmt" +import "log" func applyRewrite(f *Func, r func(*Value) bool) { // repeat rewrites until we find no more rewrites var curv *Value defer func() { if curv != nil { - fmt.Printf("panic during rewrite of %s\n", curv.LongString()) + log.Printf("panic during rewrite of %s\n", curv.LongString()) // TODO(khr): print source location also } }() @@ -19,6 +19,18 @@ func applyRewrite(f *Func, r func(*Value) bool) { change := false for _, b := range f.Blocks { for _, v := range b.Values { + // elide any copies generated during rewriting + for i, a := range v.Args { + if a.Op != OpCopy { + continue + } + for a.Op == OpCopy { + a = a.Args[0] + } + v.Args[i] = a + } + + // apply rewrite function curv = v if r(v) { change = true @@ -26,6 +38,7 @@ func applyRewrite(f *Func, r func(*Value) bool) { } } if !change { + curv = nil return } } @@ -52,3 +65,19 @@ func isSigned(t Type) bool { func typeSize(t Type) int64 { return t.Size() } + +// addOff adds two offset aux values. Each should be an int64. Fails if wraparound happens. +func addOff(a, b interface{}) interface{} { + x := a.(int64) + y := b.(int64) + z := x + y + // x and y have same sign and z has a different sign => overflow + if x^y >= 0 && x^z < 0 { + log.Panicf("offset overflow %d %d\n", x, y) + } + return z +} + +func inBounds(idx, len int64) bool { + return idx >= 0 && idx < len +} diff --git a/src/cmd/internal/ssa/rulegen/generic.rules b/src/cmd/internal/ssa/rulegen/generic.rules index d17449930f..c49d9d9f2e 100644 --- a/src/cmd/internal/ssa/rulegen/generic.rules +++ b/src/cmd/internal/ssa/rulegen/generic.rules @@ -3,17 +3,22 @@ // license that can be found in the LICENSE file. // constant folding -(Add (Const [c]) (Const [d])) && is64BitInt(t) && isSigned(t) -> (Const [{c.(int64)+d.(int64)}]) -(Add (Const [c]) (Const [d])) && is64BitInt(t) && !isSigned(t) -> (Const [{c.(uint64)+d.(uint64)}]) +(Add (Const [c]) (Const [d])) && is64BitInt(t) -> (Const [{c.(int64)+d.(int64)}]) +(Mul (Const [c]) (Const [d])) && is64BitInt(t) -> (Const [{c.(int64)*d.(int64)}]) +(IsInBounds (Const [c]) (Const [d])) -> (Const [inBounds(c.(int64),d.(int64))]) // tear apart slices // TODO: anything that generates a slice needs to go in here. (SlicePtr (Load ptr mem)) -> (Load ptr mem) -(SliceLen (Load ptr mem)) -> (Load (Add ptr (Const [int64(v.Block.Func.Config.ptrSize)])) mem) -(SliceCap (Load ptr mem)) -> (Load (Add ptr (Const [int64(v.Block.Func.Config.ptrSize*2)])) mem) - -// expand array indexing -// others? Depends on what is already done by frontend +(SliceLen (Load ptr mem)) -> (Load (Add ptr (Const [int64(v.Block.Func.Config.ptrSize)])) mem) +(SliceCap (Load ptr mem)) -> (Load (Add ptr (Const [int64(v.Block.Func.Config.ptrSize*2)])) mem) +// indexing operations // Note: bounds check has already been done -(SliceIndex s i mem) -> (Load (Add (SlicePtr s) (Mul i (Const [s.Type.Elem().Size()]))) mem) +(ArrayIndex (Load ptr mem) idx) -> (Load (PtrIndex ptr idx) mem) +(PtrIndex ptr idx) -> (Add ptr (Mul idx (Const [t.Elem().Size()]))) +// TODO: hopefully this will get rid of all full-width array copies. + +// big-object moves +// TODO: fix size +(Store dst (Load src mem) mem) && t.Size() > 8 -> (Move [t.Size()] dst src mem) diff --git a/src/cmd/internal/ssa/rulegen/lower_amd64.rules b/src/cmd/internal/ssa/rulegen/lower_amd64.rules index 55267d6842..0fed21e740 100644 --- a/src/cmd/internal/ssa/rulegen/lower_amd64.rules +++ b/src/cmd/internal/ssa/rulegen/lower_amd64.rules @@ -30,6 +30,7 @@ (Less x y) && is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type) -> (SETL (CMPQ x y)) +(Load ptr mem) && t.IsBoolean() -> (MOVBload [int64(0)] ptr mem) (Load ptr mem) && (is64BitInt(t) || isPtr(t)) -> (MOVQload [int64(0)] ptr mem) (Store ptr val mem) && (is64BitInt(val.Type) || isPtr(val.Type)) -> (MOVQstore [int64(0)] ptr val mem) @@ -37,28 +38,27 @@ (IsNonNil p) -> (SETNE (TESTQ p p)) (IsInBounds idx len) -> (SETB (CMPQ idx len)) +(Move [size] dst src mem) -> (REPMOVSB dst src (Const [size.(int64)]) mem) + +(OffPtr [off] ptr) -> (ADDCQ [off] ptr) + +(Const [val]) && is64BitInt(t) -> (MOVQconst [val]) + // Rules below here apply some simple optimizations after lowering. // TODO: Should this be a separate pass? -// stack loads/stores -(MOVQload [off1] (FPAddr [off2]) mem) -> (MOVQloadFP [off1.(int64)+off2.(int64)] mem) -(MOVQload [off1] (SPAddr [off2]) mem) -> (MOVQloadSP [off1.(int64)+off2.(int64)] mem) -(MOVQstore [off1] (FPAddr [off2]) val mem) -> (MOVQstoreFP [off1.(int64)+off2.(int64)] val mem) -(MOVQstore [off1] (SPAddr [off2]) val mem) -> (MOVQstoreSP [off1.(int64)+off2.(int64)] val mem) - // global loads/stores -(MOVQload [off] (Global [sym]) mem) -> (MOVQloadglobal [GlobalOffset{sym,off.(int64)}] mem) -(MOVQstore [off] (Global [sym]) val mem) -> (MOVQstoreglobal [GlobalOffset{sym,off.(int64)}] val mem) +(Global [sym]) -> (LEAQglobal [GlobalOffset{sym,0}]) // fold constants into instructions -(ADDQ x (Const [c])) -> (ADDCQ [c] x) // TODO: restrict c to int32 range? -(ADDQ (Const [c]) x) -> (ADDCQ [c] x) -(SUBQ x (Const [c])) -> (SUBCQ x [c]) -(SUBQ (Const [c]) x) -> (NEGQ (SUBCQ x [c])) -(MULQ x (Const [c])) -> (MULCQ [c] x) -(MULQ (Const [c]) x) -> (MULCQ [c] x) -(CMPQ x (Const [c])) -> (CMPCQ x [c]) -(CMPQ (Const [c]) x) -> (InvertFlags (CMPCQ x [c])) +(ADDQ x (MOVQconst [c])) -> (ADDCQ [c] x) // TODO: restrict c to int32 range? +(ADDQ (MOVQconst [c]) x) -> (ADDCQ [c] x) +(SUBQ x (MOVQconst [c])) -> (SUBCQ x [c]) +(SUBQ (MOVQconst [c]) x) -> (NEGQ (SUBCQ x [c])) +(MULQ x (MOVQconst [c])) -> (MULCQ [c] x) +(MULQ (MOVQconst [c]) x) -> (MULCQ [c] x) +(CMPQ x (MOVQconst [c])) -> (CMPCQ x [c]) +(CMPQ (MOVQconst [c]) x) -> (InvertFlags (CMPCQ x [c])) // strength reduction // TODO: do this a lot more generically @@ -66,7 +66,7 @@ // fold add/shift into leaq (ADDQ x (SHLCQ [shift] y)) && shift.(int64) == 3 -> (LEAQ8 [int64(0)] x y) -(ADDCQ [c] (LEAQ8 [d] x y)) -> (LEAQ8 [c.(int64)+d.(int64)] x y) +(ADDCQ [c] (LEAQ8 [d] x y)) -> (LEAQ8 [addOff(c, d)] x y) // reverse ordering of compare instruction (SETL (InvertFlags x)) -> (SETGE x) @@ -76,13 +76,14 @@ // the ADDCQ get eliminated, we still have to compute the ADDCQ and we now // have potentially two live values (ptr and (ADDCQ [off] ptr)) instead of one. // Nevertheless, let's do it! -(MOVQload [off1] (ADDCQ [off2] ptr) mem) -> (MOVQload [off1.(int64)+off2.(int64)] ptr mem) -(MOVQstore [off1] (ADDCQ [off2] ptr) val mem) -> (MOVQstore [off1.(int64)+off2.(int64)] ptr val mem) +(MOVQload [off1] (ADDCQ [off2] ptr) mem) -> (MOVQload [addOff(off1, off2)] ptr mem) +(MOVQstore [off1] (ADDCQ [off2] ptr) val mem) -> (MOVQstore [addOff(off1, off2)] ptr val mem) // indexed loads and stores -(MOVQload [off1] (LEAQ8 [off2] ptr idx) mem) -> (MOVQloadidx8 [off1.(int64)+off2.(int64)] ptr idx mem) -(MOVQstore [off1] (LEAQ8 [off2] ptr idx) val mem) -> (MOVQstoreidx8 [off1.(int64)+off2.(int64)] ptr idx val mem) +(MOVQload [off1] (LEAQ8 [off2] ptr idx) mem) -> (MOVQloadidx8 [addOff(off1, off2)] ptr idx mem) +(MOVQstore [off1] (LEAQ8 [off2] ptr idx) val mem) -> (MOVQstoreidx8 [addOff(off1, off2)] ptr idx val mem) + +(MOVQloadidx8 [off1] (ADDCQ [off2] ptr) idx mem) -> (MOVQloadidx8 [addOff(off1, off2)] ptr idx mem) +(MOVQstoreidx8 [off1] (ADDCQ [off2] ptr) idx val mem) -> (MOVQstoreidx8 [addOff(off1, off2)] ptr idx val mem) -// Combine the offset of a stack object with the offset within a stack object -(ADDCQ [off1] (FPAddr [off2])) -> (FPAddr [off1.(int64)+off2.(int64)]) -(ADDCQ [off1] (SPAddr [off2])) -> (SPAddr [off1.(int64)+off2.(int64)]) +(ADDCQ [off] x) && off.(int64) == 0 -> (Copy x) diff --git a/src/cmd/internal/ssa/rulegen/rulegen.go b/src/cmd/internal/ssa/rulegen/rulegen.go index 31f46f7cce..4ac930298b 100644 --- a/src/cmd/internal/ssa/rulegen/rulegen.go +++ b/src/cmd/internal/ssa/rulegen/rulegen.go @@ -245,6 +245,12 @@ func genResult(w io.Writer, result string) { func genResult0(w io.Writer, result string, alloc *int, top bool) string { if result[0] != '(' { // variable + if top { + fmt.Fprintf(w, "v.Op = %s.Op\n", result) + fmt.Fprintf(w, "v.Aux = %s.Aux\n", result) + fmt.Fprintf(w, "v.resetArgs()\n") + fmt.Fprintf(w, "v.AddArgs(%s.Args...)\n", result) + } return result } @@ -297,20 +303,33 @@ func split(s string) []string { outer: for s != "" { - d := 0 // depth of ({[< - nonsp := false // found a non-space char so far + 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 s[i] { - case '(', '{', '[', '<': + switch { + case d == 0 && s[i] == '(': + open, close = '(', ')' d++ - case ')', '}', ']', '>': - d-- - case ' ', '\t': - if d == 0 && nonsp { + 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 } diff --git a/src/cmd/internal/ssa/stackalloc.go b/src/cmd/internal/ssa/stackalloc.go index 4d0359ed81..8a315e1045 100644 --- a/src/cmd/internal/ssa/stackalloc.go +++ b/src/cmd/internal/ssa/stackalloc.go @@ -15,6 +15,9 @@ func stackalloc(f *Func) { if v.Op != OpPhi { continue } + if v.Type.IsMemory() { // TODO: only "regallocable" types + continue + } n += v.Type.Size() // a := v.Type.Align() // n = (n + a - 1) / a * a TODO @@ -35,10 +38,11 @@ func stackalloc(f *Func) { if v.Type.IsMemory() { // TODO: only "regallocable" types continue } - if v.Op == OpConst { - // don't allocate space for OpConsts. They should - // have been rematerialized everywhere. - // TODO: is this the right thing to do? + if len(v.Args) == 0 { + // v will have been materialized wherever it is needed. + continue + } + if len(v.Args) == 1 && (v.Args[0].Op == OpFP || v.Args[0].Op == OpSP || v.Args[0].Op == OpGlobal) { continue } // a := v.Type.Align() -- cgit v1.3 From 247786c1745abc0c7185f7c15ca256edf68ed6d6 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Thu, 28 May 2015 10:47:24 -0700 Subject: [dev.ssa] B[dev.ssa] cmd/internal/ssa: Cleanup & reorg Rename ops like ADDCQ to ADDQconst, so it is clear what the base opcode is and what the modifiers are. Convert FP references to SP references once we know the frame size. Related, compute the frame size in the ssa package. Do a bunch of small fixes. Add a TODO list for people to peruse. Change-Id: Ia6a3fe2bf57e5a2e5e883032e2a2a3fdd566c038 Reviewed-on: https://go-review.googlesource.com/10465 Reviewed-by: Alan Donovan --- src/cmd/internal/gc/ssa.go | 125 ++++++---- src/cmd/internal/ssa/TODO | 47 ++++ src/cmd/internal/ssa/func.go | 2 + src/cmd/internal/ssa/location.go | 14 +- src/cmd/internal/ssa/lower.go | 11 +- src/cmd/internal/ssa/lowerAmd64.go | 327 +++++++++++++++---------- src/cmd/internal/ssa/op.go | 8 +- src/cmd/internal/ssa/op_string.go | 10 +- src/cmd/internal/ssa/opamd64.go | 71 +++--- src/cmd/internal/ssa/rewrite.go | 5 +- src/cmd/internal/ssa/rulegen/lower_amd64.rules | 42 ++-- src/cmd/internal/ssa/stackalloc.go | 58 ++++- 12 files changed, 454 insertions(+), 266 deletions(-) create mode 100644 src/cmd/internal/ssa/TODO (limited to 'src/cmd') diff --git a/src/cmd/internal/gc/ssa.go b/src/cmd/internal/gc/ssa.go index 8e81163ad4..bb4d278383 100644 --- a/src/cmd/internal/gc/ssa.go +++ b/src/cmd/internal/gc/ssa.go @@ -287,6 +287,14 @@ func (s *state) expr(n *Node) *ssa.Value { a := s.expr(n.Left) b := s.expr(n.Right) return s.curBlock.NewValue2(ssa.OpSub, a.Type, nil, a, b) + case OLSH: + a := s.expr(n.Left) + b := s.expr(n.Right) + return s.curBlock.NewValue2(ssa.OpLsh, a.Type, nil, a, b) + case ORSH: + a := s.expr(n.Left) + b := s.expr(n.Right) + return s.curBlock.NewValue2(ssa.OpRsh, a.Type, nil, a, b) case OADDR: return s.addr(n.Left) @@ -519,25 +527,15 @@ type branch struct { // gcargs and gclocals are filled in with pointer maps for the frame. func genssa(f *ssa.Func, ptxt *obj.Prog, gcargs, gclocals *Sym) { // TODO: line numbers - // TODO: layout frame - stkSize := int64(64) - - if Hasdefer != 0 { - // deferreturn pretends to have one uintptr argument. - // Reserve space for it so stack scanner is happy. - if Maxarg < int64(Widthptr) { - Maxarg = int64(Widthptr) - } - } - if stkSize+Maxarg > 1<<31 { + + if f.FrameSize > 1<<31 { Yyerror("stack frame too large (>2GB)") return } - frameSize := stkSize + Maxarg ptxt.To.Type = obj.TYPE_TEXTSIZE ptxt.To.Val = int32(Rnd(Curfn.Type.Argwid, int64(Widthptr))) // arg size - ptxt.To.Offset = frameSize - 8 // TODO: arch-dependent + ptxt.To.Offset = f.FrameSize - 8 // TODO: arch-dependent // Remember where each block starts. bstart := make([]*obj.Prog, f.NumBlocks()) @@ -551,7 +549,7 @@ func genssa(f *ssa.Func, ptxt *obj.Prog, gcargs, gclocals *Sym) { bstart[b.ID] = Pc // Emit values in block for _, v := range b.Values { - genValue(v, frameSize) + genValue(v) } // Emit control flow instructions for block var next *ssa.Block @@ -578,7 +576,7 @@ func genssa(f *ssa.Func, ptxt *obj.Prog, gcargs, gclocals *Sym) { liveness(Curfn, ptxt, gcargs, gclocals) } -func genValue(v *ssa.Value, frameSize int64) { +func genValue(v *ssa.Value) { switch v.Op { case ssa.OpADDQ: // TODO: use addq instead of leaq if target is in the right register. @@ -589,7 +587,7 @@ func genValue(v *ssa.Value, frameSize int64) { p.From.Index = regnum(v.Args[1]) p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v) - case ssa.OpADDCQ: + case ssa.OpADDQconst: // TODO: use addq instead of leaq if target is in the right register. p := Prog(x86.ALEAQ) p.From.Type = obj.TYPE_MEM @@ -597,7 +595,17 @@ func genValue(v *ssa.Value, frameSize int64) { p.From.Offset = v.Aux.(int64) p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v) - case ssa.OpSUBCQ: + case ssa.OpMULQconst: + // TODO: this isn't right. doasm fails on it. I don't think obj + // has ever been taught to compile imul $c, r1, r2. + p := Prog(x86.AIMULQ) + p.From.Type = obj.TYPE_CONST + p.From.Offset = v.Aux.(int64) + p.From3.Type = obj.TYPE_REG + p.From3.Reg = regnum(v.Args[0]) + p.To.Type = obj.TYPE_REG + p.To.Reg = regnum(v) + case ssa.OpSUBQconst: // 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]) @@ -615,13 +623,38 @@ func genValue(v *ssa.Value, frameSize int64) { p.From.Offset = v.Aux.(int64) p.To.Type = obj.TYPE_REG p.To.Reg = r + case ssa.OpSHLQconst: + x := regnum(v.Args[0]) + r := regnum(v) + if x != r { + p := Prog(x86.AMOVQ) + p.From.Type = obj.TYPE_REG + p.From.Reg = x + p.To.Type = obj.TYPE_REG + p.To.Reg = r + x = r + } + p := Prog(x86.ASHLQ) + p.From.Type = obj.TYPE_CONST + p.From.Offset = v.Aux.(int64) + p.To.Type = obj.TYPE_REG + p.To.Reg = r + case ssa.OpLEAQ: + p := Prog(x86.ALEAQ) + p.From.Type = obj.TYPE_MEM + p.From.Reg = regnum(v.Args[0]) + p.From.Scale = 1 + p.From.Index = regnum(v.Args[1]) + p.From.Offset = v.Aux.(int64) + p.To.Type = obj.TYPE_REG + p.To.Reg = regnum(v) case ssa.OpCMPQ: p := Prog(x86.ACMPQ) p.From.Type = obj.TYPE_REG p.From.Reg = regnum(v.Args[0]) p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v.Args[1]) - case ssa.OpCMPCQ: + case ssa.OpCMPQconst: p := Prog(x86.ACMPQ) p.From.Type = obj.TYPE_REG p.From.Reg = regnum(v.Args[0]) @@ -643,38 +676,22 @@ func genValue(v *ssa.Value, frameSize int64) { case ssa.OpMOVQload: p := Prog(x86.AMOVQ) p.From.Type = obj.TYPE_MEM - if v.Block.Func.RegAlloc[v.Args[0].ID].Name() == "FP" { - // TODO: do the fp/sp adjustment somewhere else? - p.From.Reg = x86.REG_SP - p.From.Offset = v.Aux.(int64) + frameSize - } else { - p.From.Reg = regnum(v.Args[0]) - p.From.Offset = v.Aux.(int64) - } + p.From.Reg = regnum(v.Args[0]) + p.From.Offset = v.Aux.(int64) p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v) case ssa.OpMOVBload: p := Prog(x86.AMOVB) p.From.Type = obj.TYPE_MEM - if v.Block.Func.RegAlloc[v.Args[0].ID].Name() == "FP" { - p.From.Reg = x86.REG_SP - p.From.Offset = v.Aux.(int64) + frameSize - } else { - p.From.Reg = regnum(v.Args[0]) - p.From.Offset = v.Aux.(int64) - } + p.From.Reg = regnum(v.Args[0]) + p.From.Offset = v.Aux.(int64) p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v) case ssa.OpMOVQloadidx8: p := Prog(x86.AMOVQ) p.From.Type = obj.TYPE_MEM - if v.Block.Func.RegAlloc[v.Args[0].ID].Name() == "FP" { - p.From.Reg = x86.REG_SP - p.From.Offset = v.Aux.(int64) + frameSize - } else { - p.From.Reg = regnum(v.Args[0]) - p.From.Offset = v.Aux.(int64) - } + p.From.Reg = regnum(v.Args[0]) + p.From.Offset = v.Aux.(int64) p.From.Scale = 8 p.From.Index = regnum(v.Args[1]) p.To.Type = obj.TYPE_REG @@ -684,13 +701,8 @@ func genValue(v *ssa.Value, frameSize int64) { p.From.Type = obj.TYPE_REG p.From.Reg = regnum(v.Args[1]) p.To.Type = obj.TYPE_MEM - if v.Block.Func.RegAlloc[v.Args[0].ID].Name() == "FP" { - p.To.Reg = x86.REG_SP - p.To.Offset = v.Aux.(int64) + frameSize - } else { - p.To.Reg = regnum(v.Args[0]) - p.To.Offset = v.Aux.(int64) - } + p.To.Reg = regnum(v.Args[0]) + p.To.Offset = v.Aux.(int64) case ssa.OpCopy: x := regnum(v.Args[0]) y := regnum(v) @@ -705,7 +717,7 @@ func genValue(v *ssa.Value, frameSize int64) { p := Prog(x86.AMOVQ) p.From.Type = obj.TYPE_MEM p.From.Reg = x86.REG_SP - p.From.Offset = frameSize - localOffset(v.Args[0]) + p.From.Offset = localOffset(v.Args[0]) p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v) case ssa.OpStoreReg8: @@ -714,7 +726,7 @@ func genValue(v *ssa.Value, frameSize int64) { p.From.Reg = regnum(v.Args[0]) p.To.Type = obj.TYPE_MEM p.To.Reg = x86.REG_SP - p.To.Offset = frameSize - localOffset(v) + p.To.Offset = localOffset(v) case ssa.OpPhi: // just check to make sure regalloc did it right f := v.Block.Func @@ -740,10 +752,15 @@ func genValue(v *ssa.Value, frameSize int64) { p.From.Offset = g.Offset p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v) + case ssa.OpStaticCall: + p := Prog(obj.ACALL) + p.To.Type = obj.TYPE_MEM + p.To.Name = obj.NAME_EXTERN + p.To.Sym = Linksym(v.Aux.(*Sym)) case ssa.OpFP, ssa.OpSP: // nothing to do default: - log.Fatalf("value %s not implemented yet", v.LongString()) + log.Fatalf("value %s not implemented", v.LongString()) } } @@ -757,6 +774,12 @@ func genBlock(b, next *ssa.Block, branches []branch) []branch { } case ssa.BlockExit: Prog(obj.ARET) + case ssa.BlockCall: + if b.Succs[0] != next { + p := Prog(obj.AJMP) + p.To.Type = obj.TYPE_BRANCH + branches = append(branches, branch{p, b.Succs[0]}) + } case ssa.BlockEQ: if b.Succs[0] == next { p := Prog(x86.AJNE) @@ -844,7 +867,7 @@ func genBlock(b, next *ssa.Block, branches []branch) []branch { } default: - log.Fatalf("branch %s not implemented yet", b.LongString()) + log.Fatalf("branch %s not implemented", b.LongString()) } return branches } diff --git a/src/cmd/internal/ssa/TODO b/src/cmd/internal/ssa/TODO new file mode 100644 index 0000000000..afb723ae4c --- /dev/null +++ b/src/cmd/internal/ssa/TODO @@ -0,0 +1,47 @@ +This is a list of things that need to be worked on. It is by no means complete. + +Allocation +- Allocation of decls in stackalloc. Decls survive if they are + addrtaken or are too large for registerization. + +Scheduling + - Make sure loads are scheduled correctly with respect to stores. + Same for flag type values. We can't have more than one value of + mem or flag types live at once. + - Reduce register pressure. Schedule instructions which kill + variables first. + +Values + - Add a line number field. Figure out how to populate it and + maintain it during rewrites. + - Store *Type instead of Type? Keep an array of used Types in Func + and reference by id? Unify with the type ../gc so we just use a + pointer instead of an interface? + - Recycle dead values instead of using GC to do that. + - A lot of Aux fields are just int64. Add a separate AuxInt field? + If not that, then cache the interfaces that wrap int64s. + - OpStore uses 3 args. Increase the size of argstorage to 3? + +Opcodes + - Rename ops to prevent cross-arch conflicts. MOVQ -> MOVQamd64 (or + MOVQ6?). Other option: build opcode table in Config instead of globally. + - Remove asm string from opinfo, no longer needed. + - It's annoying to list the opcode both in the opcode list and an + opInfo map entry. Specify it one place and use go:generate to + produce both? + +Regalloc + - Make less arch-dependent + - Don't spill everything at every basic block boundary. + - Allow args and return values to be ssa-able. + - Handle 2-address instructions. + +Rewrites + - Strength reduction (both arch-indep and arch-dependent?) + - Code sequence for shifts >= wordsize + - Start another architecture (arm?) + +Common-Subexpression Elimination + - Make better decision about which value in an equivalence class we should + choose to replace other values in that class. + - Can we move control values out of their basic block? diff --git a/src/cmd/internal/ssa/func.go b/src/cmd/internal/ssa/func.go index bdc8815e1a..3e41ef3bc1 100644 --- a/src/cmd/internal/ssa/func.go +++ b/src/cmd/internal/ssa/func.go @@ -17,6 +17,8 @@ type Func struct { // when register allocation is done, maps value ids to locations RegAlloc []Location + // when stackalloc is done, the size of the stack frame + FrameSize int64 } // NumBlocks returns an integer larger than the id of any Block in the Func. diff --git a/src/cmd/internal/ssa/location.go b/src/cmd/internal/ssa/location.go index 528956e681..1b6f6d66c1 100644 --- a/src/cmd/internal/ssa/location.go +++ b/src/cmd/internal/ssa/location.go @@ -26,19 +26,9 @@ func (r *Register) Name() string { // A LocalSlot is a location in the stack frame. type LocalSlot struct { - Idx int64 // offset in locals area (distance down from FP == caller's SP) + Idx int64 // offset in locals area (distance up from SP) } func (s *LocalSlot) Name() string { - return fmt.Sprintf("-%d(FP)", s.Idx) -} - -// An ArgSlot is a location in the parents' stack frame where it passed us an argument. -type ArgSlot struct { - idx int64 // offset in argument area -} - -// A CalleeSlot is a location in the stack frame where we pass an argument to a callee. -type CalleeSlot struct { - idx int64 // offset in callee area + return fmt.Sprintf("%d(SP)", s.Idx) } diff --git a/src/cmd/internal/ssa/lower.go b/src/cmd/internal/ssa/lower.go index 84379c00de..44f0b83fa8 100644 --- a/src/cmd/internal/ssa/lower.go +++ b/src/cmd/internal/ssa/lower.go @@ -4,6 +4,8 @@ package ssa +import "log" + //go:generate go run rulegen/rulegen.go rulegen/lower_amd64.rules lowerAmd64 lowerAmd64.go // convert to machine-dependent ops @@ -11,7 +13,14 @@ func lower(f *Func) { // repeat rewrites until we find no more rewrites applyRewrite(f, f.Config.lower) - // TODO: check for unlowered opcodes, fail if we find one + // Check for unlowered opcodes, fail if we find one. + for _, b := range f.Blocks { + for _, v := range b.Values { + if v.Op < OpGenericEnd && v.Op != OpFP && v.Op != OpSP && v.Op != OpArg && v.Op != OpCopy && v.Op != OpPhi { + log.Panicf("%s not lowered", v.LongString()) + } + } + } // additional pass for 386/amd64, link condition codes directly to blocks // TODO: do generically somehow? Special "block" rewrite rules? diff --git a/src/cmd/internal/ssa/lowerAmd64.go b/src/cmd/internal/ssa/lowerAmd64.go index 356f646dcc..51cef97b30 100644 --- a/src/cmd/internal/ssa/lowerAmd64.go +++ b/src/cmd/internal/ssa/lowerAmd64.go @@ -4,98 +4,57 @@ package ssa func lowerAmd64(v *Value) bool { switch v.Op { - case OpADDCQ: - // match: (ADDCQ [c] (LEAQ8 [d] x y)) - // cond: - // result: (LEAQ8 [addOff(c, d)] x y) - { - c := v.Aux - if v.Args[0].Op != OpLEAQ8 { - goto end3bc1457811adc0cb81ad6b88a7461c60 - } - d := v.Args[0].Aux - x := v.Args[0].Args[0] - y := v.Args[0].Args[1] - v.Op = OpLEAQ8 - v.Aux = nil - v.resetArgs() - v.Aux = addOff(c, d) - v.AddArg(x) - v.AddArg(y) - return true - } - goto end3bc1457811adc0cb81ad6b88a7461c60 - end3bc1457811adc0cb81ad6b88a7461c60: - ; - // match: (ADDCQ [off] x) - // cond: off.(int64) == 0 - // result: (Copy x) - { - off := v.Aux - x := v.Args[0] - if !(off.(int64) == 0) { - goto end6710a6679c47b70577ecea7ad00dae87 - } - v.Op = OpCopy - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto end6710a6679c47b70577ecea7ad00dae87 - end6710a6679c47b70577ecea7ad00dae87: - ; case OpADDQ: // match: (ADDQ x (MOVQconst [c])) // cond: - // result: (ADDCQ [c] x) + // result: (ADDQconst [c] x) { x := v.Args[0] if v.Args[1].Op != OpMOVQconst { - goto end39b79e84f20a6d44b5c4136aae220ac2 + goto endacffd55e74ee0ff59ad58a18ddfc9973 } c := v.Args[1].Aux - v.Op = OpADDCQ + v.Op = OpADDQconst v.Aux = nil v.resetArgs() v.Aux = c v.AddArg(x) return true } - goto end39b79e84f20a6d44b5c4136aae220ac2 - end39b79e84f20a6d44b5c4136aae220ac2: + goto endacffd55e74ee0ff59ad58a18ddfc9973 + endacffd55e74ee0ff59ad58a18ddfc9973: ; // match: (ADDQ (MOVQconst [c]) x) // cond: - // result: (ADDCQ [c] x) + // result: (ADDQconst [c] x) { if v.Args[0].Op != OpMOVQconst { - goto endc05ff5a2a132241b69d00c852001d820 + goto end7166f476d744ab7a51125959d3d3c7e2 } c := v.Args[0].Aux x := v.Args[1] - v.Op = OpADDCQ + v.Op = OpADDQconst v.Aux = nil v.resetArgs() v.Aux = c v.AddArg(x) return true } - goto endc05ff5a2a132241b69d00c852001d820 - endc05ff5a2a132241b69d00c852001d820: + goto end7166f476d744ab7a51125959d3d3c7e2 + end7166f476d744ab7a51125959d3d3c7e2: ; - // match: (ADDQ x (SHLCQ [shift] y)) + // match: (ADDQ x (SHLQconst [shift] y)) // cond: shift.(int64) == 3 // result: (LEAQ8 [int64(0)] x y) { x := v.Args[0] - if v.Args[1].Op != OpSHLCQ { - goto end7fa0d837edd248748cef516853fd9475 + if v.Args[1].Op != OpSHLQconst { + goto endaf4f724e1e17f2b116d336c07da0165d } shift := v.Args[1].Aux y := v.Args[1].Args[0] if !(shift.(int64) == 3) { - goto end7fa0d837edd248748cef516853fd9475 + goto endaf4f724e1e17f2b116d336c07da0165d } v.Op = OpLEAQ8 v.Aux = nil @@ -105,8 +64,49 @@ func lowerAmd64(v *Value) bool { v.AddArg(y) return true } - goto end7fa0d837edd248748cef516853fd9475 - end7fa0d837edd248748cef516853fd9475: + goto endaf4f724e1e17f2b116d336c07da0165d + endaf4f724e1e17f2b116d336c07da0165d: + ; + case OpADDQconst: + // match: (ADDQconst [c] (LEAQ8 [d] x y)) + // cond: + // result: (LEAQ8 [addOff(c, d)] x y) + { + c := v.Aux + if v.Args[0].Op != OpLEAQ8 { + goto ende2cc681c9abf9913288803fb1b39e639 + } + d := v.Args[0].Aux + x := v.Args[0].Args[0] + y := v.Args[0].Args[1] + v.Op = OpLEAQ8 + v.Aux = nil + v.resetArgs() + v.Aux = addOff(c, d) + v.AddArg(x) + v.AddArg(y) + return true + } + goto ende2cc681c9abf9913288803fb1b39e639 + ende2cc681c9abf9913288803fb1b39e639: + ; + // match: (ADDQconst [off] x) + // cond: off.(int64) == 0 + // result: (Copy x) + { + off := v.Aux + x := v.Args[0] + if !(off.(int64) == 0) { + goto endfa1c7cc5ac4716697e891376787f86ce + } + v.Op = OpCopy + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto endfa1c7cc5ac4716697e891376787f86ce + endfa1c7cc5ac4716697e891376787f86ce: ; case OpAdd: // match: (Add x y) @@ -152,44 +152,44 @@ func lowerAmd64(v *Value) bool { case OpCMPQ: // match: (CMPQ x (MOVQconst [c])) // cond: - // result: (CMPCQ x [c]) + // result: (CMPQconst x [c]) { x := v.Args[0] if v.Args[1].Op != OpMOVQconst { - goto endf180bae15b3d24c0213520d7f7aa98b4 + goto end32ef1328af280ac18fa8045a3502dae9 } c := v.Args[1].Aux - v.Op = OpCMPCQ + v.Op = OpCMPQconst v.Aux = nil v.resetArgs() v.AddArg(x) v.Aux = c return true } - goto endf180bae15b3d24c0213520d7f7aa98b4 - endf180bae15b3d24c0213520d7f7aa98b4: + goto end32ef1328af280ac18fa8045a3502dae9 + end32ef1328af280ac18fa8045a3502dae9: ; // match: (CMPQ (MOVQconst [c]) x) // cond: - // result: (InvertFlags (CMPCQ x [c])) + // result: (InvertFlags (CMPQconst x [c])) { if v.Args[0].Op != OpMOVQconst { - goto end8fc58bffa73b3df80b3de72c91844884 + goto endf8ca12fe79290bc82b11cfa463bc9413 } c := v.Args[0].Aux x := v.Args[1] v.Op = OpInvertFlags v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue(OpCMPCQ, TypeInvalid, nil) + v0 := v.Block.NewValue(OpCMPQconst, TypeInvalid, nil) v0.Type = TypeFlags v0.AddArg(x) v0.Aux = c v.AddArg(v0) return true } - goto end8fc58bffa73b3df80b3de72c91844884 - end8fc58bffa73b3df80b3de72c91844884: + goto endf8ca12fe79290bc82b11cfa463bc9413 + endf8ca12fe79290bc82b11cfa463bc9413: ; case OpConst: // match: (Const [val]) @@ -330,14 +330,35 @@ func lowerAmd64(v *Value) bool { goto end581ce5a20901df1b8143448ba031685b end581ce5a20901df1b8143448ba031685b: ; + case OpLsh: + // match: (Lsh x y) + // cond: is64BitInt(t) + // result: (SHLQ x y) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + if !(is64BitInt(t)) { + goto end9f05c9539e51db6ad557989e0c822e9b + } + v.Op = OpSHLQ + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end9f05c9539e51db6ad557989e0c822e9b + end9f05c9539e51db6ad557989e0c822e9b: + ; case OpMOVQload: - // match: (MOVQload [off1] (ADDCQ [off2] ptr) mem) + // match: (MOVQload [off1] (ADDQconst [off2] ptr) mem) // cond: // result: (MOVQload [addOff(off1, off2)] ptr mem) { off1 := v.Aux - if v.Args[0].Op != OpADDCQ { - goto end218ceec16b8299d573d3c9ccaa69b086 + if v.Args[0].Op != OpADDQconst { + goto end843d29b538c4483b432b632e5666d6e3 } off2 := v.Args[0].Aux ptr := v.Args[0].Args[0] @@ -350,8 +371,8 @@ func lowerAmd64(v *Value) bool { v.AddArg(mem) return true } - goto end218ceec16b8299d573d3c9ccaa69b086 - end218ceec16b8299d573d3c9ccaa69b086: + goto end843d29b538c4483b432b632e5666d6e3 + end843d29b538c4483b432b632e5666d6e3: ; // match: (MOVQload [off1] (LEAQ8 [off2] ptr idx) mem) // cond: @@ -378,13 +399,13 @@ func lowerAmd64(v *Value) bool { end02f5ad148292c46463e7c20d3b821735: ; case OpMOVQloadidx8: - // match: (MOVQloadidx8 [off1] (ADDCQ [off2] ptr) idx mem) + // match: (MOVQloadidx8 [off1] (ADDQconst [off2] ptr) idx mem) // cond: // result: (MOVQloadidx8 [addOff(off1, off2)] ptr idx mem) { off1 := v.Aux - if v.Args[0].Op != OpADDCQ { - goto ende47e8d742e2615f39fb6509a5749e414 + if v.Args[0].Op != OpADDQconst { + goto ende81e44bcfb11f90916ccb440c590121f } off2 := v.Args[0].Aux ptr := v.Args[0].Args[0] @@ -399,17 +420,17 @@ func lowerAmd64(v *Value) bool { v.AddArg(mem) return true } - goto ende47e8d742e2615f39fb6509a5749e414 - ende47e8d742e2615f39fb6509a5749e414: + goto ende81e44bcfb11f90916ccb440c590121f + ende81e44bcfb11f90916ccb440c590121f: ; case OpMOVQstore: - // match: (MOVQstore [off1] (ADDCQ [off2] ptr) val mem) + // match: (MOVQstore [off1] (ADDQconst [off2] ptr) val mem) // cond: // result: (MOVQstore [addOff(off1, off2)] ptr val mem) { off1 := v.Aux - if v.Args[0].Op != OpADDCQ { - goto enddfd4c7a20fd3b84eb9dcf84b98c661fc + if v.Args[0].Op != OpADDQconst { + goto end2108c693a43c79aed10b9246c39c80aa } off2 := v.Args[0].Aux ptr := v.Args[0].Args[0] @@ -424,8 +445,8 @@ func lowerAmd64(v *Value) bool { v.AddArg(mem) return true } - goto enddfd4c7a20fd3b84eb9dcf84b98c661fc - enddfd4c7a20fd3b84eb9dcf84b98c661fc: + goto end2108c693a43c79aed10b9246c39c80aa + end2108c693a43c79aed10b9246c39c80aa: ; // match: (MOVQstore [off1] (LEAQ8 [off2] ptr idx) val mem) // cond: @@ -454,13 +475,13 @@ func lowerAmd64(v *Value) bool { endce1db8c8d37c8397c500a2068a65c215: ; case OpMOVQstoreidx8: - // match: (MOVQstoreidx8 [off1] (ADDCQ [off2] ptr) idx val mem) + // match: (MOVQstoreidx8 [off1] (ADDQconst [off2] ptr) idx val mem) // cond: // result: (MOVQstoreidx8 [addOff(off1, off2)] ptr idx val mem) { off1 := v.Aux - if v.Args[0].Op != OpADDCQ { - goto endcdb222707a568ad468f7fff2fc42fc39 + if v.Args[0].Op != OpADDQconst { + goto end01c970657b0fdefeab82458c15022163 } off2 := v.Args[0].Aux ptr := v.Args[0].Args[0] @@ -477,67 +498,89 @@ func lowerAmd64(v *Value) bool { v.AddArg(mem) return true } - goto endcdb222707a568ad468f7fff2fc42fc39 - endcdb222707a568ad468f7fff2fc42fc39: - ; - case OpMULCQ: - // match: (MULCQ [c] x) - // cond: c.(int64) == 8 - // result: (SHLCQ [int64(3)] x) - { - c := v.Aux - x := v.Args[0] - if !(c.(int64) == 8) { - goto end90a1c055d9658aecacce5e101c1848b4 - } - v.Op = OpSHLCQ - v.Aux = nil - v.resetArgs() - v.Aux = int64(3) - v.AddArg(x) - return true - } - goto end90a1c055d9658aecacce5e101c1848b4 - end90a1c055d9658aecacce5e101c1848b4: + goto end01c970657b0fdefeab82458c15022163 + end01c970657b0fdefeab82458c15022163: ; case OpMULQ: // match: (MULQ x (MOVQconst [c])) - // cond: - // result: (MULCQ [c] x) + // cond: c.(int64) == int64(int32(c.(int64))) + // result: (MULQconst [c] x) { x := v.Args[0] if v.Args[1].Op != OpMOVQconst { - goto endce35d001482ea209e62e9394bd07c7cb + goto ende8c09b194fcde7d9cdc69f2deff86304 } c := v.Args[1].Aux - v.Op = OpMULCQ + if !(c.(int64) == int64(int32(c.(int64)))) { + goto ende8c09b194fcde7d9cdc69f2deff86304 + } + v.Op = OpMULQconst v.Aux = nil v.resetArgs() v.Aux = c v.AddArg(x) return true } - goto endce35d001482ea209e62e9394bd07c7cb - endce35d001482ea209e62e9394bd07c7cb: + goto ende8c09b194fcde7d9cdc69f2deff86304 + ende8c09b194fcde7d9cdc69f2deff86304: ; // match: (MULQ (MOVQconst [c]) x) // cond: - // result: (MULCQ [c] x) + // result: (MULQconst [c] x) { if v.Args[0].Op != OpMOVQconst { - goto end804f58b1f6a7cce19d48379999ec03f1 + goto endc6e18d6968175d6e58eafa6dcf40c1b8 } c := v.Args[0].Aux x := v.Args[1] - v.Op = OpMULCQ + v.Op = OpMULQconst v.Aux = nil v.resetArgs() v.Aux = c v.AddArg(x) return true } - goto end804f58b1f6a7cce19d48379999ec03f1 - end804f58b1f6a7cce19d48379999ec03f1: + goto endc6e18d6968175d6e58eafa6dcf40c1b8 + endc6e18d6968175d6e58eafa6dcf40c1b8: + ; + case OpMULQconst: + // match: (MULQconst [c] x) + // cond: c.(int64) == 8 + // result: (SHLQconst [int64(3)] x) + { + c := v.Aux + x := v.Args[0] + if !(c.(int64) == 8) { + goto end7e16978c56138324ff2abf91fd6d94d4 + } + v.Op = OpSHLQconst + v.Aux = nil + v.resetArgs() + v.Aux = int64(3) + v.AddArg(x) + return true + } + goto end7e16978c56138324ff2abf91fd6d94d4 + end7e16978c56138324ff2abf91fd6d94d4: + ; + // match: (MULQconst [c] x) + // cond: c.(int64) == 64 + // result: (SHLQconst [int64(5)] x) + { + c := v.Aux + x := v.Args[0] + if !(c.(int64) == 64) { + goto end2c7a02f230e4b311ac3a4e22f70a4f08 + } + v.Op = OpSHLQconst + v.Aux = nil + v.resetArgs() + v.Aux = int64(5) + v.AddArg(x) + return true + } + goto end2c7a02f230e4b311ac3a4e22f70a4f08 + end2c7a02f230e4b311ac3a4e22f70a4f08: ; case OpMove: // match: (Move [size] dst src mem) @@ -587,19 +630,19 @@ func lowerAmd64(v *Value) bool { case OpOffPtr: // match: (OffPtr [off] ptr) // cond: - // result: (ADDCQ [off] ptr) + // result: (ADDQconst [off] ptr) { off := v.Aux ptr := v.Args[0] - v.Op = OpADDCQ + v.Op = OpADDQconst v.Aux = nil v.resetArgs() v.Aux = off v.AddArg(ptr) return true } - goto endfe8f713b1d237a23311fb721ee46bedb - endfe8f713b1d237a23311fb721ee46bedb: + goto end0429f947ee7ac49ff45a243e461a5290 + end0429f947ee7ac49ff45a243e461a5290: ; case OpSETL: // match: (SETL (InvertFlags x)) @@ -619,48 +662,68 @@ func lowerAmd64(v *Value) bool { goto end456c7681d48305698c1ef462d244bdc6 end456c7681d48305698c1ef462d244bdc6: ; + case OpSHLQ: + // match: (SHLQ x (MOVQconst [c])) + // cond: + // result: (SHLQconst [c] x) + { + x := v.Args[0] + if v.Args[1].Op != OpMOVQconst { + goto endcca412bead06dc3d56ef034a82d184d6 + } + c := v.Args[1].Aux + v.Op = OpSHLQconst + v.Aux = nil + v.resetArgs() + v.Aux = c + v.AddArg(x) + return true + } + goto endcca412bead06dc3d56ef034a82d184d6 + endcca412bead06dc3d56ef034a82d184d6: + ; case OpSUBQ: // match: (SUBQ x (MOVQconst [c])) // cond: - // result: (SUBCQ x [c]) + // result: (SUBQconst x [c]) { x := v.Args[0] if v.Args[1].Op != OpMOVQconst { - goto endc96cd1cb2dd98427c34fb9543feca4fe + goto end5a74a63bd9ad15437717c6df3b25eebb } c := v.Args[1].Aux - v.Op = OpSUBCQ + v.Op = OpSUBQconst v.Aux = nil v.resetArgs() v.AddArg(x) v.Aux = c return true } - goto endc96cd1cb2dd98427c34fb9543feca4fe - endc96cd1cb2dd98427c34fb9543feca4fe: + goto end5a74a63bd9ad15437717c6df3b25eebb + end5a74a63bd9ad15437717c6df3b25eebb: ; // match: (SUBQ (MOVQconst [c]) x) // cond: - // result: (NEGQ (SUBCQ x [c])) + // result: (NEGQ (SUBQconst x [c])) { t := v.Type if v.Args[0].Op != OpMOVQconst { - goto end900aaaf28cefac6bb62e76b5151611cf + goto end78e66b6fc298684ff4ac8aec5ce873c9 } c := v.Args[0].Aux x := v.Args[1] v.Op = OpNEGQ v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue(OpSUBCQ, TypeInvalid, nil) + v0 := v.Block.NewValue(OpSUBQconst, TypeInvalid, nil) v0.Type = t v0.AddArg(x) v0.Aux = c v.AddArg(v0) return true } - goto end900aaaf28cefac6bb62e76b5151611cf - end900aaaf28cefac6bb62e76b5151611cf: + goto end78e66b6fc298684ff4ac8aec5ce873c9 + end78e66b6fc298684ff4ac8aec5ce873c9: ; case OpStore: // match: (Store ptr val mem) diff --git a/src/cmd/internal/ssa/op.go b/src/cmd/internal/ssa/op.go index e0dc531fc9..f02c1ae0c0 100644 --- a/src/cmd/internal/ssa/op.go +++ b/src/cmd/internal/ssa/op.go @@ -34,6 +34,8 @@ const ( OpAdd // arg0 + arg1 OpSub // arg0 - arg1 OpMul // arg0 * arg1 + OpLsh // arg0 << arg1 + OpRsh // arg0 >> arg1 (signed/unsigned depending on signedness of type) // 2-input comparisons OpLess // arg0 < arg1 @@ -83,10 +85,6 @@ const ( OpOffPtr // arg0 + aux.(int64) (arg0 and result are pointers) - // These ops return a pointer to a location on the stack. - OpFPAddr // FP + aux.(int64) (+ == args from caller, - == locals) - OpSPAddr // SP + aux.(int64) - // 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 @@ -96,6 +94,8 @@ const ( // used during ssa construction. Like OpCopy, but the arg has not been specified yet. OpFwdRef + + OpGenericEnd ) // GlobalOffset represents a fixed offset within a global variable diff --git a/src/cmd/internal/ssa/op_string.go b/src/cmd/internal/ssa/op_string.go index 9b22f664ef..c8f27bb2e4 100644 --- a/src/cmd/internal/ssa/op_string.go +++ b/src/cmd/internal/ssa/op_string.go @@ -6,16 +6,16 @@ import "fmt" const ( _Op_name_0 = "opInvalid" - _Op_name_1 = "opGenericBaseOpAddOpSubOpMulOpLessOpConstOpArgOpGlobalOpFuncOpFPOpSPOpCopyOpMoveOpPhiOpSliceMakeOpSlicePtrOpSliceLenOpSliceCapOpStringMakeOpStringPtrOpStringLenOpLoadOpStoreOpArrayIndexOpPtrIndexOpIsNonNilOpIsInBoundsOpCallOpStaticCallOpConvertOpConvNopOpOffPtrOpFPAddrOpSPAddrOpStoreReg8OpLoadReg8OpFwdRef" - _Op_name_2 = "opAMD64BaseOpADDQOpSUBQOpADDCQOpSUBCQOpMULQOpMULCQOpSHLQOpSHLCQOpNEGQOpADDLOpCMPQOpCMPCQOpTESTQOpTESTBOpSETEQOpSETNEOpSETLOpSETGEOpSETBOpInvertFlagsOpLEAQOpLEAQ2OpLEAQ4OpLEAQ8OpLEAQglobalOpMOVBloadOpMOVBQZXloadOpMOVBQSXloadOpMOVQloadOpMOVQstoreOpMOVQloadidx8OpMOVQstoreidx8OpMOVQloadglobalOpMOVQstoreglobalOpMOVQconstOpREPMOVSB" + _Op_name_1 = "opGenericBaseOpAddOpSubOpMulOpLshOpRshOpLessOpConstOpArgOpGlobalOpFuncOpFPOpSPOpCopyOpMoveOpPhiOpSliceMakeOpSlicePtrOpSliceLenOpSliceCapOpStringMakeOpStringPtrOpStringLenOpLoadOpStoreOpArrayIndexOpPtrIndexOpIsNonNilOpIsInBoundsOpCallOpStaticCallOpConvertOpConvNopOpOffPtrOpStoreReg8OpLoadReg8OpFwdRefOpGenericEnd" + _Op_name_2 = "opAMD64BaseOpADDQOpADDQconstOpSUBQOpSUBQconstOpMULQOpMULQconstOpSHLQOpSHLQconstOpNEGQOpADDLOpCMPQOpCMPQconstOpTESTQOpTESTBOpSETEQOpSETNEOpSETLOpSETGEOpSETBOpInvertFlagsOpLEAQOpLEAQ2OpLEAQ4OpLEAQ8OpLEAQglobalOpMOVBloadOpMOVBQZXloadOpMOVBQSXloadOpMOVQloadOpMOVQstoreOpMOVQloadidx8OpMOVQstoreidx8OpMOVQloadglobalOpMOVQstoreglobalOpMOVQconstOpREPMOVSB" _Op_name_3 = "op386Base" _Op_name_4 = "opMax" ) var ( _Op_index_0 = [...]uint8{0, 9} - _Op_index_1 = [...]uint16{0, 13, 18, 23, 28, 34, 41, 46, 54, 60, 64, 68, 74, 80, 85, 96, 106, 116, 126, 138, 149, 160, 166, 173, 185, 195, 205, 217, 223, 235, 244, 253, 261, 269, 277, 288, 298, 306} - _Op_index_2 = [...]uint16{0, 11, 17, 23, 30, 37, 43, 50, 56, 63, 69, 75, 81, 88, 95, 102, 109, 116, 122, 129, 135, 148, 154, 161, 168, 175, 187, 197, 210, 223, 233, 244, 258, 273, 289, 306, 317, 327} + _Op_index_1 = [...]uint16{0, 13, 18, 23, 28, 33, 38, 44, 51, 56, 64, 70, 74, 78, 84, 90, 95, 106, 116, 126, 136, 148, 159, 170, 176, 183, 195, 205, 215, 227, 233, 245, 254, 263, 271, 282, 292, 300, 312} + _Op_index_2 = [...]uint16{0, 11, 17, 28, 34, 45, 51, 62, 68, 79, 85, 91, 97, 108, 115, 122, 129, 136, 142, 149, 155, 168, 174, 181, 188, 195, 207, 217, 230, 243, 253, 264, 278, 293, 309, 326, 337, 347} _Op_index_3 = [...]uint8{0, 9} _Op_index_4 = [...]uint8{0, 5} ) @@ -24,7 +24,7 @@ func (i Op) String() string { switch { case i == 0: return _Op_name_0 - case 1001 <= i && i <= 1037: + case 1001 <= i && i <= 1038: i -= 1001 return _Op_name_1[_Op_index_1[i]:_Op_index_1[i+1]] case 2001 <= i && i <= 2037: diff --git a/src/cmd/internal/ssa/opamd64.go b/src/cmd/internal/ssa/opamd64.go index 46f0a69dfb..46a0069a18 100644 --- a/src/cmd/internal/ssa/opamd64.go +++ b/src/cmd/internal/ssa/opamd64.go @@ -13,24 +13,24 @@ const ( // Q = 64 bit, L = 32 bit, W = 16 bit, B = 8 bit // arithmetic - OpADDQ // arg0 + arg1 - OpSUBQ // arg0 - arg1 - OpADDCQ // arg + aux.(int64) - OpSUBCQ // arg - aux.(int64) - OpMULQ // arg0 * arg1 - OpMULCQ // arg * aux.(int64) - OpSHLQ // arg0 << arg1 - OpSHLCQ // arg << aux.(int64) - OpNEGQ // -arg - OpADDL // arg0 + arg1 + OpADDQ // arg0 + arg1 + OpADDQconst // arg + aux.(int64) + OpSUBQ // arg0 - arg1 + OpSUBQconst // arg - aux.(int64) + OpMULQ // arg0 * arg1 + OpMULQconst // arg * aux.(int64) + OpSHLQ // arg0 << arg1 + OpSHLQconst // arg << aux.(int64) + OpNEGQ // -arg + OpADDL // arg0 + arg1 // Flags value generation. // We pretend the flags type is an opaque thing that comparisons generate // and from which we can extract boolean conditions like <, ==, etc. - OpCMPQ // arg0 compare to arg1 - OpCMPCQ // arg0 compare to aux.(int64) - OpTESTQ // (arg0 & arg1) compare to 0 - OpTESTB // (arg0 & arg1) compare to 0 + OpCMPQ // arg0 compare to arg1 + OpCMPQconst // arg0 compare to aux.(int64) + OpTESTQ // (arg0 & arg1) compare to 0 + OpTESTB // (arg0 & arg1) compare to 0 // These opcodes extract a particular boolean condition from a flags value. OpSETEQ // extract == condition from arg0 @@ -96,7 +96,8 @@ var regsAMD64 = [...]string{ "OVERWRITE0", // the same register as the first input } -var gp regMask = 0x1ffff // all integer registers (including SP&FP) +var gp regMask = 0x1ffff // all integer registers including SP&FP +var gpout regMask = 0xffef // integer registers not including SP&FP var cx regMask = 1 << 1 var si regMask = 1 << 6 var di regMask = 1 << 7 @@ -104,37 +105,37 @@ var flags regMask = 1 << 17 var ( // gp = general purpose (integer) registers - gp21 = [2][]regMask{{gp, gp}, {gp}} // 2 input, 1 output - gp11 = [2][]regMask{{gp}, {gp}} // 1 input, 1 output - gp01 = [2][]regMask{{}, {gp}} // 0 input, 1 output - shift = [2][]regMask{{gp, cx}, {gp}} // shift operations + gp21 = [2][]regMask{{gp, gp}, {gpout}} // 2 input, 1 output + gp11 = [2][]regMask{{gp}, {gpout}} // 1 input, 1 output + gp01 = [2][]regMask{{}, {gpout}} // 0 input, 1 output + shift = [2][]regMask{{gp, cx}, {gpout}} // shift operations gp2_flags = [2][]regMask{{gp, gp}, {flags}} // generate flags from 2 gp regs gp1_flags = [2][]regMask{{gp}, {flags}} // generate flags from 1 gp reg - gpload = [2][]regMask{{gp, 0}, {gp}} - gploadidx = [2][]regMask{{gp, gp, 0}, {gp}} + gpload = [2][]regMask{{gp, 0}, {gpout}} + gploadidx = [2][]regMask{{gp, gp, 0}, {gpout}} gpstore = [2][]regMask{{gp, gp, 0}, {0}} gpstoreidx = [2][]regMask{{gp, gp, gp, 0}, {0}} - gpload_stack = [2][]regMask{{0}, {gp}} + gpload_stack = [2][]regMask{{0}, {gpout}} gpstore_stack = [2][]regMask{{gp, 0}, {0}} ) // Opcodes that appear in an output amd64 program var amd64Table = map[Op]opInfo{ - OpADDQ: {flags: OpFlagCommutative, asm: "ADDQ\t%I0,%I1,%O0", reg: gp21}, // TODO: overwrite - OpADDCQ: {asm: "ADDQ\t$%A,%I0,%O0", reg: gp11}, // aux = int64 constant to add - OpSUBQ: {asm: "SUBQ\t%I0,%I1,%O0", reg: gp21}, - OpSUBCQ: {asm: "SUBQ\t$%A,%I0,%O0", reg: gp11}, - OpMULQ: {asm: "MULQ\t%I0,%I1,%O0", reg: gp21}, - OpMULCQ: {asm: "MULQ\t$%A,%I0,%O0", reg: gp11}, - OpSHLQ: {asm: "SHLQ\t%I0,%I1,%O0", reg: gp21}, - OpSHLCQ: {asm: "SHLQ\t$%A,%I0,%O0", reg: gp11}, - - OpCMPQ: {asm: "CMPQ\t%I0,%I1", reg: gp2_flags}, // compute arg[0]-arg[1] and produce flags - OpCMPCQ: {asm: "CMPQ\t$%A,%I0", reg: gp1_flags}, - OpTESTQ: {asm: "TESTQ\t%I0,%I1", reg: gp2_flags}, - OpTESTB: {asm: "TESTB\t%I0,%I1", reg: gp2_flags}, + OpADDQ: {flags: OpFlagCommutative, asm: "ADDQ\t%I0,%I1,%O0", reg: gp21}, // TODO: overwrite + OpADDQconst: {asm: "ADDQ\t$%A,%I0,%O0", reg: gp11}, // aux = int64 constant to add + OpSUBQ: {asm: "SUBQ\t%I0,%I1,%O0", reg: gp21}, + OpSUBQconst: {asm: "SUBQ\t$%A,%I0,%O0", reg: gp11}, + OpMULQ: {asm: "MULQ\t%I0,%I1,%O0", reg: gp21}, + OpMULQconst: {asm: "IMULQ\t$%A,%I0,%O0", reg: gp11}, + OpSHLQ: {asm: "SHLQ\t%I0,%I1,%O0", reg: gp21}, + OpSHLQconst: {asm: "SHLQ\t$%A,%I0,%O0", reg: gp11}, + + OpCMPQ: {asm: "CMPQ\t%I0,%I1", reg: gp2_flags}, // compute arg[0]-arg[1] and produce flags + OpCMPQconst: {asm: "CMPQ\t$%A,%I0", reg: gp1_flags}, + OpTESTQ: {asm: "TESTQ\t%I0,%I1", reg: gp2_flags}, + OpTESTB: {asm: "TESTB\t%I0,%I1", reg: gp2_flags}, OpLEAQ: {flags: OpFlagCommutative, asm: "LEAQ\t%A(%I0)(%I1*1),%O0", reg: gp21}, // aux = int64 constant to add OpLEAQ2: {asm: "LEAQ\t%A(%I0)(%I1*2),%O0"}, diff --git a/src/cmd/internal/ssa/rewrite.go b/src/cmd/internal/ssa/rewrite.go index 75e910d690..671270d7f2 100644 --- a/src/cmd/internal/ssa/rewrite.go +++ b/src/cmd/internal/ssa/rewrite.go @@ -68,8 +68,9 @@ func typeSize(t Type) int64 { // addOff adds two offset aux values. Each should be an int64. Fails if wraparound happens. func addOff(a, b interface{}) interface{} { - x := a.(int64) - y := b.(int64) + return addOffset(a.(int64), b.(int64)) +} +func addOffset(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 { diff --git a/src/cmd/internal/ssa/rulegen/lower_amd64.rules b/src/cmd/internal/ssa/rulegen/lower_amd64.rules index 0fed21e740..dc910b70b1 100644 --- a/src/cmd/internal/ssa/rulegen/lower_amd64.rules +++ b/src/cmd/internal/ssa/rulegen/lower_amd64.rules @@ -27,7 +27,7 @@ (Sub x y) && is64BitInt(t) -> (SUBQ x y) (Mul x y) && is64BitInt(t) -> (MULQ x y) - +(Lsh x y) && is64BitInt(t) -> (SHLQ x y) // TODO: check y>63 (Less x y) && is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type) -> (SETL (CMPQ x y)) (Load ptr mem) && t.IsBoolean() -> (MOVBload [int64(0)] ptr mem) @@ -40,7 +40,7 @@ (Move [size] dst src mem) -> (REPMOVSB dst src (Const [size.(int64)]) mem) -(OffPtr [off] ptr) -> (ADDCQ [off] ptr) +(OffPtr [off] ptr) -> (ADDQconst [off] ptr) (Const [val]) && is64BitInt(t) -> (MOVQconst [val]) @@ -51,39 +51,41 @@ (Global [sym]) -> (LEAQglobal [GlobalOffset{sym,0}]) // fold constants into instructions -(ADDQ x (MOVQconst [c])) -> (ADDCQ [c] x) // TODO: restrict c to int32 range? -(ADDQ (MOVQconst [c]) x) -> (ADDCQ [c] x) -(SUBQ x (MOVQconst [c])) -> (SUBCQ x [c]) -(SUBQ (MOVQconst [c]) x) -> (NEGQ (SUBCQ x [c])) -(MULQ x (MOVQconst [c])) -> (MULCQ [c] x) -(MULQ (MOVQconst [c]) x) -> (MULCQ [c] x) -(CMPQ x (MOVQconst [c])) -> (CMPCQ x [c]) -(CMPQ (MOVQconst [c]) x) -> (InvertFlags (CMPCQ x [c])) +(ADDQ x (MOVQconst [c])) -> (ADDQconst [c] x) // TODO: restrict c to int32 range? +(ADDQ (MOVQconst [c]) x) -> (ADDQconst [c] x) +(SUBQ x (MOVQconst [c])) -> (SUBQconst x [c]) +(SUBQ (MOVQconst [c]) x) -> (NEGQ (SUBQconst x [c])) +(MULQ x (MOVQconst [c])) && c.(int64) == int64(int32(c.(int64))) -> (MULQconst [c] x) +(MULQ (MOVQconst [c]) x) -> (MULQconst [c] x) +(SHLQ x (MOVQconst [c])) -> (SHLQconst [c] x) +(CMPQ x (MOVQconst [c])) -> (CMPQconst x [c]) +(CMPQ (MOVQconst [c]) x) -> (InvertFlags (CMPQconst x [c])) // strength reduction // TODO: do this a lot more generically -(MULCQ [c] x) && c.(int64) == 8 -> (SHLCQ [int64(3)] x) +(MULQconst [c] x) && c.(int64) == 8 -> (SHLQconst [int64(3)] x) +(MULQconst [c] x) && c.(int64) == 64 -> (SHLQconst [int64(5)] x) // fold add/shift into leaq -(ADDQ x (SHLCQ [shift] y)) && shift.(int64) == 3 -> (LEAQ8 [int64(0)] x y) -(ADDCQ [c] (LEAQ8 [d] x y)) -> (LEAQ8 [addOff(c, d)] x y) +(ADDQ x (SHLQconst [shift] y)) && shift.(int64) == 3 -> (LEAQ8 [int64(0)] x y) +(ADDQconst [c] (LEAQ8 [d] x y)) -> (LEAQ8 [addOff(c, d)] x y) // reverse ordering of compare instruction (SETL (InvertFlags x)) -> (SETGE x) // fold constants into memory operations // Note that this is not always a good idea because if not all the uses of -// the ADDCQ get eliminated, we still have to compute the ADDCQ and we now -// have potentially two live values (ptr and (ADDCQ [off] ptr)) instead of one. +// 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] (ADDCQ [off2] ptr) mem) -> (MOVQload [addOff(off1, off2)] ptr mem) -(MOVQstore [off1] (ADDCQ [off2] ptr) val mem) -> (MOVQstore [addOff(off1, off2)] ptr val mem) +(MOVQload [off1] (ADDQconst [off2] ptr) mem) -> (MOVQload [addOff(off1, off2)] ptr mem) +(MOVQstore [off1] (ADDQconst [off2] ptr) val mem) -> (MOVQstore [addOff(off1, off2)] ptr val mem) // indexed loads and stores (MOVQload [off1] (LEAQ8 [off2] ptr idx) mem) -> (MOVQloadidx8 [addOff(off1, off2)] ptr idx mem) (MOVQstore [off1] (LEAQ8 [off2] ptr idx) val mem) -> (MOVQstoreidx8 [addOff(off1, off2)] ptr idx val mem) -(MOVQloadidx8 [off1] (ADDCQ [off2] ptr) idx mem) -> (MOVQloadidx8 [addOff(off1, off2)] ptr idx mem) -(MOVQstoreidx8 [off1] (ADDCQ [off2] ptr) idx val mem) -> (MOVQstoreidx8 [addOff(off1, off2)] ptr idx val mem) +(MOVQloadidx8 [off1] (ADDQconst [off2] ptr) idx mem) -> (MOVQloadidx8 [addOff(off1, off2)] ptr idx mem) +(MOVQstoreidx8 [off1] (ADDQconst [off2] ptr) idx val mem) -> (MOVQstoreidx8 [addOff(off1, off2)] ptr idx val mem) -(ADDCQ [off] x) && off.(int64) == 0 -> (Copy x) +(ADDQconst [off] x) && off.(int64) == 0 -> (Copy x) diff --git a/src/cmd/internal/ssa/stackalloc.go b/src/cmd/internal/ssa/stackalloc.go index 8a315e1045..ab686470be 100644 --- a/src/cmd/internal/ssa/stackalloc.go +++ b/src/cmd/internal/ssa/stackalloc.go @@ -1,11 +1,22 @@ package ssa +import "log" + // stackalloc allocates storage in the stack frame for // all Values that did not get a register. func stackalloc(f *Func) { home := f.RegAlloc - var n int64 = 8 // 8 = space for return address. TODO: arch-dependent + // First compute the size of the outargs section. + n := int64(16) //TODO: compute max of all callsites + + // Include one slot for deferreturn. + if false && n < f.Config.ptrSize { //TODO: check for deferreturn + n = f.Config.ptrSize + } + + // TODO: group variables by ptr/nonptr, size, etc. Emit ptr vars last + // so stackmap is smaller. // Assign stack locations to phis first, because we // must also assign the same locations to the phi copies @@ -52,10 +63,49 @@ func stackalloc(f *Func) { home = setloc(home, v, loc) } } + + // TODO: align n + n += f.Config.ptrSize // space for return address. TODO: arch-dependent f.RegAlloc = home + f.FrameSize = n // TODO: share stack slots among noninterfering (& gc type compatible) values - // TODO: align final n - // TODO: compute total frame size: n + max paramout space - // TODO: save total size somewhere + + // adjust all uses of FP to SP now that we have the frame size. + var fp *Value + for _, b := range f.Blocks { + for _, v := range b.Values { + if v.Op == OpFP { + if fp != nil { + log.Panicf("multiple FP ops: %s %s", fp, v) + } + fp = v + } + for i, a := range v.Args { + if a.Op != OpFP { + continue + } + // TODO: do this with arch-specific rewrite rules somehow? + switch v.Op { + case OpADDQ: + // (ADDQ (FP) x) -> (LEAQ [n] (SP) x) + v.Op = OpLEAQ + v.Aux = n + case OpLEAQ, OpMOVQload, OpMOVQstore, OpMOVBload, OpMOVQloadidx8: + if v.Op == OpMOVQloadidx8 && i == 1 { + // Note: we could do it, but it is probably an error + log.Panicf("can't do FP->SP adjust on index slot of load %s", v.Op) + } + // eg: (MOVQload [c] (FP) mem) -> (MOVQload [c+n] (SP) mem) + v.Aux = addOffset(v.Aux.(int64), n) + default: + log.Panicf("can't do FP->SP adjust on %s", v.Op) + } + } + } + } + if fp != nil { + fp.Op = OpSP + home[fp.ID] = ®isters[4] // TODO: arch-dependent + } } -- cgit v1.3 From 7bdecbf840978e618665c284d273f81ce639a293 Mon Sep 17 00:00:00 2001 From: Michael Matloob Date: Fri, 29 May 2015 13:47:38 -0400 Subject: [dev.ssa] cmd/compile/internal/ssa: remove cgen pass Code generation is now done in genssa. Also remove the asm field in opInfo. It's no longer used. Change-Id: I65fffac267e138fd424b2ef8aa7ed79f0ebb63d5 Reviewed-on: https://go-review.googlesource.com/10539 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/TODO | 1 - src/cmd/compile/internal/ssa/cgen.go | 135 -------------------------------- src/cmd/compile/internal/ssa/compile.go | 3 - src/cmd/compile/internal/ssa/op.go | 6 -- src/cmd/compile/internal/ssa/opamd64.go | 62 +++++++-------- 5 files changed, 31 insertions(+), 176 deletions(-) delete mode 100644 src/cmd/compile/internal/ssa/cgen.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/TODO b/src/cmd/compile/internal/ssa/TODO index afb723ae4c..e3ffdd2692 100644 --- a/src/cmd/compile/internal/ssa/TODO +++ b/src/cmd/compile/internal/ssa/TODO @@ -25,7 +25,6 @@ Values Opcodes - Rename ops to prevent cross-arch conflicts. MOVQ -> MOVQamd64 (or MOVQ6?). Other option: build opcode table in Config instead of globally. - - Remove asm string from opinfo, no longer needed. - It's annoying to list the opcode both in the opcode list and an opInfo map entry. Specify it one place and use go:generate to produce both? diff --git a/src/cmd/compile/internal/ssa/cgen.go b/src/cmd/compile/internal/ssa/cgen.go deleted file mode 100644 index 51c72aacd9..0000000000 --- a/src/cmd/compile/internal/ssa/cgen.go +++ /dev/null @@ -1,135 +0,0 @@ -// 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" - "os" -) - -// cgen selects machine instructions for the function. -// This pass generates assembly output for now, but should -// TODO(khr): generate binary output (via liblink?) instead of text. -func cgen(f *Func) { - fmt.Printf("TEXT %s(SB),0,$0\n", f.Name) // TODO: frame size / arg size - - // TODO: prolog, allocate stack frame - - for idx, b := range f.Blocks { - fmt.Printf("%d:\n", b.ID) - for _, v := range b.Values { - var buf bytes.Buffer - asm := opcodeTable[v.Op].asm - buf.WriteString(" ") - for i := 0; i < len(asm); i++ { - switch asm[i] { - default: - buf.WriteByte(asm[i]) - case '\t': - buf.WriteByte(' ') - for buf.Len()%8 != 0 { - buf.WriteByte(' ') - } - case '%': - i++ - switch asm[i] { - case '%': - buf.WriteByte('%') - case 'I': - i++ - n := asm[i] - '0' - if f.RegAlloc[v.Args[n].ID] != nil { - buf.WriteString(f.RegAlloc[v.Args[n].ID].Name()) - } else { - fmt.Fprintf(&buf, "v%d", v.Args[n].ID) - } - case 'O': - i++ - n := asm[i] - '0' - if n != 0 { - panic("can only handle 1 output for now") - } - if f.RegAlloc[v.ID] != nil { - buf.WriteString(f.RegAlloc[v.ID].Name()) - } else { - fmt.Fprintf(&buf, "v%d", v.ID) - } - case 'A': - fmt.Fprint(&buf, v.Aux) - } - } - } - for buf.Len() < 40 { - buf.WriteByte(' ') - } - buf.WriteString("; ") - buf.WriteString(v.LongString()) - buf.WriteByte('\n') - os.Stdout.Write(buf.Bytes()) - } - // find next block in layout sequence - var next *Block - if idx < len(f.Blocks)-1 { - next = f.Blocks[idx+1] - } - // emit end of block code - // TODO: this is machine specific - switch b.Kind { - case BlockPlain: - if b.Succs[0] != next { - fmt.Printf("\tJMP\t%d\n", b.Succs[0].ID) - } - case BlockExit: - // TODO: run defers (if any) - // TODO: deallocate frame - fmt.Println("\tRET") - case BlockCall: - // nothing to emit - call instruction already happened - case BlockEQ: - if b.Succs[0] == next { - fmt.Printf("\tJNE\t%d\n", b.Succs[1].ID) - } else if b.Succs[1] == next { - fmt.Printf("\tJEQ\t%d\n", b.Succs[0].ID) - } else { - fmt.Printf("\tJEQ\t%d\n", b.Succs[0].ID) - fmt.Printf("\tJMP\t%d\n", b.Succs[1].ID) - } - case BlockNE: - if b.Succs[0] == next { - fmt.Printf("\tJEQ\t%d\n", b.Succs[1].ID) - } else if b.Succs[1] == next { - fmt.Printf("\tJNE\t%d\n", b.Succs[0].ID) - } else { - fmt.Printf("\tJNE\t%d\n", b.Succs[0].ID) - fmt.Printf("\tJMP\t%d\n", b.Succs[1].ID) - } - case BlockLT: - if b.Succs[0] == next { - fmt.Printf("\tJGE\t%d\n", b.Succs[1].ID) - } else if b.Succs[1] == next { - fmt.Printf("\tJLT\t%d\n", b.Succs[0].ID) - } else { - fmt.Printf("\tJLT\t%d\n", b.Succs[0].ID) - fmt.Printf("\tJMP\t%d\n", b.Succs[1].ID) - } - case BlockULT: - if b.Succs[0] == next { - fmt.Printf("\tJAE\t%d\n", b.Succs[1].ID) - } else if b.Succs[1] == next { - fmt.Printf("\tJB\t%d\n", b.Succs[0].ID) - } else { - fmt.Printf("\tJB\t%d\n", b.Succs[0].ID) - fmt.Printf("\tJMP\t%d\n", b.Succs[1].ID) - } - default: - fmt.Printf("\t%s ->", b.Kind.String()) - for _, s := range b.Succs { - fmt.Printf(" %d", s.ID) - } - fmt.Printf("\n") - } - } -} diff --git a/src/cmd/compile/internal/ssa/compile.go b/src/cmd/compile/internal/ssa/compile.go index c1f7956791..b497beade9 100644 --- a/src/cmd/compile/internal/ssa/compile.go +++ b/src/cmd/compile/internal/ssa/compile.go @@ -65,7 +65,6 @@ var passes = [...]pass{ {"schedule", schedule}, // schedule values {"regalloc", regalloc}, {"stackalloc", stackalloc}, - {"cgen", cgen}, } // Double-check phase ordering constraints. @@ -85,8 +84,6 @@ var passOrder = [...]constraint{ {"schedule", "regalloc"}, // stack allocation requires register allocation {"regalloc", "stackalloc"}, - // code generation requires stack allocation - {"stackalloc", "cgen"}, } func init() { diff --git a/src/cmd/compile/internal/ssa/op.go b/src/cmd/compile/internal/ssa/op.go index f02c1ae0c0..75c655758d 100644 --- a/src/cmd/compile/internal/ssa/op.go +++ b/src/cmd/compile/internal/ssa/op.go @@ -118,12 +118,6 @@ func (g GlobalOffset) String() string { type opInfo struct { flags int32 - // assembly template - // %In: location of input n - // %On: location of output n - // %A: print aux with fmt.Print - asm string - // returns a reg constraint for the instruction. [0] gives a reg constraint // for each input, [1] gives a reg constraint for each output. (Values have // exactly one output for now) diff --git a/src/cmd/compile/internal/ssa/opamd64.go b/src/cmd/compile/internal/ssa/opamd64.go index 46a0069a18..517090992a 100644 --- a/src/cmd/compile/internal/ssa/opamd64.go +++ b/src/cmd/compile/internal/ssa/opamd64.go @@ -123,39 +123,39 @@ var ( // Opcodes that appear in an output amd64 program var amd64Table = map[Op]opInfo{ - OpADDQ: {flags: OpFlagCommutative, asm: "ADDQ\t%I0,%I1,%O0", reg: gp21}, // TODO: overwrite - OpADDQconst: {asm: "ADDQ\t$%A,%I0,%O0", reg: gp11}, // aux = int64 constant to add - OpSUBQ: {asm: "SUBQ\t%I0,%I1,%O0", reg: gp21}, - OpSUBQconst: {asm: "SUBQ\t$%A,%I0,%O0", reg: gp11}, - OpMULQ: {asm: "MULQ\t%I0,%I1,%O0", reg: gp21}, - OpMULQconst: {asm: "IMULQ\t$%A,%I0,%O0", reg: gp11}, - OpSHLQ: {asm: "SHLQ\t%I0,%I1,%O0", reg: gp21}, - OpSHLQconst: {asm: "SHLQ\t$%A,%I0,%O0", reg: gp11}, - - OpCMPQ: {asm: "CMPQ\t%I0,%I1", reg: gp2_flags}, // compute arg[0]-arg[1] and produce flags - OpCMPQconst: {asm: "CMPQ\t$%A,%I0", reg: gp1_flags}, - OpTESTQ: {asm: "TESTQ\t%I0,%I1", reg: gp2_flags}, - OpTESTB: {asm: "TESTB\t%I0,%I1", reg: gp2_flags}, - - OpLEAQ: {flags: OpFlagCommutative, asm: "LEAQ\t%A(%I0)(%I1*1),%O0", reg: gp21}, // aux = int64 constant to add - OpLEAQ2: {asm: "LEAQ\t%A(%I0)(%I1*2),%O0"}, - OpLEAQ4: {asm: "LEAQ\t%A(%I0)(%I1*4),%O0"}, - OpLEAQ8: {asm: "LEAQ\t%A(%I0)(%I1*8),%O0"}, - OpLEAQglobal: {asm: "LEAQ\t%A(SB),%O0", reg: gp01}, + OpADDQ: {flags: OpFlagCommutative, reg: gp21}, // TODO: overwrite + OpADDQconst: {reg: gp11}, // aux = int64 constant to add + OpSUBQ: {reg: gp21}, + OpSUBQconst: {reg: gp11}, + OpMULQ: {reg: gp21}, + OpMULQconst: {reg: gp11}, + OpSHLQ: {reg: gp21}, + OpSHLQconst: {reg: gp11}, + + OpCMPQ: {reg: gp2_flags}, // compute arg[0]-arg[1] and produce flags + OpCMPQconst: {reg: gp1_flags}, + OpTESTQ: {reg: gp2_flags}, + OpTESTB: {reg: gp2_flags}, + + OpLEAQ: {flags: OpFlagCommutative, reg: gp21}, // aux = int64 constant to add + OpLEAQ2: {}, + OpLEAQ4: {}, + OpLEAQ8: {}, + OpLEAQglobal: {reg: gp01}, // loads and stores - OpMOVBload: {asm: "MOVB\t%A(%I0),%O0", reg: gpload}, - OpMOVQload: {asm: "MOVQ\t%A(%I0),%O0", reg: gpload}, - OpMOVQstore: {asm: "MOVQ\t%I1,%A(%I0)", reg: gpstore}, - OpMOVQloadidx8: {asm: "MOVQ\t%A(%I0)(%I1*8),%O0", reg: gploadidx}, - OpMOVQstoreidx8: {asm: "MOVQ\t%I2,%A(%I0)(%I1*8)", reg: gpstoreidx}, + OpMOVBload: {reg: gpload}, + OpMOVQload: {reg: gpload}, + OpMOVQstore: {reg: gpstore}, + OpMOVQloadidx8: {reg: gploadidx}, + OpMOVQstoreidx8: {reg: gpstoreidx}, - OpMOVQconst: {asm: "MOVQ\t$%A,%O0", reg: gp01}, + OpMOVQconst: {reg: gp01}, - OpStaticCall: {asm: "CALL\t%A(SB)"}, + OpStaticCall: {}, - OpCopy: {asm: "MOVQ\t%I0,%O0", reg: gp11}, // TODO: make arch-specific - OpConvNop: {asm: "MOVQ\t%I0,%O0", reg: gp11}, // TODO: make arch-specific. Or get rid of this altogether. + OpCopy: {reg: gp11}, // TODO: make arch-specific + OpConvNop: {reg: gp11}, // TODO: make arch-specific. Or get rid of this altogether. // convert from flags back to boolean OpSETL: {}, @@ -164,10 +164,10 @@ var amd64Table = map[Op]opInfo{ // unlike regular loads & stores, these take no memory argument. // They are just like OpCopy but we use them during register allocation. // TODO: different widths, float - OpLoadReg8: {asm: "MOVQ\t%I0,%O0"}, - OpStoreReg8: {asm: "MOVQ\t%I0,%O0"}, + OpLoadReg8: {}, + OpStoreReg8: {}, - OpREPMOVSB: {asm: "REP MOVSB", reg: [2][]regMask{{di, si, cx, 0}, {0}}}, // TODO: record that si/di/cx are clobbered + OpREPMOVSB: {reg: [2][]regMask{{di, si, cx, 0}, {0}}}, // TODO: record that si/di/cx are clobbered } func init() { -- cgit v1.3 From b0da62903d045f6d3e832ba1181387a1e9ad33f1 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Fri, 29 May 2015 16:20:33 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: Add code to test generated opcode counts Add test handler to count and check generated opcodes. This will be useful for testing that certain optimizations don't regress. Also pass a *Config to the Fun constructor so that compile() works. Change-Id: Iee679e87cf0bc635ddcbe433fc1bd4c1d9c953cc Reviewed-on: https://go-review.googlesource.com/10502 Reviewed-by: Michael Matloob Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/deadcode_test.go | 9 +++-- src/cmd/compile/internal/ssa/func_test.go | 54 ++++++++++++++++++++------- 2 files changed, 46 insertions(+), 17 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/deadcode_test.go b/src/cmd/compile/internal/ssa/deadcode_test.go index ced46e524b..f3d5682355 100644 --- a/src/cmd/compile/internal/ssa/deadcode_test.go +++ b/src/cmd/compile/internal/ssa/deadcode_test.go @@ -9,7 +9,8 @@ import ( ) func TestDeadLoop(t *testing.T) { - fun := Fun("entry", + c := NewConfig("amd64") + fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, ".mem"), Goto("exit")), @@ -38,7 +39,8 @@ func TestDeadLoop(t *testing.T) { } func TestDeadValue(t *testing.T) { - fun := Fun("entry", + c := NewConfig("amd64") + fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, ".mem"), Valu("deadval", OpConst, TypeInt64, int64(37)), @@ -60,7 +62,8 @@ func TestDeadValue(t *testing.T) { } func TestNeverTaken(t *testing.T) { - fun := Fun("entry", + c := NewConfig("amd64") + fun := Fun(c, "entry", Bloc("entry", Valu("cond", OpConst, TypeBool, false), Valu("mem", OpArg, TypeMem, ".mem"), diff --git a/src/cmd/compile/internal/ssa/func_test.go b/src/cmd/compile/internal/ssa/func_test.go index e7619ca4f8..4839c1ee63 100644 --- a/src/cmd/compile/internal/ssa/func_test.go +++ b/src/cmd/compile/internal/ssa/func_test.go @@ -134,8 +134,9 @@ type fun struct { // 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(entry string, blocs ...bloc) fun { +func Fun(c *Config, entry string, blocs ...bloc) fun { f := new(Func) + f.Config = c blocks := make(map[string]*Block) values := make(map[string]*Value) // Create all the blocks and values. @@ -256,7 +257,8 @@ func addEdge(b, c *Block) { } func TestArgs(t *testing.T) { - fun := Fun("entry", + c := NewConfig("amd64") + fun := Fun(c, "entry", Bloc("entry", Valu("a", OpConst, TypeInt64, 14), Valu("b", OpConst, TypeInt64, 26), @@ -275,10 +277,11 @@ func TestArgs(t *testing.T) { } func TestEquiv(t *testing.T) { + c := NewConfig("amd64") equivalentCases := []struct{ f, g fun }{ // simple case { - Fun("entry", + Fun(c, "entry", Bloc("entry", Valu("a", OpConst, TypeInt64, 14), Valu("b", OpConst, TypeInt64, 26), @@ -287,7 +290,7 @@ func TestEquiv(t *testing.T) { Goto("exit")), Bloc("exit", Exit("mem"))), - Fun("entry", + Fun(c, "entry", Bloc("entry", Valu("a", OpConst, TypeInt64, 14), Valu("b", OpConst, TypeInt64, 26), @@ -299,7 +302,7 @@ func TestEquiv(t *testing.T) { }, // block order changed { - Fun("entry", + Fun(c, "entry", Bloc("entry", Valu("a", OpConst, TypeInt64, 14), Valu("b", OpConst, TypeInt64, 26), @@ -308,7 +311,7 @@ func TestEquiv(t *testing.T) { Goto("exit")), Bloc("exit", Exit("mem"))), - Fun("entry", + Fun(c, "entry", Bloc("exit", Exit("mem")), Bloc("entry", @@ -332,26 +335,26 @@ func TestEquiv(t *testing.T) { differentCases := []struct{ f, g fun }{ // different shape { - Fun("entry", + Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, ".mem"), Goto("exit")), Bloc("exit", Exit("mem"))), - Fun("entry", + Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, ".mem"), Exit("mem"))), }, // value order changed { - Fun("entry", + Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, ".mem"), Valu("b", OpConst, TypeInt64, 26), Valu("a", OpConst, TypeInt64, 14), Exit("mem"))), - Fun("entry", + Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, ".mem"), Valu("a", OpConst, TypeInt64, 14), @@ -360,12 +363,12 @@ func TestEquiv(t *testing.T) { }, // value aux different { - Fun("entry", + Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, ".mem"), Valu("a", OpConst, TypeInt64, 14), Exit("mem"))), - Fun("entry", + Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, ".mem"), Valu("a", OpConst, TypeInt64, 26), @@ -373,14 +376,14 @@ func TestEquiv(t *testing.T) { }, // value args different { - Fun("entry", + Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, ".mem"), Valu("a", OpConst, TypeInt64, 14), Valu("b", OpConst, TypeInt64, 26), Valu("sum", OpAdd, TypeInt64, nil, "a", "b"), Exit("mem"))), - Fun("entry", + Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, ".mem"), Valu("a", OpConst, TypeInt64, 0), @@ -399,3 +402,26 @@ func TestEquiv(t *testing.T) { } } } + +// 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) + } + } +} -- cgit v1.3 From a9cec30fdcc549282e0a5d520edb2eaf60f3061a Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Thu, 28 May 2015 16:45:33 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: Implement block rewriting rules Change-Id: I47e5349e34fc18118c4d35bf433f875b958cc3e5 Reviewed-on: https://go-review.googlesource.com/10495 Reviewed-by: Alan Donovan --- src/cmd/compile/internal/ssa/TODO | 9 + src/cmd/compile/internal/ssa/block.go | 36 +-- src/cmd/compile/internal/ssa/blockkind_string.go | 24 +- src/cmd/compile/internal/ssa/config.go | 15 +- src/cmd/compile/internal/ssa/deadcode.go | 24 +- src/cmd/compile/internal/ssa/deadcode_test.go | 5 +- src/cmd/compile/internal/ssa/export_test.go | 1 + src/cmd/compile/internal/ssa/fuse.go | 2 +- src/cmd/compile/internal/ssa/generic.go | 57 +++- src/cmd/compile/internal/ssa/lower.go | 92 +----- src/cmd/compile/internal/ssa/lowerAmd64.go | 331 ++++++++++++++++++++- src/cmd/compile/internal/ssa/op.go | 2 +- src/cmd/compile/internal/ssa/op_string.go | 18 +- src/cmd/compile/internal/ssa/opamd64.go | 23 +- src/cmd/compile/internal/ssa/opt.go | 4 +- src/cmd/compile/internal/ssa/rewrite.go | 20 +- src/cmd/compile/internal/ssa/rulegen/generic.rules | 19 ++ .../compile/internal/ssa/rulegen/lower_amd64.rules | 31 +- src/cmd/compile/internal/ssa/rulegen/rulegen.go | 151 ++++++++-- 19 files changed, 658 insertions(+), 206 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/TODO b/src/cmd/compile/internal/ssa/TODO index e3ffdd2692..2ffba17612 100644 --- a/src/cmd/compile/internal/ssa/TODO +++ b/src/cmd/compile/internal/ssa/TODO @@ -34,13 +34,22 @@ Regalloc - Don't spill everything at every basic block boundary. - Allow args and return values to be ssa-able. - Handle 2-address instructions. + - Floating point registers Rewrites - Strength reduction (both arch-indep and arch-dependent?) - Code sequence for shifts >= wordsize - Start another architecture (arm?) + - 64-bit ops on 32-bit machines + - (MOVLstore x m) + to get rid of most of the MOVLQSX. Common-Subexpression Elimination - Make better decision about which value in an equivalence class we should choose to replace other values in that class. - Can we move control values out of their basic block? + +Other + - Make go:generate less painful. Have a subpackage that just has the + generate commands in it? diff --git a/src/cmd/compile/internal/ssa/block.go b/src/cmd/compile/internal/ssa/block.go index dcf3676bc2..899d69bc32 100644 --- a/src/cmd/compile/internal/ssa/block.go +++ b/src/cmd/compile/internal/ssa/block.go @@ -48,27 +48,27 @@ type Block struct { // Plain nil [next] // If a boolean Value [then, else] // Call mem [nopanic, panic] (control opcode should be OpCall or OpStaticCall) -type BlockKind int8 +type BlockKind int32 +// block kind ranges const ( - BlockExit BlockKind = iota // no successors. There should only be 1 of these. - BlockPlain // a single successor - BlockIf // 2 successors, if control goto Succs[0] else goto Succs[1] - BlockCall // 2 successors, normal return and panic + blockInvalid BlockKind = 0 + blockGenericBase = 1 + 100*iota + blockAMD64Base + block386Base + + blockMax // sentinel +) + +// generic block kinds +const ( + blockGenericStart BlockKind = blockGenericBase + iota + + BlockExit // no successors. There should only be 1 of these. + BlockPlain // a single successor + BlockIf // 2 successors, if control goto Succs[0] else goto Succs[1] + BlockCall // 2 successors, normal return and panic // TODO(khr): BlockPanic for the built-in panic call, has 1 edge to the exit block - BlockUnknown - - // 386/amd64 variants of BlockIf that take the flags register as an arg - BlockEQ - BlockNE - BlockLT - BlockLE - BlockGT - BlockGE - BlockULT - BlockULE - BlockUGT - BlockUGE ) //go:generate stringer -type=BlockKind diff --git a/src/cmd/compile/internal/ssa/blockkind_string.go b/src/cmd/compile/internal/ssa/blockkind_string.go index 6204f1948f..60c820c871 100644 --- a/src/cmd/compile/internal/ssa/blockkind_string.go +++ b/src/cmd/compile/internal/ssa/blockkind_string.go @@ -4,13 +4,29 @@ package ssa import "fmt" -const _BlockKind_name = "BlockExitBlockPlainBlockIfBlockCallBlockUnknownBlockEQBlockNEBlockLTBlockLEBlockGTBlockGEBlockULTBlockULEBlockUGTBlockUGE" +const ( + _BlockKind_name_0 = "blockInvalid" + _BlockKind_name_1 = "blockGenericStartBlockExitBlockPlainBlockIfBlockCall" + _BlockKind_name_2 = "blockAMD64StartBlockEQBlockNEBlockLTBlockLEBlockGTBlockGEBlockULTBlockULEBlockUGTBlockUGE" +) -var _BlockKind_index = [...]uint8{0, 9, 19, 26, 35, 47, 54, 61, 68, 75, 82, 89, 97, 105, 113, 121} +var ( + _BlockKind_index_0 = [...]uint8{0, 12} + _BlockKind_index_1 = [...]uint8{0, 17, 26, 36, 43, 52} + _BlockKind_index_2 = [...]uint8{0, 15, 22, 29, 36, 43, 50, 57, 65, 73, 81, 89} +) func (i BlockKind) String() string { - if i < 0 || i+1 >= BlockKind(len(_BlockKind_index)) { + switch { + case i == 0: + return _BlockKind_name_0 + case 101 <= i && i <= 105: + i -= 101 + return _BlockKind_name_1[_BlockKind_index_1[i]:_BlockKind_index_1[i+1]] + case 201 <= i && i <= 211: + i -= 201 + return _BlockKind_name_2[_BlockKind_index_2[i]:_BlockKind_index_2[i+1]] + default: return fmt.Sprintf("BlockKind(%d)", i) } - return _BlockKind_name[_BlockKind_index[i]:_BlockKind_index[i+1]] } diff --git a/src/cmd/compile/internal/ssa/config.go b/src/cmd/compile/internal/ssa/config.go index 9f1d2a8593..2436554cb5 100644 --- a/src/cmd/compile/internal/ssa/config.go +++ b/src/cmd/compile/internal/ssa/config.go @@ -7,10 +7,11 @@ package ssa import "log" type Config struct { - arch string // "amd64", etc. - ptrSize int64 // 4 or 8 - Uintptr Type // pointer arithmetic type - lower func(*Value) bool // lowering function + arch string // "amd64", etc. + ptrSize int64 // 4 or 8 + Uintptr Type // pointer arithmetic type + lowerBlock func(*Block) bool // lowering function + lowerValue func(*Value) bool // lowering function // TODO: more stuff. Compiler flags of interest, ... } @@ -21,10 +22,12 @@ func NewConfig(arch string) *Config { switch arch { case "amd64": c.ptrSize = 8 - c.lower = lowerAmd64 + c.lowerBlock = lowerBlockAMD64 + c.lowerValue = lowerValueAMD64 case "386": c.ptrSize = 4 - c.lower = lowerAmd64 // TODO(khr): full 32-bit support + c.lowerBlock = lowerBlockAMD64 + c.lowerValue = lowerValueAMD64 // TODO(khr): full 32-bit support default: log.Fatalf("arch %s not implemented", arch) } diff --git a/src/cmd/compile/internal/ssa/deadcode.go b/src/cmd/compile/internal/ssa/deadcode.go index a805861489..ba5d8758d9 100644 --- a/src/cmd/compile/internal/ssa/deadcode.go +++ b/src/cmd/compile/internal/ssa/deadcode.go @@ -14,30 +14,10 @@ func deadcode(f *Func) { reachable[f.Entry.ID] = true p := []*Block{f.Entry} // stack-like worklist for len(p) > 0 { - // pop a reachable block + // Pop a reachable block b := p[len(p)-1] p = p[:len(p)-1] - - // constant-fold conditionals - // TODO: rewrite rules instead? - if b.Kind == BlockIf && b.Control.Op == OpConst { - cond := b.Control.Aux.(bool) - var c *Block - if cond { - // then branch is always taken - c = b.Succs[1] - } else { - // else branch is always taken - c = b.Succs[0] - b.Succs[0] = b.Succs[1] - } - b.Succs[1] = nil // aid GC - b.Succs = b.Succs[:1] - removePredecessor(b, c) - b.Kind = BlockPlain - b.Control = nil - } - + // Mark successors as reachable for _, c := range b.Succs { if !reachable[c.ID] { reachable[c.ID] = true diff --git a/src/cmd/compile/internal/ssa/deadcode_test.go b/src/cmd/compile/internal/ssa/deadcode_test.go index f3d5682355..07e017c73a 100644 --- a/src/cmd/compile/internal/ssa/deadcode_test.go +++ b/src/cmd/compile/internal/ssa/deadcode_test.go @@ -4,9 +4,7 @@ package ssa -import ( - "testing" -) +import "testing" func TestDeadLoop(t *testing.T) { c := NewConfig("amd64") @@ -76,6 +74,7 @@ func TestNeverTaken(t *testing.T) { Exit("mem"))) CheckFunc(fun.f) + Opt(fun.f) Deadcode(fun.f) CheckFunc(fun.f) diff --git a/src/cmd/compile/internal/ssa/export_test.go b/src/cmd/compile/internal/ssa/export_test.go index ab4ab82345..f2e7b0cd10 100644 --- a/src/cmd/compile/internal/ssa/export_test.go +++ b/src/cmd/compile/internal/ssa/export_test.go @@ -6,4 +6,5 @@ package ssa var CheckFunc = checkFunc var PrintFunc = printFunc +var Opt = opt var Deadcode = deadcode diff --git a/src/cmd/compile/internal/ssa/fuse.go b/src/cmd/compile/internal/ssa/fuse.go index af3e8a8e14..e6bd44d573 100644 --- a/src/cmd/compile/internal/ssa/fuse.go +++ b/src/cmd/compile/internal/ssa/fuse.go @@ -35,7 +35,7 @@ func fuse(f *Func) { } // trash b, just in case - b.Kind = BlockUnknown + b.Kind = blockInvalid b.Values = nil b.Preds = nil b.Succs = nil diff --git a/src/cmd/compile/internal/ssa/generic.go b/src/cmd/compile/internal/ssa/generic.go index 91f9c17d11..dc0323e0c1 100644 --- a/src/cmd/compile/internal/ssa/generic.go +++ b/src/cmd/compile/internal/ssa/generic.go @@ -1,8 +1,8 @@ // autogenerated from rulegen/generic.rules: do not edit! -// generated with: go run rulegen/rulegen.go rulegen/generic.rules genericRules generic.go +// generated with: go run rulegen/rulegen.go rulegen/generic.rules genericBlockRules genericValueRules generic.go package ssa -func genericRules(v *Value) bool { +func genericValueRules(v *Value) bool { switch v.Op { case OpAdd: // match: (Add (Const [c]) (Const [d])) @@ -234,3 +234,56 @@ func genericRules(v *Value) bool { } return false } +func genericBlockRules(b *Block) bool { + switch b.Kind { + case BlockIf: + // match: (BlockIf (Const [c]) yes no) + // cond: c.(bool) + // result: (BlockPlain nil yes) + { + v := b.Control + if v.Op != OpConst { + goto endbe39807508a6192b4022c7293eb6e114 + } + c := v.Aux + yes := b.Succs[0] + no := b.Succs[1] + if !(c.(bool)) { + goto endbe39807508a6192b4022c7293eb6e114 + } + removePredecessor(b, no) + b.Kind = BlockPlain + b.Control = nil + b.Succs = b.Succs[:1] + b.Succs[0] = yes + return true + } + goto endbe39807508a6192b4022c7293eb6e114 + endbe39807508a6192b4022c7293eb6e114: + ; + // match: (BlockIf (Const [c]) yes no) + // cond: !c.(bool) + // result: (BlockPlain nil no) + { + v := b.Control + if v.Op != OpConst { + goto end69ac35957ebe0a77a5ef5103c1f79fbf + } + c := v.Aux + yes := b.Succs[0] + no := b.Succs[1] + if !(!c.(bool)) { + goto end69ac35957ebe0a77a5ef5103c1f79fbf + } + removePredecessor(b, yes) + b.Kind = BlockPlain + b.Control = nil + b.Succs = b.Succs[:1] + b.Succs[0] = no + return true + } + goto end69ac35957ebe0a77a5ef5103c1f79fbf + end69ac35957ebe0a77a5ef5103c1f79fbf: + } + return false +} diff --git a/src/cmd/compile/internal/ssa/lower.go b/src/cmd/compile/internal/ssa/lower.go index 44f0b83fa8..ebed4f2607 100644 --- a/src/cmd/compile/internal/ssa/lower.go +++ b/src/cmd/compile/internal/ssa/lower.go @@ -6,12 +6,12 @@ package ssa import "log" -//go:generate go run rulegen/rulegen.go rulegen/lower_amd64.rules lowerAmd64 lowerAmd64.go +//go:generate go run rulegen/rulegen.go rulegen/lower_amd64.rules lowerBlockAMD64 lowerValueAMD64 lowerAmd64.go // convert to machine-dependent ops func lower(f *Func) { // repeat rewrites until we find no more rewrites - applyRewrite(f, f.Config.lower) + applyRewrite(f, f.Config.lowerBlock, f.Config.lowerValue) // Check for unlowered opcodes, fail if we find one. for _, b := range f.Blocks { @@ -21,92 +21,4 @@ func lower(f *Func) { } } } - - // additional pass for 386/amd64, link condition codes directly to blocks - // TODO: do generically somehow? Special "block" rewrite rules? - for _, b := range f.Blocks { - for { - switch b.Kind { - case BlockIf: - switch b.Control.Op { - case OpSETL: - b.Kind = BlockLT - b.Control = b.Control.Args[0] - continue - case OpSETNE: - b.Kind = BlockNE - b.Control = b.Control.Args[0] - continue - case OpSETB: - b.Kind = BlockULT - b.Control = b.Control.Args[0] - continue - case OpMOVBload: - b.Kind = BlockNE - b.Control = b.NewValue2(OpTESTB, TypeFlags, nil, b.Control, b.Control) - continue - // TODO: others - } - case BlockLT: - if b.Control.Op == OpInvertFlags { - b.Kind = BlockGT - b.Control = b.Control.Args[0] - continue - } - case BlockGT: - if b.Control.Op == OpInvertFlags { - b.Kind = BlockLT - b.Control = b.Control.Args[0] - continue - } - case BlockLE: - if b.Control.Op == OpInvertFlags { - b.Kind = BlockGE - b.Control = b.Control.Args[0] - continue - } - case BlockGE: - if b.Control.Op == OpInvertFlags { - b.Kind = BlockLE - b.Control = b.Control.Args[0] - continue - } - case BlockULT: - if b.Control.Op == OpInvertFlags { - b.Kind = BlockUGT - b.Control = b.Control.Args[0] - continue - } - case BlockUGT: - if b.Control.Op == OpInvertFlags { - b.Kind = BlockULT - b.Control = b.Control.Args[0] - continue - } - case BlockULE: - if b.Control.Op == OpInvertFlags { - b.Kind = BlockUGE - b.Control = b.Control.Args[0] - continue - } - case BlockUGE: - if b.Control.Op == OpInvertFlags { - b.Kind = BlockULE - b.Control = b.Control.Args[0] - continue - } - case BlockEQ: - if b.Control.Op == OpInvertFlags { - b.Control = b.Control.Args[0] - continue - } - case BlockNE: - if b.Control.Op == OpInvertFlags { - b.Control = b.Control.Args[0] - continue - } - } - break - } - } } diff --git a/src/cmd/compile/internal/ssa/lowerAmd64.go b/src/cmd/compile/internal/ssa/lowerAmd64.go index 51cef97b30..a233d42370 100644 --- a/src/cmd/compile/internal/ssa/lowerAmd64.go +++ b/src/cmd/compile/internal/ssa/lowerAmd64.go @@ -1,8 +1,8 @@ // autogenerated from rulegen/lower_amd64.rules: do not edit! -// generated with: go run rulegen/rulegen.go rulegen/lower_amd64.rules lowerAmd64 lowerAmd64.go +// generated with: go run rulegen/rulegen.go rulegen/lower_amd64.rules lowerBlockAMD64 lowerValueAMD64 lowerAmd64.go package ssa -func lowerAmd64(v *Value) bool { +func lowerValueAMD64(v *Value) bool { switch v.Op { case OpADDQ: // match: (ADDQ x (MOVQconst [c])) @@ -644,23 +644,41 @@ func lowerAmd64(v *Value) bool { goto end0429f947ee7ac49ff45a243e461a5290 end0429f947ee7ac49ff45a243e461a5290: ; + case OpSETG: + // match: (SETG (InvertFlags x)) + // cond: + // result: (SETL x) + { + if v.Args[0].Op != OpInvertFlags { + goto endf7586738694c9cd0b74ae28bbadb649f + } + x := v.Args[0].Args[0] + v.Op = OpSETL + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto endf7586738694c9cd0b74ae28bbadb649f + endf7586738694c9cd0b74ae28bbadb649f: + ; case OpSETL: // match: (SETL (InvertFlags x)) // cond: - // result: (SETGE x) + // result: (SETG x) { if v.Args[0].Op != OpInvertFlags { - goto end456c7681d48305698c1ef462d244bdc6 + goto ende33160cd86b9d4d3b77e02fb4658d5d3 } x := v.Args[0].Args[0] - v.Op = OpSETGE + v.Op = OpSETG v.Aux = nil v.resetArgs() v.AddArg(x) return true } - goto end456c7681d48305698c1ef462d244bdc6 - end456c7681d48305698c1ef462d244bdc6: + goto ende33160cd86b9d4d3b77e02fb4658d5d3 + ende33160cd86b9d4d3b77e02fb4658d5d3: ; case OpSHLQ: // match: (SHLQ x (MOVQconst [c])) @@ -771,3 +789,302 @@ func lowerAmd64(v *Value) bool { } return false } +func lowerBlockAMD64(b *Block) bool { + switch b.Kind { + case BlockEQ: + // match: (BlockEQ (InvertFlags cmp) yes no) + // cond: + // result: (BlockEQ cmp yes no) + { + v := b.Control + if v.Op != OpInvertFlags { + goto endea853c6aba26aace57cc8951d332ebe9 + } + cmp := v.Args[0] + yes := b.Succs[0] + no := b.Succs[1] + b.Kind = BlockEQ + b.Control = cmp + b.Succs[0] = yes + b.Succs[1] = no + return true + } + goto endea853c6aba26aace57cc8951d332ebe9 + endea853c6aba26aace57cc8951d332ebe9: + ; + case BlockGE: + // match: (BlockGE (InvertFlags cmp) yes no) + // cond: + // result: (BlockLE cmp yes no) + { + v := b.Control + if v.Op != OpInvertFlags { + goto end608065f88da8bcb570f716698fd7c5c7 + } + cmp := v.Args[0] + yes := b.Succs[0] + no := b.Succs[1] + b.Kind = BlockLE + b.Control = cmp + b.Succs[0] = yes + b.Succs[1] = no + return true + } + goto end608065f88da8bcb570f716698fd7c5c7 + end608065f88da8bcb570f716698fd7c5c7: + ; + case BlockGT: + // match: (BlockGT (InvertFlags cmp) yes no) + // cond: + // result: (BlockLT cmp yes no) + { + v := b.Control + if v.Op != OpInvertFlags { + goto ende1758ce91e7231fd66db6bb988856b14 + } + cmp := v.Args[0] + yes := b.Succs[0] + no := b.Succs[1] + b.Kind = BlockLT + b.Control = cmp + b.Succs[0] = yes + b.Succs[1] = no + return true + } + goto ende1758ce91e7231fd66db6bb988856b14 + ende1758ce91e7231fd66db6bb988856b14: + ; + case BlockIf: + // match: (BlockIf (SETL cmp) yes no) + // cond: + // result: (BlockLT cmp yes no) + { + v := b.Control + if v.Op != OpSETL { + goto endc6a5d98127b4b8aff782f6981348c864 + } + cmp := v.Args[0] + yes := b.Succs[0] + no := b.Succs[1] + b.Kind = BlockLT + b.Control = cmp + b.Succs[0] = yes + b.Succs[1] = no + return true + } + goto endc6a5d98127b4b8aff782f6981348c864 + endc6a5d98127b4b8aff782f6981348c864: + ; + // match: (BlockIf (SETNE cmp) yes no) + // cond: + // result: (BlockNE cmp yes no) + { + v := b.Control + if v.Op != OpSETNE { + goto end49bd2f760f561c30c85c3342af06753b + } + cmp := v.Args[0] + yes := b.Succs[0] + no := b.Succs[1] + b.Kind = BlockNE + b.Control = cmp + b.Succs[0] = yes + b.Succs[1] = no + return true + } + goto end49bd2f760f561c30c85c3342af06753b + end49bd2f760f561c30c85c3342af06753b: + ; + // match: (BlockIf (SETB cmp) yes no) + // cond: + // result: (BlockULT cmp yes no) + { + v := b.Control + if v.Op != OpSETB { + goto end4754c856495bfc5769799890d639a627 + } + cmp := v.Args[0] + yes := b.Succs[0] + no := b.Succs[1] + b.Kind = BlockULT + b.Control = cmp + b.Succs[0] = yes + b.Succs[1] = no + return true + } + goto end4754c856495bfc5769799890d639a627 + end4754c856495bfc5769799890d639a627: + ; + // match: (BlockIf cond yes no) + // cond: cond.Op == OpMOVBload + // result: (BlockNE (TESTB cond cond) yes no) + { + v := b.Control + cond := v + yes := b.Succs[0] + no := b.Succs[1] + if !(cond.Op == OpMOVBload) { + goto end3a3c83af305cf35c49cb10183b4c6425 + } + b.Kind = BlockNE + v0 := v.Block.NewValue(OpTESTB, TypeInvalid, nil) + v0.Type = TypeFlags + v0.AddArg(cond) + v0.AddArg(cond) + b.Control = v0 + b.Succs[0] = yes + b.Succs[1] = no + return true + } + goto end3a3c83af305cf35c49cb10183b4c6425 + end3a3c83af305cf35c49cb10183b4c6425: + ; + case BlockLE: + // match: (BlockLE (InvertFlags cmp) yes no) + // cond: + // result: (BlockGE cmp yes no) + { + v := b.Control + if v.Op != OpInvertFlags { + goto end6e761e611859351c15da0d249c3771f7 + } + cmp := v.Args[0] + yes := b.Succs[0] + no := b.Succs[1] + b.Kind = BlockGE + b.Control = cmp + b.Succs[0] = yes + b.Succs[1] = no + return true + } + goto end6e761e611859351c15da0d249c3771f7 + end6e761e611859351c15da0d249c3771f7: + ; + case BlockLT: + // match: (BlockLT (InvertFlags cmp) yes no) + // cond: + // result: (BlockGT cmp yes no) + { + v := b.Control + if v.Op != OpInvertFlags { + goto endb269f9644dffd5a416ba236545ee2524 + } + cmp := v.Args[0] + yes := b.Succs[0] + no := b.Succs[1] + b.Kind = BlockGT + b.Control = cmp + b.Succs[0] = yes + b.Succs[1] = no + return true + } + goto endb269f9644dffd5a416ba236545ee2524 + endb269f9644dffd5a416ba236545ee2524: + ; + case BlockNE: + // match: (BlockNE (InvertFlags cmp) yes no) + // cond: + // result: (BlockNE cmp yes no) + { + v := b.Control + if v.Op != OpInvertFlags { + goto endc41d56a60f8ab211baa2bf0360b7b286 + } + cmp := v.Args[0] + yes := b.Succs[0] + no := b.Succs[1] + b.Kind = BlockNE + b.Control = cmp + b.Succs[0] = yes + b.Succs[1] = no + return true + } + goto endc41d56a60f8ab211baa2bf0360b7b286 + endc41d56a60f8ab211baa2bf0360b7b286: + ; + case BlockUGE: + // match: (BlockUGE (InvertFlags cmp) yes no) + // cond: + // result: (BlockULE cmp yes no) + { + v := b.Control + if v.Op != OpInvertFlags { + goto end9ae511e4f4e81005ae1f3c1e5941ba3c + } + cmp := v.Args[0] + yes := b.Succs[0] + no := b.Succs[1] + b.Kind = BlockULE + b.Control = cmp + b.Succs[0] = yes + b.Succs[1] = no + return true + } + goto end9ae511e4f4e81005ae1f3c1e5941ba3c + end9ae511e4f4e81005ae1f3c1e5941ba3c: + ; + case BlockUGT: + // match: (BlockUGT (InvertFlags cmp) yes no) + // cond: + // result: (BlockULT cmp yes no) + { + v := b.Control + if v.Op != OpInvertFlags { + goto end073724a0ca0ec030715dd33049b647e9 + } + cmp := v.Args[0] + yes := b.Succs[0] + no := b.Succs[1] + b.Kind = BlockULT + b.Control = cmp + b.Succs[0] = yes + b.Succs[1] = no + return true + } + goto end073724a0ca0ec030715dd33049b647e9 + end073724a0ca0ec030715dd33049b647e9: + ; + case BlockULE: + // match: (BlockULE (InvertFlags cmp) yes no) + // cond: + // result: (BlockUGE cmp yes no) + { + v := b.Control + if v.Op != OpInvertFlags { + goto end2f53a6da23ace14fb1b9b9896827e62d + } + cmp := v.Args[0] + yes := b.Succs[0] + no := b.Succs[1] + b.Kind = BlockUGE + b.Control = cmp + b.Succs[0] = yes + b.Succs[1] = no + return true + } + goto end2f53a6da23ace14fb1b9b9896827e62d + end2f53a6da23ace14fb1b9b9896827e62d: + ; + case BlockULT: + // match: (BlockULT (InvertFlags cmp) yes no) + // cond: + // result: (BlockUGT cmp yes no) + { + v := b.Control + if v.Op != OpInvertFlags { + goto endbceb44a1ad6c53fb33710fc88be6a679 + } + cmp := v.Args[0] + yes := b.Succs[0] + no := b.Succs[1] + b.Kind = BlockUGT + b.Control = cmp + b.Succs[0] = yes + b.Succs[1] = no + return true + } + goto endbceb44a1ad6c53fb33710fc88be6a679 + endbceb44a1ad6c53fb33710fc88be6a679: + } + return false +} diff --git a/src/cmd/compile/internal/ssa/op.go b/src/cmd/compile/internal/ssa/op.go index 75c655758d..a894e9e16f 100644 --- a/src/cmd/compile/internal/ssa/op.go +++ b/src/cmd/compile/internal/ssa/op.go @@ -19,7 +19,7 @@ type Op int32 // Opcode ranges, a generic one and one for each architecture. const ( opInvalid Op = 0 - opGenericBase Op = 1 + 1000*iota + opGenericBase = 1 + 1000*iota opAMD64Base op386Base diff --git a/src/cmd/compile/internal/ssa/op_string.go b/src/cmd/compile/internal/ssa/op_string.go index c8f27bb2e4..2005d332ab 100644 --- a/src/cmd/compile/internal/ssa/op_string.go +++ b/src/cmd/compile/internal/ssa/op_string.go @@ -6,18 +6,14 @@ import "fmt" const ( _Op_name_0 = "opInvalid" - _Op_name_1 = "opGenericBaseOpAddOpSubOpMulOpLshOpRshOpLessOpConstOpArgOpGlobalOpFuncOpFPOpSPOpCopyOpMoveOpPhiOpSliceMakeOpSlicePtrOpSliceLenOpSliceCapOpStringMakeOpStringPtrOpStringLenOpLoadOpStoreOpArrayIndexOpPtrIndexOpIsNonNilOpIsInBoundsOpCallOpStaticCallOpConvertOpConvNopOpOffPtrOpStoreReg8OpLoadReg8OpFwdRefOpGenericEnd" - _Op_name_2 = "opAMD64BaseOpADDQOpADDQconstOpSUBQOpSUBQconstOpMULQOpMULQconstOpSHLQOpSHLQconstOpNEGQOpADDLOpCMPQOpCMPQconstOpTESTQOpTESTBOpSETEQOpSETNEOpSETLOpSETGEOpSETBOpInvertFlagsOpLEAQOpLEAQ2OpLEAQ4OpLEAQ8OpLEAQglobalOpMOVBloadOpMOVBQZXloadOpMOVBQSXloadOpMOVQloadOpMOVQstoreOpMOVQloadidx8OpMOVQstoreidx8OpMOVQloadglobalOpMOVQstoreglobalOpMOVQconstOpREPMOVSB" - _Op_name_3 = "op386Base" - _Op_name_4 = "opMax" + _Op_name_1 = "opGenericStartOpAddOpSubOpMulOpLshOpRshOpLessOpConstOpArgOpGlobalOpFuncOpFPOpSPOpCopyOpMoveOpPhiOpSliceMakeOpSlicePtrOpSliceLenOpSliceCapOpStringMakeOpStringPtrOpStringLenOpLoadOpStoreOpArrayIndexOpPtrIndexOpIsNonNilOpIsInBoundsOpCallOpStaticCallOpConvertOpConvNopOpOffPtrOpStoreReg8OpLoadReg8OpFwdRefOpGenericEnd" + _Op_name_2 = "opAMD64startOpADDQOpADDQconstOpSUBQOpSUBQconstOpMULQOpMULQconstOpSHLQOpSHLQconstOpNEGQOpADDLOpCMPQOpCMPQconstOpTESTQOpTESTBOpSETEQOpSETNEOpSETLOpSETGOpSETGEOpSETBOpInvertFlagsOpLEAQOpLEAQ2OpLEAQ4OpLEAQ8OpLEAQglobalOpMOVBloadOpMOVBQZXloadOpMOVBQSXloadOpMOVQloadOpMOVQstoreOpMOVQloadidx8OpMOVQstoreidx8OpMOVQloadglobalOpMOVQstoreglobalOpMOVQconstOpREPMOVSB" ) var ( _Op_index_0 = [...]uint8{0, 9} - _Op_index_1 = [...]uint16{0, 13, 18, 23, 28, 33, 38, 44, 51, 56, 64, 70, 74, 78, 84, 90, 95, 106, 116, 126, 136, 148, 159, 170, 176, 183, 195, 205, 215, 227, 233, 245, 254, 263, 271, 282, 292, 300, 312} - _Op_index_2 = [...]uint16{0, 11, 17, 28, 34, 45, 51, 62, 68, 79, 85, 91, 97, 108, 115, 122, 129, 136, 142, 149, 155, 168, 174, 181, 188, 195, 207, 217, 230, 243, 253, 264, 278, 293, 309, 326, 337, 347} - _Op_index_3 = [...]uint8{0, 9} - _Op_index_4 = [...]uint8{0, 5} + _Op_index_1 = [...]uint16{0, 14, 19, 24, 29, 34, 39, 45, 52, 57, 65, 71, 75, 79, 85, 91, 96, 107, 117, 127, 137, 149, 160, 171, 177, 184, 196, 206, 216, 228, 234, 246, 255, 264, 272, 283, 293, 301, 313} + _Op_index_2 = [...]uint16{0, 12, 18, 29, 35, 46, 52, 63, 69, 80, 86, 92, 98, 109, 116, 123, 130, 137, 143, 149, 156, 162, 175, 181, 188, 195, 202, 214, 224, 237, 250, 260, 271, 285, 300, 316, 333, 344, 354} ) func (i Op) String() string { @@ -27,13 +23,9 @@ func (i Op) String() string { case 1001 <= i && i <= 1038: i -= 1001 return _Op_name_1[_Op_index_1[i]:_Op_index_1[i+1]] - case 2001 <= i && i <= 2037: + case 2001 <= i && i <= 2038: i -= 2001 return _Op_name_2[_Op_index_2[i]:_Op_index_2[i+1]] - case i == 3001: - return _Op_name_3 - case i == 4001: - return _Op_name_4 default: return fmt.Sprintf("Op(%d)", i) } diff --git a/src/cmd/compile/internal/ssa/opamd64.go b/src/cmd/compile/internal/ssa/opamd64.go index 517090992a..665f087b6e 100644 --- a/src/cmd/compile/internal/ssa/opamd64.go +++ b/src/cmd/compile/internal/ssa/opamd64.go @@ -6,6 +6,21 @@ package ssa // amd64-specific opcodes +const ( + blockAMD64Start BlockKind = blockAMD64Base + iota + + BlockEQ + BlockNE + BlockLT + BlockLE + BlockGT + BlockGE + BlockULT + BlockULE + BlockUGT + BlockUGE +) + const ( opAMD64start Op = opAMD64Base + iota @@ -36,12 +51,16 @@ const ( OpSETEQ // extract == condition from arg0 OpSETNE // extract != condition from arg0 OpSETL // extract signed < condition from arg0 + OpSETG // extract signed > condition from arg0 OpSETGE // extract signed >= condition from arg0 OpSETB // extract unsigned < condition from arg0 // InvertFlags reverses the direction of a flags type interpretation: - // (InvertFlags (OpCMPQ a b)) == (OpCMPQ b a) - // This is a pseudo-op which can't appear in assembly output. + // (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. OpInvertFlags // reverse direction of arg0 OpLEAQ // arg0 + arg1 + aux.(int64) diff --git a/src/cmd/compile/internal/ssa/opt.go b/src/cmd/compile/internal/ssa/opt.go index ea2bcf0e98..81c1dfcc02 100644 --- a/src/cmd/compile/internal/ssa/opt.go +++ b/src/cmd/compile/internal/ssa/opt.go @@ -6,8 +6,8 @@ package ssa // machine-independent optimization -//go:generate go run rulegen/rulegen.go rulegen/generic.rules genericRules generic.go +//go:generate go run rulegen/rulegen.go rulegen/generic.rules genericBlockRules genericValueRules generic.go func opt(f *Func) { - applyRewrite(f, genericRules) + applyRewrite(f, genericBlockRules, genericValueRules) } diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go index 671270d7f2..08fad454a9 100644 --- a/src/cmd/compile/internal/ssa/rewrite.go +++ b/src/cmd/compile/internal/ssa/rewrite.go @@ -6,10 +6,14 @@ package ssa import "log" -func applyRewrite(f *Func, r func(*Value) bool) { +func applyRewrite(f *Func, rb func(*Block) bool, rv func(*Value) bool) { // repeat rewrites until we find no more rewrites + var curb *Block var curv *Value defer func() { + if curb != nil { + log.Printf("panic during rewrite of %s\n", curb.LongString()) + } if curv != nil { log.Printf("panic during rewrite of %s\n", curv.LongString()) // TODO(khr): print source location also @@ -18,6 +22,16 @@ func applyRewrite(f *Func, r func(*Value) bool) { for { change := false for _, b := range f.Blocks { + 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 { // elide any copies generated during rewriting for i, a := range v.Args { @@ -32,13 +46,13 @@ func applyRewrite(f *Func, r func(*Value) bool) { // apply rewrite function curv = v - if r(v) { + if rv(v) { change = true } + curv = nil } } if !change { - curv = nil return } } diff --git a/src/cmd/compile/internal/ssa/rulegen/generic.rules b/src/cmd/compile/internal/ssa/rulegen/generic.rules index c49d9d9f2e..afc22838dd 100644 --- a/src/cmd/compile/internal/ssa/rulegen/generic.rules +++ b/src/cmd/compile/internal/ssa/rulegen/generic.rules @@ -2,6 +2,22 @@ // 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 [aux] arg0 arg1 ...) +// the type and aux fields are optional +// on the matching side +// - the types and aux 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. +// - 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 (Add (Const [c]) (Const [d])) && is64BitInt(t) -> (Const [{c.(int64)+d.(int64)}]) (Mul (Const [c]) (Const [d])) && is64BitInt(t) -> (Const [{c.(int64)*d.(int64)}]) @@ -22,3 +38,6 @@ // big-object moves // TODO: fix size (Store dst (Load src mem) mem) && t.Size() > 8 -> (Move [t.Size()] dst src mem) + +(BlockIf (Const [c]) yes no) && c.(bool) -> (BlockPlain nil yes) +(BlockIf (Const [c]) yes no) && !c.(bool) -> (BlockPlain nil no) diff --git a/src/cmd/compile/internal/ssa/rulegen/lower_amd64.rules b/src/cmd/compile/internal/ssa/rulegen/lower_amd64.rules index dc910b70b1..e86e408525 100644 --- a/src/cmd/compile/internal/ssa/rulegen/lower_amd64.rules +++ b/src/cmd/compile/internal/ssa/rulegen/lower_amd64.rules @@ -2,16 +2,6 @@ // 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 [aux] arg0 arg1 ...) -// the type and aux fields are optional -// on the matching side -// - the types and aux 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. -// - aux will be nil if not specified. - // x86 register conventions: // - Integer types live in the low portion of registers. // Upper portions are correctly extended. @@ -44,6 +34,12 @@ (Const [val]) && is64BitInt(t) -> (MOVQconst [val]) +// block rewrites +(BlockIf (SETL cmp) yes no) -> (BlockLT cmp yes no) +(BlockIf (SETNE cmp) yes no) -> (BlockNE cmp yes no) +(BlockIf (SETB cmp) yes no) -> (BlockULT cmp yes no) +(BlockIf cond yes no) && cond.Op == OpMOVBload -> (BlockNE (TESTB cond cond) yes no) + // Rules below here apply some simple optimizations after lowering. // TODO: Should this be a separate pass? @@ -71,7 +67,8 @@ (ADDQconst [c] (LEAQ8 [d] x y)) -> (LEAQ8 [addOff(c, d)] x y) // reverse ordering of compare instruction -(SETL (InvertFlags x)) -> (SETGE x) +(SETL (InvertFlags x)) -> (SETG x) +(SETG (InvertFlags x)) -> (SETL x) // fold constants into memory operations // Note that this is not always a good idea because if not all the uses of @@ -89,3 +86,15 @@ (MOVQstoreidx8 [off1] (ADDQconst [off2] ptr) idx val mem) -> (MOVQstoreidx8 [addOff(off1, off2)] ptr idx val mem) (ADDQconst [off] x) && off.(int64) == 0 -> (Copy x) + +// Absorb InvertFlags into branches. +(BlockLT (InvertFlags cmp) yes no) -> (BlockGT cmp yes no) +(BlockGT (InvertFlags cmp) yes no) -> (BlockLT cmp yes no) +(BlockLE (InvertFlags cmp) yes no) -> (BlockGE cmp yes no) +(BlockGE (InvertFlags cmp) yes no) -> (BlockLE cmp yes no) +(BlockULT (InvertFlags cmp) yes no) -> (BlockUGT cmp yes no) +(BlockUGT (InvertFlags cmp) yes no) -> (BlockULT cmp yes no) +(BlockULE (InvertFlags cmp) yes no) -> (BlockUGE cmp yes no) +(BlockUGE (InvertFlags cmp) yes no) -> (BlockULE cmp yes no) +(BlockEQ (InvertFlags cmp) yes no) -> (BlockEQ cmp yes no) +(BlockNE (InvertFlags cmp) yes no) -> (BlockNE cmp yes no) diff --git a/src/cmd/compile/internal/ssa/rulegen/rulegen.go b/src/cmd/compile/internal/ssa/rulegen/rulegen.go index 4ac930298b..dd99513d96 100644 --- a/src/cmd/compile/internal/ssa/rulegen/rulegen.go +++ b/src/cmd/compile/internal/ssa/rulegen/rulegen.go @@ -7,7 +7,7 @@ // which returns true iff if did something. // Ideas stolen from Swift: http://www.hpl.hp.com/techreports/Compaq-DEC/WRL-2000-2.html -// Run with something like "go run rulegen.go lower_amd64.rules lowerAmd64 lowerAmd64.go" +// Run with something like "go run rulegen.go lower_amd64.rules lowerBlockAmd64 lowerValueAmd64 lowerAmd64.go" package main @@ -47,12 +47,13 @@ import ( // If multiple rules match, the first one in file order is selected. func main() { - if len(os.Args) < 3 || len(os.Args) > 4 { - fmt.Printf("usage: go run rulegen.go []") + if len(os.Args) < 4 || len(os.Args) > 5 { + fmt.Printf("usage: go run rulegen.go []") os.Exit(1) } rulefile := os.Args[1] - rulefn := os.Args[2] + blockfn := os.Args[2] + valuefn := os.Args[3] // Open input file. text, err := os.Open(rulefile) @@ -60,7 +61,8 @@ func main() { log.Fatalf("can't read rule file: %v", err) } - // oprules contains a list of rules for each opcode + // oprules contains a list of rules for each block and opcode + blockrules := map[string][]string{} oprules := map[string][]string{} // read rule file @@ -77,7 +79,11 @@ func main() { continue } op := strings.Split(line, " ")[0][1:] - oprules[op] = append(oprules[op], line) + if strings.HasPrefix(op, "Block") { + blockrules[op] = append(blockrules[op], line) + } else { + oprules[op] = append(oprules[op], line) + } } if err := scanner.Err(); err != nil { log.Fatalf("scanner failed: %v\n", err) @@ -88,7 +94,7 @@ func main() { fmt.Fprintf(w, "// autogenerated from %s: do not edit!\n", rulefile) fmt.Fprintf(w, "// generated with: go run rulegen/rulegen.go %s\n", strings.Join(os.Args[1:], " ")) fmt.Fprintln(w, "package ssa") - fmt.Fprintf(w, "func %s(v *Value) bool {\n", rulefn) + fmt.Fprintf(w, "func %s(v *Value) bool {\n", valuefn) // generate code for each rule fmt.Fprintf(w, "switch v.Op {\n") @@ -111,15 +117,15 @@ func main() { if len(s) != 2 { log.Fatalf("no arrow in rule %s", rule) } - lhs := strings.Trim(s[0], " \t") - result := strings.Trim(s[1], " \t\n") + lhs := strings.TrimSpace(s[0]) + result := strings.TrimSpace(s[1]) // split match into matching part and additional condition match := lhs cond := "" if i := strings.Index(match, "&&"); i >= 0 { - cond = strings.Trim(match[i+2:], " \t") - match = strings.Trim(match[:i], " \t") + cond = strings.TrimSpace(match[i+2:]) + match = strings.TrimSpace(match[:i]) } fmt.Fprintf(w, "// match: %s\n", match) @@ -147,6 +153,109 @@ func main() { fmt.Fprintf(w, "return false\n") fmt.Fprintf(w, "}\n") + // Generate block rewrite function. + fmt.Fprintf(w, "func %s(b *Block) bool {\n", blockfn) + 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", op) + for _, rule := range blockrules[op] { + rulehash := fmt.Sprintf("%02x", md5.Sum([]byte(rule))) + // split at -> + s := strings.Split(rule, "->") + if len(s) != 2 { + log.Fatalf("no arrow in rule %s", rule) + } + lhs := strings.TrimSpace(s[0]) + result := strings.TrimSpace(s[1]) + + // split match into matching part and additional condition + match := lhs + cond := "" + if i := strings.Index(match, "&&"); i >= 0 { + cond = strings.TrimSpace(match[i+2:]) + match = strings.TrimSpace(match[:i]) + } + + fmt.Fprintf(w, "// match: %s\n", match) + fmt.Fprintf(w, "// cond: %s\n", cond) + fmt.Fprintf(w, "// result: %s\n", result) + + fail := fmt.Sprintf("{\ngoto end%s\n}\n", rulehash) + + fmt.Fprintf(w, "{\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, s[1], "v", fail, 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) %s", cond, fail) + } + + // Rule matches. Generate result. + t := split(result[1 : len(result)-1]) // remove parens, then split + newsuccs := t[2:] + + // Check if newsuccs is a subset of 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) + } + + // Modify predecessor lists for no-longer-reachable blocks + for succ := range m { + fmt.Fprintf(w, "removePredecessor(b, %s)\n", succ) + } + + fmt.Fprintf(w, "b.Kind = %s\n", t[0]) + if t[1] == "nil" { + fmt.Fprintf(w, "b.Control = nil\n") + } else { + fmt.Fprintf(w, "b.Control = %s\n", genResult0(w, t[1], new(int), 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) + } + + fmt.Fprintf(w, "return true\n") + + fmt.Fprintf(w, "}\n") + fmt.Fprintf(w, "goto end%s\n", rulehash) // use label + fmt.Fprintf(w, "end%s:;\n", rulehash) + } + } + fmt.Fprintf(w, "}\n") + fmt.Fprintf(w, "return false\n") + fmt.Fprintf(w, "}\n") + // gofmt result b := w.Bytes() b, err = format.Source(b) @@ -155,8 +264,8 @@ func main() { } // Write to a file if given, otherwise stdout. - if len(os.Args) >= 4 { - err = ioutil.WriteFile(os.Args[3], b, 0666) + if len(os.Args) >= 5 { + err = ioutil.WriteFile(os.Args[4], b, 0666) } else { _, err = os.Stdout.Write(b) } @@ -187,7 +296,7 @@ func genMatch0(w io.Writer, match, v, fail string, m map[string]string, top bool // split body up into regions. Split by spaces/tabs, except those // contained in () or {}. - s := split(match[1 : len(match)-1]) + s := split(match[1 : len(match)-1]) // remove parens, then split // check op if !top { @@ -199,7 +308,7 @@ func genMatch0(w io.Writer, match, v, fail string, m map[string]string, top bool for _, a := range s[1:] { if a[0] == '<' { // type restriction - t := a[1 : len(a)-1] + t := a[1 : len(a)-1] // remove <> if t[0] == '{' { // code. We must match the results of this code. fmt.Fprintf(w, "if %s.Type != %s %s", v, t[1:len(t)-1], fail) @@ -215,7 +324,7 @@ func genMatch0(w io.Writer, match, v, fail string, m map[string]string, top bool } } else if a[0] == '[' { // aux restriction - x := a[1 : len(a)-1] + x := a[1 : len(a)-1] // remove [] if x[0] == '{' { // code fmt.Fprintf(w, "if %s.Aux != %s %s", v, x[1:len(x)-1], fail) @@ -254,7 +363,7 @@ func genResult0(w io.Writer, result string, alloc *int, top bool) string { return result } - s := split(result[1 : len(result)-1]) + s := split(result[1 : len(result)-1]) // remove parens, then split var v string var hasType bool if top { @@ -271,17 +380,17 @@ func genResult0(w io.Writer, result string, alloc *int, top bool) string { for _, a := range s[1:] { if a[0] == '<' { // type restriction - t := a[1 : len(a)-1] + t := a[1 : len(a)-1] // remove <> if t[0] == '{' { - t = t[1 : len(t)-1] + t = t[1 : len(t)-1] // remove {} } fmt.Fprintf(w, "%s.Type = %s\n", v, t) hasType = true } else if a[0] == '[' { // aux restriction - x := a[1 : len(a)-1] + x := a[1 : len(a)-1] // remove [] if x[0] == '{' { - x = x[1 : len(x)-1] + x = x[1 : len(x)-1] // remove {} } fmt.Fprintf(w, "%s.Aux = %s\n", v, x) } else if a[0] == '{' { -- cgit v1.3 From bd95412d23e80d779062abe0798b8e7d85fcc138 Mon Sep 17 00:00:00 2001 From: Michael Matloob Date: Sat, 30 May 2015 13:17:12 -0400 Subject: [dev.ssa] cmd/compile/internal/ssa: add a String() method to Func The string method has the same output as printFunc. Change-Id: Iab2ebc17a3d6418edfeb7b585e4f251e7a11f399 Reviewed-on: https://go-review.googlesource.com/10552 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/func_test.go | 16 +++++------- src/cmd/compile/internal/ssa/print.go | 41 +++++++++++++++++++++---------- 2 files changed, 34 insertions(+), 23 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/func_test.go b/src/cmd/compile/internal/ssa/func_test.go index 4839c1ee63..b66ab24778 100644 --- a/src/cmd/compile/internal/ssa/func_test.go +++ b/src/cmd/compile/internal/ssa/func_test.go @@ -324,11 +324,9 @@ func TestEquiv(t *testing.T) { } for _, c := range equivalentCases { if !Equiv(c.f.f, c.g.f) { - t.Errorf("expected equivalence. Func definitions:") - // TODO(matloob): Rewrite PrintFunc to output to a string or writer, - // so the functions can be written to the error log. - PrintFunc(c.f.f) - PrintFunc(c.g.f) + t.Error("expected equivalence. Func definitions:") + t.Error(c.f.f) + t.Error(c.g.f) } } @@ -394,11 +392,9 @@ func TestEquiv(t *testing.T) { } for _, c := range differentCases { if Equiv(c.f.f, c.g.f) { - t.Errorf("expected difference. Func definitions:") - // TODO(matloob): Rewrite PrintFunc to output to a string or writer, - // so the functions can be written to the error log. - PrintFunc(c.f.f) - PrintFunc(c.g.f) + t.Error("expected difference. Func definitions:") + t.Error(c.f.f) + t.Error(c.g.f) } } } diff --git a/src/cmd/compile/internal/ssa/print.go b/src/cmd/compile/internal/ssa/print.go index eeea30d970..b9a958c18e 100644 --- a/src/cmd/compile/internal/ssa/print.go +++ b/src/cmd/compile/internal/ssa/print.go @@ -4,15 +4,30 @@ package ssa -import "fmt" +import ( + "bytes" + "fmt" + "io" + "os" +) func printFunc(f *Func) { - fmt.Print(f.Name) - fmt.Print(" ") - fmt.Println(f.Type) + fprintFunc(os.Stdout, f) +} + +func (f *Func) String() string { + var buf bytes.Buffer + fprintFunc(&buf, f) + return buf.String() +} + +func fprintFunc(w io.Writer, f *Func) { + fmt.Fprint(w, f.Name) + fmt.Fprint(w, " ") + fmt.Fprintln(w, f.Type) printed := make([]bool, f.NumValues()) for _, b := range f.Blocks { - fmt.Printf(" b%d:\n", b.ID) + fmt.Fprintf(w, " b%d:\n", b.ID) n := 0 // print phis first since all value cycles contain a phi @@ -20,8 +35,8 @@ func printFunc(f *Func) { if v.Op != OpPhi { continue } - fmt.Print(" ") - fmt.Println(v.LongString()) + fmt.Fprint(w, " ") + fmt.Fprintln(w, v.LongString()) printed[v.ID] = true n++ } @@ -39,25 +54,25 @@ func printFunc(f *Func) { continue outer } } - fmt.Print(" ") - fmt.Println(v.LongString()) + fmt.Fprint(w, " ") + fmt.Fprintln(w, v.LongString()) printed[v.ID] = true n++ } if m == n { - fmt.Println("dependency cycle!") + fmt.Fprintln(w, "dependency cycle!") for _, v := range b.Values { if printed[v.ID] { continue } - fmt.Print(" ") - fmt.Println(v.LongString()) + fmt.Fprint(w, " ") + fmt.Fprintln(w, v.LongString()) printed[v.ID] = true n++ } } } - fmt.Println(" " + b.LongString()) + fmt.Fprintln(w, " "+b.LongString()) } } -- cgit v1.3 From f7f604e28459ac993b86832b769438c4a35f06c2 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Wed, 27 May 2015 14:52:22 -0700 Subject: [dev.ssa] cmd/internal/ssa: add string operations Add ops to load, store, select ptr & len, and build constant strings. A few other minor cleanups. Change-Id: I6f0f7419d641b119b613ed44561cd308a466051c Reviewed-on: https://go-review.googlesource.com/10449 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/gc/pgen.go | 2 +- src/cmd/compile/internal/gc/ssa.go | 50 ++++-- src/cmd/compile/internal/gc/type.go | 4 + src/cmd/compile/internal/ssa/config.go | 22 ++- src/cmd/compile/internal/ssa/generic.go | 171 ++++++++++++++++++--- src/cmd/compile/internal/ssa/lowerAmd64.go | 2 +- src/cmd/compile/internal/ssa/op.go | 12 +- src/cmd/compile/internal/ssa/regalloc.go | 4 + src/cmd/compile/internal/ssa/rewrite.go | 6 +- src/cmd/compile/internal/ssa/rulegen/generic.rules | 14 +- src/cmd/compile/internal/ssa/rulegen/rulegen.go | 5 +- src/cmd/compile/internal/ssa/type.go | 4 + 12 files changed, 251 insertions(+), 45 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/pgen.go index c170060896..50cf0d1db1 100644 --- a/src/cmd/compile/internal/gc/pgen.go +++ b/src/cmd/compile/internal/gc/pgen.go @@ -469,11 +469,11 @@ func compile(fn *Node) { } } - Genlist(Curfn.Func.Enter) if ssafn != nil { genssa(ssafn, ptxt, gcargs, gclocals) return } + Genlist(Curfn.Func.Enter) Genlist(Curfn.Nbody) gclean() checklabels() diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 7f78fce17e..3c95266bdc 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -13,12 +13,13 @@ import ( ) func buildssa(fn *Node) *ssa.Func { - dumplist("buildssa", Curfn.Nbody) + dumplist("buildssa-enter", fn.Func.Enter) + dumplist("buildssa-body", fn.Nbody) var s state // TODO(khr): build config just once at the start of the compiler binary - s.config = ssa.NewConfig(Thearch.Thestring) + s.config = ssa.NewConfig(Thearch.Thestring, ssaExport{}) s.f = s.config.NewFunc() s.f.Name = fn.Nname.Sym.Name @@ -44,6 +45,7 @@ func buildssa(fn *Node) *ssa.Func { // Convert the AST-based IR to the SSA-based IR s.startBlock(s.f.Entry) + s.stmtList(fn.Func.Enter) s.stmtList(fn.Nbody) // fallthrough to exit @@ -159,7 +161,23 @@ func (s *state) stmt(n *Node) { case OAS: // TODO(khr): colas? - val := s.expr(n.Right) + var val *ssa.Value + if n.Right == nil { + // n.Right == nil means use the zero value of the assigned type. + t := n.Left.Type + switch { + case t.IsString(): + val = s.f.Entry.NewValue(ssa.OpConst, n.Left.Type, "") + case t.IsInteger(): + val = s.f.Entry.NewValue(ssa.OpConst, n.Left.Type, int64(0)) + case t.IsBoolean(): + val = s.f.Entry.NewValue(ssa.OpConst, n.Left.Type, false) + default: + log.Fatalf("zero for type %v not implemented", t) + } + } else { + val = s.expr(n.Right) + } if n.Left.Op == ONAME && !n.Left.Addrtaken && n.Left.Class&PHEAP == 0 && n.Left.Class != PEXTERN && n.Left.Class != PPARAMOUT { // ssa-able variable. s.vars[n.Left.Sym.Name] = val @@ -250,10 +268,6 @@ func (s *state) stmt(n *Node) { // expr converts the expression n to ssa, adds it to s and returns the ssa result. func (s *state) expr(n *Node) *ssa.Value { - if n == nil { - // TODO(khr): is this nil??? - return s.f.Entry.NewValue(ssa.OpConst, n.Type, nil) - } switch n.Op { case ONAME: // TODO: remember offsets for PPARAM names @@ -268,6 +282,8 @@ func (s *state) expr(n *Node) *ssa.Value { switch n.Val.Ctype { case CTINT: return s.f.ConstInt(n.Type, Mpgetfix(n.Val.U.(*Mpint))) + case CTSTR: + return s.f.Entry.NewValue(ssa.OpConst, n.Type, n.Val.U) default: log.Fatalf("unhandled OLITERAL %v", n.Val.Ctype) return nil @@ -573,7 +589,11 @@ func genssa(f *ssa.Func, ptxt *obj.Prog, gcargs, gclocals *Sym) { // TODO: dump frame if -f // Emit garbage collection symbols. TODO: put something in them - liveness(Curfn, ptxt, gcargs, gclocals) + //liveness(Curfn, ptxt, gcargs, gclocals) + duint32(gcargs, 0, 0) + ggloblsym(gcargs, 4, obj.RODATA|obj.DUPOK) + duint32(gclocals, 0, 0) + ggloblsym(gclocals, 4, obj.RODATA|obj.DUPOK) } func genValue(v *ssa.Value) { @@ -703,7 +723,10 @@ func genValue(v *ssa.Value) { p.To.Type = obj.TYPE_MEM p.To.Reg = regnum(v.Args[0]) p.To.Offset = v.Aux.(int64) - case ssa.OpCopy: + case ssa.OpCopy: // TODO: lower to MOVQ earlier? + if v.Type.IsMemory() { + return + } x := regnum(v.Args[0]) y := regnum(v) if x != y { @@ -907,3 +930,12 @@ func regnum(v *ssa.Value) int16 { func localOffset(v *ssa.Value) int64 { return v.Block.Func.RegAlloc[v.ID].(*ssa.LocalSlot).Idx } + +// ssaExport exports a bunch of compiler services for the ssa backend. +type ssaExport struct{} + +// StringSym returns a symbol (a *Sym wrapped in an interface) which +// is a global string constant containing s. +func (serv ssaExport) StringSym(s string) interface{} { + return stringsym(s) +} diff --git a/src/cmd/compile/internal/gc/type.go b/src/cmd/compile/internal/gc/type.go index cf1589eb03..0ed07ee90a 100644 --- a/src/cmd/compile/internal/gc/type.go +++ b/src/cmd/compile/internal/gc/type.go @@ -47,6 +47,10 @@ func (t *Type) IsPtr() bool { t.Etype == TMAP || t.Etype == TCHAN || t.Etype == TFUNC } +func (t *Type) IsString() bool { + return t.Etype == TSTRING +} + func (t *Type) Elem() ssa.Type { return t.Type } diff --git a/src/cmd/compile/internal/ssa/config.go b/src/cmd/compile/internal/ssa/config.go index 2436554cb5..7c5e07e12a 100644 --- a/src/cmd/compile/internal/ssa/config.go +++ b/src/cmd/compile/internal/ssa/config.go @@ -7,18 +7,26 @@ package ssa import "log" type Config struct { - arch string // "amd64", etc. - ptrSize int64 // 4 or 8 - Uintptr Type // pointer arithmetic type - lowerBlock func(*Block) bool // lowering function - lowerValue func(*Value) bool // lowering function + arch string // "amd64", etc. + ptrSize int64 // 4 or 8 + Uintptr Type // pointer arithmetic type + lowerBlock func(*Block) bool // lowering function + lowerValue func(*Value, *Config) bool // lowering function + fe Frontend // callbacks into compiler frontend // TODO: more stuff. Compiler flags of interest, ... } +type Frontend interface { + // StringSym returns a symbol pointing to the given string. + // Strings are laid out in read-only memory with one word of pointer, + // one word of length, then the contents of the string. + StringSym(string) interface{} // returns *gc.Sym +} + // NewConfig returns a new configuration object for the given architecture. -func NewConfig(arch string) *Config { - c := &Config{arch: arch} +func NewConfig(arch string, fe Frontend) *Config { + c := &Config{arch: arch, fe: fe} switch arch { case "amd64": c.ptrSize = 8 diff --git a/src/cmd/compile/internal/ssa/generic.go b/src/cmd/compile/internal/ssa/generic.go index dc0323e0c1..b6f1e8614d 100644 --- a/src/cmd/compile/internal/ssa/generic.go +++ b/src/cmd/compile/internal/ssa/generic.go @@ -2,7 +2,7 @@ // generated with: go run rulegen/rulegen.go rulegen/generic.rules genericBlockRules genericValueRules generic.go package ssa -func genericValueRules(v *Value) bool { +func genericValueRules(v *Value, config *Config) bool { switch v.Op { case OpAdd: // match: (Add (Const [c]) (Const [d])) @@ -55,6 +55,36 @@ func genericValueRules(v *Value) bool { goto end3809f4c52270a76313e4ea26e6f0b753 end3809f4c52270a76313e4ea26e6f0b753: ; + case OpConst: + // match: (Const [s]) + // cond: t.IsString() + // result: (StringMake (OffPtr [2*config.ptrSize] (Global [config.fe.StringSym(s.(string))])) (Const [int64(len(s.(string)))])) + { + t := v.Type + s := v.Aux + if !(t.IsString()) { + goto end8442aa5b3f4e5b840055475883110372 + } + v.Op = OpStringMake + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue(OpOffPtr, TypeInvalid, nil) + v0.Type = TypeBytePtr + v0.Aux = 2 * config.ptrSize + v1 := v.Block.NewValue(OpGlobal, TypeInvalid, nil) + v1.Type = TypeBytePtr + v1.Aux = config.fe.StringSym(s.(string)) + v0.AddArg(v1) + v.AddArg(v0) + v2 := v.Block.NewValue(OpConst, TypeInvalid, nil) + v2.Type = config.Uintptr + v2.Aux = int64(len(s.(string))) + v.AddArg(v2) + return true + } + goto end8442aa5b3f4e5b840055475883110372 + end8442aa5b3f4e5b840055475883110372: + ; case OpIsInBounds: // match: (IsInBounds (Const [c]) (Const [d])) // cond: @@ -77,6 +107,39 @@ func genericValueRules(v *Value) bool { goto enddbd1a394d9b71ee64335361b8384865c enddbd1a394d9b71ee64335361b8384865c: ; + case OpLoad: + // match: (Load ptr mem) + // cond: t.IsString() + // result: (StringMake (Load ptr mem) (Load (OffPtr [config.ptrSize] ptr) mem)) + { + t := v.Type + ptr := v.Args[0] + mem := v.Args[1] + if !(t.IsString()) { + goto endd0afd003b70d726a1c5bbaf51fe06182 + } + v.Op = OpStringMake + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue(OpLoad, TypeInvalid, nil) + v0.Type = TypeBytePtr + v0.AddArg(ptr) + v0.AddArg(mem) + v.AddArg(v0) + v1 := v.Block.NewValue(OpLoad, TypeInvalid, nil) + v1.Type = config.Uintptr + v2 := v.Block.NewValue(OpOffPtr, TypeInvalid, nil) + v2.Type = TypeBytePtr + v2.Aux = config.ptrSize + v2.AddArg(ptr) + v1.AddArg(v2) + v1.AddArg(mem) + v.AddArg(v1) + return true + } + goto endd0afd003b70d726a1c5bbaf51fe06182 + endd0afd003b70d726a1c5bbaf51fe06182: + ; case OpMul: // match: (Mul (Const [c]) (Const [d])) // cond: is64BitInt(t) @@ -106,7 +169,7 @@ func genericValueRules(v *Value) bool { case OpPtrIndex: // match: (PtrIndex ptr idx) // cond: - // result: (Add ptr (Mul idx (Const [t.Elem().Size()]))) + // result: (Add ptr (Mul idx (Const [t.Elem().Size()]))) { t := v.Type ptr := v.Args[0] @@ -116,25 +179,25 @@ func genericValueRules(v *Value) bool { v.resetArgs() v.AddArg(ptr) v0 := v.Block.NewValue(OpMul, TypeInvalid, nil) - v0.Type = v.Block.Func.Config.Uintptr + v0.Type = config.Uintptr v0.AddArg(idx) v1 := v.Block.NewValue(OpConst, TypeInvalid, nil) - v1.Type = v.Block.Func.Config.Uintptr + v1.Type = config.Uintptr v1.Aux = t.Elem().Size() v0.AddArg(v1) v.AddArg(v0) return true } - goto end383c68c41e72d22ef00c4b7b0fddcbb8 - end383c68c41e72d22ef00c4b7b0fddcbb8: + goto end88c7c383675420d1581daeb899039fa8 + end88c7c383675420d1581daeb899039fa8: ; case OpSliceCap: // match: (SliceCap (Load ptr mem)) // cond: - // result: (Load (Add ptr (Const [int64(v.Block.Func.Config.ptrSize*2)])) mem) + // result: (Load (Add ptr (Const [int64(config.ptrSize*2)])) mem) { if v.Args[0].Op != OpLoad { - goto endbf1d4db93c4664ed43be3f73afb4dfa3 + goto endc871dcd9a720b4290c9cae78fe147c8a } ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] @@ -145,23 +208,23 @@ func genericValueRules(v *Value) bool { v0.Type = ptr.Type v0.AddArg(ptr) v1 := v.Block.NewValue(OpConst, TypeInvalid, nil) - v1.Type = v.Block.Func.Config.Uintptr - v1.Aux = int64(v.Block.Func.Config.ptrSize * 2) + v1.Type = config.Uintptr + v1.Aux = int64(config.ptrSize * 2) v0.AddArg(v1) v.AddArg(v0) v.AddArg(mem) return true } - goto endbf1d4db93c4664ed43be3f73afb4dfa3 - endbf1d4db93c4664ed43be3f73afb4dfa3: + goto endc871dcd9a720b4290c9cae78fe147c8a + endc871dcd9a720b4290c9cae78fe147c8a: ; case OpSliceLen: // match: (SliceLen (Load ptr mem)) // cond: - // result: (Load (Add ptr (Const [int64(v.Block.Func.Config.ptrSize)])) mem) + // result: (Load (Add ptr (Const [int64(config.ptrSize)])) mem) { if v.Args[0].Op != OpLoad { - goto end9190b1ecbda4c5dd6d3e05d2495fb297 + goto end1eec05e44f5fc8944e7c176f98a74d92 } ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] @@ -172,15 +235,15 @@ func genericValueRules(v *Value) bool { v0.Type = ptr.Type v0.AddArg(ptr) v1 := v.Block.NewValue(OpConst, TypeInvalid, nil) - v1.Type = v.Block.Func.Config.Uintptr - v1.Aux = int64(v.Block.Func.Config.ptrSize) + v1.Type = config.Uintptr + v1.Aux = int64(config.ptrSize) v0.AddArg(v1) v.AddArg(v0) v.AddArg(mem) return true } - goto end9190b1ecbda4c5dd6d3e05d2495fb297 - end9190b1ecbda4c5dd6d3e05d2495fb297: + goto end1eec05e44f5fc8944e7c176f98a74d92 + end1eec05e44f5fc8944e7c176f98a74d92: ; case OpSlicePtr: // match: (SlicePtr (Load ptr mem)) @@ -231,6 +294,78 @@ func genericValueRules(v *Value) bool { } goto end324ffb6d2771808da4267f62c854e9c8 end324ffb6d2771808da4267f62c854e9c8: + ; + // match: (Store dst str mem) + // cond: str.Type.IsString() + // result: (Store (OffPtr [config.ptrSize] dst) (StringLen str) (Store dst (StringPtr str) mem)) + { + dst := v.Args[0] + str := v.Args[1] + mem := v.Args[2] + if !(str.Type.IsString()) { + goto end410559d97aed8018f820cd88723de442 + } + v.Op = OpStore + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue(OpOffPtr, TypeInvalid, nil) + v0.Type = TypeBytePtr + v0.Aux = config.ptrSize + v0.AddArg(dst) + v.AddArg(v0) + v1 := v.Block.NewValue(OpStringLen, TypeInvalid, nil) + v1.Type = config.Uintptr + v1.AddArg(str) + v.AddArg(v1) + v2 := v.Block.NewValue(OpStore, TypeInvalid, nil) + v2.Type = TypeMem + v2.AddArg(dst) + v3 := v.Block.NewValue(OpStringPtr, TypeInvalid, nil) + v3.Type = TypeBytePtr + v3.AddArg(str) + v2.AddArg(v3) + v2.AddArg(mem) + v.AddArg(v2) + return true + } + goto end410559d97aed8018f820cd88723de442 + end410559d97aed8018f820cd88723de442: + ; + case OpStringLen: + // match: (StringLen (StringMake _ len)) + // cond: + // result: len + { + if v.Args[0].Op != OpStringMake { + goto end0d922460b7e5ca88324034f4bd6c027c + } + len := v.Args[0].Args[1] + v.Op = len.Op + v.Aux = len.Aux + v.resetArgs() + v.AddArgs(len.Args...) + return true + } + goto end0d922460b7e5ca88324034f4bd6c027c + end0d922460b7e5ca88324034f4bd6c027c: + ; + case OpStringPtr: + // match: (StringPtr (StringMake ptr _)) + // cond: + // result: ptr + { + if v.Args[0].Op != OpStringMake { + goto end061edc5d85c73ad909089af2556d9380 + } + ptr := v.Args[0].Args[0] + v.Op = ptr.Op + v.Aux = ptr.Aux + v.resetArgs() + v.AddArgs(ptr.Args...) + return true + } + goto end061edc5d85c73ad909089af2556d9380 + end061edc5d85c73ad909089af2556d9380: } return false } diff --git a/src/cmd/compile/internal/ssa/lowerAmd64.go b/src/cmd/compile/internal/ssa/lowerAmd64.go index a233d42370..6b5ff3e39f 100644 --- a/src/cmd/compile/internal/ssa/lowerAmd64.go +++ b/src/cmd/compile/internal/ssa/lowerAmd64.go @@ -2,7 +2,7 @@ // generated with: go run rulegen/rulegen.go rulegen/lower_amd64.rules lowerBlockAMD64 lowerValueAMD64 lowerAmd64.go package ssa -func lowerValueAMD64(v *Value) bool { +func lowerValueAMD64(v *Value, config *Config) bool { switch v.Op { case OpADDQ: // match: (ADDQ x (MOVQconst [c])) diff --git a/src/cmd/compile/internal/ssa/op.go b/src/cmd/compile/internal/ssa/op.go index a894e9e16f..5f6b2ca6a6 100644 --- a/src/cmd/compile/internal/ssa/op.go +++ b/src/cmd/compile/internal/ssa/op.go @@ -4,7 +4,10 @@ package ssa -import "fmt" +import ( + "fmt" + "log" +) // An Op encodes the specific operation that a Value performs. // Opcodes' semantics can be modified by the type and aux fields of the Value. @@ -106,7 +109,12 @@ type GlobalOffset struct { // offset adds x to the location specified by g and returns it. func (g GlobalOffset) offset(x int64) GlobalOffset { - return GlobalOffset{g.Global, g.Offset + x} + y := g.Offset + z := x + y + if x^y >= 0 && x^z < 0 { + log.Panicf("offset overflow %d %d\n", x, y) + } + return GlobalOffset{g.Global, z} } func (g GlobalOffset) String() string { diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index c798d2e936..23a46d66b4 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -158,6 +158,10 @@ func regalloc(f *Func) { b.Values = append(b.Values, v) continue } + if v.Op == OpCopy && v.Type.IsMemory() { + b.Values = append(b.Values, v) + continue + } // Compute a good input ordering. Start with the most constrained input. order := make([]intPair, len(inputs)) diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go index 08fad454a9..6b76e55e2a 100644 --- a/src/cmd/compile/internal/ssa/rewrite.go +++ b/src/cmd/compile/internal/ssa/rewrite.go @@ -6,7 +6,7 @@ package ssa import "log" -func applyRewrite(f *Func, rb func(*Block) bool, rv func(*Value) bool) { +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 @@ -16,9 +16,11 @@ func applyRewrite(f *Func, rb func(*Block) bool, rv func(*Value) bool) { } if curv != nil { log.Printf("panic during rewrite of %s\n", curv.LongString()) + panic("rewrite failed") // TODO(khr): print source location also } }() + config := f.Config for { change := false for _, b := range f.Blocks { @@ -46,7 +48,7 @@ func applyRewrite(f *Func, rb func(*Block) bool, rv func(*Value) bool) { // apply rewrite function curv = v - if rv(v) { + if rv(v, config) { change = true } curv = nil diff --git a/src/cmd/compile/internal/ssa/rulegen/generic.rules b/src/cmd/compile/internal/ssa/rulegen/generic.rules index afc22838dd..21e5f72d09 100644 --- a/src/cmd/compile/internal/ssa/rulegen/generic.rules +++ b/src/cmd/compile/internal/ssa/rulegen/generic.rules @@ -26,14 +26,13 @@ // tear apart slices // TODO: anything that generates a slice needs to go in here. (SlicePtr (Load ptr mem)) -> (Load ptr mem) -(SliceLen (Load ptr mem)) -> (Load (Add ptr (Const [int64(v.Block.Func.Config.ptrSize)])) mem) -(SliceCap (Load ptr mem)) -> (Load (Add ptr (Const [int64(v.Block.Func.Config.ptrSize*2)])) mem) +(SliceLen (Load ptr mem)) -> (Load (Add ptr (Const [int64(config.ptrSize)])) mem) +(SliceCap (Load ptr mem)) -> (Load (Add ptr (Const [int64(config.ptrSize*2)])) mem) // indexing operations // Note: bounds check has already been done (ArrayIndex (Load ptr mem) idx) -> (Load (PtrIndex ptr idx) mem) -(PtrIndex ptr idx) -> (Add ptr (Mul idx (Const [t.Elem().Size()]))) -// TODO: hopefully this will get rid of all full-width array copies. +(PtrIndex ptr idx) -> (Add ptr (Mul idx (Const [t.Elem().Size()]))) // big-object moves // TODO: fix size @@ -41,3 +40,10 @@ (BlockIf (Const [c]) yes no) && c.(bool) -> (BlockPlain nil yes) (BlockIf (Const [c]) yes no) && !c.(bool) -> (BlockPlain nil no) + +// string ops +(Const [s]) && t.IsString() -> (StringMake (OffPtr [2*config.ptrSize] (Global [config.fe.StringSym(s.(string))])) (Const [int64(len(s.(string)))])) // TODO: ptr +(Load ptr mem) && t.IsString() -> (StringMake (Load ptr mem) (Load (OffPtr [config.ptrSize] ptr) mem)) +(StringPtr (StringMake ptr _)) -> ptr +(StringLen (StringMake _ len)) -> len +(Store dst str mem) && str.Type.IsString() -> (Store (OffPtr [config.ptrSize] dst) (StringLen str) (Store dst (StringPtr str) mem)) diff --git a/src/cmd/compile/internal/ssa/rulegen/rulegen.go b/src/cmd/compile/internal/ssa/rulegen/rulegen.go index dd99513d96..b0916fa4d2 100644 --- a/src/cmd/compile/internal/ssa/rulegen/rulegen.go +++ b/src/cmd/compile/internal/ssa/rulegen/rulegen.go @@ -94,7 +94,7 @@ func main() { fmt.Fprintf(w, "// autogenerated from %s: do not edit!\n", rulefile) fmt.Fprintf(w, "// generated with: go run rulegen/rulegen.go %s\n", strings.Join(os.Args[1:], " ")) fmt.Fprintln(w, "package ssa") - fmt.Fprintf(w, "func %s(v *Value) bool {\n", valuefn) + fmt.Fprintf(w, "func %s(v *Value, config *Config) bool {\n", valuefn) // generate code for each rule fmt.Fprintf(w, "switch v.Op {\n") @@ -289,6 +289,9 @@ func genMatch0(w io.Writer, match, v, fail string, m map[string]string, top bool return } // remember that this variable references the given value + if match == "_" { + return + } m[match] = v fmt.Fprintf(w, "%s := %s\n", match, v) return diff --git a/src/cmd/compile/internal/ssa/type.go b/src/cmd/compile/internal/ssa/type.go index 611c85834a..1a61c75afa 100644 --- a/src/cmd/compile/internal/ssa/type.go +++ b/src/cmd/compile/internal/ssa/type.go @@ -16,6 +16,7 @@ type Type interface { IsSigned() bool IsFloat() bool IsPtr() bool + IsString() bool IsMemory() bool // special ssa-package-only types IsFlags() bool @@ -34,6 +35,7 @@ type TypeImpl struct { Signed bool Float bool Ptr bool + string bool Memory bool Flags bool @@ -47,6 +49,7 @@ 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) IsPtr() bool { return t.Ptr } +func (t *TypeImpl) IsString() bool { return t.string } func (t *TypeImpl) IsMemory() bool { return t.Memory } func (t *TypeImpl) IsFlags() bool { return t.Flags } func (t *TypeImpl) String() string { return t.Name } @@ -65,6 +68,7 @@ var ( TypeUInt64 = &TypeImpl{Size_: 8, Integer: true, Name: "uint64"} TypeBool = &TypeImpl{Size_: 1, Boolean: true, Name: "bool"} //TypeString = types.Typ[types.String] + TypeBytePtr = &TypeImpl{Size_: 8, Ptr: true, Name: "*byte"} TypeInvalid = &TypeImpl{Name: "invalid"} -- cgit v1.3 From 1114a76ae6081242c38614aeb4ff9c37b8be75c4 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Thu, 4 Jun 2015 15:18:27 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: Add dummy frontend for testing. Change-Id: Ica26c0297ac7afeb0b5b668cf5f5cd1667c6cc43 Reviewed-on: https://go-review.googlesource.com/10699 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/ssa/deadcode_test.go | 6 +++--- src/cmd/compile/internal/ssa/export_test.go | 6 ++++++ src/cmd/compile/internal/ssa/func_test.go | 4 ++-- 3 files changed, 11 insertions(+), 5 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/deadcode_test.go b/src/cmd/compile/internal/ssa/deadcode_test.go index 07e017c73a..10b8976e0f 100644 --- a/src/cmd/compile/internal/ssa/deadcode_test.go +++ b/src/cmd/compile/internal/ssa/deadcode_test.go @@ -7,7 +7,7 @@ package ssa import "testing" func TestDeadLoop(t *testing.T) { - c := NewConfig("amd64") + c := NewConfig("amd64", DummyFrontend{}) fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, ".mem"), @@ -37,7 +37,7 @@ func TestDeadLoop(t *testing.T) { } func TestDeadValue(t *testing.T) { - c := NewConfig("amd64") + c := NewConfig("amd64", DummyFrontend{}) fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, ".mem"), @@ -60,7 +60,7 @@ func TestDeadValue(t *testing.T) { } func TestNeverTaken(t *testing.T) { - c := NewConfig("amd64") + c := NewConfig("amd64", DummyFrontend{}) fun := Fun(c, "entry", Bloc("entry", Valu("cond", OpConst, TypeBool, false), diff --git a/src/cmd/compile/internal/ssa/export_test.go b/src/cmd/compile/internal/ssa/export_test.go index f2e7b0cd10..103945a73e 100644 --- a/src/cmd/compile/internal/ssa/export_test.go +++ b/src/cmd/compile/internal/ssa/export_test.go @@ -8,3 +8,9 @@ var CheckFunc = checkFunc var PrintFunc = printFunc var Opt = opt var Deadcode = deadcode + +type DummyFrontend struct{} + +func (d DummyFrontend) StringSym(s string) interface{} { + return nil +} diff --git a/src/cmd/compile/internal/ssa/func_test.go b/src/cmd/compile/internal/ssa/func_test.go index b66ab24778..c15b167bc1 100644 --- a/src/cmd/compile/internal/ssa/func_test.go +++ b/src/cmd/compile/internal/ssa/func_test.go @@ -257,7 +257,7 @@ func addEdge(b, c *Block) { } func TestArgs(t *testing.T) { - c := NewConfig("amd64") + c := NewConfig("amd64", DummyFrontend{}) fun := Fun(c, "entry", Bloc("entry", Valu("a", OpConst, TypeInt64, 14), @@ -277,7 +277,7 @@ func TestArgs(t *testing.T) { } func TestEquiv(t *testing.T) { - c := NewConfig("amd64") + c := NewConfig("amd64", DummyFrontend{}) equivalentCases := []struct{ f, g fun }{ // simple case { -- cgit v1.3 From 8d32360bddaafb4e8eafe0e57065b4883b4ec55f Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Tue, 26 May 2015 14:43:25 -0700 Subject: [dev.ssa] cmd/internal/ssa: add deadstore pass Eliminate dead stores. Dead stores are those which are unconditionally followed by another store to the same location, with no intervening load. Just a simple intra-block implementation for now. Change-Id: I2bf54e3a342608fc4e01edbe1b429e83f24764ab Reviewed-on: https://go-review.googlesource.com/10386 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/ssa/compile.go | 4 + src/cmd/compile/internal/ssa/deadstore.go | 103 +++++++++++++++++++++++++ src/cmd/compile/internal/ssa/deadstore_test.go | 87 +++++++++++++++++++++ src/cmd/compile/internal/ssa/op.go | 4 +- 4 files changed, 196 insertions(+), 2 deletions(-) create mode 100644 src/cmd/compile/internal/ssa/deadstore.go create mode 100644 src/cmd/compile/internal/ssa/deadstore_test.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/compile.go b/src/cmd/compile/internal/ssa/compile.go index b497beade9..02c9b5a4a9 100644 --- a/src/cmd/compile/internal/ssa/compile.go +++ b/src/cmd/compile/internal/ssa/compile.go @@ -56,6 +56,7 @@ var passes = [...]pass{ {"opt", opt}, {"generic cse", cse}, {"generic deadcode", deadcode}, + {"dse", dse}, {"fuse", fuse}, {"lower", lower}, {"lowered cse", cse}, @@ -76,6 +77,9 @@ type constraint struct { } var passOrder = [...]constraint{ + // common-subexpression before dead-store elim, so that we recognize + // when two address expressions are the same. + {"generic cse", "dse"}, // don't layout blocks until critical edges have been removed {"critical", "layout"}, // regalloc requires the removal of all critical edges diff --git a/src/cmd/compile/internal/ssa/deadstore.go b/src/cmd/compile/internal/ssa/deadstore.go new file mode 100644 index 0000000000..b02b35460a --- /dev/null +++ b/src/cmd/compile/internal/ssa/deadstore.go @@ -0,0 +1,103 @@ +// 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 "log" + +// 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 := newSparseSet(f.NumValues()) + storeUse := newSparseSet(f.NumValues()) + shadowed := newSparseSet(f.NumValues()) + 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 { + // 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 { + log.Fatalf("two final stores - simultaneous live stores", last, v) + } + last = v + } + if last == nil { + log.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 { + if shadowed.contains(v.Args[0].ID) { + // Modify store into a copy + v.Op = OpCopy + v.Aux = nil + v.SetArgs1(v.Args[2]) + } 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 0000000000..70b2092ec3 --- /dev/null +++ b/src/cmd/compile/internal/ssa/deadstore_test.go @@ -0,0 +1,87 @@ +// 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 := NewConfig("amd64", DummyFrontend{}) + ptrType := &TypeImpl{Size_: 8, Ptr: true, Name: "testptr"} // dummy for testing + fun := Fun(c, "entry", + Bloc("entry", + Valu("start", OpArg, TypeMem, ".mem"), + Valu("v", OpConst, TypeBool, true), + Valu("addr1", OpGlobal, ptrType, nil), + Valu("addr2", OpGlobal, ptrType, nil), + Valu("store1", OpStore, TypeMem, nil, "addr1", "v", "start"), + Valu("store2", OpStore, TypeMem, nil, "addr2", "v", "store1"), + Valu("store3", OpStore, TypeMem, nil, "addr1", "v", "store2"), + Goto("exit")), + Bloc("exit", + Exit("store3"))) + + CheckFunc(fun.f) + dse(fun.f) + CheckFunc(fun.f) + + v := fun.values["store1"] + if v.Op != OpCopy { + t.Errorf("dead store not removed") + } +} +func TestDeadStorePhi(t *testing.T) { + // make sure we don't get into an infinite loop with phi values. + c := NewConfig("amd64", DummyFrontend{}) + ptrType := &TypeImpl{Size_: 8, Ptr: true, Name: "testptr"} // dummy for testing + fun := Fun(c, "entry", + Bloc("entry", + Valu("start", OpArg, TypeMem, ".mem"), + Valu("v", OpConst, TypeBool, true), + Valu("addr", OpGlobal, ptrType, nil), + Goto("loop")), + Bloc("loop", + Valu("phi", OpPhi, TypeMem, nil, "start", "store"), + Valu("store", OpStore, TypeMem, 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 := NewConfig("amd64", DummyFrontend{}) + t1 := &TypeImpl{Size_: 8, Ptr: true, Name: "t1"} + t2 := &TypeImpl{Size_: 4, Ptr: true, Name: "t2"} + fun := Fun(c, "entry", + Bloc("entry", + Valu("start", OpArg, TypeMem, ".mem"), + Valu("v", OpConst, TypeBool, true), + Valu("addr1", OpGlobal, t1, nil), + Valu("addr2", OpGlobal, t2, nil), + Valu("store1", OpStore, TypeMem, nil, "addr1", "v", "start"), + Valu("store2", OpStore, TypeMem, 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/op.go b/src/cmd/compile/internal/ssa/op.go index 5f6b2ca6a6..c8bd3d2f3a 100644 --- a/src/cmd/compile/internal/ssa/op.go +++ b/src/cmd/compile/internal/ssa/op.go @@ -70,8 +70,8 @@ const ( OpStringPtr // ptr(arg0) OpStringLen // len(arg0) - OpLoad // Load from arg0+aux.(int64). arg1=memory - OpStore // Store arg1 to arg0+aux.(int64). arg2=memory. Returns memory. + OpLoad // Load from arg0. arg1=memory + OpStore // Store arg1 to arg0. arg2=memory. Returns memory. OpArrayIndex // arg0=array, arg1=index. Returns a[i] OpPtrIndex // arg0=ptr, arg1=index. Computes ptr+sizeof(*v.type)*index, where index is extended to ptrwidth type OpIsNonNil // arg0 != nil -- cgit v1.3 From e00d60901a225b2b08bb52126704cb3422a569f4 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Tue, 2 Jun 2015 09:16:22 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: minor fixes * Improve some docs and logging. * Set correct type and len for indexing into strings. Fixes #11029. Change-Id: Ib22c45908e41ba3752010d2f5759e37e3921a48e Reviewed-on: https://go-review.googlesource.com/10635 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 19 ++++++++++++++----- src/cmd/compile/internal/ssa/deadcode.go | 2 +- src/cmd/compile/internal/ssa/rewrite.go | 4 ++-- 3 files changed, 17 insertions(+), 8 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 3c95266bdc..fd1c30edee 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -327,11 +327,20 @@ func (s *state) expr(n *Node) *ssa.Value { return s.curBlock.NewValue2(ssa.OpLoad, n.Type, nil, p, s.mem()) case OINDEX: - if n.Left.Type.Bound >= 0 { // array + if n.Left.Type.Bound >= 0 { // array or string a := s.expr(n.Left) i := s.expr(n.Right) - s.boundsCheck(i, s.f.ConstInt(s.config.Uintptr, n.Left.Type.Bound)) - return s.curBlock.NewValue2(ssa.OpArrayIndex, n.Left.Type.Type, nil, a, i) + var elemtype *Type + var len *ssa.Value + if n.Left.Type.IsString() { + len = s.curBlock.NewValue1(ssa.OpStringLen, s.config.Uintptr, nil, a) + elemtype = Types[TUINT8] + } else { + len = s.f.ConstInt(s.config.Uintptr, n.Left.Type.Bound) + elemtype = n.Left.Type.Type + } + s.boundsCheck(i, len) + return s.curBlock.NewValue2(ssa.OpArrayIndex, elemtype, nil, a, i) } else { // slice p := s.addr(n) return s.curBlock.NewValue2(ssa.OpLoad, n.Left.Type.Type, nil, p, s.mem()) @@ -367,7 +376,7 @@ func (s *state) expr(n *Node) *ssa.Value { } } -// expr converts the address of the expression n to SSA, adds it to s and returns the SSA result. +// addr converts the address of the expression n to SSA, adds it to s and returns the SSA result. func (s *state) addr(n *Node) *ssa.Value { switch n.Op { case ONAME: @@ -402,7 +411,7 @@ func (s *state) addr(n *Node) *ssa.Value { return s.curBlock.NewValue2(ssa.OpPtrIndex, Ptrto(n.Left.Type.Type), nil, p, i) } default: - log.Fatalf("addr: bad op %v", n.Op) + log.Fatalf("addr: bad op %v", Oconv(int(n.Op), 0)) return nil } } diff --git a/src/cmd/compile/internal/ssa/deadcode.go b/src/cmd/compile/internal/ssa/deadcode.go index ba5d8758d9..1a5589cd0a 100644 --- a/src/cmd/compile/internal/ssa/deadcode.go +++ b/src/cmd/compile/internal/ssa/deadcode.go @@ -82,7 +82,7 @@ func deadcode(f *Func) { i++ } else { if len(b.Values) > 0 { - panic("live value in unreachable block") + log.Panicf("live values in unreachable block %v: %v", b, b.Values) } f.bid.put(b.ID) } diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go index 6b76e55e2a..fd0fc7e1a7 100644 --- a/src/cmd/compile/internal/ssa/rewrite.go +++ b/src/cmd/compile/internal/ssa/rewrite.go @@ -12,10 +12,10 @@ func applyRewrite(f *Func, rb func(*Block) bool, rv func(*Value, *Config) bool) var curv *Value defer func() { if curb != nil { - log.Printf("panic during rewrite of %s\n", curb.LongString()) + log.Printf("panic during rewrite of block %s\n", curb.LongString()) } if curv != nil { - log.Printf("panic during rewrite of %s\n", curv.LongString()) + log.Printf("panic during rewrite of value %s\n", curv.LongString()) panic("rewrite failed") // TODO(khr): print source location also } -- cgit v1.3 From c8285bb501eb9581af930a9ccd0ad8f791ea2ab2 Mon Sep 17 00:00:00 2001 From: Michael Matloob Date: Fri, 5 Jun 2015 13:04:29 -0400 Subject: [dev.ssa] cmd/compile/internal/ssa: add missing copyright notices Change-Id: I9d4e0f3e9afc9920ee0d77b0073ac8597c7c048f Reviewed-on: https://go-review.googlesource.com/10756 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/func_test.go | 4 ++++ src/cmd/compile/internal/ssa/regalloc.go | 4 ++++ src/cmd/compile/internal/ssa/stackalloc.go | 4 ++++ 3 files changed, 12 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/func_test.go b/src/cmd/compile/internal/ssa/func_test.go index c15b167bc1..947a0b72c4 100644 --- a/src/cmd/compile/internal/ssa/func_test.go +++ b/src/cmd/compile/internal/ssa/func_test.go @@ -1,3 +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 file contains some utility functions to help define Funcs for testing. // As an example, the following func // diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index 23a46d66b4..8da969b660 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -1,3 +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. + package ssa import ( diff --git a/src/cmd/compile/internal/ssa/stackalloc.go b/src/cmd/compile/internal/ssa/stackalloc.go index ab686470be..dd55d96ccc 100644 --- a/src/cmd/compile/internal/ssa/stackalloc.go +++ b/src/cmd/compile/internal/ssa/stackalloc.go @@ -1,3 +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. + package ssa import "log" -- cgit v1.3 From 6241a41e33fb1dcfb36f86b0578592219a36d443 Mon Sep 17 00:00:00 2001 From: Michael Matloob Date: Sat, 30 May 2015 01:03:40 -0400 Subject: [dev.ssa] cmd/compile/internal/ssa: enforce single live mem Change-Id: I21edff280a283895e4f0cbf91a3b4406f2f86788 Reviewed-on: https://go-review.googlesource.com/10558 Reviewed-by: David Chase Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/schedule.go | 47 ++++++++++++++++++++-- src/cmd/compile/internal/ssa/schedule_test.go | 57 +++++++++++++++++++++++++++ 2 files changed, 100 insertions(+), 4 deletions(-) create mode 100644 src/cmd/compile/internal/ssa/schedule_test.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/schedule.go b/src/cmd/compile/internal/ssa/schedule.go index 0a89ac3773..b93b0d8a45 100644 --- a/src/cmd/compile/internal/ssa/schedule.go +++ b/src/cmd/compile/internal/ssa/schedule.go @@ -20,7 +20,40 @@ func schedule(f *Func) { var queue []*Value //stack-like worklist. Contains found and expanded nodes. var order []*Value + nextMem := make([]*Value, f.NumValues()) // maps mem values to the next live value + additionalEdges := make([][]*Value, f.NumValues()) for _, b := range f.Blocks { + // Set the nextMem values for this block. If the previous + // write is from a different block, then its nextMem entry + // might have already been set during processing of an earlier + // block. This loop resets the nextMem entries to be correct + // for this block. + for _, v := range b.Values { + if v.Type.IsMemory() { + for _, w := range v.Args { + if w.Type.IsMemory() { + nextMem[w.ID] = v + } + } + } + } + // Add a anti-dependency between each load v and the memory value n + // following the memory value that v loads from. + // This will enforce the single-live-mem restriction. + for _, v := range b.Values { + if v.Type.IsMemory() { + continue + } + for _, w := range v.Args { + if w.Type.IsMemory() && nextMem[w.ID] != nil { + // Filter for intra-block edges. + if n := nextMem[w.ID]; n.Block == b { + additionalEdges[n.ID] = append(additionalEdges[n.ID], v) + } + } + } + } + // Topologically sort the values in b. order = order[:0] for _, v := range b.Values { @@ -51,6 +84,12 @@ func schedule(f *Func) { queue = append(queue, w) } } + for _, w := range additionalEdges[v.ID] { + if w.Block == b && w.Op != OpPhi && state[w.ID] == unmarked { + state[w.ID] = found + queue = append(queue, w) + } + } case expanded: queue = queue[:len(queue)-1] state[v.ID] = done @@ -62,8 +101,8 @@ func schedule(f *Func) { } copy(b.Values, order) } - // TODO: only allow one live mem type and one live flags type (x86) - // This restriction will force any loads (and any flag uses) to appear - // before the next store (flag update). This "anti-dependence" is not - // recorded explicitly in ssa form. + // TODO: only allow one live flags type (x86) + // This restriction will force and any flag uses to appear before + // the next flag update. This "anti-dependence" is not recorded + // explicitly in ssa form. } 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 0000000000..4830f79628 --- /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 := NewConfig("amd64", DummyFrontend{}) + cases := []fun{ + Fun(c, "entry", + Bloc("entry", + Valu("mem0", OpArg, TypeMem, ".mem"), + Valu("ptr", OpConst, TypeInt64, 0xABCD), + Valu("v", OpConst, TypeInt64, 12), + Valu("mem1", OpStore, TypeMem, 32, "ptr", "v", "mem0"), + Valu("mem2", OpStore, TypeMem, 32, "ptr", "v", "mem1"), + Valu("mem3", OpStore, TypeInt64, "ptr", "sum", "mem2"), + Valu("l1", OpLoad, TypeInt64, 16, "ptr", "mem1"), + Valu("l2", OpLoad, TypeInt64, 8, "ptr", "mem2"), + Valu("sum", OpAdd, TypeInt64, "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 +} -- cgit v1.3 From 0dca7351e9d51bdaf980e1256ec41af8cb1b9747 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Sat, 6 Jun 2015 16:03:33 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: autogenerate opcodes Revamp autogeneration. Get rid of gogenerate commands, they are more trouble than they are worth. (If the code won't compile, gogenerate doesn't work.) Generate opcode enums & tables. This means we only have to specify opcodes in one place instead of two. Add arch prefixes to opcodes so they will be globally unique. Change-Id: I175d0a89b701b2377bbe699f3756731b7c9f5a9f Reviewed-on: https://go-review.googlesource.com/10812 Reviewed-by: Alan Donovan --- src/cmd/compile/internal/gc/ssa.go | 40 +- src/cmd/compile/internal/ssa/block.go | 30 +- src/cmd/compile/internal/ssa/blockkind_string.go | 32 - src/cmd/compile/internal/ssa/config.go | 8 +- src/cmd/compile/internal/ssa/gen/AMD64.rules | 100 ++ src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 161 +++ src/cmd/compile/internal/ssa/gen/README | 7 + src/cmd/compile/internal/ssa/gen/generic.rules | 49 + src/cmd/compile/internal/ssa/gen/genericOps.go | 104 ++ src/cmd/compile/internal/ssa/gen/main.go | 146 +++ src/cmd/compile/internal/ssa/gen/rulegen.go | 480 +++++++++ src/cmd/compile/internal/ssa/lower.go | 4 +- src/cmd/compile/internal/ssa/lowerAmd64.go | 1090 -------------------- src/cmd/compile/internal/ssa/lowergeneric.go | 289 ++++++ src/cmd/compile/internal/ssa/op.go | 176 +--- src/cmd/compile/internal/ssa/opGen.go | 916 ++++++++++++++++ src/cmd/compile/internal/ssa/op_string.go | 32 - src/cmd/compile/internal/ssa/opamd64.go | 196 ---- src/cmd/compile/internal/ssa/opt.go | 5 +- src/cmd/compile/internal/ssa/regalloc.go | 42 +- src/cmd/compile/internal/ssa/rewriteAMD64.go | 1090 ++++++++++++++++++++ src/cmd/compile/internal/ssa/rewritegeneric.go | 424 ++++++++ src/cmd/compile/internal/ssa/rulegen/generic.rules | 49 - .../compile/internal/ssa/rulegen/lower_amd64.rules | 100 -- src/cmd/compile/internal/ssa/rulegen/rulegen.go | 458 -------- src/cmd/compile/internal/ssa/stackalloc.go | 9 +- src/cmd/compile/internal/ssa/value.go | 7 +- 27 files changed, 3843 insertions(+), 2201 deletions(-) delete mode 100644 src/cmd/compile/internal/ssa/blockkind_string.go create mode 100644 src/cmd/compile/internal/ssa/gen/AMD64.rules create mode 100644 src/cmd/compile/internal/ssa/gen/AMD64Ops.go create mode 100644 src/cmd/compile/internal/ssa/gen/README create mode 100644 src/cmd/compile/internal/ssa/gen/generic.rules create mode 100644 src/cmd/compile/internal/ssa/gen/genericOps.go create mode 100644 src/cmd/compile/internal/ssa/gen/main.go create mode 100644 src/cmd/compile/internal/ssa/gen/rulegen.go delete mode 100644 src/cmd/compile/internal/ssa/lowerAmd64.go create mode 100644 src/cmd/compile/internal/ssa/lowergeneric.go create mode 100644 src/cmd/compile/internal/ssa/opGen.go delete mode 100644 src/cmd/compile/internal/ssa/op_string.go delete mode 100644 src/cmd/compile/internal/ssa/opamd64.go create mode 100644 src/cmd/compile/internal/ssa/rewriteAMD64.go create mode 100644 src/cmd/compile/internal/ssa/rewritegeneric.go delete mode 100644 src/cmd/compile/internal/ssa/rulegen/generic.rules delete mode 100644 src/cmd/compile/internal/ssa/rulegen/lower_amd64.rules delete mode 100644 src/cmd/compile/internal/ssa/rulegen/rulegen.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index fd1c30edee..d017a981d4 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -607,7 +607,7 @@ func genssa(f *ssa.Func, ptxt *obj.Prog, gcargs, gclocals *Sym) { func genValue(v *ssa.Value) { switch v.Op { - case ssa.OpADDQ: + case ssa.OpAMD64ADDQ: // TODO: use addq instead of leaq if target is in the right register. p := Prog(x86.ALEAQ) p.From.Type = obj.TYPE_MEM @@ -616,7 +616,7 @@ func genValue(v *ssa.Value) { p.From.Index = regnum(v.Args[1]) p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v) - case ssa.OpADDQconst: + case ssa.OpAMD64ADDQconst: // TODO: use addq instead of leaq if target is in the right register. p := Prog(x86.ALEAQ) p.From.Type = obj.TYPE_MEM @@ -624,7 +624,7 @@ func genValue(v *ssa.Value) { p.From.Offset = v.Aux.(int64) p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v) - case ssa.OpMULQconst: + case ssa.OpAMD64MULQconst: // TODO: this isn't right. doasm fails on it. I don't think obj // has ever been taught to compile imul $c, r1, r2. p := Prog(x86.AIMULQ) @@ -634,7 +634,7 @@ func genValue(v *ssa.Value) { p.From3.Reg = regnum(v.Args[0]) p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v) - case ssa.OpSUBQconst: + case ssa.OpAMD64SUBQconst: // 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]) @@ -652,7 +652,7 @@ func genValue(v *ssa.Value) { p.From.Offset = v.Aux.(int64) p.To.Type = obj.TYPE_REG p.To.Reg = r - case ssa.OpSHLQconst: + case ssa.OpAMD64SHLQconst: x := regnum(v.Args[0]) r := regnum(v) if x != r { @@ -668,7 +668,7 @@ func genValue(v *ssa.Value) { p.From.Offset = v.Aux.(int64) p.To.Type = obj.TYPE_REG p.To.Reg = r - case ssa.OpLEAQ: + case ssa.OpAMD64LEAQ: p := Prog(x86.ALEAQ) p.From.Type = obj.TYPE_MEM p.From.Reg = regnum(v.Args[0]) @@ -677,46 +677,46 @@ func genValue(v *ssa.Value) { p.From.Offset = v.Aux.(int64) p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v) - case ssa.OpCMPQ: + case ssa.OpAMD64CMPQ: p := Prog(x86.ACMPQ) p.From.Type = obj.TYPE_REG p.From.Reg = regnum(v.Args[0]) p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v.Args[1]) - case ssa.OpCMPQconst: + case ssa.OpAMD64CMPQconst: p := Prog(x86.ACMPQ) p.From.Type = obj.TYPE_REG p.From.Reg = regnum(v.Args[0]) p.To.Type = obj.TYPE_CONST p.To.Offset = v.Aux.(int64) - case ssa.OpTESTB: + case ssa.OpAMD64TESTB: p := Prog(x86.ATESTB) p.From.Type = obj.TYPE_REG p.From.Reg = regnum(v.Args[0]) p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v.Args[1]) - case ssa.OpMOVQconst: + case ssa.OpAMD64MOVQconst: x := regnum(v) p := Prog(x86.AMOVQ) p.From.Type = obj.TYPE_CONST p.From.Offset = v.Aux.(int64) p.To.Type = obj.TYPE_REG p.To.Reg = x - case ssa.OpMOVQload: + case ssa.OpAMD64MOVQload: p := Prog(x86.AMOVQ) p.From.Type = obj.TYPE_MEM p.From.Reg = regnum(v.Args[0]) p.From.Offset = v.Aux.(int64) p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v) - case ssa.OpMOVBload: + case ssa.OpAMD64MOVBload: p := Prog(x86.AMOVB) p.From.Type = obj.TYPE_MEM p.From.Reg = regnum(v.Args[0]) p.From.Offset = v.Aux.(int64) p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v) - case ssa.OpMOVQloadidx8: + case ssa.OpAMD64MOVQloadidx8: p := Prog(x86.AMOVQ) p.From.Type = obj.TYPE_MEM p.From.Reg = regnum(v.Args[0]) @@ -725,7 +725,7 @@ func genValue(v *ssa.Value) { p.From.Index = regnum(v.Args[1]) p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v) - case ssa.OpMOVQstore: + case ssa.OpAMD64MOVQstore: p := Prog(x86.AMOVQ) p.From.Type = obj.TYPE_REG p.From.Reg = regnum(v.Args[1]) @@ -775,7 +775,7 @@ func genValue(v *ssa.Value) { case ssa.OpArg: // memory arg needs no code // TODO: only mem arg goes here. - case ssa.OpLEAQglobal: + case ssa.OpAMD64LEAQglobal: g := v.Aux.(ssa.GlobalOffset) p := Prog(x86.ALEAQ) p.From.Type = obj.TYPE_MEM @@ -812,7 +812,7 @@ func genBlock(b, next *ssa.Block, branches []branch) []branch { p.To.Type = obj.TYPE_BRANCH branches = append(branches, branch{p, b.Succs[0]}) } - case ssa.BlockEQ: + case ssa.BlockAMD64EQ: if b.Succs[0] == next { p := Prog(x86.AJNE) p.To.Type = obj.TYPE_BRANCH @@ -829,7 +829,7 @@ func genBlock(b, next *ssa.Block, branches []branch) []branch { q.To.Type = obj.TYPE_BRANCH branches = append(branches, branch{q, b.Succs[1]}) } - case ssa.BlockNE: + case ssa.BlockAMD64NE: if b.Succs[0] == next { p := Prog(x86.AJEQ) p.To.Type = obj.TYPE_BRANCH @@ -846,7 +846,7 @@ func genBlock(b, next *ssa.Block, branches []branch) []branch { q.To.Type = obj.TYPE_BRANCH branches = append(branches, branch{q, b.Succs[1]}) } - case ssa.BlockLT: + case ssa.BlockAMD64LT: if b.Succs[0] == next { p := Prog(x86.AJGE) p.To.Type = obj.TYPE_BRANCH @@ -863,7 +863,7 @@ func genBlock(b, next *ssa.Block, branches []branch) []branch { q.To.Type = obj.TYPE_BRANCH branches = append(branches, branch{q, b.Succs[1]}) } - case ssa.BlockULT: + case ssa.BlockAMD64ULT: if b.Succs[0] == next { p := Prog(x86.AJCC) p.To.Type = obj.TYPE_BRANCH @@ -880,7 +880,7 @@ func genBlock(b, next *ssa.Block, branches []branch) []branch { q.To.Type = obj.TYPE_BRANCH branches = append(branches, branch{q, b.Succs[1]}) } - case ssa.BlockUGT: + case ssa.BlockAMD64UGT: if b.Succs[0] == next { p := Prog(x86.AJLS) p.To.Type = obj.TYPE_BRANCH diff --git a/src/cmd/compile/internal/ssa/block.go b/src/cmd/compile/internal/ssa/block.go index 899d69bc32..85d73bb9b8 100644 --- a/src/cmd/compile/internal/ssa/block.go +++ b/src/cmd/compile/internal/ssa/block.go @@ -4,10 +4,7 @@ package ssa -import ( - "fmt" - "strings" -) +import "fmt" // Block represents a basic block in the control flow graph of a function. type Block struct { @@ -50,29 +47,6 @@ type Block struct { // Call mem [nopanic, panic] (control opcode should be OpCall or OpStaticCall) type BlockKind int32 -// block kind ranges -const ( - blockInvalid BlockKind = 0 - blockGenericBase = 1 + 100*iota - blockAMD64Base - block386Base - - blockMax // sentinel -) - -// generic block kinds -const ( - blockGenericStart BlockKind = blockGenericBase + iota - - BlockExit // no successors. There should only be 1 of these. - BlockPlain // a single successor - BlockIf // 2 successors, if control goto Succs[0] else goto Succs[1] - BlockCall // 2 successors, normal return and panic - // TODO(khr): BlockPanic for the built-in panic call, has 1 edge to the exit block -) - -//go:generate stringer -type=BlockKind - // short form print func (b *Block) String() string { return fmt.Sprintf("b%d", b.ID) @@ -80,7 +54,7 @@ func (b *Block) String() string { // long form print func (b *Block) LongString() string { - s := strings.TrimPrefix(b.Kind.String(), "Block") + s := b.Kind.String() if b.Control != nil { s += fmt.Sprintf(" %s", b.Control) } diff --git a/src/cmd/compile/internal/ssa/blockkind_string.go b/src/cmd/compile/internal/ssa/blockkind_string.go deleted file mode 100644 index 60c820c871..0000000000 --- a/src/cmd/compile/internal/ssa/blockkind_string.go +++ /dev/null @@ -1,32 +0,0 @@ -// generated by stringer -type=BlockKind; DO NOT EDIT - -package ssa - -import "fmt" - -const ( - _BlockKind_name_0 = "blockInvalid" - _BlockKind_name_1 = "blockGenericStartBlockExitBlockPlainBlockIfBlockCall" - _BlockKind_name_2 = "blockAMD64StartBlockEQBlockNEBlockLTBlockLEBlockGTBlockGEBlockULTBlockULEBlockUGTBlockUGE" -) - -var ( - _BlockKind_index_0 = [...]uint8{0, 12} - _BlockKind_index_1 = [...]uint8{0, 17, 26, 36, 43, 52} - _BlockKind_index_2 = [...]uint8{0, 15, 22, 29, 36, 43, 50, 57, 65, 73, 81, 89} -) - -func (i BlockKind) String() string { - switch { - case i == 0: - return _BlockKind_name_0 - case 101 <= i && i <= 105: - i -= 101 - return _BlockKind_name_1[_BlockKind_index_1[i]:_BlockKind_index_1[i+1]] - case 201 <= i && i <= 211: - i -= 201 - return _BlockKind_name_2[_BlockKind_index_2[i]:_BlockKind_index_2[i+1]] - default: - return fmt.Sprintf("BlockKind(%d)", i) - } -} diff --git a/src/cmd/compile/internal/ssa/config.go b/src/cmd/compile/internal/ssa/config.go index 7c5e07e12a..db2d80a7c4 100644 --- a/src/cmd/compile/internal/ssa/config.go +++ b/src/cmd/compile/internal/ssa/config.go @@ -30,12 +30,12 @@ func NewConfig(arch string, fe Frontend) *Config { switch arch { case "amd64": c.ptrSize = 8 - c.lowerBlock = lowerBlockAMD64 - c.lowerValue = lowerValueAMD64 + c.lowerBlock = rewriteBlockAMD64 + c.lowerValue = rewriteValueAMD64 case "386": c.ptrSize = 4 - c.lowerBlock = lowerBlockAMD64 - c.lowerValue = lowerValueAMD64 // TODO(khr): full 32-bit support + c.lowerBlock = rewriteBlockAMD64 + c.lowerValue = rewriteValueAMD64 // TODO(khr): full 32-bit support default: log.Fatalf("arch %s not implemented", arch) } 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 0000000000..c4ff744421 --- /dev/null +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -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. + +// x86 register conventions: +// - Integer types live in the low portion of registers. +// Upper portions are correctly extended. +// - 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. + +// These are the lowerings themselves +(Add x y) && (is64BitInt(t) || isPtr(t)) -> (ADDQ x y) +(Add x y) && is32BitInt(t) -> (ADDL x y) + +(Sub x y) && is64BitInt(t) -> (SUBQ x y) + +(Mul x y) && is64BitInt(t) -> (MULQ x y) +(Lsh x y) && is64BitInt(t) -> (SHLQ x y) // TODO: check y>63 +(Less x y) && is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type) -> (SETL (CMPQ x y)) + +(Load ptr mem) && t.IsBoolean() -> (MOVBload [int64(0)] ptr mem) +(Load ptr mem) && (is64BitInt(t) || isPtr(t)) -> (MOVQload [int64(0)] ptr mem) +(Store ptr val mem) && (is64BitInt(val.Type) || isPtr(val.Type)) -> (MOVQstore [int64(0)] ptr val mem) + +// checks +(IsNonNil p) -> (SETNE (TESTQ p p)) +(IsInBounds idx len) -> (SETB (CMPQ idx len)) + +(Move [size] dst src mem) -> (REPMOVSB dst src (Const [size.(int64)]) mem) + +(OffPtr [off] ptr) -> (ADDQconst [off] ptr) + +(Const [val]) && is64BitInt(t) -> (MOVQconst [val]) + +// block rewrites +(If (SETL cmp) yes no) -> (LT cmp yes no) +(If (SETNE cmp) yes no) -> (NE cmp yes no) +(If (SETB cmp) yes no) -> (ULT cmp yes no) +(If cond yes no) && cond.Op == OpAMD64MOVBload -> (NE (TESTB cond cond) yes no) + +// Rules below here apply some simple optimizations after lowering. +// TODO: Should this be a separate pass? + +// global loads/stores +(Global [sym]) -> (LEAQglobal [GlobalOffset{sym,0}]) + +// fold constants into instructions +(ADDQ x (MOVQconst [c])) -> (ADDQconst [c] x) // TODO: restrict c to int32 range? +(ADDQ (MOVQconst [c]) x) -> (ADDQconst [c] x) +(SUBQ x (MOVQconst [c])) -> (SUBQconst x [c]) +(SUBQ (MOVQconst [c]) x) -> (NEGQ (SUBQconst x [c])) +(MULQ x (MOVQconst [c])) && c.(int64) == int64(int32(c.(int64))) -> (MULQconst [c] x) +(MULQ (MOVQconst [c]) x) -> (MULQconst [c] x) +(SHLQ x (MOVQconst [c])) -> (SHLQconst [c] x) +(CMPQ x (MOVQconst [c])) -> (CMPQconst x [c]) +(CMPQ (MOVQconst [c]) x) -> (InvertFlags (CMPQconst x [c])) + +// strength reduction +// TODO: do this a lot more generically +(MULQconst [c] x) && c.(int64) == 8 -> (SHLQconst [int64(3)] x) +(MULQconst [c] x) && c.(int64) == 64 -> (SHLQconst [int64(5)] x) + +// fold add/shift into leaq +(ADDQ x (SHLQconst [shift] y)) && shift.(int64) == 3 -> (LEAQ8 [int64(0)] x y) +(ADDQconst [c] (LEAQ8 [d] x y)) -> (LEAQ8 [addOff(c, d)] x y) + +// reverse ordering of compare instruction +(SETL (InvertFlags x)) -> (SETG x) +(SETG (InvertFlags x)) -> (SETL x) + +// 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] (ADDQconst [off2] ptr) mem) -> (MOVQload [addOff(off1, off2)] ptr mem) +(MOVQstore [off1] (ADDQconst [off2] ptr) val mem) -> (MOVQstore [addOff(off1, off2)] ptr val mem) + +// indexed loads and stores +(MOVQload [off1] (LEAQ8 [off2] ptr idx) mem) -> (MOVQloadidx8 [addOff(off1, off2)] ptr idx mem) +(MOVQstore [off1] (LEAQ8 [off2] ptr idx) val mem) -> (MOVQstoreidx8 [addOff(off1, off2)] ptr idx val mem) + +(MOVQloadidx8 [off1] (ADDQconst [off2] ptr) idx mem) -> (MOVQloadidx8 [addOff(off1, off2)] ptr idx mem) +(MOVQstoreidx8 [off1] (ADDQconst [off2] ptr) idx val mem) -> (MOVQstoreidx8 [addOff(off1, off2)] ptr idx val mem) + +(ADDQconst [off] x) && off.(int64) == 0 -> (Copy x) + +// 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) 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 0000000000..38d1e87575 --- /dev/null +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.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. + +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 + ".FP", + ".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 + } + + gp := buildReg("AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15") + gpsp := gp | buildReg("SP FP") + gp01 := regInfo{[]regMask{}, 0, []regMask{gp}} + gp11 := regInfo{[]regMask{gpsp}, 0, []regMask{gp}} + gp21 := regInfo{[]regMask{gpsp, gpsp}, 0, []regMask{gp}} + gp21shift := regInfo{[]regMask{gpsp, buildReg("CX")}, 0, []regMask{gp}} + gp2flags := regInfo{[]regMask{gpsp, gpsp}, 0, []regMask{buildReg("FLAGS")}} + gp1flags := regInfo{[]regMask{gpsp}, 0, []regMask{buildReg("FLAGS")}} + gpload := regInfo{[]regMask{gpsp, 0}, 0, []regMask{gp}} + gploadidx := regInfo{[]regMask{gpsp, gpsp, 0}, 0, []regMask{gp}} + gpstore := regInfo{[]regMask{gpsp, gpsp, 0}, 0, nil} + gpstoreidx := regInfo{[]regMask{gpsp, gpsp, gpsp, 0}, 0, nil} + flagsgp := regInfo{[]regMask{buildReg("FLAGS")}, 0, []regMask{gp}} + + // 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{ + {name: "ADDQ", reg: gp21}, // arg0 + arg1 + {name: "ADDQconst", reg: gp11}, // arg0 + aux.(int64) + {name: "SUBQ", reg: gp21}, // arg0 - arg1 + {name: "SUBQconst", reg: gp11}, // arg0 - aux.(int64) + {name: "MULQ", reg: gp21}, // arg0 * arg1 + {name: "MULQconst", reg: gp11}, // arg0 * aux.(int64) + {name: "SHLQ", reg: gp21shift}, // arg0 << arg1, shift amount is mod 64 + {name: "SHLQconst", reg: gp11}, // arg0 << aux.(int64), shift amount 0-63 + {name: "NEGQ", reg: gp11}, // -arg0 + + {name: "CMPQ", reg: gp2flags}, // arg0 compare to arg1 + {name: "CMPQconst", reg: gp1flags}, // arg0 compare to aux.(int64) + {name: "TESTQ", reg: gp2flags}, // (arg0 & arg1) compare to 0 + {name: "TESTB", reg: gp2flags}, // (arg0 & arg1) compare to 0 + + {name: "SETEQ", reg: flagsgp}, // extract == condition from arg0 + {name: "SETNE", reg: flagsgp}, // extract != condition from arg0 + {name: "SETL", reg: flagsgp}, // extract signed < condition from arg0 + {name: "SETG", reg: flagsgp}, // extract signed > condition from arg0 + {name: "SETGE", reg: flagsgp}, // extract signed >= condition from arg0 + {name: "SETB", reg: flagsgp}, // extract unsigned < condition from arg0 + + {name: "MOVQconst", reg: gp01}, // aux.(int64) + {name: "LEAQ", reg: gp21}, // arg0 + arg1 + aux.(int64) + {name: "LEAQ2", reg: gp21}, // arg0 + 2*arg1 + aux.(int64) + {name: "LEAQ4", reg: gp21}, // arg0 + 4*arg1 + aux.(int64) + {name: "LEAQ8", reg: gp21}, // arg0 + 8*arg1 + aux.(int64) + {name: "LEAQglobal", reg: gp01}, // no args. address of aux.(GlobalOffset) + + {name: "MOVBload", reg: gpload}, // load byte from arg0+aux.(int64). arg1=mem + {name: "MOVBQZXload", reg: gpload}, // ditto, extend to uint64 + {name: "MOVBQSXload", reg: gpload}, // ditto, extend to int64 + {name: "MOVQload", reg: gpload}, // load 8 bytes from arg0+aux.(int64). arg1=mem + {name: "MOVQloadidx8", reg: gploadidx}, // load 8 bytes from arg0+8*arg1+aux.(int64). arg2=mem + {name: "MOVBstore", reg: gpstore}, // store byte in arg1 to arg0+aux.(int64). arg2=mem + {name: "MOVQstore", reg: gpstore}, // store 8 bytes in arg1 to arg0+aux.(int64). arg2=mem + {name: "MOVQstoreidx8", reg: gpstoreidx}, // store 8 bytes in arg2 to arg0+8*arg1+aux.(int64). arg3=mem + + // Load/store from global. Same as the above loads, but arg0 is missing and + // aux is a GlobalOffset instead of an int64. + {name: "MOVQloadglobal"}, // Load from aux.(GlobalOffset). arg0 = memory + {name: "MOVQstoreglobal"}, // store arg0 to aux.(GlobalOffset). arg1=memory, returns memory. + + {name: "REPMOVSB", reg: regInfo{[]regMask{buildReg("DI"), buildReg("SI"), buildReg("CX")}, buildReg("DI SI CX"), nil}}, // move arg2 bytes from arg1 to arg0. arg3=mem, returns memory + + {name: "ADDL", reg: gp21}, // arg0+arg1 + + // (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"}, // reverse direction of arg0 + } + + var AMD64blocks = []blockData{ + {name: "EQ"}, + {name: "NE"}, + {name: "LT"}, + {name: "LE"}, + {name: "GT"}, + {name: "GE"}, + {name: "ULT"}, + {name: "ULE"}, + {name: "UGT"}, + {name: "UGE"}, + } + + archs = append(archs, arch{"AMD64", AMD64ops, AMD64blocks}) +} diff --git a/src/cmd/compile/internal/ssa/gen/README b/src/cmd/compile/internal/ssa/gen/README new file mode 100644 index 0000000000..6731b970b3 --- /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 0000000000..b01952f402 --- /dev/null +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -0,0 +1,49 @@ +// 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 [aux] arg0 arg1 ...) +// the type and aux fields are optional +// on the matching side +// - the types and aux 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. +// - 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 +(Add (Const [c]) (Const [d])) && is64BitInt(t) -> (Const [{c.(int64)+d.(int64)}]) +(Mul (Const [c]) (Const [d])) && is64BitInt(t) -> (Const [{c.(int64)*d.(int64)}]) +(IsInBounds (Const [c]) (Const [d])) -> (Const [inBounds(c.(int64),d.(int64))]) + +// tear apart slices +// TODO: anything that generates a slice needs to go in here. +(SlicePtr (Load ptr mem)) -> (Load ptr mem) +(SliceLen (Load ptr mem)) -> (Load (Add ptr (Const [int64(config.ptrSize)])) mem) +(SliceCap (Load ptr mem)) -> (Load (Add ptr (Const [int64(config.ptrSize*2)])) mem) + +// indexing operations +// Note: bounds check has already been done +(ArrayIndex (Load ptr mem) idx) -> (Load (PtrIndex ptr idx) mem) +(PtrIndex ptr idx) -> (Add ptr (Mul idx (Const [t.Elem().Size()]))) + +// big-object moves +// TODO: fix size +(Store dst (Load src mem) mem) && t.Size() > 8 -> (Move [t.Size()] dst src mem) + +// string ops +(Const [s]) && t.IsString() -> (StringMake (OffPtr [2*config.ptrSize] (Global [config.fe.StringSym(s.(string))])) (Const [int64(len(s.(string)))])) // TODO: ptr +(Load ptr mem) && t.IsString() -> (StringMake (Load ptr mem) (Load (OffPtr [config.ptrSize] ptr) mem)) +(StringPtr (StringMake ptr _)) -> ptr +(StringLen (StringMake _ len)) -> len +(Store dst str mem) && str.Type.IsString() -> (Store (OffPtr [config.ptrSize] dst) (StringLen str) (Store dst (StringPtr str) mem)) + +(If (Const [c]) yes no) && c.(bool) -> (Plain nil yes) +(If (Const [c]) yes no) && !c.(bool) -> (Plain nil no) 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 0000000000..e8c3cbeb8a --- /dev/null +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -0,0 +1,104 @@ +// 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: "Add"}, // arg0 + arg1 + {name: "Sub"}, // arg0 - arg1 + {name: "Mul"}, // arg0 * arg1 + {name: "Lsh"}, // arg0 << arg1 + {name: "Rsh"}, // arg0 >> arg1 (signed/unsigned depending on signedness of type) + + // 2-input comparisons + {name: "Less"}, // arg0 < arg1 + + // Data movement + {name: "Phi"}, // select an argument based on which predecessor block we came from + {name: "Copy"}, // output = arg0 + + // constants. Constant values are stored in the aux field. + // booleans have a bool aux field, strings have a string aux + // field, and so on. All integer types store their value + // in the aux field as an int64 (including int, uint64, etc.). + // We could store int8 as an int8, but that won't work for int, + // as it may be different widths on the host and target. + {name: "Const"}, + + // Constant-like things + {name: "Arg"}, // address of a function parameter/result. Memory input is an arg called ".mem". aux is a string (TODO: make it something other than a string?) + {name: "Global"}, // the address of a global variable aux.(*gc.Sym) + {name: "SP"}, // stack pointer + {name: "FP"}, // frame pointer + {name: "Func"}, // entry address of a function + + // Memory operations + {name: "Load"}, // Load from arg0+aux.(int64). arg1=memory + {name: "Store"}, // Store arg1 to arg0+aux.(int64). arg2=memory. Returns memory. + {name: "Move"}, // arg0=destptr, arg1=srcptr, arg2=mem, aux.(int64)=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: "Call"}, // arg0=code pointer, arg1=context ptr, arg2=memory. Returns memory. + {name: "StaticCall"}, // call function aux.(*gc.Sym), arg0=memory. Returns memory. + + // Conversions + {name: "Convert"}, // convert arg0 to another type + {name: "ConvNop"}, // interpret arg0 as another type + + // Safety checks + {name: "IsNonNil"}, // arg0 != nil + {name: "IsInBounds"}, // 0 <= arg0 < arg1 + + // Indexing operations + {name: "ArrayIndex"}, // arg0=array, arg1=index. Returns a[i] + {name: "PtrIndex"}, // arg0=ptr, arg1=index. Computes ptr+sizeof(*v.type)*index, where index is extended to ptrwidth type + {name: "OffPtr"}, // arg0 + aux.(int64) (arg0 and result are pointers) + + // Slices + {name: "SliceMake"}, // arg0=ptr, arg1=len, arg2=cap + {name: "SlicePtr"}, // ptr(arg0) + {name: "SliceLen"}, // len(arg0) + {name: "SliceCap"}, // cap(arg0) + + // Strings + {name: "StringMake"}, // arg0=ptr, arg1=len + {name: "StringPtr"}, // ptr(arg0) + {name: "StringLen"}, // len(arg0) + + // 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. + // TODO: remove these, make them arch-specific ops stored + // in the fields of Config instead. + {name: "StoreReg8"}, + {name: "LoadReg8"}, + + // Used during ssa construction. Like Copy, but the arg has not been specified yet. + {name: "FwdRef"}, +} + +// 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) + +var genericBlocks = []blockData{ + {name: "Exit"}, // no successors. There should only be 1 of these. + {name: "Plain"}, // a single successor + {name: "If"}, // 2 successors, if control goto Succs[0] else goto Succs[1] + {name: "Call"}, // 2 successors, normal return and panic + // TODO(khr): BlockPanic for the built-in panic call, has 1 edge to the exit block +} + +func init() { + archs = append(archs, arch{"generic", genericOps, genericBlocks}) +} 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 0000000000..56b47bd99e --- /dev/null +++ b/src/cmd/compile/internal/ssa/gen/main.go @@ -0,0 +1,146 @@ +// 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" + "fmt" + "go/format" + "io/ioutil" + "log" +) + +type arch struct { + name string + ops []opData + blocks []blockData +} + +type opData struct { + name string + reg regInfo +} + +type blockData struct { + name string +} + +type regInfo struct { + inputs []regMask + clobbers regMask + outputs []regMask +} + +type regMask uint64 + +var archs []arch + +func main() { + 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, "package ssa") + + // 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) + fmt.Fprintln(w, "reg:regInfo{") + fmt.Fprintln(w, "inputs: []regMask{") + for _, r := range v.reg.inputs { + fmt.Fprintf(w, "%d,\n", r) + } + fmt.Fprintln(w, "},") + fmt.Fprintf(w, "clobbers: %d,\n", v.reg.clobbers) + fmt.Fprintln(w, "outputs: []regMask{") + for _, r := range v.reg.outputs { + fmt.Fprintf(w, "%d,\n", r) + } + fmt.Fprintln(w, "},") + fmt.Fprintln(w, "},") + if a.name == "generic" { + fmt.Fprintln(w, "generic:true,") + } + fmt.Fprintln(w, "},") + } + } + fmt.Fprintln(w, "}") + + // 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 { + panic(err) + } + + err = ioutil.WriteFile("../opGen.go", b, 0666) + if err != nil { + log.Fatalf("can't write output: %v\n", err) + } +} + +// 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) + } +} 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 0000000000..5edf178a8a --- /dev/null +++ b/src/cmd/compile/internal/ssa/gen/rulegen.go @@ -0,0 +1,480 @@ +// 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" + "crypto/md5" + "fmt" + "go/format" + "io" + "io/ioutil" + "log" + "os" + "sort" + "strings" +) + +// rule syntax: +// sexpr [&& extra conditions] -> sexpr +// +// sexpr are s-expressions (lisp-like parenthesized groupings) +// sexpr ::= (opcode sexpr*) +// | variable +// | [aux] +// | +// | {code} +// +// 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. + +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][]string{} + oprules := map[string][]string{} + + // read rule file + scanner := bufio.NewScanner(text) + for scanner.Scan() { + 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] + } + line = strings.TrimSpace(line) + if line == "" { + continue + } + op := strings.Split(line, " ")[0][1:] + if isBlock(op, arch) { + blockrules[op] = append(blockrules[op], line) + } else { + oprules[op] = append(oprules[op], line) + } + } + if err := scanner.Err(); err != nil { + log.Fatalf("scanner failed: %v\n", err) + } + + // 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, "package ssa") + fmt.Fprintf(w, "func rewriteValue%s(v *Value, config *Config) bool {\n", arch.name) + + // generate code for each rule + fmt.Fprintf(w, "switch v.Op {\n") + var ops []string + for op := range oprules { + ops = append(ops, op) + } + sort.Strings(ops) + for _, op := range ops { + fmt.Fprintf(w, "case %s:\n", opName(op, arch)) + for _, rule := range oprules[op] { + // Note: we use a hash to identify the rule so that its + // identity is invariant to adding/removing rules elsewhere + // in the rules file. This is useful to squash spurious + // diffs that would occur if we used rule index. + rulehash := fmt.Sprintf("%02x", md5.Sum([]byte(rule))) + + // split at -> + s := strings.Split(rule, "->") + if len(s) != 2 { + log.Fatalf("no arrow in rule %s", rule) + } + lhs := strings.TrimSpace(s[0]) + result := strings.TrimSpace(s[1]) + + // split match into matching part and additional condition + match := lhs + cond := "" + if i := strings.Index(match, "&&"); i >= 0 { + cond = strings.TrimSpace(match[i+2:]) + match = strings.TrimSpace(match[:i]) + } + + fmt.Fprintf(w, "// match: %s\n", match) + fmt.Fprintf(w, "// cond: %s\n", cond) + fmt.Fprintf(w, "// result: %s\n", result) + + fail := fmt.Sprintf("{\ngoto end%s\n}\n", rulehash) + + fmt.Fprintf(w, "{\n") + genMatch(w, arch, match, fail) + + if cond != "" { + fmt.Fprintf(w, "if !(%s) %s", cond, fail) + } + + genResult(w, arch, result) + fmt.Fprintf(w, "return true\n") + + fmt.Fprintf(w, "}\n") + fmt.Fprintf(w, "goto end%s\n", rulehash) // use label + fmt.Fprintf(w, "end%s:;\n", rulehash) + } + } + fmt.Fprintf(w, "}\n") + fmt.Fprintf(w, "return false\n") + fmt.Fprintf(w, "}\n") + + // Generate block rewrite function. + 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] { + rulehash := fmt.Sprintf("%02x", md5.Sum([]byte(rule))) + // split at -> + s := strings.Split(rule, "->") + if len(s) != 2 { + log.Fatalf("no arrow in rule %s", rule) + } + lhs := strings.TrimSpace(s[0]) + result := strings.TrimSpace(s[1]) + + // split match into matching part and additional condition + match := lhs + cond := "" + if i := strings.Index(match, "&&"); i >= 0 { + cond = strings.TrimSpace(match[i+2:]) + match = strings.TrimSpace(match[:i]) + } + + fmt.Fprintf(w, "// match: %s\n", match) + fmt.Fprintf(w, "// cond: %s\n", cond) + fmt.Fprintf(w, "// result: %s\n", result) + + fail := fmt.Sprintf("{\ngoto end%s\n}\n", rulehash) + + fmt.Fprintf(w, "{\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", fail, 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) %s", cond, fail) + } + + // Rule matches. Generate result. + t := split(result[1 : len(result)-1]) // remove parens, then split + newsuccs := t[2:] + + // Check if newsuccs is a subset of 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) + } + + // Modify predecessor lists for no-longer-reachable blocks + for succ := range m { + fmt.Fprintf(w, "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)) + } + 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) + } + + fmt.Fprintf(w, "return true\n") + + fmt.Fprintf(w, "}\n") + fmt.Fprintf(w, "goto end%s\n", rulehash) // use label + fmt.Fprintf(w, "end%s:;\n", rulehash) + } + } + fmt.Fprintf(w, "}\n") + fmt.Fprintf(w, "return false\n") + fmt.Fprintf(w, "}\n") + + // gofmt result + b := w.Bytes() + b, err = format.Source(b) + if err != nil { + panic(err) + } + + // Write to file + err = ioutil.WriteFile("../rewrite"+arch.name+".go", b, 0666) + if err != nil { + log.Fatalf("can't write output: %v\n", err) + } +} + +func genMatch(w io.Writer, arch arch, match, fail string) { + genMatch0(w, arch, match, "v", fail, map[string]string{}, true) +} + +func genMatch0(w io.Writer, arch arch, match, v, fail string, m map[string]string, top bool) { + if match[0] != '(' { + if x, 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 %s", v, x, fail) + 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 %s", v, opName(s[0], arch), fail) + } + + // check type/aux/args + argnum := 0 + for _, a := range s[1:] { + if a[0] == '<' { + // type restriction + t := a[1 : len(a)-1] // remove <> + if t[0] == '{' { + // code. We must match the results of this code. + fmt.Fprintf(w, "if %s.Type != %s %s", v, t[1:len(t)-1], fail) + } else { + // variable + if u, ok := m[t]; ok { + // must match previous variable + fmt.Fprintf(w, "if %s.Type != %s %s", v, u, fail) + } else { + m[t] = v + ".Type" + fmt.Fprintf(w, "%s := %s.Type\n", t, v) + } + } + } else if a[0] == '[' { + // aux restriction + x := a[1 : len(a)-1] // remove [] + if x[0] == '{' { + // code + fmt.Fprintf(w, "if %s.Aux != %s %s", v, x[1:len(x)-1], fail) + } else { + // variable + if y, ok := m[x]; ok { + fmt.Fprintf(w, "if %s.Aux != %s %s", v, y, fail) + } else { + m[x] = v + ".Aux" + fmt.Fprintf(w, "%s := %s.Aux\n", x, v) + } + } + } else if a[0] == '{' { + fmt.Fprintf(w, "if %s.Args[%d] != %s %s", v, argnum, a[1:len(a)-1], fail) + argnum++ + } else { + // variable or sexpr + genMatch0(w, arch, a, fmt.Sprintf("%s.Args[%d]", v, argnum), fail, m, false) + argnum++ + } + } +} + +func genResult(w io.Writer, arch arch, result string) { + genResult0(w, arch, result, new(int), true) +} +func genResult0(w io.Writer, arch arch, result string, alloc *int, top bool) string { + if result[0] != '(' { + // variable + if top { + fmt.Fprintf(w, "v.Op = %s.Op\n", result) + fmt.Fprintf(w, "v.Aux = %s.Aux\n", result) + fmt.Fprintf(w, "v.resetArgs()\n") + fmt.Fprintf(w, "v.AddArgs(%s.Args...)\n", result) + } + return result + } + + s := split(result[1 : len(result)-1]) // remove parens, then split + var v string + var hasType bool + if top { + v = "v" + fmt.Fprintf(w, "v.Op = %s\n", opName(s[0], arch)) + fmt.Fprintf(w, "v.Aux = nil\n") + fmt.Fprintf(w, "v.resetArgs()\n") + hasType = true + } else { + v = fmt.Sprintf("v%d", *alloc) + *alloc++ + fmt.Fprintf(w, "%s := v.Block.NewValue(%s, TypeInvalid, nil)\n", v, opName(s[0], arch)) + } + for _, a := range s[1:] { + if a[0] == '<' { + // type restriction + t := a[1 : len(a)-1] // remove <> + if t[0] == '{' { + t = t[1 : len(t)-1] // remove {} + } + fmt.Fprintf(w, "%s.Type = %s\n", v, t) + hasType = true + } else if a[0] == '[' { + // aux restriction + x := a[1 : len(a)-1] // remove [] + if x[0] == '{' { + x = x[1 : len(x)-1] // remove {} + } + fmt.Fprintf(w, "%s.Aux = %s\n", v, x) + } else if a[0] == '{' { + fmt.Fprintf(w, "%s.AddArg(%s)\n", v, a[1:len(a)-1]) + } else { + // regular argument (sexpr or variable) + x := genResult0(w, arch, a, alloc, false) + fmt.Fprintf(w, "%s.AddArg(%s)\n", v, x) + } + } + if !hasType { + log.Fatalf("sub-expression %s must have a type", result) + } + 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 +} diff --git a/src/cmd/compile/internal/ssa/lower.go b/src/cmd/compile/internal/ssa/lower.go index ebed4f2607..2ca1db784e 100644 --- a/src/cmd/compile/internal/ssa/lower.go +++ b/src/cmd/compile/internal/ssa/lower.go @@ -6,8 +6,6 @@ package ssa import "log" -//go:generate go run rulegen/rulegen.go rulegen/lower_amd64.rules lowerBlockAMD64 lowerValueAMD64 lowerAmd64.go - // convert to machine-dependent ops func lower(f *Func) { // repeat rewrites until we find no more rewrites @@ -16,7 +14,7 @@ func lower(f *Func) { // Check for unlowered opcodes, fail if we find one. for _, b := range f.Blocks { for _, v := range b.Values { - if v.Op < OpGenericEnd && v.Op != OpFP && v.Op != OpSP && v.Op != OpArg && v.Op != OpCopy && v.Op != OpPhi { + if opcodeTable[v.Op].generic && v.Op != OpFP && v.Op != OpSP && v.Op != OpArg && v.Op != OpCopy && v.Op != OpPhi { log.Panicf("%s not lowered", v.LongString()) } } diff --git a/src/cmd/compile/internal/ssa/lowerAmd64.go b/src/cmd/compile/internal/ssa/lowerAmd64.go deleted file mode 100644 index 6b5ff3e39f..0000000000 --- a/src/cmd/compile/internal/ssa/lowerAmd64.go +++ /dev/null @@ -1,1090 +0,0 @@ -// autogenerated from rulegen/lower_amd64.rules: do not edit! -// generated with: go run rulegen/rulegen.go rulegen/lower_amd64.rules lowerBlockAMD64 lowerValueAMD64 lowerAmd64.go -package ssa - -func lowerValueAMD64(v *Value, config *Config) bool { - switch v.Op { - case OpADDQ: - // match: (ADDQ x (MOVQconst [c])) - // cond: - // result: (ADDQconst [c] x) - { - x := v.Args[0] - if v.Args[1].Op != OpMOVQconst { - goto endacffd55e74ee0ff59ad58a18ddfc9973 - } - c := v.Args[1].Aux - v.Op = OpADDQconst - v.Aux = nil - v.resetArgs() - v.Aux = c - v.AddArg(x) - return true - } - goto endacffd55e74ee0ff59ad58a18ddfc9973 - endacffd55e74ee0ff59ad58a18ddfc9973: - ; - // match: (ADDQ (MOVQconst [c]) x) - // cond: - // result: (ADDQconst [c] x) - { - if v.Args[0].Op != OpMOVQconst { - goto end7166f476d744ab7a51125959d3d3c7e2 - } - c := v.Args[0].Aux - x := v.Args[1] - v.Op = OpADDQconst - v.Aux = nil - v.resetArgs() - v.Aux = c - v.AddArg(x) - return true - } - goto end7166f476d744ab7a51125959d3d3c7e2 - end7166f476d744ab7a51125959d3d3c7e2: - ; - // match: (ADDQ x (SHLQconst [shift] y)) - // cond: shift.(int64) == 3 - // result: (LEAQ8 [int64(0)] x y) - { - x := v.Args[0] - if v.Args[1].Op != OpSHLQconst { - goto endaf4f724e1e17f2b116d336c07da0165d - } - shift := v.Args[1].Aux - y := v.Args[1].Args[0] - if !(shift.(int64) == 3) { - goto endaf4f724e1e17f2b116d336c07da0165d - } - v.Op = OpLEAQ8 - v.Aux = nil - v.resetArgs() - v.Aux = int64(0) - v.AddArg(x) - v.AddArg(y) - return true - } - goto endaf4f724e1e17f2b116d336c07da0165d - endaf4f724e1e17f2b116d336c07da0165d: - ; - case OpADDQconst: - // match: (ADDQconst [c] (LEAQ8 [d] x y)) - // cond: - // result: (LEAQ8 [addOff(c, d)] x y) - { - c := v.Aux - if v.Args[0].Op != OpLEAQ8 { - goto ende2cc681c9abf9913288803fb1b39e639 - } - d := v.Args[0].Aux - x := v.Args[0].Args[0] - y := v.Args[0].Args[1] - v.Op = OpLEAQ8 - v.Aux = nil - v.resetArgs() - v.Aux = addOff(c, d) - v.AddArg(x) - v.AddArg(y) - return true - } - goto ende2cc681c9abf9913288803fb1b39e639 - ende2cc681c9abf9913288803fb1b39e639: - ; - // match: (ADDQconst [off] x) - // cond: off.(int64) == 0 - // result: (Copy x) - { - off := v.Aux - x := v.Args[0] - if !(off.(int64) == 0) { - goto endfa1c7cc5ac4716697e891376787f86ce - } - v.Op = OpCopy - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto endfa1c7cc5ac4716697e891376787f86ce - endfa1c7cc5ac4716697e891376787f86ce: - ; - case OpAdd: - // match: (Add x y) - // cond: (is64BitInt(t) || isPtr(t)) - // result: (ADDQ x y) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - if !(is64BitInt(t) || isPtr(t)) { - goto endf031c523d7dd08e4b8e7010a94cd94c9 - } - v.Op = OpADDQ - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto endf031c523d7dd08e4b8e7010a94cd94c9 - endf031c523d7dd08e4b8e7010a94cd94c9: - ; - // match: (Add x y) - // cond: is32BitInt(t) - // result: (ADDL x y) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - if !(is32BitInt(t)) { - goto end35a02a1587264e40cf1055856ff8445a - } - v.Op = OpADDL - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto end35a02a1587264e40cf1055856ff8445a - end35a02a1587264e40cf1055856ff8445a: - ; - case OpCMPQ: - // match: (CMPQ x (MOVQconst [c])) - // cond: - // result: (CMPQconst x [c]) - { - x := v.Args[0] - if v.Args[1].Op != OpMOVQconst { - goto end32ef1328af280ac18fa8045a3502dae9 - } - c := v.Args[1].Aux - v.Op = OpCMPQconst - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.Aux = c - return true - } - goto end32ef1328af280ac18fa8045a3502dae9 - end32ef1328af280ac18fa8045a3502dae9: - ; - // match: (CMPQ (MOVQconst [c]) x) - // cond: - // result: (InvertFlags (CMPQconst x [c])) - { - if v.Args[0].Op != OpMOVQconst { - goto endf8ca12fe79290bc82b11cfa463bc9413 - } - c := v.Args[0].Aux - x := v.Args[1] - v.Op = OpInvertFlags - v.Aux = nil - v.resetArgs() - v0 := v.Block.NewValue(OpCMPQconst, TypeInvalid, nil) - v0.Type = TypeFlags - v0.AddArg(x) - v0.Aux = c - v.AddArg(v0) - return true - } - goto endf8ca12fe79290bc82b11cfa463bc9413 - endf8ca12fe79290bc82b11cfa463bc9413: - ; - case OpConst: - // match: (Const [val]) - // cond: is64BitInt(t) - // result: (MOVQconst [val]) - { - t := v.Type - val := v.Aux - if !(is64BitInt(t)) { - goto end7f5c5b34093fbc6860524cb803ee51bf - } - v.Op = OpMOVQconst - v.Aux = nil - v.resetArgs() - v.Aux = val - return true - } - goto end7f5c5b34093fbc6860524cb803ee51bf - end7f5c5b34093fbc6860524cb803ee51bf: - ; - case OpGlobal: - // match: (Global [sym]) - // cond: - // result: (LEAQglobal [GlobalOffset{sym,0}]) - { - sym := v.Aux - v.Op = OpLEAQglobal - v.Aux = nil - v.resetArgs() - v.Aux = GlobalOffset{sym, 0} - return true - } - goto end3a3c76fac0e2e53c0e1c60b9524e6f1c - end3a3c76fac0e2e53c0e1c60b9524e6f1c: - ; - case OpIsInBounds: - // match: (IsInBounds idx len) - // cond: - // result: (SETB (CMPQ idx len)) - { - idx := v.Args[0] - len := v.Args[1] - v.Op = OpSETB - v.Aux = nil - v.resetArgs() - v0 := v.Block.NewValue(OpCMPQ, TypeInvalid, nil) - v0.Type = TypeFlags - v0.AddArg(idx) - v0.AddArg(len) - v.AddArg(v0) - return true - } - goto endb51d371171154c0f1613b687757e0576 - endb51d371171154c0f1613b687757e0576: - ; - case OpIsNonNil: - // match: (IsNonNil p) - // cond: - // result: (SETNE (TESTQ p p)) - { - p := v.Args[0] - v.Op = OpSETNE - v.Aux = nil - v.resetArgs() - v0 := v.Block.NewValue(OpTESTQ, TypeInvalid, nil) - v0.Type = TypeFlags - v0.AddArg(p) - v0.AddArg(p) - v.AddArg(v0) - return true - } - goto endff508c3726edfb573abc6128c177e76c - endff508c3726edfb573abc6128c177e76c: - ; - case OpLess: - // match: (Less x y) - // cond: is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type) - // result: (SETL (CMPQ x y)) - { - x := v.Args[0] - y := v.Args[1] - if !(is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type)) { - goto endcecf13a952d4c6c2383561c7d68a3cf9 - } - v.Op = OpSETL - v.Aux = nil - v.resetArgs() - v0 := v.Block.NewValue(OpCMPQ, TypeInvalid, nil) - v0.Type = TypeFlags - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - return true - } - goto endcecf13a952d4c6c2383561c7d68a3cf9 - endcecf13a952d4c6c2383561c7d68a3cf9: - ; - case OpLoad: - // match: (Load ptr mem) - // cond: t.IsBoolean() - // result: (MOVBload [int64(0)] ptr mem) - { - t := v.Type - ptr := v.Args[0] - mem := v.Args[1] - if !(t.IsBoolean()) { - goto end73f21632e56c3614902d3c29c82dc4ea - } - v.Op = OpMOVBload - v.Aux = nil - v.resetArgs() - v.Aux = int64(0) - v.AddArg(ptr) - v.AddArg(mem) - return true - } - goto end73f21632e56c3614902d3c29c82dc4ea - end73f21632e56c3614902d3c29c82dc4ea: - ; - // match: (Load ptr mem) - // cond: (is64BitInt(t) || isPtr(t)) - // result: (MOVQload [int64(0)] ptr mem) - { - t := v.Type - ptr := v.Args[0] - mem := v.Args[1] - if !(is64BitInt(t) || isPtr(t)) { - goto end581ce5a20901df1b8143448ba031685b - } - v.Op = OpMOVQload - v.Aux = nil - v.resetArgs() - v.Aux = int64(0) - v.AddArg(ptr) - v.AddArg(mem) - return true - } - goto end581ce5a20901df1b8143448ba031685b - end581ce5a20901df1b8143448ba031685b: - ; - case OpLsh: - // match: (Lsh x y) - // cond: is64BitInt(t) - // result: (SHLQ x y) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - if !(is64BitInt(t)) { - goto end9f05c9539e51db6ad557989e0c822e9b - } - v.Op = OpSHLQ - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto end9f05c9539e51db6ad557989e0c822e9b - end9f05c9539e51db6ad557989e0c822e9b: - ; - case OpMOVQload: - // match: (MOVQload [off1] (ADDQconst [off2] ptr) mem) - // cond: - // result: (MOVQload [addOff(off1, off2)] ptr mem) - { - off1 := v.Aux - if v.Args[0].Op != OpADDQconst { - goto end843d29b538c4483b432b632e5666d6e3 - } - off2 := v.Args[0].Aux - ptr := v.Args[0].Args[0] - mem := v.Args[1] - v.Op = OpMOVQload - v.Aux = nil - v.resetArgs() - v.Aux = addOff(off1, off2) - v.AddArg(ptr) - v.AddArg(mem) - return true - } - goto end843d29b538c4483b432b632e5666d6e3 - end843d29b538c4483b432b632e5666d6e3: - ; - // match: (MOVQload [off1] (LEAQ8 [off2] ptr idx) mem) - // cond: - // result: (MOVQloadidx8 [addOff(off1, off2)] ptr idx mem) - { - off1 := v.Aux - if v.Args[0].Op != OpLEAQ8 { - goto end02f5ad148292c46463e7c20d3b821735 - } - off2 := v.Args[0].Aux - ptr := v.Args[0].Args[0] - idx := v.Args[0].Args[1] - mem := v.Args[1] - v.Op = OpMOVQloadidx8 - v.Aux = nil - v.resetArgs() - v.Aux = addOff(off1, off2) - v.AddArg(ptr) - v.AddArg(idx) - v.AddArg(mem) - return true - } - goto end02f5ad148292c46463e7c20d3b821735 - end02f5ad148292c46463e7c20d3b821735: - ; - case OpMOVQloadidx8: - // match: (MOVQloadidx8 [off1] (ADDQconst [off2] ptr) idx mem) - // cond: - // result: (MOVQloadidx8 [addOff(off1, off2)] ptr idx mem) - { - off1 := v.Aux - if v.Args[0].Op != OpADDQconst { - goto ende81e44bcfb11f90916ccb440c590121f - } - off2 := v.Args[0].Aux - ptr := v.Args[0].Args[0] - idx := v.Args[1] - mem := v.Args[2] - v.Op = OpMOVQloadidx8 - v.Aux = nil - v.resetArgs() - v.Aux = addOff(off1, off2) - v.AddArg(ptr) - v.AddArg(idx) - v.AddArg(mem) - return true - } - goto ende81e44bcfb11f90916ccb440c590121f - ende81e44bcfb11f90916ccb440c590121f: - ; - case OpMOVQstore: - // match: (MOVQstore [off1] (ADDQconst [off2] ptr) val mem) - // cond: - // result: (MOVQstore [addOff(off1, off2)] ptr val mem) - { - off1 := v.Aux - if v.Args[0].Op != OpADDQconst { - goto end2108c693a43c79aed10b9246c39c80aa - } - off2 := v.Args[0].Aux - ptr := v.Args[0].Args[0] - val := v.Args[1] - mem := v.Args[2] - v.Op = OpMOVQstore - v.Aux = nil - v.resetArgs() - v.Aux = addOff(off1, off2) - v.AddArg(ptr) - v.AddArg(val) - v.AddArg(mem) - return true - } - goto end2108c693a43c79aed10b9246c39c80aa - end2108c693a43c79aed10b9246c39c80aa: - ; - // match: (MOVQstore [off1] (LEAQ8 [off2] ptr idx) val mem) - // cond: - // result: (MOVQstoreidx8 [addOff(off1, off2)] ptr idx val mem) - { - off1 := v.Aux - if v.Args[0].Op != OpLEAQ8 { - goto endce1db8c8d37c8397c500a2068a65c215 - } - off2 := v.Args[0].Aux - ptr := v.Args[0].Args[0] - idx := v.Args[0].Args[1] - val := v.Args[1] - mem := v.Args[2] - v.Op = OpMOVQstoreidx8 - v.Aux = nil - v.resetArgs() - v.Aux = addOff(off1, off2) - v.AddArg(ptr) - v.AddArg(idx) - v.AddArg(val) - v.AddArg(mem) - return true - } - goto endce1db8c8d37c8397c500a2068a65c215 - endce1db8c8d37c8397c500a2068a65c215: - ; - case OpMOVQstoreidx8: - // match: (MOVQstoreidx8 [off1] (ADDQconst [off2] ptr) idx val mem) - // cond: - // result: (MOVQstoreidx8 [addOff(off1, off2)] ptr idx val mem) - { - off1 := v.Aux - if v.Args[0].Op != OpADDQconst { - goto end01c970657b0fdefeab82458c15022163 - } - off2 := v.Args[0].Aux - ptr := v.Args[0].Args[0] - idx := v.Args[1] - val := v.Args[2] - mem := v.Args[3] - v.Op = OpMOVQstoreidx8 - v.Aux = nil - v.resetArgs() - v.Aux = addOff(off1, off2) - v.AddArg(ptr) - v.AddArg(idx) - v.AddArg(val) - v.AddArg(mem) - return true - } - goto end01c970657b0fdefeab82458c15022163 - end01c970657b0fdefeab82458c15022163: - ; - case OpMULQ: - // match: (MULQ x (MOVQconst [c])) - // cond: c.(int64) == int64(int32(c.(int64))) - // result: (MULQconst [c] x) - { - x := v.Args[0] - if v.Args[1].Op != OpMOVQconst { - goto ende8c09b194fcde7d9cdc69f2deff86304 - } - c := v.Args[1].Aux - if !(c.(int64) == int64(int32(c.(int64)))) { - goto ende8c09b194fcde7d9cdc69f2deff86304 - } - v.Op = OpMULQconst - v.Aux = nil - v.resetArgs() - v.Aux = c - v.AddArg(x) - return true - } - goto ende8c09b194fcde7d9cdc69f2deff86304 - ende8c09b194fcde7d9cdc69f2deff86304: - ; - // match: (MULQ (MOVQconst [c]) x) - // cond: - // result: (MULQconst [c] x) - { - if v.Args[0].Op != OpMOVQconst { - goto endc6e18d6968175d6e58eafa6dcf40c1b8 - } - c := v.Args[0].Aux - x := v.Args[1] - v.Op = OpMULQconst - v.Aux = nil - v.resetArgs() - v.Aux = c - v.AddArg(x) - return true - } - goto endc6e18d6968175d6e58eafa6dcf40c1b8 - endc6e18d6968175d6e58eafa6dcf40c1b8: - ; - case OpMULQconst: - // match: (MULQconst [c] x) - // cond: c.(int64) == 8 - // result: (SHLQconst [int64(3)] x) - { - c := v.Aux - x := v.Args[0] - if !(c.(int64) == 8) { - goto end7e16978c56138324ff2abf91fd6d94d4 - } - v.Op = OpSHLQconst - v.Aux = nil - v.resetArgs() - v.Aux = int64(3) - v.AddArg(x) - return true - } - goto end7e16978c56138324ff2abf91fd6d94d4 - end7e16978c56138324ff2abf91fd6d94d4: - ; - // match: (MULQconst [c] x) - // cond: c.(int64) == 64 - // result: (SHLQconst [int64(5)] x) - { - c := v.Aux - x := v.Args[0] - if !(c.(int64) == 64) { - goto end2c7a02f230e4b311ac3a4e22f70a4f08 - } - v.Op = OpSHLQconst - v.Aux = nil - v.resetArgs() - v.Aux = int64(5) - v.AddArg(x) - return true - } - goto end2c7a02f230e4b311ac3a4e22f70a4f08 - end2c7a02f230e4b311ac3a4e22f70a4f08: - ; - case OpMove: - // match: (Move [size] dst src mem) - // cond: - // result: (REPMOVSB dst src (Const [size.(int64)]) mem) - { - size := v.Aux - dst := v.Args[0] - src := v.Args[1] - mem := v.Args[2] - v.Op = OpREPMOVSB - v.Aux = nil - v.resetArgs() - v.AddArg(dst) - v.AddArg(src) - v0 := v.Block.NewValue(OpConst, TypeInvalid, nil) - v0.Type = TypeUInt64 - v0.Aux = size.(int64) - v.AddArg(v0) - v.AddArg(mem) - return true - } - goto end48909259b265a6bb2a076bc2c2dc7d1f - end48909259b265a6bb2a076bc2c2dc7d1f: - ; - case OpMul: - // match: (Mul x y) - // cond: is64BitInt(t) - // result: (MULQ x y) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - if !(is64BitInt(t)) { - goto endfab0d598f376ecba45a22587d50f7aff - } - v.Op = OpMULQ - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto endfab0d598f376ecba45a22587d50f7aff - endfab0d598f376ecba45a22587d50f7aff: - ; - case OpOffPtr: - // match: (OffPtr [off] ptr) - // cond: - // result: (ADDQconst [off] ptr) - { - off := v.Aux - ptr := v.Args[0] - v.Op = OpADDQconst - v.Aux = nil - v.resetArgs() - v.Aux = off - v.AddArg(ptr) - return true - } - goto end0429f947ee7ac49ff45a243e461a5290 - end0429f947ee7ac49ff45a243e461a5290: - ; - case OpSETG: - // match: (SETG (InvertFlags x)) - // cond: - // result: (SETL x) - { - if v.Args[0].Op != OpInvertFlags { - goto endf7586738694c9cd0b74ae28bbadb649f - } - x := v.Args[0].Args[0] - v.Op = OpSETL - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto endf7586738694c9cd0b74ae28bbadb649f - endf7586738694c9cd0b74ae28bbadb649f: - ; - case OpSETL: - // match: (SETL (InvertFlags x)) - // cond: - // result: (SETG x) - { - if v.Args[0].Op != OpInvertFlags { - goto ende33160cd86b9d4d3b77e02fb4658d5d3 - } - x := v.Args[0].Args[0] - v.Op = OpSETG - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto ende33160cd86b9d4d3b77e02fb4658d5d3 - ende33160cd86b9d4d3b77e02fb4658d5d3: - ; - case OpSHLQ: - // match: (SHLQ x (MOVQconst [c])) - // cond: - // result: (SHLQconst [c] x) - { - x := v.Args[0] - if v.Args[1].Op != OpMOVQconst { - goto endcca412bead06dc3d56ef034a82d184d6 - } - c := v.Args[1].Aux - v.Op = OpSHLQconst - v.Aux = nil - v.resetArgs() - v.Aux = c - v.AddArg(x) - return true - } - goto endcca412bead06dc3d56ef034a82d184d6 - endcca412bead06dc3d56ef034a82d184d6: - ; - case OpSUBQ: - // match: (SUBQ x (MOVQconst [c])) - // cond: - // result: (SUBQconst x [c]) - { - x := v.Args[0] - if v.Args[1].Op != OpMOVQconst { - goto end5a74a63bd9ad15437717c6df3b25eebb - } - c := v.Args[1].Aux - v.Op = OpSUBQconst - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.Aux = c - return true - } - goto end5a74a63bd9ad15437717c6df3b25eebb - end5a74a63bd9ad15437717c6df3b25eebb: - ; - // match: (SUBQ (MOVQconst [c]) x) - // cond: - // result: (NEGQ (SUBQconst x [c])) - { - t := v.Type - if v.Args[0].Op != OpMOVQconst { - goto end78e66b6fc298684ff4ac8aec5ce873c9 - } - c := v.Args[0].Aux - x := v.Args[1] - v.Op = OpNEGQ - v.Aux = nil - v.resetArgs() - v0 := v.Block.NewValue(OpSUBQconst, TypeInvalid, nil) - v0.Type = t - v0.AddArg(x) - v0.Aux = c - v.AddArg(v0) - return true - } - goto end78e66b6fc298684ff4ac8aec5ce873c9 - end78e66b6fc298684ff4ac8aec5ce873c9: - ; - case OpStore: - // match: (Store ptr val mem) - // cond: (is64BitInt(val.Type) || isPtr(val.Type)) - // result: (MOVQstore [int64(0)] ptr val mem) - { - ptr := v.Args[0] - val := v.Args[1] - mem := v.Args[2] - if !(is64BitInt(val.Type) || isPtr(val.Type)) { - goto end9680b43f504bc06f9fab000823ce471a - } - v.Op = OpMOVQstore - v.Aux = nil - v.resetArgs() - v.Aux = int64(0) - v.AddArg(ptr) - v.AddArg(val) - v.AddArg(mem) - return true - } - goto end9680b43f504bc06f9fab000823ce471a - end9680b43f504bc06f9fab000823ce471a: - ; - case OpSub: - // match: (Sub x y) - // cond: is64BitInt(t) - // result: (SUBQ x y) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - if !(is64BitInt(t)) { - goto ende6ef29f885a8ecf3058212bb95917323 - } - v.Op = OpSUBQ - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto ende6ef29f885a8ecf3058212bb95917323 - ende6ef29f885a8ecf3058212bb95917323: - } - return false -} -func lowerBlockAMD64(b *Block) bool { - switch b.Kind { - case BlockEQ: - // match: (BlockEQ (InvertFlags cmp) yes no) - // cond: - // result: (BlockEQ cmp yes no) - { - v := b.Control - if v.Op != OpInvertFlags { - goto endea853c6aba26aace57cc8951d332ebe9 - } - cmp := v.Args[0] - yes := b.Succs[0] - no := b.Succs[1] - b.Kind = BlockEQ - b.Control = cmp - b.Succs[0] = yes - b.Succs[1] = no - return true - } - goto endea853c6aba26aace57cc8951d332ebe9 - endea853c6aba26aace57cc8951d332ebe9: - ; - case BlockGE: - // match: (BlockGE (InvertFlags cmp) yes no) - // cond: - // result: (BlockLE cmp yes no) - { - v := b.Control - if v.Op != OpInvertFlags { - goto end608065f88da8bcb570f716698fd7c5c7 - } - cmp := v.Args[0] - yes := b.Succs[0] - no := b.Succs[1] - b.Kind = BlockLE - b.Control = cmp - b.Succs[0] = yes - b.Succs[1] = no - return true - } - goto end608065f88da8bcb570f716698fd7c5c7 - end608065f88da8bcb570f716698fd7c5c7: - ; - case BlockGT: - // match: (BlockGT (InvertFlags cmp) yes no) - // cond: - // result: (BlockLT cmp yes no) - { - v := b.Control - if v.Op != OpInvertFlags { - goto ende1758ce91e7231fd66db6bb988856b14 - } - cmp := v.Args[0] - yes := b.Succs[0] - no := b.Succs[1] - b.Kind = BlockLT - b.Control = cmp - b.Succs[0] = yes - b.Succs[1] = no - return true - } - goto ende1758ce91e7231fd66db6bb988856b14 - ende1758ce91e7231fd66db6bb988856b14: - ; - case BlockIf: - // match: (BlockIf (SETL cmp) yes no) - // cond: - // result: (BlockLT cmp yes no) - { - v := b.Control - if v.Op != OpSETL { - goto endc6a5d98127b4b8aff782f6981348c864 - } - cmp := v.Args[0] - yes := b.Succs[0] - no := b.Succs[1] - b.Kind = BlockLT - b.Control = cmp - b.Succs[0] = yes - b.Succs[1] = no - return true - } - goto endc6a5d98127b4b8aff782f6981348c864 - endc6a5d98127b4b8aff782f6981348c864: - ; - // match: (BlockIf (SETNE cmp) yes no) - // cond: - // result: (BlockNE cmp yes no) - { - v := b.Control - if v.Op != OpSETNE { - goto end49bd2f760f561c30c85c3342af06753b - } - cmp := v.Args[0] - yes := b.Succs[0] - no := b.Succs[1] - b.Kind = BlockNE - b.Control = cmp - b.Succs[0] = yes - b.Succs[1] = no - return true - } - goto end49bd2f760f561c30c85c3342af06753b - end49bd2f760f561c30c85c3342af06753b: - ; - // match: (BlockIf (SETB cmp) yes no) - // cond: - // result: (BlockULT cmp yes no) - { - v := b.Control - if v.Op != OpSETB { - goto end4754c856495bfc5769799890d639a627 - } - cmp := v.Args[0] - yes := b.Succs[0] - no := b.Succs[1] - b.Kind = BlockULT - b.Control = cmp - b.Succs[0] = yes - b.Succs[1] = no - return true - } - goto end4754c856495bfc5769799890d639a627 - end4754c856495bfc5769799890d639a627: - ; - // match: (BlockIf cond yes no) - // cond: cond.Op == OpMOVBload - // result: (BlockNE (TESTB cond cond) yes no) - { - v := b.Control - cond := v - yes := b.Succs[0] - no := b.Succs[1] - if !(cond.Op == OpMOVBload) { - goto end3a3c83af305cf35c49cb10183b4c6425 - } - b.Kind = BlockNE - v0 := v.Block.NewValue(OpTESTB, TypeInvalid, nil) - v0.Type = TypeFlags - v0.AddArg(cond) - v0.AddArg(cond) - b.Control = v0 - b.Succs[0] = yes - b.Succs[1] = no - return true - } - goto end3a3c83af305cf35c49cb10183b4c6425 - end3a3c83af305cf35c49cb10183b4c6425: - ; - case BlockLE: - // match: (BlockLE (InvertFlags cmp) yes no) - // cond: - // result: (BlockGE cmp yes no) - { - v := b.Control - if v.Op != OpInvertFlags { - goto end6e761e611859351c15da0d249c3771f7 - } - cmp := v.Args[0] - yes := b.Succs[0] - no := b.Succs[1] - b.Kind = BlockGE - b.Control = cmp - b.Succs[0] = yes - b.Succs[1] = no - return true - } - goto end6e761e611859351c15da0d249c3771f7 - end6e761e611859351c15da0d249c3771f7: - ; - case BlockLT: - // match: (BlockLT (InvertFlags cmp) yes no) - // cond: - // result: (BlockGT cmp yes no) - { - v := b.Control - if v.Op != OpInvertFlags { - goto endb269f9644dffd5a416ba236545ee2524 - } - cmp := v.Args[0] - yes := b.Succs[0] - no := b.Succs[1] - b.Kind = BlockGT - b.Control = cmp - b.Succs[0] = yes - b.Succs[1] = no - return true - } - goto endb269f9644dffd5a416ba236545ee2524 - endb269f9644dffd5a416ba236545ee2524: - ; - case BlockNE: - // match: (BlockNE (InvertFlags cmp) yes no) - // cond: - // result: (BlockNE cmp yes no) - { - v := b.Control - if v.Op != OpInvertFlags { - goto endc41d56a60f8ab211baa2bf0360b7b286 - } - cmp := v.Args[0] - yes := b.Succs[0] - no := b.Succs[1] - b.Kind = BlockNE - b.Control = cmp - b.Succs[0] = yes - b.Succs[1] = no - return true - } - goto endc41d56a60f8ab211baa2bf0360b7b286 - endc41d56a60f8ab211baa2bf0360b7b286: - ; - case BlockUGE: - // match: (BlockUGE (InvertFlags cmp) yes no) - // cond: - // result: (BlockULE cmp yes no) - { - v := b.Control - if v.Op != OpInvertFlags { - goto end9ae511e4f4e81005ae1f3c1e5941ba3c - } - cmp := v.Args[0] - yes := b.Succs[0] - no := b.Succs[1] - b.Kind = BlockULE - b.Control = cmp - b.Succs[0] = yes - b.Succs[1] = no - return true - } - goto end9ae511e4f4e81005ae1f3c1e5941ba3c - end9ae511e4f4e81005ae1f3c1e5941ba3c: - ; - case BlockUGT: - // match: (BlockUGT (InvertFlags cmp) yes no) - // cond: - // result: (BlockULT cmp yes no) - { - v := b.Control - if v.Op != OpInvertFlags { - goto end073724a0ca0ec030715dd33049b647e9 - } - cmp := v.Args[0] - yes := b.Succs[0] - no := b.Succs[1] - b.Kind = BlockULT - b.Control = cmp - b.Succs[0] = yes - b.Succs[1] = no - return true - } - goto end073724a0ca0ec030715dd33049b647e9 - end073724a0ca0ec030715dd33049b647e9: - ; - case BlockULE: - // match: (BlockULE (InvertFlags cmp) yes no) - // cond: - // result: (BlockUGE cmp yes no) - { - v := b.Control - if v.Op != OpInvertFlags { - goto end2f53a6da23ace14fb1b9b9896827e62d - } - cmp := v.Args[0] - yes := b.Succs[0] - no := b.Succs[1] - b.Kind = BlockUGE - b.Control = cmp - b.Succs[0] = yes - b.Succs[1] = no - return true - } - goto end2f53a6da23ace14fb1b9b9896827e62d - end2f53a6da23ace14fb1b9b9896827e62d: - ; - case BlockULT: - // match: (BlockULT (InvertFlags cmp) yes no) - // cond: - // result: (BlockUGT cmp yes no) - { - v := b.Control - if v.Op != OpInvertFlags { - goto endbceb44a1ad6c53fb33710fc88be6a679 - } - cmp := v.Args[0] - yes := b.Succs[0] - no := b.Succs[1] - b.Kind = BlockUGT - b.Control = cmp - b.Succs[0] = yes - b.Succs[1] = no - return true - } - goto endbceb44a1ad6c53fb33710fc88be6a679 - endbceb44a1ad6c53fb33710fc88be6a679: - } - return false -} diff --git a/src/cmd/compile/internal/ssa/lowergeneric.go b/src/cmd/compile/internal/ssa/lowergeneric.go new file mode 100644 index 0000000000..1ac276ad66 --- /dev/null +++ b/src/cmd/compile/internal/ssa/lowergeneric.go @@ -0,0 +1,289 @@ +// autogenerated from generic.rules: do not edit! +// generated with: go run rulegen/rulegen.go +package ssa + +func lowerValuegeneric(v *Value) bool { + switch v.Op { + case OpAdd: + // match: (Add (Const [c]) (Const [d])) + // cond: is64BitInt(t) + // result: (Const [{c.(int64)+d.(int64)}]) + { + t := v.Type + if v.Args[0].Op != OpConst { + goto end8d047ed0ae9537b840adc79ea82c6e05 + } + c := v.Args[0].Aux + if v.Args[1].Op != OpConst { + goto end8d047ed0ae9537b840adc79ea82c6e05 + } + d := v.Args[1].Aux + if !(is64BitInt(t)) { + goto end8d047ed0ae9537b840adc79ea82c6e05 + } + v.Op = OpConst + v.Aux = nil + v.resetArgs() + v.Aux = c.(int64) + d.(int64) + return true + } + goto end8d047ed0ae9537b840adc79ea82c6e05 + end8d047ed0ae9537b840adc79ea82c6e05: + ; + case OpArrayIndex: + // match: (ArrayIndex (Load ptr mem) idx) + // cond: + // result: (Load (PtrIndex ptr idx) mem) + { + if v.Args[0].Op != OpLoad { + goto end3809f4c52270a76313e4ea26e6f0b753 + } + ptr := v.Args[0].Args[0] + mem := v.Args[0].Args[1] + idx := v.Args[1] + v.Op = OpLoad + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue(OpPtrIndex, TypeInvalid, nil) + v0.Type = ptr.Type.Elem().Elem().PtrTo() + v0.AddArg(ptr) + v0.AddArg(idx) + v.AddArg(v0) + v.AddArg(mem) + return true + } + goto end3809f4c52270a76313e4ea26e6f0b753 + end3809f4c52270a76313e4ea26e6f0b753: + ; + case OpIsInBounds: + // match: (IsInBounds (Const [c]) (Const [d])) + // cond: + // result: (Const [inBounds(c.(int64),d.(int64))]) + { + if v.Args[0].Op != OpConst { + goto enddbd1a394d9b71ee64335361b8384865c + } + c := v.Args[0].Aux + if v.Args[1].Op != OpConst { + goto enddbd1a394d9b71ee64335361b8384865c + } + d := v.Args[1].Aux + v.Op = OpConst + v.Aux = nil + v.resetArgs() + v.Aux = inBounds(c.(int64), d.(int64)) + return true + } + goto enddbd1a394d9b71ee64335361b8384865c + enddbd1a394d9b71ee64335361b8384865c: + ; + case OpMul: + // match: (Mul (Const [c]) (Const [d])) + // cond: is64BitInt(t) + // result: (Const [{c.(int64)*d.(int64)}]) + { + t := v.Type + if v.Args[0].Op != OpConst { + goto end776610f88cf04f438242d76ed2b14f1c + } + c := v.Args[0].Aux + if v.Args[1].Op != OpConst { + goto end776610f88cf04f438242d76ed2b14f1c + } + d := v.Args[1].Aux + if !(is64BitInt(t)) { + goto end776610f88cf04f438242d76ed2b14f1c + } + v.Op = OpConst + v.Aux = nil + v.resetArgs() + v.Aux = c.(int64) * d.(int64) + return true + } + goto end776610f88cf04f438242d76ed2b14f1c + end776610f88cf04f438242d76ed2b14f1c: + ; + case OpPtrIndex: + // match: (PtrIndex ptr idx) + // cond: + // result: (Add ptr (Mul idx (Const [t.Elem().Size()]))) + { + t := v.Type + ptr := v.Args[0] + idx := v.Args[1] + v.Op = OpAdd + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v0 := v.Block.NewValue(OpMul, TypeInvalid, nil) + v0.Type = v.Block.Func.Config.Uintptr + v0.AddArg(idx) + v1 := v.Block.NewValue(OpConst, TypeInvalid, nil) + v1.Type = v.Block.Func.Config.Uintptr + v1.Aux = t.Elem().Size() + v0.AddArg(v1) + v.AddArg(v0) + return true + } + goto end383c68c41e72d22ef00c4b7b0fddcbb8 + end383c68c41e72d22ef00c4b7b0fddcbb8: + ; + case OpSliceCap: + // match: (SliceCap (Load ptr mem)) + // cond: + // result: (Load (Add ptr (Const [int64(v.Block.Func.Config.ptrSize*2)])) mem) + { + if v.Args[0].Op != OpLoad { + goto endbf1d4db93c4664ed43be3f73afb4dfa3 + } + ptr := v.Args[0].Args[0] + mem := v.Args[0].Args[1] + v.Op = OpLoad + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue(OpAdd, TypeInvalid, nil) + v0.Type = ptr.Type + v0.AddArg(ptr) + v1 := v.Block.NewValue(OpConst, TypeInvalid, nil) + v1.Type = v.Block.Func.Config.Uintptr + v1.Aux = int64(v.Block.Func.Config.ptrSize * 2) + v0.AddArg(v1) + v.AddArg(v0) + v.AddArg(mem) + return true + } + goto endbf1d4db93c4664ed43be3f73afb4dfa3 + endbf1d4db93c4664ed43be3f73afb4dfa3: + ; + case OpSliceLen: + // match: (SliceLen (Load ptr mem)) + // cond: + // result: (Load (Add ptr (Const [int64(v.Block.Func.Config.ptrSize)])) mem) + { + if v.Args[0].Op != OpLoad { + goto end9190b1ecbda4c5dd6d3e05d2495fb297 + } + ptr := v.Args[0].Args[0] + mem := v.Args[0].Args[1] + v.Op = OpLoad + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue(OpAdd, TypeInvalid, nil) + v0.Type = ptr.Type + v0.AddArg(ptr) + v1 := v.Block.NewValue(OpConst, TypeInvalid, nil) + v1.Type = v.Block.Func.Config.Uintptr + v1.Aux = int64(v.Block.Func.Config.ptrSize) + v0.AddArg(v1) + v.AddArg(v0) + v.AddArg(mem) + return true + } + goto end9190b1ecbda4c5dd6d3e05d2495fb297 + end9190b1ecbda4c5dd6d3e05d2495fb297: + ; + case OpSlicePtr: + // match: (SlicePtr (Load ptr mem)) + // cond: + // result: (Load ptr mem) + { + if v.Args[0].Op != OpLoad { + goto end459613b83f95b65729d45c2ed663a153 + } + ptr := v.Args[0].Args[0] + mem := v.Args[0].Args[1] + v.Op = OpLoad + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto end459613b83f95b65729d45c2ed663a153 + end459613b83f95b65729d45c2ed663a153: + ; + case OpStore: + // match: (Store dst (Load src mem) mem) + // cond: t.Size() > 8 + // result: (Move [t.Size()] dst src mem) + { + dst := v.Args[0] + if v.Args[1].Op != OpLoad { + goto end324ffb6d2771808da4267f62c854e9c8 + } + t := v.Args[1].Type + src := v.Args[1].Args[0] + mem := v.Args[1].Args[1] + if v.Args[2] != v.Args[1].Args[1] { + goto end324ffb6d2771808da4267f62c854e9c8 + } + if !(t.Size() > 8) { + goto end324ffb6d2771808da4267f62c854e9c8 + } + v.Op = OpMove + v.Aux = nil + v.resetArgs() + v.Aux = t.Size() + v.AddArg(dst) + v.AddArg(src) + v.AddArg(mem) + return true + } + goto end324ffb6d2771808da4267f62c854e9c8 + end324ffb6d2771808da4267f62c854e9c8: + } + return false +} +func lowerBlockgeneric(b *Block) bool { + switch b.Kind { + case BlockIf: + // match: (BlockIf (Const [c]) yes no) + // cond: c.(bool) + // result: (BlockPlain nil yes) + { + v := b.Control + if v.Op != OpConst { + goto endbe39807508a6192b4022c7293eb6e114 + } + c := v.Aux + yes := b.Succs[0] + no := b.Succs[1] + if !(c.(bool)) { + goto endbe39807508a6192b4022c7293eb6e114 + } + removePredecessor(b, no) + b.Kind = BlockPlain + b.Control = nil + b.Succs = b.Succs[:1] + b.Succs[0] = yes + return true + } + goto endbe39807508a6192b4022c7293eb6e114 + endbe39807508a6192b4022c7293eb6e114: + ; + // match: (BlockIf (Const [c]) yes no) + // cond: !c.(bool) + // result: (BlockPlain nil no) + { + v := b.Control + if v.Op != OpConst { + goto end69ac35957ebe0a77a5ef5103c1f79fbf + } + c := v.Aux + yes := b.Succs[0] + no := b.Succs[1] + if !(!c.(bool)) { + goto end69ac35957ebe0a77a5ef5103c1f79fbf + } + removePredecessor(b, yes) + b.Kind = BlockPlain + b.Control = nil + b.Succs = b.Succs[:1] + b.Succs[0] = no + return true + } + goto end69ac35957ebe0a77a5ef5103c1f79fbf + end69ac35957ebe0a77a5ef5103c1f79fbf: + } + return false +} diff --git a/src/cmd/compile/internal/ssa/op.go b/src/cmd/compile/internal/ssa/op.go index c8bd3d2f3a..19a3fddd49 100644 --- a/src/cmd/compile/internal/ssa/op.go +++ b/src/cmd/compile/internal/ssa/op.go @@ -12,95 +12,11 @@ import ( // 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 below. -// -// Ops come in two flavors, architecture-independent and architecture-dependent. -// Architecture-independent opcodes appear in this file. -// Architecture-dependent opcodes appear in op{arch}.go files. +// 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 -// Opcode ranges, a generic one and one for each architecture. -const ( - opInvalid Op = 0 - opGenericBase = 1 + 1000*iota - opAMD64Base - op386Base - - opMax // sentinel -) - -// Generic opcodes -const ( - opGenericStart Op = opGenericBase + iota - - // 2-input arithmetic - OpAdd // arg0 + arg1 - OpSub // arg0 - arg1 - OpMul // arg0 * arg1 - OpLsh // arg0 << arg1 - OpRsh // arg0 >> arg1 (signed/unsigned depending on signedness of type) - - // 2-input comparisons - OpLess // arg0 < arg1 - - // constants. Constant values are stored in the aux field. - // booleans have a bool aux field, strings have a string aux - // field, and so on. All integer types store their value - // in the aux field as an int64 (including int, uint64, etc.). - // We could store int8 as an int8, but that won't work for int, - // as it may be different widths on the host and target. - OpConst - - OpArg // address of a function parameter/result. Memory input is an arg called ".mem". aux is a string (TODO: make it something other than a string?) - OpGlobal // the address of a global variable aux.(*gc.Sym) - OpFunc // entry address of a function - OpFP // frame pointer - OpSP // stack pointer - - OpCopy // output = arg0 - OpMove // arg0=destptr, arg1=srcptr, arg2=mem, aux.(int64)=size. Returns memory. - OpPhi // select an argument based on which predecessor block we came from - - OpSliceMake // arg0=ptr, arg1=len, arg2=cap - OpSlicePtr // ptr(arg0) - OpSliceLen // len(arg0) - OpSliceCap // cap(arg0) - - OpStringMake // arg0=ptr, arg1=len - OpStringPtr // ptr(arg0) - OpStringLen // len(arg0) - - OpLoad // Load from arg0. arg1=memory - OpStore // Store arg1 to arg0. arg2=memory. Returns memory. - OpArrayIndex // arg0=array, arg1=index. Returns a[i] - OpPtrIndex // arg0=ptr, arg1=index. Computes ptr+sizeof(*v.type)*index, where index is extended to ptrwidth type - OpIsNonNil // arg0 != nil - OpIsInBounds // 0 <= arg0 < arg1 - - // 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. - OpCall // arg0=code pointer, arg1=context ptr, arg2=memory. Returns memory. - OpStaticCall // call function aux.(*gc.Sym), arg0=memory. Returns memory. - - OpConvert // convert arg0 to another type - OpConvNop // interpret arg0 as another type - - OpOffPtr // arg0 + aux.(int64) (arg0 and result are pointers) - - // 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. - OpStoreReg8 - OpLoadReg8 - - // used during ssa construction. Like OpCopy, but the arg has not been specified yet. - OpFwdRef - - OpGenericEnd -) - // GlobalOffset represents a fixed offset within a global variable type GlobalOffset struct { Global interface{} // holds a *gc.Sym @@ -121,86 +37,14 @@ func (g GlobalOffset) String() string { return fmt.Sprintf("%v+%d", g.Global, g.Offset) } -//go:generate stringer -type=Op - type opInfo struct { - flags int32 - - // returns a reg constraint for the instruction. [0] gives a reg constraint - // for each input, [1] gives a reg constraint for each output. (Values have - // exactly one output for now) - reg [2][]regMask + name string + reg regInfo + generic bool // this is a generic (arch-independent) opcode } -const ( - // possible properties of opcodes - OpFlagCommutative int32 = 1 << iota -) - -// Opcodes that represent the input Go program -var genericTable = map[Op]opInfo{ - // the unknown op is used only during building and should not appear in a - // fully formed ssa representation. - - OpAdd: {flags: OpFlagCommutative}, - OpSub: {}, - OpMul: {flags: OpFlagCommutative}, - OpLess: {}, - - OpConst: {}, // aux matches the type (e.g. bool, int64 float64) - OpArg: {}, // aux is the name of the input variable. Currently only ".mem" is used - OpGlobal: {}, // address of a global variable - OpFunc: {}, - OpCopy: {}, - OpPhi: {}, - - OpConvNop: {}, // aux is the type to convert to - - /* - // build and take apart slices - {name: "slicemake"}, // (ptr,len,cap) -> slice - {name: "sliceptr"}, // pointer part of slice - {name: "slicelen"}, // length part of slice - {name: "slicecap"}, // capacity part of slice - - // build and take apart strings - {name: "stringmake"}, // (ptr,len) -> string - {name: "stringptr"}, // pointer part of string - {name: "stringlen"}, // length part of string - - // operations on arrays/slices/strings - {name: "slice"}, // (s, i, j) -> s[i:j] - {name: "index"}, // (mem, ptr, idx) -> val - {name: "indexaddr"}, // (ptr, idx) -> ptr - - // loads & stores - {name: "load"}, // (mem, check, ptr) -> val - {name: "store"}, // (mem, check, ptr, val) -> mem - - // checks - {name: "checknil"}, // (mem, ptr) -> check - {name: "checkbound"}, // (mem, idx, len) -> check - - // functions - {name: "call"}, - - // builtins - {name: "len"}, - {name: "convert"}, - - // tuples - {name: "tuple"}, // build a tuple out of its arguments - {name: "extract"}, // aux is an int64. Extract that index out of a tuple - {name: "extractsuffix"}, // aux is an int64. Slice a tuple with [aux:] - - */ -} - -// table of opcodes, indexed by opcode ID -var opcodeTable [opMax]opInfo - -func init() { - for op, info := range genericTable { - opcodeTable[op] = info - } +type regInfo struct { + inputs []regMask + clobbers regMask + outputs []regMask // NOTE: values can only have 1 output for now. } diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go new file mode 100644 index 0000000000..604f096152 --- /dev/null +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -0,0 +1,916 @@ +// autogenerated: do not edit! +// generated from gen/*Ops.go +package ssa + +const ( + blockInvalid BlockKind = iota + + BlockAMD64EQ + BlockAMD64NE + BlockAMD64LT + BlockAMD64LE + BlockAMD64GT + BlockAMD64GE + BlockAMD64ULT + BlockAMD64ULE + BlockAMD64UGT + BlockAMD64UGE + + BlockExit + BlockPlain + BlockIf + BlockCall +) + +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", + + BlockExit: "Exit", + BlockPlain: "Plain", + BlockIf: "If", + BlockCall: "Call", +} + +func (k BlockKind) String() string { return blockString[k] } + +const ( + OpInvalid Op = iota + + OpAMD64ADDQ + OpAMD64ADDQconst + OpAMD64SUBQ + OpAMD64SUBQconst + OpAMD64MULQ + OpAMD64MULQconst + OpAMD64SHLQ + OpAMD64SHLQconst + OpAMD64NEGQ + OpAMD64CMPQ + OpAMD64CMPQconst + OpAMD64TESTQ + OpAMD64TESTB + OpAMD64SETEQ + OpAMD64SETNE + OpAMD64SETL + OpAMD64SETG + OpAMD64SETGE + OpAMD64SETB + OpAMD64MOVQconst + OpAMD64LEAQ + OpAMD64LEAQ2 + OpAMD64LEAQ4 + OpAMD64LEAQ8 + OpAMD64LEAQglobal + OpAMD64MOVBload + OpAMD64MOVBQZXload + OpAMD64MOVBQSXload + OpAMD64MOVQload + OpAMD64MOVQloadidx8 + OpAMD64MOVBstore + OpAMD64MOVQstore + OpAMD64MOVQstoreidx8 + OpAMD64MOVQloadglobal + OpAMD64MOVQstoreglobal + OpAMD64REPMOVSB + OpAMD64ADDL + OpAMD64InvertFlags + + OpAdd + OpSub + OpMul + OpLsh + OpRsh + OpLess + OpPhi + OpCopy + OpConst + OpArg + OpGlobal + OpSP + OpFP + OpFunc + OpLoad + OpStore + OpMove + OpCall + OpStaticCall + OpConvert + OpConvNop + OpIsNonNil + OpIsInBounds + OpArrayIndex + OpPtrIndex + OpOffPtr + OpSliceMake + OpSlicePtr + OpSliceLen + OpSliceCap + OpStringMake + OpStringPtr + OpStringLen + OpStoreReg8 + OpLoadReg8 + OpFwdRef +) + +var opcodeTable = [...]opInfo{ + {name: "OpInvalid"}, + + { + name: "ADDQ", + reg: regInfo{ + inputs: []regMask{ + 4295032831, + 4295032831, + }, + clobbers: 0, + outputs: []regMask{ + 65519, + }, + }, + }, + { + name: "ADDQconst", + reg: regInfo{ + inputs: []regMask{ + 4295032831, + }, + clobbers: 0, + outputs: []regMask{ + 65519, + }, + }, + }, + { + name: "SUBQ", + reg: regInfo{ + inputs: []regMask{ + 4295032831, + 4295032831, + }, + clobbers: 0, + outputs: []regMask{ + 65519, + }, + }, + }, + { + name: "SUBQconst", + reg: regInfo{ + inputs: []regMask{ + 4295032831, + }, + clobbers: 0, + outputs: []regMask{ + 65519, + }, + }, + }, + { + name: "MULQ", + reg: regInfo{ + inputs: []regMask{ + 4295032831, + 4295032831, + }, + clobbers: 0, + outputs: []regMask{ + 65519, + }, + }, + }, + { + name: "MULQconst", + reg: regInfo{ + inputs: []regMask{ + 4295032831, + }, + clobbers: 0, + outputs: []regMask{ + 65519, + }, + }, + }, + { + name: "SHLQ", + reg: regInfo{ + inputs: []regMask{ + 4295032831, + 2, + }, + clobbers: 0, + outputs: []regMask{ + 65519, + }, + }, + }, + { + name: "SHLQconst", + reg: regInfo{ + inputs: []regMask{ + 4295032831, + }, + clobbers: 0, + outputs: []regMask{ + 65519, + }, + }, + }, + { + name: "NEGQ", + reg: regInfo{ + inputs: []regMask{ + 4295032831, + }, + clobbers: 0, + outputs: []regMask{ + 65519, + }, + }, + }, + { + name: "CMPQ", + reg: regInfo{ + inputs: []regMask{ + 4295032831, + 4295032831, + }, + clobbers: 0, + outputs: []regMask{ + 8589934592, + }, + }, + }, + { + name: "CMPQconst", + reg: regInfo{ + inputs: []regMask{ + 4295032831, + }, + clobbers: 0, + outputs: []regMask{ + 8589934592, + }, + }, + }, + { + name: "TESTQ", + reg: regInfo{ + inputs: []regMask{ + 4295032831, + 4295032831, + }, + clobbers: 0, + outputs: []regMask{ + 8589934592, + }, + }, + }, + { + name: "TESTB", + reg: regInfo{ + inputs: []regMask{ + 4295032831, + 4295032831, + }, + clobbers: 0, + outputs: []regMask{ + 8589934592, + }, + }, + }, + { + name: "SETEQ", + reg: regInfo{ + inputs: []regMask{ + 8589934592, + }, + clobbers: 0, + outputs: []regMask{ + 65519, + }, + }, + }, + { + name: "SETNE", + reg: regInfo{ + inputs: []regMask{ + 8589934592, + }, + clobbers: 0, + outputs: []regMask{ + 65519, + }, + }, + }, + { + name: "SETL", + reg: regInfo{ + inputs: []regMask{ + 8589934592, + }, + clobbers: 0, + outputs: []regMask{ + 65519, + }, + }, + }, + { + name: "SETG", + reg: regInfo{ + inputs: []regMask{ + 8589934592, + }, + clobbers: 0, + outputs: []regMask{ + 65519, + }, + }, + }, + { + name: "SETGE", + reg: regInfo{ + inputs: []regMask{ + 8589934592, + }, + clobbers: 0, + outputs: []regMask{ + 65519, + }, + }, + }, + { + name: "SETB", + reg: regInfo{ + inputs: []regMask{ + 8589934592, + }, + clobbers: 0, + outputs: []regMask{ + 65519, + }, + }, + }, + { + name: "MOVQconst", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{ + 65519, + }, + }, + }, + { + name: "LEAQ", + reg: regInfo{ + inputs: []regMask{ + 4295032831, + 4295032831, + }, + clobbers: 0, + outputs: []regMask{ + 65519, + }, + }, + }, + { + name: "LEAQ2", + reg: regInfo{ + inputs: []regMask{ + 4295032831, + 4295032831, + }, + clobbers: 0, + outputs: []regMask{ + 65519, + }, + }, + }, + { + name: "LEAQ4", + reg: regInfo{ + inputs: []regMask{ + 4295032831, + 4295032831, + }, + clobbers: 0, + outputs: []regMask{ + 65519, + }, + }, + }, + { + name: "LEAQ8", + reg: regInfo{ + inputs: []regMask{ + 4295032831, + 4295032831, + }, + clobbers: 0, + outputs: []regMask{ + 65519, + }, + }, + }, + { + name: "LEAQglobal", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{ + 65519, + }, + }, + }, + { + name: "MOVBload", + reg: regInfo{ + inputs: []regMask{ + 4295032831, + 0, + }, + clobbers: 0, + outputs: []regMask{ + 65519, + }, + }, + }, + { + name: "MOVBQZXload", + reg: regInfo{ + inputs: []regMask{ + 4295032831, + 0, + }, + clobbers: 0, + outputs: []regMask{ + 65519, + }, + }, + }, + { + name: "MOVBQSXload", + reg: regInfo{ + inputs: []regMask{ + 4295032831, + 0, + }, + clobbers: 0, + outputs: []regMask{ + 65519, + }, + }, + }, + { + name: "MOVQload", + reg: regInfo{ + inputs: []regMask{ + 4295032831, + 0, + }, + clobbers: 0, + outputs: []regMask{ + 65519, + }, + }, + }, + { + name: "MOVQloadidx8", + reg: regInfo{ + inputs: []regMask{ + 4295032831, + 4295032831, + 0, + }, + clobbers: 0, + outputs: []regMask{ + 65519, + }, + }, + }, + { + name: "MOVBstore", + reg: regInfo{ + inputs: []regMask{ + 4295032831, + 4295032831, + 0, + }, + clobbers: 0, + outputs: []regMask{}, + }, + }, + { + name: "MOVQstore", + reg: regInfo{ + inputs: []regMask{ + 4295032831, + 4295032831, + 0, + }, + clobbers: 0, + outputs: []regMask{}, + }, + }, + { + name: "MOVQstoreidx8", + reg: regInfo{ + inputs: []regMask{ + 4295032831, + 4295032831, + 4295032831, + 0, + }, + clobbers: 0, + outputs: []regMask{}, + }, + }, + { + name: "MOVQloadglobal", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + }, + { + name: "MOVQstoreglobal", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + }, + { + name: "REPMOVSB", + reg: regInfo{ + inputs: []regMask{ + 128, + 64, + 2, + }, + clobbers: 194, + outputs: []regMask{}, + }, + }, + { + name: "ADDL", + reg: regInfo{ + inputs: []regMask{ + 4295032831, + 4295032831, + }, + clobbers: 0, + outputs: []regMask{ + 65519, + }, + }, + }, + { + name: "InvertFlags", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + }, + + { + name: "Add", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Sub", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Mul", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Lsh", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Rsh", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Less", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Phi", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Copy", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Const", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Arg", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Global", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "SP", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "FP", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Func", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Load", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Store", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Move", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Call", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "StaticCall", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Convert", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "ConvNop", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "IsNonNil", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "IsInBounds", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "ArrayIndex", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "PtrIndex", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "OffPtr", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "SliceMake", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "SlicePtr", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "SliceLen", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "SliceCap", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "StringMake", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "StringPtr", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "StringLen", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "StoreReg8", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "LoadReg8", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "FwdRef", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, +} + +func (o Op) String() string { return opcodeTable[o].name } diff --git a/src/cmd/compile/internal/ssa/op_string.go b/src/cmd/compile/internal/ssa/op_string.go deleted file mode 100644 index 2005d332ab..0000000000 --- a/src/cmd/compile/internal/ssa/op_string.go +++ /dev/null @@ -1,32 +0,0 @@ -// generated by stringer -type=Op; DO NOT EDIT - -package ssa - -import "fmt" - -const ( - _Op_name_0 = "opInvalid" - _Op_name_1 = "opGenericStartOpAddOpSubOpMulOpLshOpRshOpLessOpConstOpArgOpGlobalOpFuncOpFPOpSPOpCopyOpMoveOpPhiOpSliceMakeOpSlicePtrOpSliceLenOpSliceCapOpStringMakeOpStringPtrOpStringLenOpLoadOpStoreOpArrayIndexOpPtrIndexOpIsNonNilOpIsInBoundsOpCallOpStaticCallOpConvertOpConvNopOpOffPtrOpStoreReg8OpLoadReg8OpFwdRefOpGenericEnd" - _Op_name_2 = "opAMD64startOpADDQOpADDQconstOpSUBQOpSUBQconstOpMULQOpMULQconstOpSHLQOpSHLQconstOpNEGQOpADDLOpCMPQOpCMPQconstOpTESTQOpTESTBOpSETEQOpSETNEOpSETLOpSETGOpSETGEOpSETBOpInvertFlagsOpLEAQOpLEAQ2OpLEAQ4OpLEAQ8OpLEAQglobalOpMOVBloadOpMOVBQZXloadOpMOVBQSXloadOpMOVQloadOpMOVQstoreOpMOVQloadidx8OpMOVQstoreidx8OpMOVQloadglobalOpMOVQstoreglobalOpMOVQconstOpREPMOVSB" -) - -var ( - _Op_index_0 = [...]uint8{0, 9} - _Op_index_1 = [...]uint16{0, 14, 19, 24, 29, 34, 39, 45, 52, 57, 65, 71, 75, 79, 85, 91, 96, 107, 117, 127, 137, 149, 160, 171, 177, 184, 196, 206, 216, 228, 234, 246, 255, 264, 272, 283, 293, 301, 313} - _Op_index_2 = [...]uint16{0, 12, 18, 29, 35, 46, 52, 63, 69, 80, 86, 92, 98, 109, 116, 123, 130, 137, 143, 149, 156, 162, 175, 181, 188, 195, 202, 214, 224, 237, 250, 260, 271, 285, 300, 316, 333, 344, 354} -) - -func (i Op) String() string { - switch { - case i == 0: - return _Op_name_0 - case 1001 <= i && i <= 1038: - i -= 1001 - return _Op_name_1[_Op_index_1[i]:_Op_index_1[i+1]] - case 2001 <= i && i <= 2038: - i -= 2001 - return _Op_name_2[_Op_index_2[i]:_Op_index_2[i+1]] - default: - return fmt.Sprintf("Op(%d)", i) - } -} diff --git a/src/cmd/compile/internal/ssa/opamd64.go b/src/cmd/compile/internal/ssa/opamd64.go deleted file mode 100644 index 665f087b6e..0000000000 --- a/src/cmd/compile/internal/ssa/opamd64.go +++ /dev/null @@ -1,196 +0,0 @@ -// 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 - -// amd64-specific opcodes - -const ( - blockAMD64Start BlockKind = blockAMD64Base + iota - - BlockEQ - BlockNE - BlockLT - BlockLE - BlockGT - BlockGE - BlockULT - BlockULE - BlockUGT - BlockUGE -) - -const ( - opAMD64start Op = opAMD64Base + iota - - // Suffixes encode the bit width of various instructions. - // Q = 64 bit, L = 32 bit, W = 16 bit, B = 8 bit - - // arithmetic - OpADDQ // arg0 + arg1 - OpADDQconst // arg + aux.(int64) - OpSUBQ // arg0 - arg1 - OpSUBQconst // arg - aux.(int64) - OpMULQ // arg0 * arg1 - OpMULQconst // arg * aux.(int64) - OpSHLQ // arg0 << arg1 - OpSHLQconst // arg << aux.(int64) - OpNEGQ // -arg - OpADDL // arg0 + arg1 - - // Flags value generation. - // We pretend the flags type is an opaque thing that comparisons generate - // and from which we can extract boolean conditions like <, ==, etc. - OpCMPQ // arg0 compare to arg1 - OpCMPQconst // arg0 compare to aux.(int64) - OpTESTQ // (arg0 & arg1) compare to 0 - OpTESTB // (arg0 & arg1) compare to 0 - - // These opcodes extract a particular boolean condition from a flags value. - OpSETEQ // extract == condition from arg0 - OpSETNE // extract != condition from arg0 - OpSETL // extract signed < condition from arg0 - OpSETG // extract signed > condition from arg0 - OpSETGE // extract signed >= condition from arg0 - OpSETB // extract unsigned < condition from arg0 - - // InvertFlags reverses the direction of a flags type interpretation: - // (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. - OpInvertFlags // reverse direction of arg0 - - OpLEAQ // arg0 + arg1 + aux.(int64) - OpLEAQ2 // arg0 + 2*arg1 + aux.(int64) - OpLEAQ4 // arg0 + 4*arg1 + aux.(int64) - OpLEAQ8 // arg0 + 8*arg1 + aux.(int64) - OpLEAQglobal // no args. address of aux.(GlobalOffset) - - // Load/store from general address - OpMOVBload // Load from arg0+aux.(int64). arg1=memory - OpMOVBQZXload - OpMOVBQSXload - OpMOVQload - OpMOVQstore // Store arg1 to arg0+aux.(int64). arg2=memory, returns memory. - OpMOVQloadidx8 // Load from arg0+arg1*8+aux.(int64). arg2=memory - OpMOVQstoreidx8 // Store arg2 to arg0+arg1*8+aux.(int64). arg3=memory, returns memory. - - // Load/store from global. Same as the above loads, but arg0 is missing and aux is a GlobalOffset instead of an int64. - OpMOVQloadglobal // arg0 = memory - OpMOVQstoreglobal // store arg0. arg1=memory, returns memory. - - // materialize a constant into a register - OpMOVQconst // (takes no arguments) - - // move memory - OpREPMOVSB // arg0=destptr, arg1=srcptr, arg2=len, arg3=mem -) - -type regMask uint64 - -var regsAMD64 = [...]string{ - "AX", - "CX", - "DX", - "BX", - "SP", - "BP", - "SI", - "DI", - "R8", - "R9", - "R10", - "R11", - "R12", - "R13", - "R14", - "R15", - - // pseudo registers - "FP", - "FLAGS", - "OVERWRITE0", // the same register as the first input -} - -var gp regMask = 0x1ffff // all integer registers including SP&FP -var gpout regMask = 0xffef // integer registers not including SP&FP -var cx regMask = 1 << 1 -var si regMask = 1 << 6 -var di regMask = 1 << 7 -var flags regMask = 1 << 17 - -var ( - // gp = general purpose (integer) registers - gp21 = [2][]regMask{{gp, gp}, {gpout}} // 2 input, 1 output - gp11 = [2][]regMask{{gp}, {gpout}} // 1 input, 1 output - gp01 = [2][]regMask{{}, {gpout}} // 0 input, 1 output - shift = [2][]regMask{{gp, cx}, {gpout}} // shift operations - gp2_flags = [2][]regMask{{gp, gp}, {flags}} // generate flags from 2 gp regs - gp1_flags = [2][]regMask{{gp}, {flags}} // generate flags from 1 gp reg - - gpload = [2][]regMask{{gp, 0}, {gpout}} - gploadidx = [2][]regMask{{gp, gp, 0}, {gpout}} - gpstore = [2][]regMask{{gp, gp, 0}, {0}} - gpstoreidx = [2][]regMask{{gp, gp, gp, 0}, {0}} - - gpload_stack = [2][]regMask{{0}, {gpout}} - gpstore_stack = [2][]regMask{{gp, 0}, {0}} -) - -// Opcodes that appear in an output amd64 program -var amd64Table = map[Op]opInfo{ - OpADDQ: {flags: OpFlagCommutative, reg: gp21}, // TODO: overwrite - OpADDQconst: {reg: gp11}, // aux = int64 constant to add - OpSUBQ: {reg: gp21}, - OpSUBQconst: {reg: gp11}, - OpMULQ: {reg: gp21}, - OpMULQconst: {reg: gp11}, - OpSHLQ: {reg: gp21}, - OpSHLQconst: {reg: gp11}, - - OpCMPQ: {reg: gp2_flags}, // compute arg[0]-arg[1] and produce flags - OpCMPQconst: {reg: gp1_flags}, - OpTESTQ: {reg: gp2_flags}, - OpTESTB: {reg: gp2_flags}, - - OpLEAQ: {flags: OpFlagCommutative, reg: gp21}, // aux = int64 constant to add - OpLEAQ2: {}, - OpLEAQ4: {}, - OpLEAQ8: {}, - OpLEAQglobal: {reg: gp01}, - - // loads and stores - OpMOVBload: {reg: gpload}, - OpMOVQload: {reg: gpload}, - OpMOVQstore: {reg: gpstore}, - OpMOVQloadidx8: {reg: gploadidx}, - OpMOVQstoreidx8: {reg: gpstoreidx}, - - OpMOVQconst: {reg: gp01}, - - OpStaticCall: {}, - - OpCopy: {reg: gp11}, // TODO: make arch-specific - OpConvNop: {reg: gp11}, // TODO: make arch-specific. Or get rid of this altogether. - - // convert from flags back to boolean - OpSETL: {}, - - // ops for spilling of registers - // unlike regular loads & stores, these take no memory argument. - // They are just like OpCopy but we use them during register allocation. - // TODO: different widths, float - OpLoadReg8: {}, - OpStoreReg8: {}, - - OpREPMOVSB: {reg: [2][]regMask{{di, si, cx, 0}, {0}}}, // TODO: record that si/di/cx are clobbered -} - -func init() { - for op, info := range amd64Table { - opcodeTable[op] = info - } -} diff --git a/src/cmd/compile/internal/ssa/opt.go b/src/cmd/compile/internal/ssa/opt.go index 81c1dfcc02..6e91fd7da3 100644 --- a/src/cmd/compile/internal/ssa/opt.go +++ b/src/cmd/compile/internal/ssa/opt.go @@ -5,9 +5,6 @@ package ssa // machine-independent optimization - -//go:generate go run rulegen/rulegen.go rulegen/generic.rules genericBlockRules genericValueRules generic.go - func opt(f *Func) { - applyRewrite(f, genericBlockRules, genericValueRules) + applyRewrite(f, rewriteBlockgeneric, rewriteValuegeneric) } diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index 8da969b660..839008445c 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -20,8 +20,10 @@ func setloc(home []Location, v *Value, loc Location) []Location { type register uint +type regMask uint64 + // TODO: make arch-dependent -var numRegs register = 32 +var numRegs register = 64 var registers = [...]Register{ Register{0, "AX"}, @@ -40,12 +42,26 @@ var registers = [...]Register{ 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, "FP"}, // pseudo-register, actually a constant offset from SP + Register{33, "FLAGS"}, - // TODO X0, ... // TODO: make arch-dependent - Register{16, "FP"}, // pseudo-register, actually a constant offset from SP - Register{17, "FLAGS"}, - Register{18, "OVERWRITE"}, } // countRegs returns the number of set bits in the register mask. @@ -98,7 +114,7 @@ func regalloc(f *Func) { home = setloc(home, v, ®isters[4]) // TODO: arch-dependent case OpFP: fp = v - home = setloc(home, v, ®isters[16]) // TODO: arch-dependent + home = setloc(home, v, ®isters[32]) // TODO: arch-dependent } } @@ -135,7 +151,7 @@ func regalloc(f *Func) { // TODO: hack: initialize fixed registers regs[4] = regInfo{sp, sp, false} - regs[16] = regInfo{fp, fp, false} + regs[32] = regInfo{fp, fp, false} var used regMask // has a 1 for each non-nil entry in regs var dirty regMask // has a 1 for each dirty entry in regs @@ -155,8 +171,12 @@ func regalloc(f *Func) { // - definition of v. c will be identical to v but will live in // a register. v will be modified into a spill of c. regspec := opcodeTable[v.Op].reg - inputs := regspec[0] - outputs := regspec[1] + if v.Op == OpCopy || v.Op == OpConvNop { + // TODO: make this less of a hack + regspec = opcodeTable[OpAMD64ADDQconst].reg + } + inputs := regspec.inputs + outputs := regspec.outputs if len(inputs) == 0 && len(outputs) == 0 { // No register allocation required (or none specified yet) b.Values = append(b.Values, v) @@ -177,7 +197,7 @@ func regalloc(f *Func) { // nospill contains registers that we can't spill because // we already set them up for use by the current instruction. var nospill regMask - nospill |= 0x10010 // SP and FP can't be spilled (TODO: arch-specific) + nospill |= 0x100000010 // SP and FP can't be spilled (TODO: arch-specific) // Move inputs into registers for _, o := range order { @@ -278,6 +298,8 @@ func regalloc(f *Func) { nospill |= regMask(1) << r } + // TODO: do any clobbering + // pick a register for v itself. if len(outputs) > 1 { panic("can't do multi-output yet") diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go new file mode 100644 index 0000000000..d49245ad3a --- /dev/null +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -0,0 +1,1090 @@ +// autogenerated from gen/AMD64.rules: do not edit! +// generated with: cd gen; go run *.go +package ssa + +func rewriteValueAMD64(v *Value, config *Config) bool { + switch v.Op { + case OpAMD64ADDQ: + // match: (ADDQ x (MOVQconst [c])) + // cond: + // result: (ADDQconst [c] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVQconst { + goto endacffd55e74ee0ff59ad58a18ddfc9973 + } + c := v.Args[1].Aux + v.Op = OpAMD64ADDQconst + v.Aux = nil + v.resetArgs() + v.Aux = c + v.AddArg(x) + return true + } + goto endacffd55e74ee0ff59ad58a18ddfc9973 + endacffd55e74ee0ff59ad58a18ddfc9973: + ; + // match: (ADDQ (MOVQconst [c]) x) + // cond: + // result: (ADDQconst [c] x) + { + if v.Args[0].Op != OpAMD64MOVQconst { + goto end7166f476d744ab7a51125959d3d3c7e2 + } + c := v.Args[0].Aux + x := v.Args[1] + v.Op = OpAMD64ADDQconst + v.Aux = nil + v.resetArgs() + v.Aux = c + v.AddArg(x) + return true + } + goto end7166f476d744ab7a51125959d3d3c7e2 + end7166f476d744ab7a51125959d3d3c7e2: + ; + // match: (ADDQ x (SHLQconst [shift] y)) + // cond: shift.(int64) == 3 + // result: (LEAQ8 [int64(0)] x y) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64SHLQconst { + goto endaf4f724e1e17f2b116d336c07da0165d + } + shift := v.Args[1].Aux + y := v.Args[1].Args[0] + if !(shift.(int64) == 3) { + goto endaf4f724e1e17f2b116d336c07da0165d + } + v.Op = OpAMD64LEAQ8 + v.Aux = nil + v.resetArgs() + v.Aux = int64(0) + v.AddArg(x) + v.AddArg(y) + return true + } + goto endaf4f724e1e17f2b116d336c07da0165d + endaf4f724e1e17f2b116d336c07da0165d: + ; + case OpAMD64ADDQconst: + // match: (ADDQconst [c] (LEAQ8 [d] x y)) + // cond: + // result: (LEAQ8 [addOff(c, d)] x y) + { + c := v.Aux + if v.Args[0].Op != OpAMD64LEAQ8 { + goto ende2cc681c9abf9913288803fb1b39e639 + } + d := v.Args[0].Aux + x := v.Args[0].Args[0] + y := v.Args[0].Args[1] + v.Op = OpAMD64LEAQ8 + v.Aux = nil + v.resetArgs() + v.Aux = addOff(c, d) + v.AddArg(x) + v.AddArg(y) + return true + } + goto ende2cc681c9abf9913288803fb1b39e639 + ende2cc681c9abf9913288803fb1b39e639: + ; + // match: (ADDQconst [off] x) + // cond: off.(int64) == 0 + // result: (Copy x) + { + off := v.Aux + x := v.Args[0] + if !(off.(int64) == 0) { + goto endfa1c7cc5ac4716697e891376787f86ce + } + v.Op = OpCopy + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto endfa1c7cc5ac4716697e891376787f86ce + endfa1c7cc5ac4716697e891376787f86ce: + ; + case OpAdd: + // match: (Add x y) + // cond: (is64BitInt(t) || isPtr(t)) + // result: (ADDQ x y) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + if !(is64BitInt(t) || isPtr(t)) { + goto endf031c523d7dd08e4b8e7010a94cd94c9 + } + v.Op = OpAMD64ADDQ + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto endf031c523d7dd08e4b8e7010a94cd94c9 + endf031c523d7dd08e4b8e7010a94cd94c9: + ; + // match: (Add x y) + // cond: is32BitInt(t) + // result: (ADDL x y) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + if !(is32BitInt(t)) { + goto end35a02a1587264e40cf1055856ff8445a + } + v.Op = OpAMD64ADDL + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end35a02a1587264e40cf1055856ff8445a + end35a02a1587264e40cf1055856ff8445a: + ; + case OpAMD64CMPQ: + // match: (CMPQ x (MOVQconst [c])) + // cond: + // result: (CMPQconst x [c]) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVQconst { + goto end32ef1328af280ac18fa8045a3502dae9 + } + c := v.Args[1].Aux + v.Op = OpAMD64CMPQconst + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.Aux = c + return true + } + goto end32ef1328af280ac18fa8045a3502dae9 + end32ef1328af280ac18fa8045a3502dae9: + ; + // match: (CMPQ (MOVQconst [c]) x) + // cond: + // result: (InvertFlags (CMPQconst x [c])) + { + if v.Args[0].Op != OpAMD64MOVQconst { + goto endf8ca12fe79290bc82b11cfa463bc9413 + } + c := v.Args[0].Aux + x := v.Args[1] + v.Op = OpAMD64InvertFlags + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue(OpAMD64CMPQconst, TypeInvalid, nil) + v0.Type = TypeFlags + v0.AddArg(x) + v0.Aux = c + v.AddArg(v0) + return true + } + goto endf8ca12fe79290bc82b11cfa463bc9413 + endf8ca12fe79290bc82b11cfa463bc9413: + ; + case OpConst: + // match: (Const [val]) + // cond: is64BitInt(t) + // result: (MOVQconst [val]) + { + t := v.Type + val := v.Aux + if !(is64BitInt(t)) { + goto end7f5c5b34093fbc6860524cb803ee51bf + } + v.Op = OpAMD64MOVQconst + v.Aux = nil + v.resetArgs() + v.Aux = val + return true + } + goto end7f5c5b34093fbc6860524cb803ee51bf + end7f5c5b34093fbc6860524cb803ee51bf: + ; + case OpGlobal: + // match: (Global [sym]) + // cond: + // result: (LEAQglobal [GlobalOffset{sym,0}]) + { + sym := v.Aux + v.Op = OpAMD64LEAQglobal + v.Aux = nil + v.resetArgs() + v.Aux = GlobalOffset{sym, 0} + return true + } + goto end3a3c76fac0e2e53c0e1c60b9524e6f1c + end3a3c76fac0e2e53c0e1c60b9524e6f1c: + ; + case OpIsInBounds: + // match: (IsInBounds idx len) + // cond: + // result: (SETB (CMPQ idx len)) + { + idx := v.Args[0] + len := v.Args[1] + v.Op = OpAMD64SETB + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue(OpAMD64CMPQ, TypeInvalid, nil) + v0.Type = TypeFlags + v0.AddArg(idx) + v0.AddArg(len) + v.AddArg(v0) + return true + } + goto endb51d371171154c0f1613b687757e0576 + endb51d371171154c0f1613b687757e0576: + ; + case OpIsNonNil: + // match: (IsNonNil p) + // cond: + // result: (SETNE (TESTQ p p)) + { + p := v.Args[0] + v.Op = OpAMD64SETNE + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue(OpAMD64TESTQ, TypeInvalid, nil) + v0.Type = TypeFlags + v0.AddArg(p) + v0.AddArg(p) + v.AddArg(v0) + return true + } + goto endff508c3726edfb573abc6128c177e76c + endff508c3726edfb573abc6128c177e76c: + ; + case OpLess: + // match: (Less x y) + // cond: is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type) + // result: (SETL (CMPQ x y)) + { + x := v.Args[0] + y := v.Args[1] + if !(is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type)) { + goto endcecf13a952d4c6c2383561c7d68a3cf9 + } + v.Op = OpAMD64SETL + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue(OpAMD64CMPQ, TypeInvalid, nil) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto endcecf13a952d4c6c2383561c7d68a3cf9 + endcecf13a952d4c6c2383561c7d68a3cf9: + ; + case OpLoad: + // match: (Load ptr mem) + // cond: t.IsBoolean() + // result: (MOVBload [int64(0)] ptr mem) + { + t := v.Type + ptr := v.Args[0] + mem := v.Args[1] + if !(t.IsBoolean()) { + goto end73f21632e56c3614902d3c29c82dc4ea + } + v.Op = OpAMD64MOVBload + v.Aux = nil + v.resetArgs() + v.Aux = int64(0) + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto end73f21632e56c3614902d3c29c82dc4ea + end73f21632e56c3614902d3c29c82dc4ea: + ; + // match: (Load ptr mem) + // cond: (is64BitInt(t) || isPtr(t)) + // result: (MOVQload [int64(0)] ptr mem) + { + t := v.Type + ptr := v.Args[0] + mem := v.Args[1] + if !(is64BitInt(t) || isPtr(t)) { + goto end581ce5a20901df1b8143448ba031685b + } + v.Op = OpAMD64MOVQload + v.Aux = nil + v.resetArgs() + v.Aux = int64(0) + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto end581ce5a20901df1b8143448ba031685b + end581ce5a20901df1b8143448ba031685b: + ; + case OpLsh: + // match: (Lsh x y) + // cond: is64BitInt(t) + // result: (SHLQ x y) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + if !(is64BitInt(t)) { + goto end9f05c9539e51db6ad557989e0c822e9b + } + v.Op = OpAMD64SHLQ + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end9f05c9539e51db6ad557989e0c822e9b + end9f05c9539e51db6ad557989e0c822e9b: + ; + case OpAMD64MOVQload: + // match: (MOVQload [off1] (ADDQconst [off2] ptr) mem) + // cond: + // result: (MOVQload [addOff(off1, off2)] ptr mem) + { + off1 := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto end843d29b538c4483b432b632e5666d6e3 + } + off2 := v.Args[0].Aux + ptr := v.Args[0].Args[0] + mem := v.Args[1] + v.Op = OpAMD64MOVQload + v.Aux = nil + v.resetArgs() + v.Aux = addOff(off1, off2) + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto end843d29b538c4483b432b632e5666d6e3 + end843d29b538c4483b432b632e5666d6e3: + ; + // match: (MOVQload [off1] (LEAQ8 [off2] ptr idx) mem) + // cond: + // result: (MOVQloadidx8 [addOff(off1, off2)] ptr idx mem) + { + off1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ8 { + goto end02f5ad148292c46463e7c20d3b821735 + } + off2 := v.Args[0].Aux + ptr := v.Args[0].Args[0] + idx := v.Args[0].Args[1] + mem := v.Args[1] + v.Op = OpAMD64MOVQloadidx8 + v.Aux = nil + v.resetArgs() + v.Aux = addOff(off1, off2) + v.AddArg(ptr) + v.AddArg(idx) + v.AddArg(mem) + return true + } + goto end02f5ad148292c46463e7c20d3b821735 + end02f5ad148292c46463e7c20d3b821735: + ; + case OpAMD64MOVQloadidx8: + // match: (MOVQloadidx8 [off1] (ADDQconst [off2] ptr) idx mem) + // cond: + // result: (MOVQloadidx8 [addOff(off1, off2)] ptr idx mem) + { + off1 := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto ende81e44bcfb11f90916ccb440c590121f + } + off2 := v.Args[0].Aux + ptr := v.Args[0].Args[0] + idx := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64MOVQloadidx8 + v.Aux = nil + v.resetArgs() + v.Aux = addOff(off1, off2) + v.AddArg(ptr) + v.AddArg(idx) + v.AddArg(mem) + return true + } + goto ende81e44bcfb11f90916ccb440c590121f + ende81e44bcfb11f90916ccb440c590121f: + ; + case OpAMD64MOVQstore: + // match: (MOVQstore [off1] (ADDQconst [off2] ptr) val mem) + // cond: + // result: (MOVQstore [addOff(off1, off2)] ptr val mem) + { + off1 := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto end2108c693a43c79aed10b9246c39c80aa + } + off2 := v.Args[0].Aux + ptr := v.Args[0].Args[0] + val := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64MOVQstore + v.Aux = nil + v.resetArgs() + v.Aux = addOff(off1, off2) + v.AddArg(ptr) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto end2108c693a43c79aed10b9246c39c80aa + end2108c693a43c79aed10b9246c39c80aa: + ; + // match: (MOVQstore [off1] (LEAQ8 [off2] ptr idx) val mem) + // cond: + // result: (MOVQstoreidx8 [addOff(off1, off2)] ptr idx val mem) + { + off1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ8 { + goto endce1db8c8d37c8397c500a2068a65c215 + } + off2 := v.Args[0].Aux + ptr := v.Args[0].Args[0] + idx := v.Args[0].Args[1] + val := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64MOVQstoreidx8 + v.Aux = nil + v.resetArgs() + v.Aux = addOff(off1, off2) + v.AddArg(ptr) + v.AddArg(idx) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto endce1db8c8d37c8397c500a2068a65c215 + endce1db8c8d37c8397c500a2068a65c215: + ; + case OpAMD64MOVQstoreidx8: + // match: (MOVQstoreidx8 [off1] (ADDQconst [off2] ptr) idx val mem) + // cond: + // result: (MOVQstoreidx8 [addOff(off1, off2)] ptr idx val mem) + { + off1 := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto end01c970657b0fdefeab82458c15022163 + } + off2 := v.Args[0].Aux + ptr := v.Args[0].Args[0] + idx := v.Args[1] + val := v.Args[2] + mem := v.Args[3] + v.Op = OpAMD64MOVQstoreidx8 + v.Aux = nil + v.resetArgs() + v.Aux = addOff(off1, off2) + v.AddArg(ptr) + v.AddArg(idx) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto end01c970657b0fdefeab82458c15022163 + end01c970657b0fdefeab82458c15022163: + ; + case OpAMD64MULQ: + // match: (MULQ x (MOVQconst [c])) + // cond: c.(int64) == int64(int32(c.(int64))) + // result: (MULQconst [c] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVQconst { + goto ende8c09b194fcde7d9cdc69f2deff86304 + } + c := v.Args[1].Aux + if !(c.(int64) == int64(int32(c.(int64)))) { + goto ende8c09b194fcde7d9cdc69f2deff86304 + } + v.Op = OpAMD64MULQconst + v.Aux = nil + v.resetArgs() + v.Aux = c + v.AddArg(x) + return true + } + goto ende8c09b194fcde7d9cdc69f2deff86304 + ende8c09b194fcde7d9cdc69f2deff86304: + ; + // match: (MULQ (MOVQconst [c]) x) + // cond: + // result: (MULQconst [c] x) + { + if v.Args[0].Op != OpAMD64MOVQconst { + goto endc6e18d6968175d6e58eafa6dcf40c1b8 + } + c := v.Args[0].Aux + x := v.Args[1] + v.Op = OpAMD64MULQconst + v.Aux = nil + v.resetArgs() + v.Aux = c + v.AddArg(x) + return true + } + goto endc6e18d6968175d6e58eafa6dcf40c1b8 + endc6e18d6968175d6e58eafa6dcf40c1b8: + ; + case OpAMD64MULQconst: + // match: (MULQconst [c] x) + // cond: c.(int64) == 8 + // result: (SHLQconst [int64(3)] x) + { + c := v.Aux + x := v.Args[0] + if !(c.(int64) == 8) { + goto end7e16978c56138324ff2abf91fd6d94d4 + } + v.Op = OpAMD64SHLQconst + v.Aux = nil + v.resetArgs() + v.Aux = int64(3) + v.AddArg(x) + return true + } + goto end7e16978c56138324ff2abf91fd6d94d4 + end7e16978c56138324ff2abf91fd6d94d4: + ; + // match: (MULQconst [c] x) + // cond: c.(int64) == 64 + // result: (SHLQconst [int64(5)] x) + { + c := v.Aux + x := v.Args[0] + if !(c.(int64) == 64) { + goto end2c7a02f230e4b311ac3a4e22f70a4f08 + } + v.Op = OpAMD64SHLQconst + v.Aux = nil + v.resetArgs() + v.Aux = int64(5) + v.AddArg(x) + return true + } + goto end2c7a02f230e4b311ac3a4e22f70a4f08 + end2c7a02f230e4b311ac3a4e22f70a4f08: + ; + case OpMove: + // match: (Move [size] dst src mem) + // cond: + // result: (REPMOVSB dst src (Const [size.(int64)]) mem) + { + size := v.Aux + dst := v.Args[0] + src := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64REPMOVSB + v.Aux = nil + v.resetArgs() + v.AddArg(dst) + v.AddArg(src) + v0 := v.Block.NewValue(OpConst, TypeInvalid, nil) + v0.Type = TypeUInt64 + v0.Aux = size.(int64) + v.AddArg(v0) + v.AddArg(mem) + return true + } + goto end48909259b265a6bb2a076bc2c2dc7d1f + end48909259b265a6bb2a076bc2c2dc7d1f: + ; + case OpMul: + // match: (Mul x y) + // cond: is64BitInt(t) + // result: (MULQ x y) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + if !(is64BitInt(t)) { + goto endfab0d598f376ecba45a22587d50f7aff + } + v.Op = OpAMD64MULQ + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto endfab0d598f376ecba45a22587d50f7aff + endfab0d598f376ecba45a22587d50f7aff: + ; + case OpOffPtr: + // match: (OffPtr [off] ptr) + // cond: + // result: (ADDQconst [off] ptr) + { + off := v.Aux + ptr := v.Args[0] + v.Op = OpAMD64ADDQconst + v.Aux = nil + v.resetArgs() + v.Aux = off + v.AddArg(ptr) + return true + } + goto end0429f947ee7ac49ff45a243e461a5290 + end0429f947ee7ac49ff45a243e461a5290: + ; + case OpAMD64SETG: + // match: (SETG (InvertFlags x)) + // cond: + // result: (SETL x) + { + if v.Args[0].Op != OpAMD64InvertFlags { + goto endf7586738694c9cd0b74ae28bbadb649f + } + x := v.Args[0].Args[0] + v.Op = OpAMD64SETL + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto endf7586738694c9cd0b74ae28bbadb649f + endf7586738694c9cd0b74ae28bbadb649f: + ; + case OpAMD64SETL: + // match: (SETL (InvertFlags x)) + // cond: + // result: (SETG x) + { + if v.Args[0].Op != OpAMD64InvertFlags { + goto ende33160cd86b9d4d3b77e02fb4658d5d3 + } + x := v.Args[0].Args[0] + v.Op = OpAMD64SETG + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto ende33160cd86b9d4d3b77e02fb4658d5d3 + ende33160cd86b9d4d3b77e02fb4658d5d3: + ; + case OpAMD64SHLQ: + // match: (SHLQ x (MOVQconst [c])) + // cond: + // result: (SHLQconst [c] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVQconst { + goto endcca412bead06dc3d56ef034a82d184d6 + } + c := v.Args[1].Aux + v.Op = OpAMD64SHLQconst + v.Aux = nil + v.resetArgs() + v.Aux = c + v.AddArg(x) + return true + } + goto endcca412bead06dc3d56ef034a82d184d6 + endcca412bead06dc3d56ef034a82d184d6: + ; + case OpAMD64SUBQ: + // match: (SUBQ x (MOVQconst [c])) + // cond: + // result: (SUBQconst x [c]) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVQconst { + goto end5a74a63bd9ad15437717c6df3b25eebb + } + c := v.Args[1].Aux + v.Op = OpAMD64SUBQconst + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.Aux = c + return true + } + goto end5a74a63bd9ad15437717c6df3b25eebb + end5a74a63bd9ad15437717c6df3b25eebb: + ; + // match: (SUBQ (MOVQconst [c]) x) + // cond: + // result: (NEGQ (SUBQconst x [c])) + { + t := v.Type + if v.Args[0].Op != OpAMD64MOVQconst { + goto end78e66b6fc298684ff4ac8aec5ce873c9 + } + c := v.Args[0].Aux + x := v.Args[1] + v.Op = OpAMD64NEGQ + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue(OpAMD64SUBQconst, TypeInvalid, nil) + v0.Type = t + v0.AddArg(x) + v0.Aux = c + v.AddArg(v0) + return true + } + goto end78e66b6fc298684ff4ac8aec5ce873c9 + end78e66b6fc298684ff4ac8aec5ce873c9: + ; + case OpStore: + // match: (Store ptr val mem) + // cond: (is64BitInt(val.Type) || isPtr(val.Type)) + // result: (MOVQstore [int64(0)] ptr val mem) + { + ptr := v.Args[0] + val := v.Args[1] + mem := v.Args[2] + if !(is64BitInt(val.Type) || isPtr(val.Type)) { + goto end9680b43f504bc06f9fab000823ce471a + } + v.Op = OpAMD64MOVQstore + v.Aux = nil + v.resetArgs() + v.Aux = int64(0) + v.AddArg(ptr) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto end9680b43f504bc06f9fab000823ce471a + end9680b43f504bc06f9fab000823ce471a: + ; + case OpSub: + // match: (Sub x y) + // cond: is64BitInt(t) + // result: (SUBQ x y) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + if !(is64BitInt(t)) { + goto ende6ef29f885a8ecf3058212bb95917323 + } + v.Op = OpAMD64SUBQ + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto ende6ef29f885a8ecf3058212bb95917323 + ende6ef29f885a8ecf3058212bb95917323: + } + return false +} +func rewriteBlockAMD64(b *Block) bool { + switch b.Kind { + case BlockAMD64EQ: + // match: (EQ (InvertFlags cmp) yes no) + // cond: + // result: (EQ cmp yes no) + { + v := b.Control + if v.Op != OpAMD64InvertFlags { + goto end6b8e9afc73b1c4d528f31a60d2575fae + } + 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 + } + goto end6b8e9afc73b1c4d528f31a60d2575fae + end6b8e9afc73b1c4d528f31a60d2575fae: + ; + case BlockAMD64GE: + // match: (GE (InvertFlags cmp) yes no) + // cond: + // result: (LE cmp yes no) + { + v := b.Control + if v.Op != OpAMD64InvertFlags { + goto end0610f000a6988ee8310307ec2ea138f8 + } + 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 + } + goto end0610f000a6988ee8310307ec2ea138f8 + end0610f000a6988ee8310307ec2ea138f8: + ; + case BlockAMD64GT: + // match: (GT (InvertFlags cmp) yes no) + // cond: + // result: (LT cmp yes no) + { + v := b.Control + if v.Op != OpAMD64InvertFlags { + goto endf60c0660b6a8aa9565c97fc87f04eb34 + } + 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 + } + goto endf60c0660b6a8aa9565c97fc87f04eb34 + endf60c0660b6a8aa9565c97fc87f04eb34: + ; + case BlockIf: + // match: (If (SETL cmp) yes no) + // cond: + // result: (LT cmp yes no) + { + v := b.Control + if v.Op != OpAMD64SETL { + goto ende4d36879bb8e1bd8facaa8c91ba99dcc + } + 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 + } + goto ende4d36879bb8e1bd8facaa8c91ba99dcc + ende4d36879bb8e1bd8facaa8c91ba99dcc: + ; + // match: (If (SETNE cmp) yes no) + // cond: + // result: (NE cmp yes no) + { + v := b.Control + if v.Op != OpAMD64SETNE { + goto end5ff1403aaf7b543bc454177ab584e4f5 + } + 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 + } + goto end5ff1403aaf7b543bc454177ab584e4f5 + end5ff1403aaf7b543bc454177ab584e4f5: + ; + // match: (If (SETB cmp) yes no) + // cond: + // result: (ULT cmp yes no) + { + v := b.Control + if v.Op != OpAMD64SETB { + goto end04935012db9defeafceef8175f803ea2 + } + 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 + } + goto end04935012db9defeafceef8175f803ea2 + end04935012db9defeafceef8175f803ea2: + ; + // match: (If cond yes no) + // cond: cond.Op == OpAMD64MOVBload + // result: (NE (TESTB cond cond) yes no) + { + v := b.Control + cond := v + yes := b.Succs[0] + no := b.Succs[1] + if !(cond.Op == OpAMD64MOVBload) { + goto end7e22019fb0effc80f85c05ea30bdb5d9 + } + b.Kind = BlockAMD64NE + v0 := v.Block.NewValue(OpAMD64TESTB, TypeInvalid, nil) + v0.Type = TypeFlags + v0.AddArg(cond) + v0.AddArg(cond) + b.Control = v0 + b.Succs[0] = yes + b.Succs[1] = no + return true + } + goto end7e22019fb0effc80f85c05ea30bdb5d9 + end7e22019fb0effc80f85c05ea30bdb5d9: + ; + case BlockAMD64LE: + // match: (LE (InvertFlags cmp) yes no) + // cond: + // result: (GE cmp yes no) + { + v := b.Control + if v.Op != OpAMD64InvertFlags { + goto end0d49d7d087fe7578e8015cf13dae37e3 + } + 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 + } + goto end0d49d7d087fe7578e8015cf13dae37e3 + end0d49d7d087fe7578e8015cf13dae37e3: + ; + case BlockAMD64LT: + // match: (LT (InvertFlags cmp) yes no) + // cond: + // result: (GT cmp yes no) + { + v := b.Control + if v.Op != OpAMD64InvertFlags { + goto end6a408cde0fee0ae7b7da0443c8d902bf + } + 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 + } + goto end6a408cde0fee0ae7b7da0443c8d902bf + end6a408cde0fee0ae7b7da0443c8d902bf: + ; + case BlockAMD64NE: + // match: (NE (InvertFlags cmp) yes no) + // cond: + // result: (NE cmp yes no) + { + v := b.Control + if v.Op != OpAMD64InvertFlags { + goto end713001aba794e50b582fbff930e110af + } + 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 + } + goto end713001aba794e50b582fbff930e110af + end713001aba794e50b582fbff930e110af: + ; + case BlockAMD64UGE: + // match: (UGE (InvertFlags cmp) yes no) + // cond: + // result: (ULE cmp yes no) + { + v := b.Control + if v.Op != OpAMD64InvertFlags { + goto ende3e4ddc183ca1a46598b11c2d0d13966 + } + 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 + } + goto ende3e4ddc183ca1a46598b11c2d0d13966 + ende3e4ddc183ca1a46598b11c2d0d13966: + ; + case BlockAMD64UGT: + // match: (UGT (InvertFlags cmp) yes no) + // cond: + // result: (ULT cmp yes no) + { + v := b.Control + if v.Op != OpAMD64InvertFlags { + goto end49818853af2e5251175d06c62768cae7 + } + 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 + } + goto end49818853af2e5251175d06c62768cae7 + end49818853af2e5251175d06c62768cae7: + ; + case BlockAMD64ULE: + // match: (ULE (InvertFlags cmp) yes no) + // cond: + // result: (UGE cmp yes no) + { + v := b.Control + if v.Op != OpAMD64InvertFlags { + goto endd6698aac0d67261293b558c95ea17b4f + } + 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 + } + goto endd6698aac0d67261293b558c95ea17b4f + endd6698aac0d67261293b558c95ea17b4f: + ; + case BlockAMD64ULT: + // match: (ULT (InvertFlags cmp) yes no) + // cond: + // result: (UGT cmp yes no) + { + v := b.Control + if v.Op != OpAMD64InvertFlags { + goto end35105dbc9646f02577167e45ae2f2fd2 + } + 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 + } + goto end35105dbc9646f02577167e45ae2f2fd2 + end35105dbc9646f02577167e45ae2f2fd2: + } + return false +} diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go new file mode 100644 index 0000000000..e9552e68f3 --- /dev/null +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -0,0 +1,424 @@ +// autogenerated from gen/generic.rules: do not edit! +// generated with: cd gen; go run *.go +package ssa + +func rewriteValuegeneric(v *Value, config *Config) bool { + switch v.Op { + case OpAdd: + // match: (Add (Const [c]) (Const [d])) + // cond: is64BitInt(t) + // result: (Const [{c.(int64)+d.(int64)}]) + { + t := v.Type + if v.Args[0].Op != OpConst { + goto end8d047ed0ae9537b840adc79ea82c6e05 + } + c := v.Args[0].Aux + if v.Args[1].Op != OpConst { + goto end8d047ed0ae9537b840adc79ea82c6e05 + } + d := v.Args[1].Aux + if !(is64BitInt(t)) { + goto end8d047ed0ae9537b840adc79ea82c6e05 + } + v.Op = OpConst + v.Aux = nil + v.resetArgs() + v.Aux = c.(int64) + d.(int64) + return true + } + goto end8d047ed0ae9537b840adc79ea82c6e05 + end8d047ed0ae9537b840adc79ea82c6e05: + ; + case OpArrayIndex: + // match: (ArrayIndex (Load ptr mem) idx) + // cond: + // result: (Load (PtrIndex ptr idx) mem) + { + if v.Args[0].Op != OpLoad { + goto end3809f4c52270a76313e4ea26e6f0b753 + } + ptr := v.Args[0].Args[0] + mem := v.Args[0].Args[1] + idx := v.Args[1] + v.Op = OpLoad + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue(OpPtrIndex, TypeInvalid, nil) + v0.Type = ptr.Type.Elem().Elem().PtrTo() + v0.AddArg(ptr) + v0.AddArg(idx) + v.AddArg(v0) + v.AddArg(mem) + return true + } + goto end3809f4c52270a76313e4ea26e6f0b753 + end3809f4c52270a76313e4ea26e6f0b753: + ; + case OpConst: + // match: (Const [s]) + // cond: t.IsString() + // result: (StringMake (OffPtr [2*config.ptrSize] (Global [config.fe.StringSym(s.(string))])) (Const [int64(len(s.(string)))])) + { + t := v.Type + s := v.Aux + if !(t.IsString()) { + goto end8442aa5b3f4e5b840055475883110372 + } + v.Op = OpStringMake + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue(OpOffPtr, TypeInvalid, nil) + v0.Type = TypeBytePtr + v0.Aux = 2 * config.ptrSize + v1 := v.Block.NewValue(OpGlobal, TypeInvalid, nil) + v1.Type = TypeBytePtr + v1.Aux = config.fe.StringSym(s.(string)) + v0.AddArg(v1) + v.AddArg(v0) + v2 := v.Block.NewValue(OpConst, TypeInvalid, nil) + v2.Type = config.Uintptr + v2.Aux = int64(len(s.(string))) + v.AddArg(v2) + return true + } + goto end8442aa5b3f4e5b840055475883110372 + end8442aa5b3f4e5b840055475883110372: + ; + case OpIsInBounds: + // match: (IsInBounds (Const [c]) (Const [d])) + // cond: + // result: (Const [inBounds(c.(int64),d.(int64))]) + { + if v.Args[0].Op != OpConst { + goto enddbd1a394d9b71ee64335361b8384865c + } + c := v.Args[0].Aux + if v.Args[1].Op != OpConst { + goto enddbd1a394d9b71ee64335361b8384865c + } + d := v.Args[1].Aux + v.Op = OpConst + v.Aux = nil + v.resetArgs() + v.Aux = inBounds(c.(int64), d.(int64)) + return true + } + goto enddbd1a394d9b71ee64335361b8384865c + enddbd1a394d9b71ee64335361b8384865c: + ; + case OpLoad: + // match: (Load ptr mem) + // cond: t.IsString() + // result: (StringMake (Load ptr mem) (Load (OffPtr [config.ptrSize] ptr) mem)) + { + t := v.Type + ptr := v.Args[0] + mem := v.Args[1] + if !(t.IsString()) { + goto endd0afd003b70d726a1c5bbaf51fe06182 + } + v.Op = OpStringMake + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue(OpLoad, TypeInvalid, nil) + v0.Type = TypeBytePtr + v0.AddArg(ptr) + v0.AddArg(mem) + v.AddArg(v0) + v1 := v.Block.NewValue(OpLoad, TypeInvalid, nil) + v1.Type = config.Uintptr + v2 := v.Block.NewValue(OpOffPtr, TypeInvalid, nil) + v2.Type = TypeBytePtr + v2.Aux = config.ptrSize + v2.AddArg(ptr) + v1.AddArg(v2) + v1.AddArg(mem) + v.AddArg(v1) + return true + } + goto endd0afd003b70d726a1c5bbaf51fe06182 + endd0afd003b70d726a1c5bbaf51fe06182: + ; + case OpMul: + // match: (Mul (Const [c]) (Const [d])) + // cond: is64BitInt(t) + // result: (Const [{c.(int64)*d.(int64)}]) + { + t := v.Type + if v.Args[0].Op != OpConst { + goto end776610f88cf04f438242d76ed2b14f1c + } + c := v.Args[0].Aux + if v.Args[1].Op != OpConst { + goto end776610f88cf04f438242d76ed2b14f1c + } + d := v.Args[1].Aux + if !(is64BitInt(t)) { + goto end776610f88cf04f438242d76ed2b14f1c + } + v.Op = OpConst + v.Aux = nil + v.resetArgs() + v.Aux = c.(int64) * d.(int64) + return true + } + goto end776610f88cf04f438242d76ed2b14f1c + end776610f88cf04f438242d76ed2b14f1c: + ; + case OpPtrIndex: + // match: (PtrIndex ptr idx) + // cond: + // result: (Add ptr (Mul idx (Const [t.Elem().Size()]))) + { + t := v.Type + ptr := v.Args[0] + idx := v.Args[1] + v.Op = OpAdd + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v0 := v.Block.NewValue(OpMul, TypeInvalid, nil) + v0.Type = config.Uintptr + v0.AddArg(idx) + v1 := v.Block.NewValue(OpConst, TypeInvalid, nil) + v1.Type = config.Uintptr + v1.Aux = t.Elem().Size() + v0.AddArg(v1) + v.AddArg(v0) + return true + } + goto end88c7c383675420d1581daeb899039fa8 + end88c7c383675420d1581daeb899039fa8: + ; + case OpSliceCap: + // match: (SliceCap (Load ptr mem)) + // cond: + // result: (Load (Add ptr (Const [int64(config.ptrSize*2)])) mem) + { + if v.Args[0].Op != OpLoad { + goto endc871dcd9a720b4290c9cae78fe147c8a + } + ptr := v.Args[0].Args[0] + mem := v.Args[0].Args[1] + v.Op = OpLoad + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue(OpAdd, TypeInvalid, nil) + v0.Type = ptr.Type + v0.AddArg(ptr) + v1 := v.Block.NewValue(OpConst, TypeInvalid, nil) + v1.Type = config.Uintptr + v1.Aux = int64(config.ptrSize * 2) + v0.AddArg(v1) + v.AddArg(v0) + v.AddArg(mem) + return true + } + goto endc871dcd9a720b4290c9cae78fe147c8a + endc871dcd9a720b4290c9cae78fe147c8a: + ; + case OpSliceLen: + // match: (SliceLen (Load ptr mem)) + // cond: + // result: (Load (Add ptr (Const [int64(config.ptrSize)])) mem) + { + if v.Args[0].Op != OpLoad { + goto end1eec05e44f5fc8944e7c176f98a74d92 + } + ptr := v.Args[0].Args[0] + mem := v.Args[0].Args[1] + v.Op = OpLoad + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue(OpAdd, TypeInvalid, nil) + v0.Type = ptr.Type + v0.AddArg(ptr) + v1 := v.Block.NewValue(OpConst, TypeInvalid, nil) + v1.Type = config.Uintptr + v1.Aux = int64(config.ptrSize) + v0.AddArg(v1) + v.AddArg(v0) + v.AddArg(mem) + return true + } + goto end1eec05e44f5fc8944e7c176f98a74d92 + end1eec05e44f5fc8944e7c176f98a74d92: + ; + case OpSlicePtr: + // match: (SlicePtr (Load ptr mem)) + // cond: + // result: (Load ptr mem) + { + if v.Args[0].Op != OpLoad { + goto end459613b83f95b65729d45c2ed663a153 + } + ptr := v.Args[0].Args[0] + mem := v.Args[0].Args[1] + v.Op = OpLoad + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto end459613b83f95b65729d45c2ed663a153 + end459613b83f95b65729d45c2ed663a153: + ; + case OpStore: + // match: (Store dst (Load src mem) mem) + // cond: t.Size() > 8 + // result: (Move [t.Size()] dst src mem) + { + dst := v.Args[0] + if v.Args[1].Op != OpLoad { + goto end324ffb6d2771808da4267f62c854e9c8 + } + t := v.Args[1].Type + src := v.Args[1].Args[0] + mem := v.Args[1].Args[1] + if v.Args[2] != v.Args[1].Args[1] { + goto end324ffb6d2771808da4267f62c854e9c8 + } + if !(t.Size() > 8) { + goto end324ffb6d2771808da4267f62c854e9c8 + } + v.Op = OpMove + v.Aux = nil + v.resetArgs() + v.Aux = t.Size() + v.AddArg(dst) + v.AddArg(src) + v.AddArg(mem) + return true + } + goto end324ffb6d2771808da4267f62c854e9c8 + end324ffb6d2771808da4267f62c854e9c8: + ; + // match: (Store dst str mem) + // cond: str.Type.IsString() + // result: (Store (OffPtr [config.ptrSize] dst) (StringLen str) (Store dst (StringPtr str) mem)) + { + dst := v.Args[0] + str := v.Args[1] + mem := v.Args[2] + if !(str.Type.IsString()) { + goto end410559d97aed8018f820cd88723de442 + } + v.Op = OpStore + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue(OpOffPtr, TypeInvalid, nil) + v0.Type = TypeBytePtr + v0.Aux = config.ptrSize + v0.AddArg(dst) + v.AddArg(v0) + v1 := v.Block.NewValue(OpStringLen, TypeInvalid, nil) + v1.Type = config.Uintptr + v1.AddArg(str) + v.AddArg(v1) + v2 := v.Block.NewValue(OpStore, TypeInvalid, nil) + v2.Type = TypeMem + v2.AddArg(dst) + v3 := v.Block.NewValue(OpStringPtr, TypeInvalid, nil) + v3.Type = TypeBytePtr + v3.AddArg(str) + v2.AddArg(v3) + v2.AddArg(mem) + v.AddArg(v2) + return true + } + goto end410559d97aed8018f820cd88723de442 + end410559d97aed8018f820cd88723de442: + ; + case OpStringLen: + // match: (StringLen (StringMake _ len)) + // cond: + // result: len + { + if v.Args[0].Op != OpStringMake { + goto end0d922460b7e5ca88324034f4bd6c027c + } + len := v.Args[0].Args[1] + v.Op = len.Op + v.Aux = len.Aux + v.resetArgs() + v.AddArgs(len.Args...) + return true + } + goto end0d922460b7e5ca88324034f4bd6c027c + end0d922460b7e5ca88324034f4bd6c027c: + ; + case OpStringPtr: + // match: (StringPtr (StringMake ptr _)) + // cond: + // result: ptr + { + if v.Args[0].Op != OpStringMake { + goto end061edc5d85c73ad909089af2556d9380 + } + ptr := v.Args[0].Args[0] + v.Op = ptr.Op + v.Aux = ptr.Aux + v.resetArgs() + v.AddArgs(ptr.Args...) + return true + } + goto end061edc5d85c73ad909089af2556d9380 + end061edc5d85c73ad909089af2556d9380: + } + return false +} +func rewriteBlockgeneric(b *Block) bool { + switch b.Kind { + case BlockIf: + // match: (If (Const [c]) yes no) + // cond: c.(bool) + // result: (Plain nil yes) + { + v := b.Control + if v.Op != OpConst { + goto end60cde11c1be8092f493d9cda982445ca + } + c := v.Aux + yes := b.Succs[0] + no := b.Succs[1] + if !(c.(bool)) { + goto end60cde11c1be8092f493d9cda982445ca + } + removePredecessor(b, no) + b.Kind = BlockPlain + b.Control = nil + b.Succs = b.Succs[:1] + b.Succs[0] = yes + return true + } + goto end60cde11c1be8092f493d9cda982445ca + end60cde11c1be8092f493d9cda982445ca: + ; + // match: (If (Const [c]) yes no) + // cond: !c.(bool) + // result: (Plain nil no) + { + v := b.Control + if v.Op != OpConst { + goto endf2a5efbfd2d40dead087c33685c8f30b + } + c := v.Aux + yes := b.Succs[0] + no := b.Succs[1] + if !(!c.(bool)) { + goto endf2a5efbfd2d40dead087c33685c8f30b + } + removePredecessor(b, yes) + b.Kind = BlockPlain + b.Control = nil + b.Succs = b.Succs[:1] + b.Succs[0] = no + return true + } + goto endf2a5efbfd2d40dead087c33685c8f30b + endf2a5efbfd2d40dead087c33685c8f30b: + } + return false +} diff --git a/src/cmd/compile/internal/ssa/rulegen/generic.rules b/src/cmd/compile/internal/ssa/rulegen/generic.rules deleted file mode 100644 index 21e5f72d09..0000000000 --- a/src/cmd/compile/internal/ssa/rulegen/generic.rules +++ /dev/null @@ -1,49 +0,0 @@ -// 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 [aux] arg0 arg1 ...) -// the type and aux fields are optional -// on the matching side -// - the types and aux 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. -// - 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 -(Add (Const [c]) (Const [d])) && is64BitInt(t) -> (Const [{c.(int64)+d.(int64)}]) -(Mul (Const [c]) (Const [d])) && is64BitInt(t) -> (Const [{c.(int64)*d.(int64)}]) -(IsInBounds (Const [c]) (Const [d])) -> (Const [inBounds(c.(int64),d.(int64))]) - -// tear apart slices -// TODO: anything that generates a slice needs to go in here. -(SlicePtr (Load ptr mem)) -> (Load ptr mem) -(SliceLen (Load ptr mem)) -> (Load (Add ptr (Const [int64(config.ptrSize)])) mem) -(SliceCap (Load ptr mem)) -> (Load (Add ptr (Const [int64(config.ptrSize*2)])) mem) - -// indexing operations -// Note: bounds check has already been done -(ArrayIndex (Load ptr mem) idx) -> (Load (PtrIndex ptr idx) mem) -(PtrIndex ptr idx) -> (Add ptr (Mul idx (Const [t.Elem().Size()]))) - -// big-object moves -// TODO: fix size -(Store dst (Load src mem) mem) && t.Size() > 8 -> (Move [t.Size()] dst src mem) - -(BlockIf (Const [c]) yes no) && c.(bool) -> (BlockPlain nil yes) -(BlockIf (Const [c]) yes no) && !c.(bool) -> (BlockPlain nil no) - -// string ops -(Const [s]) && t.IsString() -> (StringMake (OffPtr [2*config.ptrSize] (Global [config.fe.StringSym(s.(string))])) (Const [int64(len(s.(string)))])) // TODO: ptr -(Load ptr mem) && t.IsString() -> (StringMake (Load ptr mem) (Load (OffPtr [config.ptrSize] ptr) mem)) -(StringPtr (StringMake ptr _)) -> ptr -(StringLen (StringMake _ len)) -> len -(Store dst str mem) && str.Type.IsString() -> (Store (OffPtr [config.ptrSize] dst) (StringLen str) (Store dst (StringPtr str) mem)) diff --git a/src/cmd/compile/internal/ssa/rulegen/lower_amd64.rules b/src/cmd/compile/internal/ssa/rulegen/lower_amd64.rules deleted file mode 100644 index e86e408525..0000000000 --- a/src/cmd/compile/internal/ssa/rulegen/lower_amd64.rules +++ /dev/null @@ -1,100 +0,0 @@ -// 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 correctly extended. -// - 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. - -// These are the lowerings themselves -(Add x y) && (is64BitInt(t) || isPtr(t)) -> (ADDQ x y) -(Add x y) && is32BitInt(t) -> (ADDL x y) - -(Sub x y) && is64BitInt(t) -> (SUBQ x y) - -(Mul x y) && is64BitInt(t) -> (MULQ x y) -(Lsh x y) && is64BitInt(t) -> (SHLQ x y) // TODO: check y>63 -(Less x y) && is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type) -> (SETL (CMPQ x y)) - -(Load ptr mem) && t.IsBoolean() -> (MOVBload [int64(0)] ptr mem) -(Load ptr mem) && (is64BitInt(t) || isPtr(t)) -> (MOVQload [int64(0)] ptr mem) -(Store ptr val mem) && (is64BitInt(val.Type) || isPtr(val.Type)) -> (MOVQstore [int64(0)] ptr val mem) - -// checks -(IsNonNil p) -> (SETNE (TESTQ p p)) -(IsInBounds idx len) -> (SETB (CMPQ idx len)) - -(Move [size] dst src mem) -> (REPMOVSB dst src (Const [size.(int64)]) mem) - -(OffPtr [off] ptr) -> (ADDQconst [off] ptr) - -(Const [val]) && is64BitInt(t) -> (MOVQconst [val]) - -// block rewrites -(BlockIf (SETL cmp) yes no) -> (BlockLT cmp yes no) -(BlockIf (SETNE cmp) yes no) -> (BlockNE cmp yes no) -(BlockIf (SETB cmp) yes no) -> (BlockULT cmp yes no) -(BlockIf cond yes no) && cond.Op == OpMOVBload -> (BlockNE (TESTB cond cond) yes no) - -// Rules below here apply some simple optimizations after lowering. -// TODO: Should this be a separate pass? - -// global loads/stores -(Global [sym]) -> (LEAQglobal [GlobalOffset{sym,0}]) - -// fold constants into instructions -(ADDQ x (MOVQconst [c])) -> (ADDQconst [c] x) // TODO: restrict c to int32 range? -(ADDQ (MOVQconst [c]) x) -> (ADDQconst [c] x) -(SUBQ x (MOVQconst [c])) -> (SUBQconst x [c]) -(SUBQ (MOVQconst [c]) x) -> (NEGQ (SUBQconst x [c])) -(MULQ x (MOVQconst [c])) && c.(int64) == int64(int32(c.(int64))) -> (MULQconst [c] x) -(MULQ (MOVQconst [c]) x) -> (MULQconst [c] x) -(SHLQ x (MOVQconst [c])) -> (SHLQconst [c] x) -(CMPQ x (MOVQconst [c])) -> (CMPQconst x [c]) -(CMPQ (MOVQconst [c]) x) -> (InvertFlags (CMPQconst x [c])) - -// strength reduction -// TODO: do this a lot more generically -(MULQconst [c] x) && c.(int64) == 8 -> (SHLQconst [int64(3)] x) -(MULQconst [c] x) && c.(int64) == 64 -> (SHLQconst [int64(5)] x) - -// fold add/shift into leaq -(ADDQ x (SHLQconst [shift] y)) && shift.(int64) == 3 -> (LEAQ8 [int64(0)] x y) -(ADDQconst [c] (LEAQ8 [d] x y)) -> (LEAQ8 [addOff(c, d)] x y) - -// reverse ordering of compare instruction -(SETL (InvertFlags x)) -> (SETG x) -(SETG (InvertFlags x)) -> (SETL x) - -// 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] (ADDQconst [off2] ptr) mem) -> (MOVQload [addOff(off1, off2)] ptr mem) -(MOVQstore [off1] (ADDQconst [off2] ptr) val mem) -> (MOVQstore [addOff(off1, off2)] ptr val mem) - -// indexed loads and stores -(MOVQload [off1] (LEAQ8 [off2] ptr idx) mem) -> (MOVQloadidx8 [addOff(off1, off2)] ptr idx mem) -(MOVQstore [off1] (LEAQ8 [off2] ptr idx) val mem) -> (MOVQstoreidx8 [addOff(off1, off2)] ptr idx val mem) - -(MOVQloadidx8 [off1] (ADDQconst [off2] ptr) idx mem) -> (MOVQloadidx8 [addOff(off1, off2)] ptr idx mem) -(MOVQstoreidx8 [off1] (ADDQconst [off2] ptr) idx val mem) -> (MOVQstoreidx8 [addOff(off1, off2)] ptr idx val mem) - -(ADDQconst [off] x) && off.(int64) == 0 -> (Copy x) - -// Absorb InvertFlags into branches. -(BlockLT (InvertFlags cmp) yes no) -> (BlockGT cmp yes no) -(BlockGT (InvertFlags cmp) yes no) -> (BlockLT cmp yes no) -(BlockLE (InvertFlags cmp) yes no) -> (BlockGE cmp yes no) -(BlockGE (InvertFlags cmp) yes no) -> (BlockLE cmp yes no) -(BlockULT (InvertFlags cmp) yes no) -> (BlockUGT cmp yes no) -(BlockUGT (InvertFlags cmp) yes no) -> (BlockULT cmp yes no) -(BlockULE (InvertFlags cmp) yes no) -> (BlockUGE cmp yes no) -(BlockUGE (InvertFlags cmp) yes no) -> (BlockULE cmp yes no) -(BlockEQ (InvertFlags cmp) yes no) -> (BlockEQ cmp yes no) -(BlockNE (InvertFlags cmp) yes no) -> (BlockNE cmp yes no) diff --git a/src/cmd/compile/internal/ssa/rulegen/rulegen.go b/src/cmd/compile/internal/ssa/rulegen/rulegen.go deleted file mode 100644 index b0916fa4d2..0000000000 --- a/src/cmd/compile/internal/ssa/rulegen/rulegen.go +++ /dev/null @@ -1,458 +0,0 @@ -// 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 - -// Run with something like "go run rulegen.go lower_amd64.rules lowerBlockAmd64 lowerValueAmd64 lowerAmd64.go" - -package main - -import ( - "bufio" - "bytes" - "crypto/md5" - "fmt" - "go/format" - "io" - "io/ioutil" - "log" - "os" - "sort" - "strings" -) - -// rule syntax: -// sexpr [&& extra conditions] -> sexpr -// -// sexpr are s-expressions (lisp-like parenthesized groupings) -// sexpr ::= (opcode sexpr*) -// | variable -// | [aux] -// | -// | {code} -// -// 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. - -func main() { - if len(os.Args) < 4 || len(os.Args) > 5 { - fmt.Printf("usage: go run rulegen.go []") - os.Exit(1) - } - rulefile := os.Args[1] - blockfn := os.Args[2] - valuefn := os.Args[3] - - // Open input file. - text, err := os.Open(rulefile) - 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][]string{} - oprules := map[string][]string{} - - // read rule file - scanner := bufio.NewScanner(text) - for scanner.Scan() { - 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] - } - line = strings.TrimSpace(line) - if line == "" { - continue - } - op := strings.Split(line, " ")[0][1:] - if strings.HasPrefix(op, "Block") { - blockrules[op] = append(blockrules[op], line) - } else { - oprules[op] = append(oprules[op], line) - } - } - if err := scanner.Err(); err != nil { - log.Fatalf("scanner failed: %v\n", err) - } - - // Start output buffer, write header. - w := new(bytes.Buffer) - fmt.Fprintf(w, "// autogenerated from %s: do not edit!\n", rulefile) - fmt.Fprintf(w, "// generated with: go run rulegen/rulegen.go %s\n", strings.Join(os.Args[1:], " ")) - fmt.Fprintln(w, "package ssa") - fmt.Fprintf(w, "func %s(v *Value, config *Config) bool {\n", valuefn) - - // generate code for each rule - fmt.Fprintf(w, "switch v.Op {\n") - var ops []string - for op := range oprules { - ops = append(ops, op) - } - sort.Strings(ops) - for _, op := range ops { - fmt.Fprintf(w, "case Op%s:\n", op) - for _, rule := range oprules[op] { - // Note: we use a hash to identify the rule so that its - // identity is invariant to adding/removing rules elsewhere - // in the rules file. This is useful to squash spurious - // diffs that would occur if we used rule index. - rulehash := fmt.Sprintf("%02x", md5.Sum([]byte(rule))) - - // split at -> - s := strings.Split(rule, "->") - if len(s) != 2 { - log.Fatalf("no arrow in rule %s", rule) - } - lhs := strings.TrimSpace(s[0]) - result := strings.TrimSpace(s[1]) - - // split match into matching part and additional condition - match := lhs - cond := "" - if i := strings.Index(match, "&&"); i >= 0 { - cond = strings.TrimSpace(match[i+2:]) - match = strings.TrimSpace(match[:i]) - } - - fmt.Fprintf(w, "// match: %s\n", match) - fmt.Fprintf(w, "// cond: %s\n", cond) - fmt.Fprintf(w, "// result: %s\n", result) - - fail := fmt.Sprintf("{\ngoto end%s\n}\n", rulehash) - - fmt.Fprintf(w, "{\n") - genMatch(w, match, fail) - - if cond != "" { - fmt.Fprintf(w, "if !(%s) %s", cond, fail) - } - - genResult(w, result) - fmt.Fprintf(w, "return true\n") - - fmt.Fprintf(w, "}\n") - fmt.Fprintf(w, "goto end%s\n", rulehash) // use label - fmt.Fprintf(w, "end%s:;\n", rulehash) - } - } - fmt.Fprintf(w, "}\n") - fmt.Fprintf(w, "return false\n") - fmt.Fprintf(w, "}\n") - - // Generate block rewrite function. - fmt.Fprintf(w, "func %s(b *Block) bool {\n", blockfn) - 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", op) - for _, rule := range blockrules[op] { - rulehash := fmt.Sprintf("%02x", md5.Sum([]byte(rule))) - // split at -> - s := strings.Split(rule, "->") - if len(s) != 2 { - log.Fatalf("no arrow in rule %s", rule) - } - lhs := strings.TrimSpace(s[0]) - result := strings.TrimSpace(s[1]) - - // split match into matching part and additional condition - match := lhs - cond := "" - if i := strings.Index(match, "&&"); i >= 0 { - cond = strings.TrimSpace(match[i+2:]) - match = strings.TrimSpace(match[:i]) - } - - fmt.Fprintf(w, "// match: %s\n", match) - fmt.Fprintf(w, "// cond: %s\n", cond) - fmt.Fprintf(w, "// result: %s\n", result) - - fail := fmt.Sprintf("{\ngoto end%s\n}\n", rulehash) - - fmt.Fprintf(w, "{\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, s[1], "v", fail, 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) %s", cond, fail) - } - - // Rule matches. Generate result. - t := split(result[1 : len(result)-1]) // remove parens, then split - newsuccs := t[2:] - - // Check if newsuccs is a subset of 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) - } - - // Modify predecessor lists for no-longer-reachable blocks - for succ := range m { - fmt.Fprintf(w, "removePredecessor(b, %s)\n", succ) - } - - fmt.Fprintf(w, "b.Kind = %s\n", t[0]) - if t[1] == "nil" { - fmt.Fprintf(w, "b.Control = nil\n") - } else { - fmt.Fprintf(w, "b.Control = %s\n", genResult0(w, t[1], new(int), 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) - } - - fmt.Fprintf(w, "return true\n") - - fmt.Fprintf(w, "}\n") - fmt.Fprintf(w, "goto end%s\n", rulehash) // use label - fmt.Fprintf(w, "end%s:;\n", rulehash) - } - } - fmt.Fprintf(w, "}\n") - fmt.Fprintf(w, "return false\n") - fmt.Fprintf(w, "}\n") - - // gofmt result - b := w.Bytes() - b, err = format.Source(b) - if err != nil { - panic(err) - } - - // Write to a file if given, otherwise stdout. - if len(os.Args) >= 5 { - err = ioutil.WriteFile(os.Args[4], b, 0666) - } else { - _, err = os.Stdout.Write(b) - } - if err != nil { - log.Fatalf("can't write output: %v\n", err) - } -} - -func genMatch(w io.Writer, match, fail string) { - genMatch0(w, match, "v", fail, map[string]string{}, true) -} - -func genMatch0(w io.Writer, match, v, fail string, m map[string]string, top bool) { - if match[0] != '(' { - if x, 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 %s", v, x, fail) - 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 != Op%s %s", v, s[0], fail) - } - - // check type/aux/args - argnum := 0 - for _, a := range s[1:] { - if a[0] == '<' { - // type restriction - t := a[1 : len(a)-1] // remove <> - if t[0] == '{' { - // code. We must match the results of this code. - fmt.Fprintf(w, "if %s.Type != %s %s", v, t[1:len(t)-1], fail) - } else { - // variable - if u, ok := m[t]; ok { - // must match previous variable - fmt.Fprintf(w, "if %s.Type != %s %s", v, u, fail) - } else { - m[t] = v + ".Type" - fmt.Fprintf(w, "%s := %s.Type\n", t, v) - } - } - } else if a[0] == '[' { - // aux restriction - x := a[1 : len(a)-1] // remove [] - if x[0] == '{' { - // code - fmt.Fprintf(w, "if %s.Aux != %s %s", v, x[1:len(x)-1], fail) - } else { - // variable - if y, ok := m[x]; ok { - fmt.Fprintf(w, "if %s.Aux != %s %s", v, y, fail) - } else { - m[x] = v + ".Aux" - fmt.Fprintf(w, "%s := %s.Aux\n", x, v) - } - } - } else if a[0] == '{' { - fmt.Fprintf(w, "if %s.Args[%d] != %s %s", v, argnum, a[1:len(a)-1], fail) - argnum++ - } else { - // variable or sexpr - genMatch0(w, a, fmt.Sprintf("%s.Args[%d]", v, argnum), fail, m, false) - argnum++ - } - } -} - -func genResult(w io.Writer, result string) { - genResult0(w, result, new(int), true) -} -func genResult0(w io.Writer, result string, alloc *int, top bool) string { - if result[0] != '(' { - // variable - if top { - fmt.Fprintf(w, "v.Op = %s.Op\n", result) - fmt.Fprintf(w, "v.Aux = %s.Aux\n", result) - fmt.Fprintf(w, "v.resetArgs()\n") - fmt.Fprintf(w, "v.AddArgs(%s.Args...)\n", result) - } - return result - } - - s := split(result[1 : len(result)-1]) // remove parens, then split - var v string - var hasType bool - if top { - v = "v" - fmt.Fprintf(w, "v.Op = Op%s\n", s[0]) - fmt.Fprintf(w, "v.Aux = nil\n") - fmt.Fprintf(w, "v.resetArgs()\n") - hasType = true - } else { - v = fmt.Sprintf("v%d", *alloc) - *alloc++ - fmt.Fprintf(w, "%s := v.Block.NewValue(Op%s, TypeInvalid, nil)\n", v, s[0]) - } - for _, a := range s[1:] { - if a[0] == '<' { - // type restriction - t := a[1 : len(a)-1] // remove <> - if t[0] == '{' { - t = t[1 : len(t)-1] // remove {} - } - fmt.Fprintf(w, "%s.Type = %s\n", v, t) - hasType = true - } else if a[0] == '[' { - // aux restriction - x := a[1 : len(a)-1] // remove [] - if x[0] == '{' { - x = x[1 : len(x)-1] // remove {} - } - fmt.Fprintf(w, "%s.Aux = %s\n", v, x) - } else if a[0] == '{' { - fmt.Fprintf(w, "%s.AddArg(%s)\n", v, a[1:len(a)-1]) - } else { - // regular argument (sexpr or variable) - x := genResult0(w, a, alloc, false) - fmt.Fprintf(w, "%s.AddArg(%s)\n", v, x) - } - } - if !hasType { - log.Fatalf("sub-expression %s must have a type", result) - } - 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 -} diff --git a/src/cmd/compile/internal/ssa/stackalloc.go b/src/cmd/compile/internal/ssa/stackalloc.go index dd55d96ccc..a4ce343b5d 100644 --- a/src/cmd/compile/internal/ssa/stackalloc.go +++ b/src/cmd/compile/internal/ssa/stackalloc.go @@ -91,12 +91,12 @@ func stackalloc(f *Func) { } // TODO: do this with arch-specific rewrite rules somehow? switch v.Op { - case OpADDQ: + case OpAMD64ADDQ: // (ADDQ (FP) x) -> (LEAQ [n] (SP) x) - v.Op = OpLEAQ + v.Op = OpAMD64LEAQ v.Aux = n - case OpLEAQ, OpMOVQload, OpMOVQstore, OpMOVBload, OpMOVQloadidx8: - if v.Op == OpMOVQloadidx8 && i == 1 { + case OpAMD64LEAQ, OpAMD64MOVQload, OpAMD64MOVQstore, OpAMD64MOVBload, OpAMD64MOVQloadidx8: + if v.Op == OpAMD64MOVQloadidx8 && i == 1 { // Note: we could do it, but it is probably an error log.Panicf("can't do FP->SP adjust on index slot of load %s", v.Op) } @@ -104,6 +104,7 @@ func stackalloc(f *Func) { v.Aux = addOffset(v.Aux.(int64), n) default: log.Panicf("can't do FP->SP adjust on %s", v.Op) + // TODO: OpCopy -> ADDQ } } } diff --git a/src/cmd/compile/internal/ssa/value.go b/src/cmd/compile/internal/ssa/value.go index dab6239dee..08e368ab04 100644 --- a/src/cmd/compile/internal/ssa/value.go +++ b/src/cmd/compile/internal/ssa/value.go @@ -4,10 +4,7 @@ package ssa -import ( - "fmt" - "strings" -) +import "fmt" // 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 @@ -51,7 +48,7 @@ func (v *Value) String() string { // long form print. v# = opcode [aux] args [: reg] func (v *Value) LongString() string { - s := fmt.Sprintf("v%d = %s", v.ID, strings.TrimPrefix(v.Op.String(), "Op")) + s := fmt.Sprintf("v%d = %s", v.ID, v.Op.String()) s += " <" + v.Type.String() + ">" if v.Aux != nil { s += fmt.Sprintf(" [%v]", v.Aux) -- cgit v1.3 From 43a2676ff091d403b62ea59c72f4686fbfd546fc Mon Sep 17 00:00:00 2001 From: Michael Matloob Date: Mon, 8 Jun 2015 22:46:36 -0400 Subject: [dev.ssa] cmd/compile/internal/ssa: delete lowergeneric.go It's been replaced by rewritegeneric.go Change-Id: I2658abbc6201ecfedae4513c6da04ea3cac8bb9c Reviewed-on: https://go-review.googlesource.com/10846 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/lowergeneric.go | 289 --------------------------- 1 file changed, 289 deletions(-) delete mode 100644 src/cmd/compile/internal/ssa/lowergeneric.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/lowergeneric.go b/src/cmd/compile/internal/ssa/lowergeneric.go deleted file mode 100644 index 1ac276ad66..0000000000 --- a/src/cmd/compile/internal/ssa/lowergeneric.go +++ /dev/null @@ -1,289 +0,0 @@ -// autogenerated from generic.rules: do not edit! -// generated with: go run rulegen/rulegen.go -package ssa - -func lowerValuegeneric(v *Value) bool { - switch v.Op { - case OpAdd: - // match: (Add (Const [c]) (Const [d])) - // cond: is64BitInt(t) - // result: (Const [{c.(int64)+d.(int64)}]) - { - t := v.Type - if v.Args[0].Op != OpConst { - goto end8d047ed0ae9537b840adc79ea82c6e05 - } - c := v.Args[0].Aux - if v.Args[1].Op != OpConst { - goto end8d047ed0ae9537b840adc79ea82c6e05 - } - d := v.Args[1].Aux - if !(is64BitInt(t)) { - goto end8d047ed0ae9537b840adc79ea82c6e05 - } - v.Op = OpConst - v.Aux = nil - v.resetArgs() - v.Aux = c.(int64) + d.(int64) - return true - } - goto end8d047ed0ae9537b840adc79ea82c6e05 - end8d047ed0ae9537b840adc79ea82c6e05: - ; - case OpArrayIndex: - // match: (ArrayIndex (Load ptr mem) idx) - // cond: - // result: (Load (PtrIndex ptr idx) mem) - { - if v.Args[0].Op != OpLoad { - goto end3809f4c52270a76313e4ea26e6f0b753 - } - ptr := v.Args[0].Args[0] - mem := v.Args[0].Args[1] - idx := v.Args[1] - v.Op = OpLoad - v.Aux = nil - v.resetArgs() - v0 := v.Block.NewValue(OpPtrIndex, TypeInvalid, nil) - v0.Type = ptr.Type.Elem().Elem().PtrTo() - v0.AddArg(ptr) - v0.AddArg(idx) - v.AddArg(v0) - v.AddArg(mem) - return true - } - goto end3809f4c52270a76313e4ea26e6f0b753 - end3809f4c52270a76313e4ea26e6f0b753: - ; - case OpIsInBounds: - // match: (IsInBounds (Const [c]) (Const [d])) - // cond: - // result: (Const [inBounds(c.(int64),d.(int64))]) - { - if v.Args[0].Op != OpConst { - goto enddbd1a394d9b71ee64335361b8384865c - } - c := v.Args[0].Aux - if v.Args[1].Op != OpConst { - goto enddbd1a394d9b71ee64335361b8384865c - } - d := v.Args[1].Aux - v.Op = OpConst - v.Aux = nil - v.resetArgs() - v.Aux = inBounds(c.(int64), d.(int64)) - return true - } - goto enddbd1a394d9b71ee64335361b8384865c - enddbd1a394d9b71ee64335361b8384865c: - ; - case OpMul: - // match: (Mul (Const [c]) (Const [d])) - // cond: is64BitInt(t) - // result: (Const [{c.(int64)*d.(int64)}]) - { - t := v.Type - if v.Args[0].Op != OpConst { - goto end776610f88cf04f438242d76ed2b14f1c - } - c := v.Args[0].Aux - if v.Args[1].Op != OpConst { - goto end776610f88cf04f438242d76ed2b14f1c - } - d := v.Args[1].Aux - if !(is64BitInt(t)) { - goto end776610f88cf04f438242d76ed2b14f1c - } - v.Op = OpConst - v.Aux = nil - v.resetArgs() - v.Aux = c.(int64) * d.(int64) - return true - } - goto end776610f88cf04f438242d76ed2b14f1c - end776610f88cf04f438242d76ed2b14f1c: - ; - case OpPtrIndex: - // match: (PtrIndex ptr idx) - // cond: - // result: (Add ptr (Mul idx (Const [t.Elem().Size()]))) - { - t := v.Type - ptr := v.Args[0] - idx := v.Args[1] - v.Op = OpAdd - v.Aux = nil - v.resetArgs() - v.AddArg(ptr) - v0 := v.Block.NewValue(OpMul, TypeInvalid, nil) - v0.Type = v.Block.Func.Config.Uintptr - v0.AddArg(idx) - v1 := v.Block.NewValue(OpConst, TypeInvalid, nil) - v1.Type = v.Block.Func.Config.Uintptr - v1.Aux = t.Elem().Size() - v0.AddArg(v1) - v.AddArg(v0) - return true - } - goto end383c68c41e72d22ef00c4b7b0fddcbb8 - end383c68c41e72d22ef00c4b7b0fddcbb8: - ; - case OpSliceCap: - // match: (SliceCap (Load ptr mem)) - // cond: - // result: (Load (Add ptr (Const [int64(v.Block.Func.Config.ptrSize*2)])) mem) - { - if v.Args[0].Op != OpLoad { - goto endbf1d4db93c4664ed43be3f73afb4dfa3 - } - ptr := v.Args[0].Args[0] - mem := v.Args[0].Args[1] - v.Op = OpLoad - v.Aux = nil - v.resetArgs() - v0 := v.Block.NewValue(OpAdd, TypeInvalid, nil) - v0.Type = ptr.Type - v0.AddArg(ptr) - v1 := v.Block.NewValue(OpConst, TypeInvalid, nil) - v1.Type = v.Block.Func.Config.Uintptr - v1.Aux = int64(v.Block.Func.Config.ptrSize * 2) - v0.AddArg(v1) - v.AddArg(v0) - v.AddArg(mem) - return true - } - goto endbf1d4db93c4664ed43be3f73afb4dfa3 - endbf1d4db93c4664ed43be3f73afb4dfa3: - ; - case OpSliceLen: - // match: (SliceLen (Load ptr mem)) - // cond: - // result: (Load (Add ptr (Const [int64(v.Block.Func.Config.ptrSize)])) mem) - { - if v.Args[0].Op != OpLoad { - goto end9190b1ecbda4c5dd6d3e05d2495fb297 - } - ptr := v.Args[0].Args[0] - mem := v.Args[0].Args[1] - v.Op = OpLoad - v.Aux = nil - v.resetArgs() - v0 := v.Block.NewValue(OpAdd, TypeInvalid, nil) - v0.Type = ptr.Type - v0.AddArg(ptr) - v1 := v.Block.NewValue(OpConst, TypeInvalid, nil) - v1.Type = v.Block.Func.Config.Uintptr - v1.Aux = int64(v.Block.Func.Config.ptrSize) - v0.AddArg(v1) - v.AddArg(v0) - v.AddArg(mem) - return true - } - goto end9190b1ecbda4c5dd6d3e05d2495fb297 - end9190b1ecbda4c5dd6d3e05d2495fb297: - ; - case OpSlicePtr: - // match: (SlicePtr (Load ptr mem)) - // cond: - // result: (Load ptr mem) - { - if v.Args[0].Op != OpLoad { - goto end459613b83f95b65729d45c2ed663a153 - } - ptr := v.Args[0].Args[0] - mem := v.Args[0].Args[1] - v.Op = OpLoad - v.Aux = nil - v.resetArgs() - v.AddArg(ptr) - v.AddArg(mem) - return true - } - goto end459613b83f95b65729d45c2ed663a153 - end459613b83f95b65729d45c2ed663a153: - ; - case OpStore: - // match: (Store dst (Load src mem) mem) - // cond: t.Size() > 8 - // result: (Move [t.Size()] dst src mem) - { - dst := v.Args[0] - if v.Args[1].Op != OpLoad { - goto end324ffb6d2771808da4267f62c854e9c8 - } - t := v.Args[1].Type - src := v.Args[1].Args[0] - mem := v.Args[1].Args[1] - if v.Args[2] != v.Args[1].Args[1] { - goto end324ffb6d2771808da4267f62c854e9c8 - } - if !(t.Size() > 8) { - goto end324ffb6d2771808da4267f62c854e9c8 - } - v.Op = OpMove - v.Aux = nil - v.resetArgs() - v.Aux = t.Size() - v.AddArg(dst) - v.AddArg(src) - v.AddArg(mem) - return true - } - goto end324ffb6d2771808da4267f62c854e9c8 - end324ffb6d2771808da4267f62c854e9c8: - } - return false -} -func lowerBlockgeneric(b *Block) bool { - switch b.Kind { - case BlockIf: - // match: (BlockIf (Const [c]) yes no) - // cond: c.(bool) - // result: (BlockPlain nil yes) - { - v := b.Control - if v.Op != OpConst { - goto endbe39807508a6192b4022c7293eb6e114 - } - c := v.Aux - yes := b.Succs[0] - no := b.Succs[1] - if !(c.(bool)) { - goto endbe39807508a6192b4022c7293eb6e114 - } - removePredecessor(b, no) - b.Kind = BlockPlain - b.Control = nil - b.Succs = b.Succs[:1] - b.Succs[0] = yes - return true - } - goto endbe39807508a6192b4022c7293eb6e114 - endbe39807508a6192b4022c7293eb6e114: - ; - // match: (BlockIf (Const [c]) yes no) - // cond: !c.(bool) - // result: (BlockPlain nil no) - { - v := b.Control - if v.Op != OpConst { - goto end69ac35957ebe0a77a5ef5103c1f79fbf - } - c := v.Aux - yes := b.Succs[0] - no := b.Succs[1] - if !(!c.(bool)) { - goto end69ac35957ebe0a77a5ef5103c1f79fbf - } - removePredecessor(b, yes) - b.Kind = BlockPlain - b.Control = nil - b.Succs = b.Succs[:1] - b.Succs[0] = no - return true - } - goto end69ac35957ebe0a77a5ef5103c1f79fbf - end69ac35957ebe0a77a5ef5103c1f79fbf: - } - return false -} -- cgit v1.3 From 81ccf508aa4080d997bbb86a7cf3da710abbd969 Mon Sep 17 00:00:00 2001 From: Michael Matloob Date: Sat, 30 May 2015 01:03:06 -0400 Subject: [dev.ssa] cmd/compile/internal/ssa: add line numbers to Values Change-Id: I1dfffd75cc1f49307c654f910f7133c03da6c84f Reviewed-on: https://go-review.googlesource.com/10559 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 153 ++++++++++++++++++------- src/cmd/compile/internal/ssa/TODO | 2 - src/cmd/compile/internal/ssa/block.go | 3 + src/cmd/compile/internal/ssa/func.go | 12 +- src/cmd/compile/internal/ssa/func_test.go | 2 +- src/cmd/compile/internal/ssa/gen/rulegen.go | 2 +- src/cmd/compile/internal/ssa/generic.go | 34 +++--- src/cmd/compile/internal/ssa/regalloc.go | 14 +-- src/cmd/compile/internal/ssa/rewriteAMD64.go | 14 +-- src/cmd/compile/internal/ssa/rewritegeneric.go | 34 +++--- src/cmd/compile/internal/ssa/value.go | 3 + 11 files changed, 174 insertions(+), 99 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index d017a981d4..773d79ba30 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -18,6 +18,9 @@ func buildssa(fn *Node) *ssa.Func { var s state + s.pushLine(fn.Lineno) + defer s.popLine() + // TODO(khr): build config just once at the start of the compiler binary s.config = ssa.NewConfig(Thearch.Thestring, ssaExport{}) s.f = s.config.NewFunc() @@ -35,9 +38,9 @@ func buildssa(fn *Node) *ssa.Func { s.exit = s.f.NewBlock(ssa.BlockExit) // Allocate starting values - s.startmem = s.f.Entry.NewValue(ssa.OpArg, ssa.TypeMem, ".mem") - s.fp = s.f.Entry.NewValue(ssa.OpFP, s.config.Uintptr, nil) // TODO: use generic pointer type (unsafe.Pointer?) instead - s.sp = s.f.Entry.NewValue(ssa.OpSP, s.config.Uintptr, nil) + s.startmem = s.entryNewValue(ssa.OpArg, ssa.TypeMem, ".mem") + s.fp = s.entryNewValue(ssa.OpFP, s.config.Uintptr, nil) // TODO: use generic pointer type (unsafe.Pointer?) instead + s.sp = s.entryNewValue(ssa.OpSP, s.config.Uintptr, nil) s.vars = map[string]*ssa.Value{} s.labels = map[string]*ssa.Block{} @@ -97,6 +100,9 @@ type state struct { startmem *ssa.Value fp *ssa.Value sp *ssa.Value + + // line number stack. The current line number is top of stack + line []int32 } // startBlock sets the current block we're generating code in to b. @@ -122,9 +128,65 @@ func (s *state) endBlock() *ssa.Block { 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] +} + +// newValue adds a new value with no argueents to the current block. +func (s *state) newValue(op ssa.Op, t ssa.Type, aux interface{}) *ssa.Value { + return s.curBlock.NewValue(s.peekLine(), op, t, aux) +} + +// newValue1 adds a new value with one argument to the current block. +func (s *state) newValue1(op ssa.Op, t ssa.Type, aux interface{}, arg *ssa.Value) *ssa.Value { + return s.curBlock.NewValue1(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, aux interface{}, arg0, arg1 *ssa.Value) *ssa.Value { + return s.curBlock.NewValue2(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, aux interface{}, arg0, arg1, arg2 *ssa.Value) *ssa.Value { + return s.curBlock.NewValue3(s.peekLine(), op, t, aux, arg0, arg1, arg2) +} + +// entryNewValue adds a new value with no arguments to the entry block. +func (s *state) entryNewValue(op ssa.Op, t ssa.Type, aux interface{}) *ssa.Value { + return s.f.Entry.NewValue(s.peekLine(), op, t, aux) +} + +// entryNewValue1 adds a new value with one argument to the entry block. +func (s *state) entryNewValue1(op ssa.Op, t ssa.Type, aux interface{}, arg *ssa.Value) *ssa.Value { + return s.f.Entry.NewValue1(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, aux interface{}, arg0, arg1 *ssa.Value) *ssa.Value { + return s.f.Entry.NewValue2(s.peekLine(), op, t, aux, arg0, arg1) +} + +// constInt adds a new const int value to the entry block. +func (s *state) constInt(t ssa.Type, c int64) *ssa.Value { + return s.f.ConstInt(s.peekLine(), t, c) +} + // ssaStmtList converts the statement n to SSA and adds it to s. func (s *state) stmtList(l *NodeList) { for ; l != nil; l = l.Next { @@ -134,6 +196,9 @@ func (s *state) stmtList(l *NodeList) { // 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() + s.stmtList(n.Ninit) switch n.Op { @@ -167,11 +232,11 @@ func (s *state) stmt(n *Node) { t := n.Left.Type switch { case t.IsString(): - val = s.f.Entry.NewValue(ssa.OpConst, n.Left.Type, "") + val = s.entryNewValue(ssa.OpConst, n.Left.Type, "") case t.IsInteger(): - val = s.f.Entry.NewValue(ssa.OpConst, n.Left.Type, int64(0)) + val = s.entryNewValue(ssa.OpConst, n.Left.Type, int64(0)) case t.IsBoolean(): - val = s.f.Entry.NewValue(ssa.OpConst, n.Left.Type, false) + val = s.entryNewValue(ssa.OpConst, n.Left.Type, false) default: log.Fatalf("zero for type %v not implemented", t) } @@ -185,7 +250,7 @@ func (s *state) stmt(n *Node) { } // not ssa-able. Treat as a store. addr := s.addr(n.Left) - s.vars[".mem"] = s.curBlock.NewValue3(ssa.OpStore, ssa.TypeMem, nil, addr, val, s.mem()) + s.vars[".mem"] = s.newValue3(ssa.OpStore, ssa.TypeMem, nil, addr, val, s.mem()) // TODO: try to make more variables registerizeable. case OIF: cond := s.expr(n.Ntest) @@ -268,22 +333,25 @@ func (s *state) stmt(n *Node) { // 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() + switch n.Op { case ONAME: // TODO: remember offsets for PPARAM names if n.Class == PEXTERN { // global variable - addr := s.f.Entry.NewValue(ssa.OpGlobal, Ptrto(n.Type), n.Sym) - return s.curBlock.NewValue2(ssa.OpLoad, n.Type, nil, addr, s.mem()) + addr := s.entryNewValue(ssa.OpGlobal, Ptrto(n.Type), n.Sym) + return s.newValue2(ssa.OpLoad, n.Type, nil, addr, s.mem()) } s.argOffsets[n.Sym.Name] = n.Xoffset return s.variable(n.Sym.Name, n.Type) case OLITERAL: switch n.Val.Ctype { case CTINT: - return s.f.ConstInt(n.Type, Mpgetfix(n.Val.U.(*Mpint))) + return s.constInt(n.Type, Mpgetfix(n.Val.U.(*Mpint))) case CTSTR: - return s.f.Entry.NewValue(ssa.OpConst, n.Type, n.Val.U) + return s.entryNewValue(ssa.OpConst, n.Type, n.Val.U) default: log.Fatalf("unhandled OLITERAL %v", n.Val.Ctype) return nil @@ -293,24 +361,24 @@ func (s *state) expr(n *Node) *ssa.Value { case OLT: a := s.expr(n.Left) b := s.expr(n.Right) - return s.curBlock.NewValue2(ssa.OpLess, ssa.TypeBool, nil, a, b) + return s.newValue2(ssa.OpLess, ssa.TypeBool, nil, a, b) case OADD: a := s.expr(n.Left) b := s.expr(n.Right) - return s.curBlock.NewValue2(ssa.OpAdd, a.Type, nil, a, b) + return s.newValue2(ssa.OpAdd, a.Type, nil, a, b) case OSUB: // TODO:(khr) fold code for all binary ops together somehow a := s.expr(n.Left) b := s.expr(n.Right) - return s.curBlock.NewValue2(ssa.OpSub, a.Type, nil, a, b) + return s.newValue2(ssa.OpSub, a.Type, nil, a, b) case OLSH: a := s.expr(n.Left) b := s.expr(n.Right) - return s.curBlock.NewValue2(ssa.OpLsh, a.Type, nil, a, b) + return s.newValue2(ssa.OpLsh, a.Type, nil, a, b) case ORSH: a := s.expr(n.Left) b := s.expr(n.Right) - return s.curBlock.NewValue2(ssa.OpRsh, a.Type, nil, a, b) + return s.newValue2(ssa.OpRsh, a.Type, nil, a, b) case OADDR: return s.addr(n.Left) @@ -318,13 +386,13 @@ func (s *state) expr(n *Node) *ssa.Value { case OIND: p := s.expr(n.Left) s.nilCheck(p) - return s.curBlock.NewValue2(ssa.OpLoad, n.Type, nil, p, s.mem()) + return s.newValue2(ssa.OpLoad, n.Type, nil, p, s.mem()) case ODOTPTR: p := s.expr(n.Left) s.nilCheck(p) - p = s.curBlock.NewValue2(ssa.OpAdd, p.Type, nil, p, s.f.ConstInt(s.config.Uintptr, n.Xoffset)) - return s.curBlock.NewValue2(ssa.OpLoad, n.Type, nil, p, s.mem()) + p = s.newValue2(ssa.OpAdd, p.Type, nil, p, s.constInt(s.config.Uintptr, n.Xoffset)) + return s.newValue2(ssa.OpLoad, n.Type, nil, p, s.mem()) case OINDEX: if n.Left.Type.Bound >= 0 { // array or string @@ -333,17 +401,17 @@ func (s *state) expr(n *Node) *ssa.Value { var elemtype *Type var len *ssa.Value if n.Left.Type.IsString() { - len = s.curBlock.NewValue1(ssa.OpStringLen, s.config.Uintptr, nil, a) + len = s.newValue1(ssa.OpStringLen, s.config.Uintptr, nil, a) elemtype = Types[TUINT8] } else { - len = s.f.ConstInt(s.config.Uintptr, n.Left.Type.Bound) + len = s.constInt(s.config.Uintptr, n.Left.Type.Bound) elemtype = n.Left.Type.Type } s.boundsCheck(i, len) - return s.curBlock.NewValue2(ssa.OpArrayIndex, elemtype, nil, a, i) + return s.newValue2(ssa.OpArrayIndex, elemtype, nil, a, i) } else { // slice p := s.addr(n) - return s.curBlock.NewValue2(ssa.OpLoad, n.Left.Type.Type, nil, p, s.mem()) + return s.newValue2(ssa.OpLoad, n.Left.Type.Type, nil, p, s.mem()) } case OCALLFUNC: @@ -357,7 +425,7 @@ func (s *state) expr(n *Node) *ssa.Value { log.Fatalf("can't handle CALLFUNC with non-ONAME fn %s", opnames[n.Left.Op]) } bNext := s.f.NewBlock(ssa.BlockPlain) - call := s.curBlock.NewValue1(ssa.OpStaticCall, ssa.TypeMem, n.Left.Sym, s.mem()) + call := s.newValue1(ssa.OpStaticCall, ssa.TypeMem, n.Left.Sym, s.mem()) b := s.endBlock() b.Kind = ssa.BlockCall b.Control = call @@ -368,8 +436,8 @@ func (s *state) expr(n *Node) *ssa.Value { s.startBlock(bNext) var titer Iter fp := Structfirst(&titer, Getoutarg(n.Left.Type)) - a := s.f.Entry.NewValue1(ssa.OpOffPtr, Ptrto(fp.Type), fp.Width, s.sp) - return s.curBlock.NewValue2(ssa.OpLoad, fp.Type, nil, a, call) + a := s.entryNewValue1(ssa.OpOffPtr, Ptrto(fp.Type), fp.Width, s.sp) + return s.newValue2(ssa.OpLoad, fp.Type, nil, a, call) default: log.Fatalf("unhandled expr %s", opnames[n.Op]) return nil @@ -382,11 +450,11 @@ func (s *state) addr(n *Node) *ssa.Value { case ONAME: if n.Class == PEXTERN { // global variable - return s.f.Entry.NewValue(ssa.OpGlobal, Ptrto(n.Type), n.Sym) + return s.entryNewValue(ssa.OpGlobal, Ptrto(n.Type), n.Sym) } if n.Class == PPARAMOUT { // store to parameter slot - return s.f.Entry.NewValue1(ssa.OpOffPtr, Ptrto(n.Type), n.Xoffset, s.fp) + return s.entryNewValue1(ssa.OpOffPtr, Ptrto(n.Type), n.Xoffset, s.fp) } // TODO: address of locals log.Fatalf("variable address of %v not implemented", n) @@ -394,21 +462,21 @@ func (s *state) addr(n *Node) *ssa.Value { case OINDREG: // indirect off a register (TODO: always SP?) // used for storing/loading arguments/returns to/from callees - return s.f.Entry.NewValue1(ssa.OpOffPtr, Ptrto(n.Type), n.Xoffset, s.sp) + return s.entryNewValue1(ssa.OpOffPtr, Ptrto(n.Type), n.Xoffset, s.sp) case OINDEX: if n.Left.Type.Bound >= 0 { // array a := s.addr(n.Left) i := s.expr(n.Right) - len := s.f.ConstInt(s.config.Uintptr, n.Left.Type.Bound) + len := s.constInt(s.config.Uintptr, n.Left.Type.Bound) s.boundsCheck(i, len) - return s.curBlock.NewValue2(ssa.OpPtrIndex, Ptrto(n.Left.Type.Type), nil, a, i) + return s.newValue2(ssa.OpPtrIndex, Ptrto(n.Left.Type.Type), nil, a, i) } else { // slice a := s.expr(n.Left) i := s.expr(n.Right) - len := s.curBlock.NewValue1(ssa.OpSliceLen, s.config.Uintptr, nil, a) + len := s.newValue1(ssa.OpSliceLen, s.config.Uintptr, nil, a) s.boundsCheck(i, len) - p := s.curBlock.NewValue1(ssa.OpSlicePtr, Ptrto(n.Left.Type.Type), nil, a) - return s.curBlock.NewValue2(ssa.OpPtrIndex, Ptrto(n.Left.Type.Type), nil, p, i) + p := s.newValue1(ssa.OpSlicePtr, Ptrto(n.Left.Type.Type), nil, a) + return s.newValue2(ssa.OpPtrIndex, Ptrto(n.Left.Type.Type), nil, p, i) } default: log.Fatalf("addr: bad op %v", Oconv(int(n.Op), 0)) @@ -419,7 +487,7 @@ func (s *state) addr(n *Node) *ssa.Value { // nilCheck generates nil pointer checking code. // Starts a new block on return. func (s *state) nilCheck(ptr *ssa.Value) { - c := s.curBlock.NewValue1(ssa.OpIsNonNil, ssa.TypeBool, nil, ptr) + c := s.newValue1(ssa.OpIsNonNil, ssa.TypeBool, nil, ptr) b := s.endBlock() b.Kind = ssa.BlockIf b.Control = c @@ -438,7 +506,7 @@ func (s *state) boundsCheck(idx, len *ssa.Value) { // TODO: if index is 64-bit and we're compiling to 32-bit, check that high 32 bits are zero. // bounds check - cmp := s.curBlock.NewValue2(ssa.OpIsInBounds, ssa.TypeBool, nil, idx, len) + cmp := s.newValue2(ssa.OpIsInBounds, ssa.TypeBool, nil, idx, len) b := s.endBlock() b.Kind = ssa.BlockIf b.Control = cmp @@ -457,7 +525,7 @@ func (s *state) variable(name string, t ssa.Type) *ssa.Value { v := s.vars[name] if v == nil { // TODO: get type? Take Sym as arg? - v = s.curBlock.NewValue(ssa.OpFwdRef, t, name) + v = s.newValue(ssa.OpFwdRef, t, name) s.vars[name] = v } return v @@ -496,8 +564,9 @@ func (s *state) lookupVarIncoming(b *ssa.Block, t ssa.Type, name string) *ssa.Va return s.startmem } // variable is live at the entry block. Load it. - addr := s.f.Entry.NewValue1(ssa.OpOffPtr, Ptrto(t.(*Type)), s.argOffsets[name], s.fp) - return b.NewValue2(ssa.OpLoad, t, nil, addr, s.startmem) + addr := s.entryNewValue1(ssa.OpOffPtr, Ptrto(t.(*Type)), s.argOffsets[name], s.fp) + return s.entryNewValue2(ssa.OpLoad, t, nil, addr, s.startmem) + } var vals []*ssa.Value for _, p := range b.Preds { @@ -507,7 +576,7 @@ func (s *state) lookupVarIncoming(b *ssa.Block, t ssa.Type, name string) *ssa.Va for i := 1; i < len(vals); i++ { if vals[i] != v0 { // need a phi value - v := b.NewValue(ssa.OpPhi, t, nil) + v := b.NewValue(s.peekLine(), ssa.OpPhi, t, nil) v.AddArgs(vals...) return v } @@ -528,7 +597,7 @@ func (s *state) lookupVarOutgoing(b *ssa.Block, t ssa.Type, name string) *ssa.Va // Make v = copy(w). We need the extra copy to // prevent infinite recursion when looking up the // incoming value of the variable. - v := b.NewValue(ssa.OpCopy, t, nil) + v := b.NewValue(s.peekLine(), ssa.OpCopy, t, nil) m[name] = v v.AddArg(s.lookupVarIncoming(b, t, name)) return v @@ -606,6 +675,7 @@ func genssa(f *ssa.Func, ptxt *obj.Prog, gcargs, gclocals *Sym) { } func genValue(v *ssa.Value) { + lineno = v.Line switch v.Op { case ssa.OpAMD64ADDQ: // TODO: use addq instead of leaq if target is in the right register. @@ -797,6 +867,7 @@ func genValue(v *ssa.Value) { } func genBlock(b, next *ssa.Block, branches []branch) []branch { + lineno = b.Line switch b.Kind { case ssa.BlockPlain: if b.Succs[0] != next { diff --git a/src/cmd/compile/internal/ssa/TODO b/src/cmd/compile/internal/ssa/TODO index 2ffba17612..7cd2206db3 100644 --- a/src/cmd/compile/internal/ssa/TODO +++ b/src/cmd/compile/internal/ssa/TODO @@ -12,8 +12,6 @@ Scheduling variables first. Values - - Add a line number field. Figure out how to populate it and - maintain it during rewrites. - Store *Type instead of Type? Keep an array of used Types in Func and reference by id? Unify with the type ../gc so we just use a pointer instead of an interface? diff --git a/src/cmd/compile/internal/ssa/block.go b/src/cmd/compile/internal/ssa/block.go index 85d73bb9b8..db16fb4a53 100644 --- a/src/cmd/compile/internal/ssa/block.go +++ b/src/cmd/compile/internal/ssa/block.go @@ -37,6 +37,9 @@ type Block struct { // The containing function Func *Func + + // Line number for block's control operation + Line int32 } // kind control successors diff --git a/src/cmd/compile/internal/ssa/func.go b/src/cmd/compile/internal/ssa/func.go index 3e41ef3bc1..06a2455e87 100644 --- a/src/cmd/compile/internal/ssa/func.go +++ b/src/cmd/compile/internal/ssa/func.go @@ -43,7 +43,7 @@ func (f *Func) NewBlock(kind BlockKind) *Block { } // NewValue returns a new value in the block with no arguments. -func (b *Block) NewValue(op Op, t Type, aux interface{}) *Value { +func (b *Block) NewValue(line int32, op Op, t Type, aux interface{}) *Value { v := &Value{ ID: b.Func.vid.get(), Op: op, @@ -57,7 +57,7 @@ func (b *Block) NewValue(op Op, t Type, aux interface{}) *Value { } // NewValue1 returns a new value in the block with one argument. -func (b *Block) NewValue1(op Op, t Type, aux interface{}, arg *Value) *Value { +func (b *Block) NewValue1(line int32, op Op, t Type, aux interface{}, arg *Value) *Value { v := &Value{ ID: b.Func.vid.get(), Op: op, @@ -72,7 +72,7 @@ func (b *Block) NewValue1(op Op, t Type, aux interface{}, arg *Value) *Value { } // NewValue2 returns a new value in the block with two arguments. -func (b *Block) NewValue2(op Op, t Type, aux interface{}, arg0, arg1 *Value) *Value { +func (b *Block) NewValue2(line int32, op Op, t Type, aux interface{}, arg0, arg1 *Value) *Value { v := &Value{ ID: b.Func.vid.get(), Op: op, @@ -88,7 +88,7 @@ func (b *Block) NewValue2(op Op, t Type, aux interface{}, arg0, arg1 *Value) *Va } // NewValue3 returns a new value in the block with three arguments. -func (b *Block) NewValue3(op Op, t Type, aux interface{}, arg0, arg1, arg2 *Value) *Value { +func (b *Block) NewValue3(line int32, op Op, t Type, aux interface{}, arg0, arg1, arg2 *Value) *Value { v := &Value{ ID: b.Func.vid.get(), Op: op, @@ -102,7 +102,7 @@ func (b *Block) NewValue3(op Op, t Type, aux interface{}, arg0, arg1, arg2 *Valu } // ConstInt returns an int constant representing its argument. -func (f *Func) ConstInt(t Type, c int64) *Value { +func (f *Func) ConstInt(line int32, t Type, c int64) *Value { // TODO: cache? - return f.Entry.NewValue(OpConst, t, c) + return f.Entry.NewValue(line, OpConst, t, c) } diff --git a/src/cmd/compile/internal/ssa/func_test.go b/src/cmd/compile/internal/ssa/func_test.go index 947a0b72c4..3f94589e8b 100644 --- a/src/cmd/compile/internal/ssa/func_test.go +++ b/src/cmd/compile/internal/ssa/func_test.go @@ -149,7 +149,7 @@ func Fun(c *Config, entry string, blocs ...bloc) fun { blocks[bloc.name] = b for _, valu := range bloc.valus { // args are filled in the second pass. - values[valu.name] = b.NewValue(valu.op, valu.t, valu.aux) + values[valu.name] = b.NewValue(0, valu.op, valu.t, valu.aux) } } // Connect the blocks together and specify control values. diff --git a/src/cmd/compile/internal/ssa/gen/rulegen.go b/src/cmd/compile/internal/ssa/gen/rulegen.go index 5edf178a8a..441e08ab5d 100644 --- a/src/cmd/compile/internal/ssa/gen/rulegen.go +++ b/src/cmd/compile/internal/ssa/gen/rulegen.go @@ -364,7 +364,7 @@ func genResult0(w io.Writer, arch arch, result string, alloc *int, top bool) str } else { v = fmt.Sprintf("v%d", *alloc) *alloc++ - fmt.Fprintf(w, "%s := v.Block.NewValue(%s, TypeInvalid, nil)\n", v, opName(s[0], arch)) + fmt.Fprintf(w, "%s := v.Block.NewValue(v.Line, %s, TypeInvalid, nil)\n", v, opName(s[0], arch)) } for _, a := range s[1:] { if a[0] == '<' { diff --git a/src/cmd/compile/internal/ssa/generic.go b/src/cmd/compile/internal/ssa/generic.go index b6f1e8614d..ebbb1327d4 100644 --- a/src/cmd/compile/internal/ssa/generic.go +++ b/src/cmd/compile/internal/ssa/generic.go @@ -44,7 +44,7 @@ func genericValueRules(v *Value, config *Config) bool { v.Op = OpLoad v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue(OpPtrIndex, TypeInvalid, nil) + v0 := v.Block.NewValue(v.Line, OpPtrIndex, TypeInvalid, nil) v0.Type = ptr.Type.Elem().Elem().PtrTo() v0.AddArg(ptr) v0.AddArg(idx) @@ -68,15 +68,15 @@ func genericValueRules(v *Value, config *Config) bool { v.Op = OpStringMake v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue(OpOffPtr, TypeInvalid, nil) + v0 := v.Block.NewValue(v.Line, OpOffPtr, TypeInvalid, nil) v0.Type = TypeBytePtr v0.Aux = 2 * config.ptrSize - v1 := v.Block.NewValue(OpGlobal, TypeInvalid, nil) + v1 := v.Block.NewValue(v.Line, OpGlobal, TypeInvalid, nil) v1.Type = TypeBytePtr v1.Aux = config.fe.StringSym(s.(string)) v0.AddArg(v1) v.AddArg(v0) - v2 := v.Block.NewValue(OpConst, TypeInvalid, nil) + v2 := v.Block.NewValue(v.Line, OpConst, TypeInvalid, nil) v2.Type = config.Uintptr v2.Aux = int64(len(s.(string))) v.AddArg(v2) @@ -121,14 +121,14 @@ func genericValueRules(v *Value, config *Config) bool { v.Op = OpStringMake v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue(OpLoad, TypeInvalid, nil) + v0 := v.Block.NewValue(v.Line, OpLoad, TypeInvalid, nil) v0.Type = TypeBytePtr v0.AddArg(ptr) v0.AddArg(mem) v.AddArg(v0) - v1 := v.Block.NewValue(OpLoad, TypeInvalid, nil) + v1 := v.Block.NewValue(v.Line, OpLoad, TypeInvalid, nil) v1.Type = config.Uintptr - v2 := v.Block.NewValue(OpOffPtr, TypeInvalid, nil) + v2 := v.Block.NewValue(v.Line, OpOffPtr, TypeInvalid, nil) v2.Type = TypeBytePtr v2.Aux = config.ptrSize v2.AddArg(ptr) @@ -178,10 +178,10 @@ func genericValueRules(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(ptr) - v0 := v.Block.NewValue(OpMul, TypeInvalid, nil) + v0 := v.Block.NewValue(v.Line, OpMul, TypeInvalid, nil) v0.Type = config.Uintptr v0.AddArg(idx) - v1 := v.Block.NewValue(OpConst, TypeInvalid, nil) + v1 := v.Block.NewValue(v.Line, OpConst, TypeInvalid, nil) v1.Type = config.Uintptr v1.Aux = t.Elem().Size() v0.AddArg(v1) @@ -204,10 +204,10 @@ func genericValueRules(v *Value, config *Config) bool { v.Op = OpLoad v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue(OpAdd, TypeInvalid, nil) + v0 := v.Block.NewValue(v.Line, OpAdd, TypeInvalid, nil) v0.Type = ptr.Type v0.AddArg(ptr) - v1 := v.Block.NewValue(OpConst, TypeInvalid, nil) + v1 := v.Block.NewValue(v.Line, OpConst, TypeInvalid, nil) v1.Type = config.Uintptr v1.Aux = int64(config.ptrSize * 2) v0.AddArg(v1) @@ -231,10 +231,10 @@ func genericValueRules(v *Value, config *Config) bool { v.Op = OpLoad v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue(OpAdd, TypeInvalid, nil) + v0 := v.Block.NewValue(v.Line, OpAdd, TypeInvalid, nil) v0.Type = ptr.Type v0.AddArg(ptr) - v1 := v.Block.NewValue(OpConst, TypeInvalid, nil) + v1 := v.Block.NewValue(v.Line, OpConst, TypeInvalid, nil) v1.Type = config.Uintptr v1.Aux = int64(config.ptrSize) v0.AddArg(v1) @@ -308,19 +308,19 @@ func genericValueRules(v *Value, config *Config) bool { v.Op = OpStore v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue(OpOffPtr, TypeInvalid, nil) + v0 := v.Block.NewValue(v.Line, OpOffPtr, TypeInvalid, nil) v0.Type = TypeBytePtr v0.Aux = config.ptrSize v0.AddArg(dst) v.AddArg(v0) - v1 := v.Block.NewValue(OpStringLen, TypeInvalid, nil) + v1 := v.Block.NewValue(v.Line, OpStringLen, TypeInvalid, nil) v1.Type = config.Uintptr v1.AddArg(str) v.AddArg(v1) - v2 := v.Block.NewValue(OpStore, TypeInvalid, nil) + v2 := v.Block.NewValue(v.Line, OpStore, TypeInvalid, nil) v2.Type = TypeMem v2.AddArg(dst) - v3 := v.Block.NewValue(OpStringPtr, TypeInvalid, nil) + v3 := v.Block.NewValue(v.Line, OpStringPtr, TypeInvalid, nil) v3.Type = TypeBytePtr v3.AddArg(str) v2.AddArg(v3) diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index 839008445c..ed80a5b97d 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -262,24 +262,24 @@ func regalloc(f *Func) { if len(w.Args) == 0 { // Materialize w if w.Op == OpFP || w.Op == OpSP || w.Op == OpGlobal { - c = b.NewValue1(OpCopy, w.Type, nil, w) + c = b.NewValue1(w.Line, OpCopy, w.Type, nil, w) } else { - c = b.NewValue(w.Op, w.Type, w.Aux) + c = b.NewValue(w.Line, w.Op, w.Type, w.Aux) } } else if len(w.Args) == 1 && (w.Args[0].Op == OpFP || w.Args[0].Op == OpSP || w.Args[0].Op == OpGlobal) { // Materialize offsets from SP/FP/Global - c = b.NewValue1(w.Op, w.Type, w.Aux, w.Args[0]) + c = b.NewValue1(w.Line, w.Op, w.Type, w.Aux, w.Args[0]) } else if wreg != 0 { // Copy from another register. // Typically just an optimization, but this is // required if w is dirty. s := pickReg(wreg) // inv: s != r - c = b.NewValue(OpCopy, w.Type, nil) + c = b.NewValue(w.Line, OpCopy, w.Type, nil) c.AddArg(regs[s].c) } else { // Load from home location - c = b.NewValue(OpLoadReg8, w.Type, nil) + c = b.NewValue(w.Line, OpLoadReg8, w.Type, nil) c.AddArg(w) } home = setloc(home, c, ®isters[r]) @@ -337,7 +337,7 @@ func regalloc(f *Func) { } // Reissue v with new op, with r as its home. - c := b.NewValue(v.Op, v.Type, v.Aux) + c := b.NewValue(v.Line, v.Op, v.Type, v.Aux) c.AddArgs(v.Args...) home = setloc(home, c, ®isters[r]) @@ -406,7 +406,7 @@ func addPhiCopies(f *Func) { } for i, w := range v.Args { c := b.Preds[i] - cpy := c.NewValue1(OpCopy, v.Type, nil, w) + cpy := c.NewValue1(w.Line, OpCopy, v.Type, nil, w) v.Args[i] = cpy } } diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index d49245ad3a..0878a12eb9 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -181,7 +181,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Op = OpAMD64InvertFlags v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue(OpAMD64CMPQconst, TypeInvalid, nil) + v0 := v.Block.NewValue(v.Line, OpAMD64CMPQconst, TypeInvalid, nil) v0.Type = TypeFlags v0.AddArg(x) v0.Aux = c @@ -235,7 +235,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Op = OpAMD64SETB v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue(OpAMD64CMPQ, TypeInvalid, nil) + v0 := v.Block.NewValue(v.Line, OpAMD64CMPQ, TypeInvalid, nil) v0.Type = TypeFlags v0.AddArg(idx) v0.AddArg(len) @@ -254,7 +254,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Op = OpAMD64SETNE v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue(OpAMD64TESTQ, TypeInvalid, nil) + v0 := v.Block.NewValue(v.Line, OpAMD64TESTQ, TypeInvalid, nil) v0.Type = TypeFlags v0.AddArg(p) v0.AddArg(p) @@ -277,7 +277,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Op = OpAMD64SETL v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue(OpAMD64CMPQ, TypeInvalid, nil) + v0 := v.Block.NewValue(v.Line, OpAMD64CMPQ, TypeInvalid, nil) v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) @@ -596,7 +596,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(dst) v.AddArg(src) - v0 := v.Block.NewValue(OpConst, TypeInvalid, nil) + v0 := v.Block.NewValue(v.Line, OpConst, TypeInvalid, nil) v0.Type = TypeUInt64 v0.Aux = size.(int64) v.AddArg(v0) @@ -733,7 +733,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Op = OpAMD64NEGQ v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue(OpAMD64SUBQconst, TypeInvalid, nil) + v0 := v.Block.NewValue(v.Line, OpAMD64SUBQconst, TypeInvalid, nil) v0.Type = t v0.AddArg(x) v0.Aux = c @@ -927,7 +927,7 @@ func rewriteBlockAMD64(b *Block) bool { goto end7e22019fb0effc80f85c05ea30bdb5d9 } b.Kind = BlockAMD64NE - v0 := v.Block.NewValue(OpAMD64TESTB, TypeInvalid, nil) + v0 := v.Block.NewValue(v.Line, OpAMD64TESTB, TypeInvalid, nil) v0.Type = TypeFlags v0.AddArg(cond) v0.AddArg(cond) diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index e9552e68f3..e38439de14 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -44,7 +44,7 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.Op = OpLoad v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue(OpPtrIndex, TypeInvalid, nil) + v0 := v.Block.NewValue(v.Line, OpPtrIndex, TypeInvalid, nil) v0.Type = ptr.Type.Elem().Elem().PtrTo() v0.AddArg(ptr) v0.AddArg(idx) @@ -68,15 +68,15 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.Op = OpStringMake v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue(OpOffPtr, TypeInvalid, nil) + v0 := v.Block.NewValue(v.Line, OpOffPtr, TypeInvalid, nil) v0.Type = TypeBytePtr v0.Aux = 2 * config.ptrSize - v1 := v.Block.NewValue(OpGlobal, TypeInvalid, nil) + v1 := v.Block.NewValue(v.Line, OpGlobal, TypeInvalid, nil) v1.Type = TypeBytePtr v1.Aux = config.fe.StringSym(s.(string)) v0.AddArg(v1) v.AddArg(v0) - v2 := v.Block.NewValue(OpConst, TypeInvalid, nil) + v2 := v.Block.NewValue(v.Line, OpConst, TypeInvalid, nil) v2.Type = config.Uintptr v2.Aux = int64(len(s.(string))) v.AddArg(v2) @@ -121,14 +121,14 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.Op = OpStringMake v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue(OpLoad, TypeInvalid, nil) + v0 := v.Block.NewValue(v.Line, OpLoad, TypeInvalid, nil) v0.Type = TypeBytePtr v0.AddArg(ptr) v0.AddArg(mem) v.AddArg(v0) - v1 := v.Block.NewValue(OpLoad, TypeInvalid, nil) + v1 := v.Block.NewValue(v.Line, OpLoad, TypeInvalid, nil) v1.Type = config.Uintptr - v2 := v.Block.NewValue(OpOffPtr, TypeInvalid, nil) + v2 := v.Block.NewValue(v.Line, OpOffPtr, TypeInvalid, nil) v2.Type = TypeBytePtr v2.Aux = config.ptrSize v2.AddArg(ptr) @@ -178,10 +178,10 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(ptr) - v0 := v.Block.NewValue(OpMul, TypeInvalid, nil) + v0 := v.Block.NewValue(v.Line, OpMul, TypeInvalid, nil) v0.Type = config.Uintptr v0.AddArg(idx) - v1 := v.Block.NewValue(OpConst, TypeInvalid, nil) + v1 := v.Block.NewValue(v.Line, OpConst, TypeInvalid, nil) v1.Type = config.Uintptr v1.Aux = t.Elem().Size() v0.AddArg(v1) @@ -204,10 +204,10 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.Op = OpLoad v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue(OpAdd, TypeInvalid, nil) + v0 := v.Block.NewValue(v.Line, OpAdd, TypeInvalid, nil) v0.Type = ptr.Type v0.AddArg(ptr) - v1 := v.Block.NewValue(OpConst, TypeInvalid, nil) + v1 := v.Block.NewValue(v.Line, OpConst, TypeInvalid, nil) v1.Type = config.Uintptr v1.Aux = int64(config.ptrSize * 2) v0.AddArg(v1) @@ -231,10 +231,10 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.Op = OpLoad v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue(OpAdd, TypeInvalid, nil) + v0 := v.Block.NewValue(v.Line, OpAdd, TypeInvalid, nil) v0.Type = ptr.Type v0.AddArg(ptr) - v1 := v.Block.NewValue(OpConst, TypeInvalid, nil) + v1 := v.Block.NewValue(v.Line, OpConst, TypeInvalid, nil) v1.Type = config.Uintptr v1.Aux = int64(config.ptrSize) v0.AddArg(v1) @@ -308,19 +308,19 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.Op = OpStore v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue(OpOffPtr, TypeInvalid, nil) + v0 := v.Block.NewValue(v.Line, OpOffPtr, TypeInvalid, nil) v0.Type = TypeBytePtr v0.Aux = config.ptrSize v0.AddArg(dst) v.AddArg(v0) - v1 := v.Block.NewValue(OpStringLen, TypeInvalid, nil) + v1 := v.Block.NewValue(v.Line, OpStringLen, TypeInvalid, nil) v1.Type = config.Uintptr v1.AddArg(str) v.AddArg(v1) - v2 := v.Block.NewValue(OpStore, TypeInvalid, nil) + v2 := v.Block.NewValue(v.Line, OpStore, TypeInvalid, nil) v2.Type = TypeMem v2.AddArg(dst) - v3 := v.Block.NewValue(OpStringPtr, TypeInvalid, nil) + v3 := v.Block.NewValue(v.Line, OpStringPtr, TypeInvalid, nil) v3.Type = TypeBytePtr v3.AddArg(str) v2.AddArg(v3) diff --git a/src/cmd/compile/internal/ssa/value.go b/src/cmd/compile/internal/ssa/value.go index 08e368ab04..f249bba43e 100644 --- a/src/cmd/compile/internal/ssa/value.go +++ b/src/cmd/compile/internal/ssa/value.go @@ -30,6 +30,9 @@ type Value struct { // Containing basic block Block *Block + // Source line number + Line int32 + // Storage for the first two args argstorage [2]*Value } -- cgit v1.3 From 290d8fc14a755a970e8f2bb441676e183dcd0c26 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Wed, 10 Jun 2015 15:03:06 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: add call opcodes Add calls, particularly closure calls. Reorg SSAable variable test for converting to SSA. Change-Id: Ia75c04295e6b0b040122f97e2381836a393b7f42 Reviewed-on: https://go-review.googlesource.com/10912 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/gc/opnames.go | 1 + src/cmd/compile/internal/gc/ssa.go | 87 ++++++++++++++++++-------- src/cmd/compile/internal/ssa/TODO | 3 + src/cmd/compile/internal/ssa/gen/AMD64.rules | 3 + src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 4 ++ src/cmd/compile/internal/ssa/gen/genericOps.go | 4 +- src/cmd/compile/internal/ssa/opGen.go | 26 +++++++- src/cmd/compile/internal/ssa/rewriteAMD64.go | 36 +++++++++++ 8 files changed, 135 insertions(+), 29 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/opnames.go b/src/cmd/compile/internal/gc/opnames.go index fc03ec6666..9134bd4332 100644 --- a/src/cmd/compile/internal/gc/opnames.go +++ b/src/cmd/compile/internal/gc/opnames.go @@ -33,6 +33,7 @@ var opnames = []string{ OAS2MAPR: "AS2MAPR", OAS2DOTTYPE: "AS2DOTTYPE", OASOP: "ASOP", + OASWB: "ASWB", OCALL: "CALL", OCALLFUNC: "CALLFUNC", OCALLMETH: "CALLMETH", diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 773d79ba30..fd47c54ad0 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -224,8 +224,9 @@ func (s *state) stmt(n *Node) { s.startBlock(t) } - case OAS: + case OAS, OASWB: // TODO(khr): colas? + // TODO: do write barrier var val *ssa.Value if n.Right == nil { // n.Right == nil means use the zero value of the assigned type. @@ -243,15 +244,14 @@ func (s *state) stmt(n *Node) { } else { val = s.expr(n.Right) } - if n.Left.Op == ONAME && !n.Left.Addrtaken && n.Left.Class&PHEAP == 0 && n.Left.Class != PEXTERN && n.Left.Class != PPARAMOUT { - // ssa-able variable. + if n.Left.Op == ONAME && canSSA(n.Left) { + // Update variable assignment. s.vars[n.Left.Sym.Name] = val return } // not ssa-able. Treat as a store. addr := s.addr(n.Left) s.vars[".mem"] = s.newValue3(ssa.OpStore, ssa.TypeMem, nil, addr, val, s.mem()) - // TODO: try to make more variables registerizeable. case OIF: cond := s.expr(n.Ntest) b := s.endBlock() @@ -338,14 +338,16 @@ func (s *state) expr(n *Node) *ssa.Value { switch n.Op { case ONAME: - // TODO: remember offsets for PPARAM names - if n.Class == PEXTERN { - // global variable - addr := s.entryNewValue(ssa.OpGlobal, Ptrto(n.Type), n.Sym) - return s.newValue2(ssa.OpLoad, n.Type, nil, addr, s.mem()) + if n.Class == PFUNC { + // "value" of a function is the address of the function's closure + return s.entryNewValue(ssa.OpGlobal, Ptrto(n.Type), funcsym(n.Sym)) + } + s.argOffsets[n.Sym.Name] = n.Xoffset // TODO: remember this another way? + if canSSA(n) { + return s.variable(n.Sym.Name, n.Type) } - s.argOffsets[n.Sym.Name] = n.Xoffset - return s.variable(n.Sym.Name, n.Type) + addr := s.addr(n) + return s.newValue2(ssa.OpLoad, n.Type, nil, addr, s.mem()) case OLITERAL: switch n.Val.Ctype { case CTINT: @@ -415,17 +417,25 @@ func (s *state) expr(n *Node) *ssa.Value { } case OCALLFUNC: + static := n.Left.Op == ONAME && n.Left.Class == PFUNC + + // evaluate closure + var closure *ssa.Value + if !static { + closure = s.expr(n.Left) + } + // run all argument assignments - // TODO(khr): do we need to evaluate function first? - // Or is it already side-effect-free and does not require a call? s.stmtList(n.List) - if n.Left.Op != ONAME { - // TODO(khr): closure calls? - log.Fatalf("can't handle CALLFUNC with non-ONAME fn %s", opnames[n.Left.Op]) - } bNext := s.f.NewBlock(ssa.BlockPlain) - call := s.newValue1(ssa.OpStaticCall, ssa.TypeMem, n.Left.Sym, s.mem()) + var call *ssa.Value + if static { + call = s.newValue1(ssa.OpStaticCall, ssa.TypeMem, n.Left.Sym, s.mem()) + } else { + entry := s.newValue2(ssa.OpLoad, s.config.Uintptr, nil, closure, s.mem()) + call = s.newValue3(ssa.OpClosureCall, ssa.TypeMem, nil, entry, closure, s.mem()) + } b := s.endBlock() b.Kind = ssa.BlockCall b.Control = call @@ -448,17 +458,18 @@ func (s *state) expr(n *Node) *ssa.Value { func (s *state) addr(n *Node) *ssa.Value { switch n.Op { case ONAME: - if n.Class == PEXTERN { + switch n.Class { + case PEXTERN: // global variable return s.entryNewValue(ssa.OpGlobal, Ptrto(n.Type), n.Sym) - } - if n.Class == PPARAMOUT { + case PPARAMOUT: // store to parameter slot return s.entryNewValue1(ssa.OpOffPtr, Ptrto(n.Type), n.Xoffset, s.fp) + default: + // TODO: address of locals + log.Fatalf("variable address of %v not implemented", n) + return nil } - // TODO: address of locals - log.Fatalf("variable address of %v not implemented", n) - return nil case OINDREG: // indirect off a register (TODO: always SP?) // used for storing/loading arguments/returns to/from callees @@ -484,6 +495,28 @@ func (s *state) addr(n *Node) *ssa.Value { } } +// canSSA reports whether n is SSA-able. +// n must be an ONAME. +func canSSA(n *Node) bool { + if n.Op != ONAME { + log.Fatalf("canSSA passed a non-ONAME %s %v", Oconv(int(n.Op), 0), n) + } + if n.Addrtaken { + return false + } + if n.Class&PHEAP != 0 { + return false + } + if n.Class == PEXTERN { + return false + } + if n.Class == PPARAMOUT { + return false + } + return true + // TODO: try to make more variables SSAable. +} + // nilCheck generates nil pointer checking code. // Starts a new block on return. func (s *state) nilCheck(ptr *ssa.Value) { @@ -854,11 +887,15 @@ func genValue(v *ssa.Value) { p.From.Offset = g.Offset p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v) - case ssa.OpStaticCall: + 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)) + case ssa.OpAMD64CALLclosure: + p := Prog(obj.ACALL) + p.To.Type = obj.TYPE_REG + p.To.Reg = regnum(v.Args[0]) case ssa.OpFP, ssa.OpSP: // nothing to do default: diff --git a/src/cmd/compile/internal/ssa/TODO b/src/cmd/compile/internal/ssa/TODO index 7cd2206db3..d5e8788e36 100644 --- a/src/cmd/compile/internal/ssa/TODO +++ b/src/cmd/compile/internal/ssa/TODO @@ -26,6 +26,7 @@ Opcodes - It's annoying to list the opcode both in the opcode list and an opInfo map entry. Specify it one place and use go:generate to produce both? + - Write barriers Regalloc - Make less arch-dependent @@ -33,6 +34,7 @@ Regalloc - Allow args and return values to be ssa-able. - Handle 2-address instructions. - Floating point registers + - Make calls clobber all registers Rewrites - Strength reduction (both arch-indep and arch-dependent?) @@ -51,3 +53,4 @@ Common-Subexpression Elimination Other - Make go:generate less painful. Have a subpackage that just has the generate commands in it? + - Use gc.Fatal for errors. Add a callback to Frontend? diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index c4ff744421..15cd79a3f5 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -40,6 +40,9 @@ (If (SETB cmp) yes no) -> (ULT cmp yes no) (If cond yes no) && cond.Op == OpAMD64MOVBload -> (NE (TESTB cond cond) yes no) +(StaticCall [target] mem) -> (CALLstatic [target] mem) +(ClosureCall entry closure mem) -> (CALLclosure entry closure mem) + // Rules below here apply some simple optimizations after lowering. // TODO: Should this be a separate pass? diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 38d1e87575..b3b2e3b5e2 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -132,6 +132,10 @@ func init() { {name: "MOVQloadglobal"}, // Load from aux.(GlobalOffset). arg0 = memory {name: "MOVQstoreglobal"}, // store arg0 to aux.(GlobalOffset). arg1=memory, returns memory. + //TODO: set register clobber to everything? + {name: "CALLstatic"}, // call static function. arg0=mem, returns mem + {name: "CALLclosure", reg: regInfo{[]regMask{gpsp, buildReg("DX"), 0}, 0, nil}}, // call function via closure. arg0=codeptr, arg1=closure, arg2=mem returns mem + {name: "REPMOVSB", reg: regInfo{[]regMask{buildReg("DI"), buildReg("SI"), buildReg("CX")}, buildReg("DI SI CX"), nil}}, // move arg2 bytes from arg1 to arg0. arg3=mem, returns memory {name: "ADDL", reg: gp21}, // arg0+arg1 diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index e8c3cbeb8a..e415f3d16b 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -44,8 +44,8 @@ var genericOps = []opData{ // 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: "Call"}, // arg0=code pointer, arg1=context ptr, arg2=memory. Returns memory. - {name: "StaticCall"}, // call function aux.(*gc.Sym), arg0=memory. Returns memory. + {name: "ClosureCall"}, // arg0=code pointer, arg1=context ptr, arg2=memory. Returns memory. + {name: "StaticCall"}, // call function aux.(*gc.Sym), arg0=memory. Returns memory. // Conversions {name: "Convert"}, // convert arg0 to another type diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 604f096152..550f641c14 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -82,6 +82,8 @@ const ( OpAMD64MOVQstoreidx8 OpAMD64MOVQloadglobal OpAMD64MOVQstoreglobal + OpAMD64CALLstatic + OpAMD64CALLclosure OpAMD64REPMOVSB OpAMD64ADDL OpAMD64InvertFlags @@ -103,7 +105,7 @@ const ( OpLoad OpStore OpMove - OpCall + OpClosureCall OpStaticCall OpConvert OpConvNop @@ -553,6 +555,26 @@ var opcodeTable = [...]opInfo{ outputs: []regMask{}, }, }, + { + name: "CALLstatic", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + }, + { + name: "CALLclosure", + reg: regInfo{ + inputs: []regMask{ + 4295032831, + 4, + 0, + }, + clobbers: 0, + outputs: []regMask{}, + }, + }, { name: "REPMOVSB", reg: regInfo{ @@ -741,7 +763,7 @@ var opcodeTable = [...]opInfo{ generic: true, }, { - name: "Call", + name: "ClosureCall", reg: regInfo{ inputs: []regMask{}, clobbers: 0, diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 0878a12eb9..542dad4500 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -191,6 +191,25 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endf8ca12fe79290bc82b11cfa463bc9413 endf8ca12fe79290bc82b11cfa463bc9413: ; + case OpClosureCall: + // match: (ClosureCall entry closure mem) + // cond: + // result: (CALLclosure entry closure mem) + { + entry := v.Args[0] + closure := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64CALLclosure + v.Aux = nil + v.resetArgs() + v.AddArg(entry) + v.AddArg(closure) + v.AddArg(mem) + return true + } + goto endee26da781e813a3c602ccb4f7ade98c7 + endee26da781e813a3c602ccb4f7ade98c7: + ; case OpConst: // match: (Const [val]) // cond: is64BitInt(t) @@ -743,6 +762,23 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end78e66b6fc298684ff4ac8aec5ce873c9 end78e66b6fc298684ff4ac8aec5ce873c9: ; + case OpStaticCall: + // match: (StaticCall [target] mem) + // cond: + // result: (CALLstatic [target] mem) + { + target := v.Aux + mem := v.Args[0] + v.Op = OpAMD64CALLstatic + v.Aux = nil + v.resetArgs() + v.Aux = target + v.AddArg(mem) + return true + } + goto endcf02eb60d90086f6c42bfdc5842b145d + endcf02eb60d90086f6c42bfdc5842b145d: + ; case OpStore: // match: (Store ptr val mem) // cond: (is64BitInt(val.Type) || isPtr(val.Type)) -- cgit v1.3 From 6f1884757f26f4906d71e2465a2238c80245c323 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Wed, 10 Jun 2015 10:39:57 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: Complete 64-bit shifts Implement correct Go shifts. Allow multi-line rewrite rules. Fix offset & alignment in stack alloc. Change-Id: I0ae9e522c83df9205bbe4ab94bc0e43d16dace58 Reviewed-on: https://go-review.googlesource.com/10891 Reviewed-by: Keith Randall --- src/cmd/compile/internal/amd64/prog.go | 2 + src/cmd/compile/internal/gc/ssa.go | 140 ++++++++++++ src/cmd/compile/internal/gc/type.go | 5 + src/cmd/compile/internal/ssa/TODO | 16 +- src/cmd/compile/internal/ssa/gen/AMD64.rules | 38 +++- src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 22 +- src/cmd/compile/internal/ssa/gen/rulegen.go | 38 +++- src/cmd/compile/internal/ssa/opGen.go | 109 ++++++++++ src/cmd/compile/internal/ssa/rewriteAMD64.go | 305 ++++++++++++++++++++++++++- src/cmd/compile/internal/ssa/shift_test.go | 42 ++++ src/cmd/compile/internal/ssa/stackalloc.go | 17 +- src/cmd/compile/internal/ssa/type.go | 47 +++-- 12 files changed, 720 insertions(+), 61 deletions(-) create mode 100644 src/cmd/compile/internal/ssa/shift_test.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/amd64/prog.go b/src/cmd/compile/internal/amd64/prog.go index 00918c8691..97f7241fbd 100644 --- a/src/cmd/compile/internal/amd64/prog.go +++ b/src/cmd/compile/internal/amd64/prog.go @@ -57,6 +57,8 @@ var progtable = [x86.ALAST]obj.ProgInfo{ x86.ACWD: {gc.OK, AX, AX | DX, 0}, x86.ACLD: {gc.OK, 0, 0, 0}, x86.ASTD: {gc.OK, 0, 0, 0}, + x86.ACMOVQCC: {gc.SizeQ | gc.LeftRead | gc.RightRead | gc.RightWrite | gc.UseCarry, 0, 0, 0}, + x86.ACMOVQCS: {gc.SizeQ | gc.LeftRead | gc.RightRead | gc.RightWrite | gc.UseCarry, 0, 0, 0}, x86.ACMPB: {gc.SizeB | gc.LeftRead | gc.RightRead | gc.SetCarry, 0, 0, 0}, x86.ACMPL: {gc.SizeL | gc.LeftRead | gc.RightRead | gc.SetCarry, 0, 0, 0}, x86.ACMPQ: {gc.SizeQ | gc.LeftRead | gc.RightRead | gc.SetCarry, 0, 0, 0}, diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index fd47c54ad0..fcef7d3b81 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -755,6 +755,63 @@ func genValue(v *ssa.Value) { p.From.Offset = v.Aux.(int64) p.To.Type = obj.TYPE_REG p.To.Reg = r + case ssa.OpAMD64SHLQ: + x := regnum(v.Args[0]) + r := regnum(v) + if x != r { + if r == x86.REG_CX { + log.Fatalf("can't implement %s, target and shift both in CX", v.LongString()) + } + p := Prog(x86.AMOVQ) + p.From.Type = obj.TYPE_REG + p.From.Reg = x + p.To.Type = obj.TYPE_REG + p.To.Reg = r + x = r + } + p := Prog(x86.ASHLQ) + 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.OpAMD64SHRQ: + x := regnum(v.Args[0]) + r := regnum(v) + if x != r { + if r == x86.REG_CX { + log.Fatalf("can't implement %s, target and shift both in CX", v.LongString()) + } + p := Prog(x86.AMOVQ) + p.From.Type = obj.TYPE_REG + p.From.Reg = x + p.To.Type = obj.TYPE_REG + p.To.Reg = r + x = r + } + p := Prog(x86.ASHRQ) + 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.OpAMD64SARQ: + x := regnum(v.Args[0]) + r := regnum(v) + if x != r { + if r == x86.REG_CX { + log.Fatalf("can't implement %s, target and shift both in CX", v.LongString()) + } + p := Prog(x86.AMOVQ) + p.From.Type = obj.TYPE_REG + p.From.Reg = x + p.To.Type = obj.TYPE_REG + p.To.Reg = r + x = r + } + p := Prog(x86.ASARQ) + 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.OpAMD64SHLQconst: x := regnum(v.Args[0]) r := regnum(v) @@ -771,6 +828,89 @@ func genValue(v *ssa.Value) { p.From.Offset = v.Aux.(int64) p.To.Type = obj.TYPE_REG p.To.Reg = r + case ssa.OpAMD64SHRQconst: + x := regnum(v.Args[0]) + r := regnum(v) + if x != r { + p := Prog(x86.AMOVQ) + p.From.Type = obj.TYPE_REG + p.From.Reg = x + p.To.Type = obj.TYPE_REG + p.To.Reg = r + x = r + } + p := Prog(x86.ASHRQ) + p.From.Type = obj.TYPE_CONST + p.From.Offset = v.Aux.(int64) + p.To.Type = obj.TYPE_REG + p.To.Reg = r + case ssa.OpAMD64SARQconst: + x := regnum(v.Args[0]) + r := regnum(v) + if x != r { + p := Prog(x86.AMOVQ) + p.From.Type = obj.TYPE_REG + p.From.Reg = x + p.To.Type = obj.TYPE_REG + p.To.Reg = r + x = r + } + p := Prog(x86.ASARQ) + p.From.Type = obj.TYPE_CONST + p.From.Offset = v.Aux.(int64) + p.To.Type = obj.TYPE_REG + p.To.Reg = r + case ssa.OpAMD64SBBQcarrymask: + r := regnum(v) + p := Prog(x86.ASBBQ) + p.From.Type = obj.TYPE_REG + p.From.Reg = r + p.To.Type = obj.TYPE_REG + p.To.Reg = r + case ssa.OpAMD64CMOVQCC: + r := regnum(v) + x := regnum(v.Args[1]) + y := regnum(v.Args[2]) + if x != r && y != r { + p := Prog(x86.AMOVQ) + p.From.Type = obj.TYPE_REG + p.From.Reg = x + p.To.Type = obj.TYPE_REG + p.To.Reg = r + x = r + } + var p *obj.Prog + if x == r { + p = Prog(x86.ACMOVQCS) + p.From.Reg = y + } else { + p = Prog(x86.ACMOVQCC) + p.From.Reg = x + } + p.From.Type = obj.TYPE_REG + p.To.Type = obj.TYPE_REG + p.To.Reg = r + case ssa.OpAMD64ANDQ: + r := regnum(v) + x := regnum(v.Args[0]) + y := regnum(v.Args[1]) + if x != r && y != r { + p := Prog(x86.AMOVQ) + p.From.Type = obj.TYPE_REG + p.From.Reg = x + p.To.Type = obj.TYPE_REG + p.To.Reg = r + x = r + } + p := Prog(x86.AANDQ) + 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 + } case ssa.OpAMD64LEAQ: p := Prog(x86.ALEAQ) p.From.Type = obj.TYPE_MEM diff --git a/src/cmd/compile/internal/gc/type.go b/src/cmd/compile/internal/gc/type.go index 0ed07ee90a..1417bfc196 100644 --- a/src/cmd/compile/internal/gc/type.go +++ b/src/cmd/compile/internal/gc/type.go @@ -18,6 +18,11 @@ func (t *Type) Size() int64 { return t.Width } +func (t *Type) Alignment() int64 { + dowidth(t) + return int64(t.Align) +} + func (t *Type) IsBoolean() bool { return t.Etype == TBOOL } diff --git a/src/cmd/compile/internal/ssa/TODO b/src/cmd/compile/internal/ssa/TODO index d5e8788e36..e9b7553534 100644 --- a/src/cmd/compile/internal/ssa/TODO +++ b/src/cmd/compile/internal/ssa/TODO @@ -20,14 +20,6 @@ Values If not that, then cache the interfaces that wrap int64s. - OpStore uses 3 args. Increase the size of argstorage to 3? -Opcodes - - Rename ops to prevent cross-arch conflicts. MOVQ -> MOVQamd64 (or - MOVQ6?). Other option: build opcode table in Config instead of globally. - - It's annoying to list the opcode both in the opcode list and an - opInfo map entry. Specify it one place and use go:generate to - produce both? - - Write barriers - Regalloc - Make less arch-dependent - Don't spill everything at every basic block boundary. @@ -38,7 +30,6 @@ Regalloc Rewrites - Strength reduction (both arch-indep and arch-dependent?) - - Code sequence for shifts >= wordsize - Start another architecture (arm?) - 64-bit ops on 32-bit machines - x y) && (is64BitInt(t) || isPtr(t)) -> (ADDQ x y) (Add x y) && is32BitInt(t) -> (ADDL x y) - (Sub x y) && is64BitInt(t) -> (SUBQ x y) - (Mul x y) && is64BitInt(t) -> (MULQ x y) -(Lsh x y) && is64BitInt(t) -> (SHLQ x y) // TODO: check y>63 + +// Lowering shifts +// Note: unsigned shifts need to return 0 if shift amount is >= 64. +// mask = shift >= 64 ? 0 : 0xffffffffffffffff +// result = mask & arg << shift +(Lsh x y) && is64BitInt(t) -> + (ANDQ (SHLQ x y) (SBBQcarrymask (CMPQconst [int64(64)] y))) +(Rsh x y) && is64BitInt(t) && !t.IsSigned() -> + (ANDQ (SHRQ x y) (SBBQcarrymask (CMPQconst [int64(64)] y))) + +// Note: signed right shift needs to return 0/-1 if shift amount is >= 64. +// if shift > 63 { shift = 63 } +// result = arg >> shift +(Rsh x y) && is64BitInt(t) && t.IsSigned() -> + (SARQ x (CMOVQCC + (CMPQconst [int64(64)] y) + (Const [int64(63)]) + y)) + (Less x y) && is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type) -> (SETL (CMPQ x y)) (Load ptr mem) && t.IsBoolean() -> (MOVBload [int64(0)] ptr mem) @@ -56,7 +74,11 @@ (SUBQ (MOVQconst [c]) x) -> (NEGQ (SUBQconst x [c])) (MULQ x (MOVQconst [c])) && c.(int64) == int64(int32(c.(int64))) -> (MULQconst [c] x) (MULQ (MOVQconst [c]) x) -> (MULQconst [c] x) +(ANDQ x (MOVQconst [c])) -> (ANDQconst [c] x) +(ANDQ (MOVQconst [c]) x) -> (ANDQconst [c] x) (SHLQ x (MOVQconst [c])) -> (SHLQconst [c] x) +(SHRQ x (MOVQconst [c])) -> (SHRQconst [c] x) +(SARQ x (MOVQconst [c])) -> (SARQconst [c] x) (CMPQ x (MOVQconst [c])) -> (CMPQconst x [c]) (CMPQ (MOVQconst [c]) x) -> (InvertFlags (CMPQconst x [c])) @@ -101,3 +123,11 @@ (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) + +// get rid of >=64 code for constant shifts +(SBBQcarrymask (CMPQconst [c] (MOVQconst [d]))) && inBounds(d.(int64), c.(int64)) -> (Const [int64(-1)]) +(SBBQcarrymask (CMPQconst [c] (MOVQconst [d]))) && !inBounds(d.(int64), c.(int64)) -> (Const [int64(0)]) +(ANDQconst [c] _) && c.(int64) == 0 -> (MOVQconst [int64(0)]) +(ANDQconst [c] x) && c.(int64) == -1 -> (Copy x) +(CMOVQCC (CMPQconst [c] (MOVQconst [d])) _ x) && inBounds(d.(int64), c.(int64)) -> (Copy x) +(CMOVQCC (CMPQconst [c] (MOVQconst [d])) x _) && !inBounds(d.(int64), c.(int64)) -> (Copy x) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index b3b2e3b5e2..8bb22d270d 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -72,17 +72,20 @@ func init() { gp := buildReg("AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15") gpsp := gp | buildReg("SP FP") + flags := buildReg("FLAGS") gp01 := regInfo{[]regMask{}, 0, []regMask{gp}} gp11 := regInfo{[]regMask{gpsp}, 0, []regMask{gp}} gp21 := regInfo{[]regMask{gpsp, gpsp}, 0, []regMask{gp}} gp21shift := regInfo{[]regMask{gpsp, buildReg("CX")}, 0, []regMask{gp}} - gp2flags := regInfo{[]regMask{gpsp, gpsp}, 0, []regMask{buildReg("FLAGS")}} - gp1flags := regInfo{[]regMask{gpsp}, 0, []regMask{buildReg("FLAGS")}} + gp2flags := regInfo{[]regMask{gpsp, gpsp}, 0, []regMask{flags}} + gp1flags := regInfo{[]regMask{gpsp}, 0, []regMask{flags}} + flagsgp1 := regInfo{[]regMask{flags}, 0, []regMask{gp}} gpload := regInfo{[]regMask{gpsp, 0}, 0, []regMask{gp}} gploadidx := regInfo{[]regMask{gpsp, gpsp, 0}, 0, []regMask{gp}} gpstore := regInfo{[]regMask{gpsp, gpsp, 0}, 0, nil} gpstoreidx := regInfo{[]regMask{gpsp, gpsp, gpsp, 0}, 0, nil} - flagsgp := regInfo{[]regMask{buildReg("FLAGS")}, 0, []regMask{gp}} + flagsgp := regInfo{[]regMask{flags}, 0, []regMask{gp}} + cmov := regInfo{[]regMask{flags, gp, gp}, 0, []regMask{gp}} // Suffixes encode the bit width of various instructions. // Q = 64 bit, L = 32 bit, W = 16 bit, B = 8 bit @@ -95,15 +98,24 @@ func init() { {name: "SUBQconst", reg: gp11}, // arg0 - aux.(int64) {name: "MULQ", reg: gp21}, // arg0 * arg1 {name: "MULQconst", reg: gp11}, // arg0 * aux.(int64) + {name: "ANDQ", reg: gp21}, // arg0 & arg1 + {name: "ANDQconst", reg: gp11}, // arg0 & aux.(int64) {name: "SHLQ", reg: gp21shift}, // arg0 << arg1, shift amount is mod 64 {name: "SHLQconst", reg: gp11}, // arg0 << aux.(int64), shift amount 0-63 - {name: "NEGQ", reg: gp11}, // -arg0 + {name: "SHRQ", reg: gp21shift}, // unsigned arg0 >> arg1, shift amount is mod 64 + {name: "SHRQconst", reg: gp11}, // unsigned arg0 >> aux.(int64), shift amount 0-63 + {name: "SARQ", reg: gp21shift}, // signed arg0 >> arg1, shift amount is mod 64 + {name: "SARQconst", reg: gp11}, // signed arg0 >> aux.(int64), shift amount 0-63 + + {name: "NEGQ", reg: gp11}, // -arg0 {name: "CMPQ", reg: gp2flags}, // arg0 compare to arg1 {name: "CMPQconst", reg: gp1flags}, // arg0 compare to aux.(int64) {name: "TESTQ", reg: gp2flags}, // (arg0 & arg1) compare to 0 {name: "TESTB", reg: gp2flags}, // (arg0 & arg1) compare to 0 + {name: "SBBQcarrymask", reg: flagsgp1}, // (int64)(-1) if carry is set, 0 if carry is clear. + {name: "SETEQ", reg: flagsgp}, // extract == condition from arg0 {name: "SETNE", reg: flagsgp}, // extract != condition from arg0 {name: "SETL", reg: flagsgp}, // extract signed < condition from arg0 @@ -111,6 +123,8 @@ func init() { {name: "SETGE", reg: flagsgp}, // extract signed >= condition from arg0 {name: "SETB", reg: flagsgp}, // extract unsigned < condition from arg0 + {name: "CMOVQCC", reg: cmov}, // carry clear + {name: "MOVQconst", reg: gp01}, // aux.(int64) {name: "LEAQ", reg: gp21}, // arg0 + arg1 + aux.(int64) {name: "LEAQ2", reg: gp21}, // arg0 + 2*arg1 + aux.(int64) diff --git a/src/cmd/compile/internal/ssa/gen/rulegen.go b/src/cmd/compile/internal/ssa/gen/rulegen.go index 441e08ab5d..4f689199a0 100644 --- a/src/cmd/compile/internal/ssa/gen/rulegen.go +++ b/src/cmd/compile/internal/ssa/gen/rulegen.go @@ -57,6 +57,7 @@ func genRules(arch arch) { // read rule file scanner := bufio.NewScanner(text) + rule := "" for scanner.Scan() { line := scanner.Text() if i := strings.Index(line, "//"); i >= 0 { @@ -64,16 +65,27 @@ func genRules(arch arch) { // it will truncate lines with // inside strings. Oh well. line = line[:i] } - line = strings.TrimSpace(line) - if line == "" { + rule += " " + line + rule = strings.TrimSpace(rule) + if rule == "" { continue } - op := strings.Split(line, " ")[0][1:] + if !strings.Contains(rule, "->") { + continue + } + if strings.HasSuffix(rule, "->") { + continue + } + if unbalanced(rule) { + continue + } + op := strings.Split(rule, " ")[0][1:] if isBlock(op, arch) { - blockrules[op] = append(blockrules[op], line) + blockrules[op] = append(blockrules[op], rule) } else { - oprules[op] = append(oprules[op], line) + oprules[op] = append(oprules[op], rule) } + rule = "" } if err := scanner.Err(); err != nil { log.Fatalf("scanner failed: %v\n", err) @@ -105,7 +117,7 @@ func genRules(arch arch) { // split at -> s := strings.Split(rule, "->") if len(s) != 2 { - log.Fatalf("no arrow in rule %s", rule) + log.Fatalf("rule must contain exactly one arrow: %s", rule) } lhs := strings.TrimSpace(s[0]) result := strings.TrimSpace(s[1]) @@ -478,3 +490,17 @@ func blockName(name string, arch arch) string { } return "Block" + arch.name + name } + +// 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 +} diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 550f641c14..a18f0c748b 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -53,19 +53,27 @@ const ( OpAMD64SUBQconst OpAMD64MULQ OpAMD64MULQconst + OpAMD64ANDQ + OpAMD64ANDQconst OpAMD64SHLQ OpAMD64SHLQconst + OpAMD64SHRQ + OpAMD64SHRQconst + OpAMD64SARQ + OpAMD64SARQconst OpAMD64NEGQ OpAMD64CMPQ OpAMD64CMPQconst OpAMD64TESTQ OpAMD64TESTB + OpAMD64SBBQcarrymask OpAMD64SETEQ OpAMD64SETNE OpAMD64SETL OpAMD64SETG OpAMD64SETGE OpAMD64SETB + OpAMD64CMOVQCC OpAMD64MOVQconst OpAMD64LEAQ OpAMD64LEAQ2 @@ -204,6 +212,31 @@ var opcodeTable = [...]opInfo{ }, }, }, + { + name: "ANDQ", + reg: regInfo{ + inputs: []regMask{ + 4295032831, + 4295032831, + }, + clobbers: 0, + outputs: []regMask{ + 65519, + }, + }, + }, + { + name: "ANDQconst", + reg: regInfo{ + inputs: []regMask{ + 4295032831, + }, + clobbers: 0, + outputs: []regMask{ + 65519, + }, + }, + }, { name: "SHLQ", reg: regInfo{ @@ -229,6 +262,56 @@ var opcodeTable = [...]opInfo{ }, }, }, + { + name: "SHRQ", + reg: regInfo{ + inputs: []regMask{ + 4295032831, + 2, + }, + clobbers: 0, + outputs: []regMask{ + 65519, + }, + }, + }, + { + name: "SHRQconst", + reg: regInfo{ + inputs: []regMask{ + 4295032831, + }, + clobbers: 0, + outputs: []regMask{ + 65519, + }, + }, + }, + { + name: "SARQ", + reg: regInfo{ + inputs: []regMask{ + 4295032831, + 2, + }, + clobbers: 0, + outputs: []regMask{ + 65519, + }, + }, + }, + { + name: "SARQconst", + reg: regInfo{ + inputs: []regMask{ + 4295032831, + }, + clobbers: 0, + outputs: []regMask{ + 65519, + }, + }, + }, { name: "NEGQ", reg: regInfo{ @@ -292,6 +375,18 @@ var opcodeTable = [...]opInfo{ }, }, }, + { + name: "SBBQcarrymask", + reg: regInfo{ + inputs: []regMask{ + 8589934592, + }, + clobbers: 0, + outputs: []regMask{ + 65519, + }, + }, + }, { name: "SETEQ", reg: regInfo{ @@ -364,6 +459,20 @@ var opcodeTable = [...]opInfo{ }, }, }, + { + name: "CMOVQCC", + reg: regInfo{ + inputs: []regMask{ + 8589934592, + 65519, + 65519, + }, + clobbers: 0, + outputs: []regMask{ + 65519, + }, + }, + }, { name: "MOVQconst", reg: regInfo{ diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 542dad4500..f57cf7f333 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -108,6 +108,81 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endfa1c7cc5ac4716697e891376787f86ce endfa1c7cc5ac4716697e891376787f86ce: ; + case OpAMD64ANDQ: + // match: (ANDQ x (MOVQconst [c])) + // cond: + // result: (ANDQconst [c] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVQconst { + goto endb98096e3bbb90933e39c88bf41c688a9 + } + c := v.Args[1].Aux + v.Op = OpAMD64ANDQconst + v.Aux = nil + v.resetArgs() + v.Aux = c + v.AddArg(x) + return true + } + goto endb98096e3bbb90933e39c88bf41c688a9 + endb98096e3bbb90933e39c88bf41c688a9: + ; + // match: (ANDQ (MOVQconst [c]) x) + // cond: + // result: (ANDQconst [c] x) + { + if v.Args[0].Op != OpAMD64MOVQconst { + goto endd313fd1897a0d2bc79eff70159a81b6b + } + c := v.Args[0].Aux + x := v.Args[1] + v.Op = OpAMD64ANDQconst + v.Aux = nil + v.resetArgs() + v.Aux = c + v.AddArg(x) + return true + } + goto endd313fd1897a0d2bc79eff70159a81b6b + endd313fd1897a0d2bc79eff70159a81b6b: + ; + case OpAMD64ANDQconst: + // match: (ANDQconst [c] _) + // cond: c.(int64) == 0 + // result: (MOVQconst [int64(0)]) + { + c := v.Aux + if !(c.(int64) == 0) { + goto end383ada81cd8ffa88918387cd221acf5c + } + v.Op = OpAMD64MOVQconst + v.Aux = nil + v.resetArgs() + v.Aux = int64(0) + return true + } + goto end383ada81cd8ffa88918387cd221acf5c + end383ada81cd8ffa88918387cd221acf5c: + ; + // match: (ANDQconst [c] x) + // cond: c.(int64) == -1 + // result: (Copy x) + { + c := v.Aux + x := v.Args[0] + if !(c.(int64) == -1) { + goto end90aef368f20963a6ba27b3e9317ccf03 + } + v.Op = OpCopy + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end90aef368f20963a6ba27b3e9317ccf03 + end90aef368f20963a6ba27b3e9317ccf03: + ; case OpAdd: // match: (Add x y) // cond: (is64BitInt(t) || isPtr(t)) @@ -149,6 +224,57 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end35a02a1587264e40cf1055856ff8445a end35a02a1587264e40cf1055856ff8445a: ; + case OpAMD64CMOVQCC: + // match: (CMOVQCC (CMPQconst [c] (MOVQconst [d])) _ x) + // cond: inBounds(d.(int64), c.(int64)) + // result: (Copy x) + { + if v.Args[0].Op != OpAMD64CMPQconst { + goto endb8f4f98b06c41e559bf0323e798c147a + } + c := v.Args[0].Aux + if v.Args[0].Args[0].Op != OpAMD64MOVQconst { + goto endb8f4f98b06c41e559bf0323e798c147a + } + d := v.Args[0].Args[0].Aux + x := v.Args[2] + if !(inBounds(d.(int64), c.(int64))) { + goto endb8f4f98b06c41e559bf0323e798c147a + } + v.Op = OpCopy + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto endb8f4f98b06c41e559bf0323e798c147a + endb8f4f98b06c41e559bf0323e798c147a: + ; + // match: (CMOVQCC (CMPQconst [c] (MOVQconst [d])) x _) + // cond: !inBounds(d.(int64), c.(int64)) + // result: (Copy x) + { + if v.Args[0].Op != OpAMD64CMPQconst { + goto end29407b5c4731ac24b4c25600752cb895 + } + c := v.Args[0].Aux + if v.Args[0].Args[0].Op != OpAMD64MOVQconst { + goto end29407b5c4731ac24b4c25600752cb895 + } + d := v.Args[0].Args[0].Aux + x := v.Args[1] + if !(!inBounds(d.(int64), c.(int64))) { + goto end29407b5c4731ac24b4c25600752cb895 + } + v.Op = OpCopy + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end29407b5c4731ac24b4c25600752cb895 + end29407b5c4731ac24b4c25600752cb895: + ; case OpAMD64CMPQ: // match: (CMPQ x (MOVQconst [c])) // cond: @@ -352,23 +478,34 @@ func rewriteValueAMD64(v *Value, config *Config) bool { case OpLsh: // match: (Lsh x y) // cond: is64BitInt(t) - // result: (SHLQ x y) + // result: (ANDQ (SHLQ x y) (SBBQcarrymask (CMPQconst [int64(64)] y))) { t := v.Type x := v.Args[0] y := v.Args[1] if !(is64BitInt(t)) { - goto end9f05c9539e51db6ad557989e0c822e9b + goto end7002b6d4becf7d1247e3756641ccb0c2 } - v.Op = OpAMD64SHLQ + v.Op = OpAMD64ANDQ v.Aux = nil v.resetArgs() - v.AddArg(x) - v.AddArg(y) + v0 := v.Block.NewValue(v.Line, OpAMD64SHLQ, TypeInvalid, nil) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := v.Block.NewValue(v.Line, OpAMD64SBBQcarrymask, TypeInvalid, nil) + v1.Type = t + v2 := v.Block.NewValue(v.Line, OpAMD64CMPQconst, TypeInvalid, nil) + v2.Type = TypeFlags + v2.Aux = int64(64) + v2.AddArg(y) + v1.AddArg(v2) + v.AddArg(v1) return true } - goto end9f05c9539e51db6ad557989e0c822e9b - end9f05c9539e51db6ad557989e0c822e9b: + goto end7002b6d4becf7d1247e3756641ccb0c2 + end7002b6d4becf7d1247e3756641ccb0c2: ; case OpAMD64MOVQload: // match: (MOVQload [off1] (ADDQconst [off2] ptr) mem) @@ -663,6 +800,140 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end0429f947ee7ac49ff45a243e461a5290 end0429f947ee7ac49ff45a243e461a5290: ; + case OpRsh: + // match: (Rsh x y) + // cond: is64BitInt(t) && !t.IsSigned() + // result: (ANDQ (SHRQ x y) (SBBQcarrymask (CMPQconst [int64(64)] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + if !(is64BitInt(t) && !t.IsSigned()) { + goto end9463ddaa21c75f8e15cb9f31472a2e23 + } + v.Op = OpAMD64ANDQ + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue(v.Line, OpAMD64SHRQ, TypeInvalid, nil) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := v.Block.NewValue(v.Line, OpAMD64SBBQcarrymask, TypeInvalid, nil) + v1.Type = t + v2 := v.Block.NewValue(v.Line, OpAMD64CMPQconst, TypeInvalid, nil) + v2.Type = TypeFlags + v2.Aux = int64(64) + v2.AddArg(y) + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto end9463ddaa21c75f8e15cb9f31472a2e23 + end9463ddaa21c75f8e15cb9f31472a2e23: + ; + // match: (Rsh x y) + // cond: is64BitInt(t) && t.IsSigned() + // result: (SARQ x (CMOVQCC (CMPQconst [int64(64)] y) (Const [int64(63)]) y)) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + if !(is64BitInt(t) && t.IsSigned()) { + goto endd297b9e569ac90bf815bd4c425d3b770 + } + v.Op = OpAMD64SARQ + v.Aux = nil + v.resetArgs() + v.Type = t + v.AddArg(x) + v0 := v.Block.NewValue(v.Line, OpAMD64CMOVQCC, TypeInvalid, nil) + v0.Type = t + v1 := v.Block.NewValue(v.Line, OpAMD64CMPQconst, TypeInvalid, nil) + v1.Type = TypeFlags + v1.Aux = int64(64) + v1.AddArg(y) + v0.AddArg(v1) + v2 := v.Block.NewValue(v.Line, OpConst, TypeInvalid, nil) + v2.Type = t + v2.Aux = int64(63) + v0.AddArg(v2) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto endd297b9e569ac90bf815bd4c425d3b770 + endd297b9e569ac90bf815bd4c425d3b770: + ; + case OpAMD64SARQ: + // match: (SARQ x (MOVQconst [c])) + // cond: + // result: (SARQconst [c] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVQconst { + goto end031712b4008075e25a5827dcb8dd3ebb + } + c := v.Args[1].Aux + v.Op = OpAMD64SARQconst + v.Aux = nil + v.resetArgs() + v.Aux = c + v.AddArg(x) + return true + } + goto end031712b4008075e25a5827dcb8dd3ebb + end031712b4008075e25a5827dcb8dd3ebb: + ; + case OpAMD64SBBQcarrymask: + // match: (SBBQcarrymask (CMPQconst [c] (MOVQconst [d]))) + // cond: inBounds(d.(int64), c.(int64)) + // result: (Const [int64(-1)]) + { + if v.Args[0].Op != OpAMD64CMPQconst { + goto end35e369f67ebb9423a1d36a808a16777c + } + c := v.Args[0].Aux + if v.Args[0].Args[0].Op != OpAMD64MOVQconst { + goto end35e369f67ebb9423a1d36a808a16777c + } + d := v.Args[0].Args[0].Aux + if !(inBounds(d.(int64), c.(int64))) { + goto end35e369f67ebb9423a1d36a808a16777c + } + v.Op = OpConst + v.Aux = nil + v.resetArgs() + v.Aux = int64(-1) + return true + } + goto end35e369f67ebb9423a1d36a808a16777c + end35e369f67ebb9423a1d36a808a16777c: + ; + // match: (SBBQcarrymask (CMPQconst [c] (MOVQconst [d]))) + // cond: !inBounds(d.(int64), c.(int64)) + // result: (Const [int64(0)]) + { + if v.Args[0].Op != OpAMD64CMPQconst { + goto end5c767fada028c1cc96210af2cf098aff + } + c := v.Args[0].Aux + if v.Args[0].Args[0].Op != OpAMD64MOVQconst { + goto end5c767fada028c1cc96210af2cf098aff + } + d := v.Args[0].Args[0].Aux + if !(!inBounds(d.(int64), c.(int64))) { + goto end5c767fada028c1cc96210af2cf098aff + } + v.Op = OpConst + v.Aux = nil + v.resetArgs() + v.Aux = int64(0) + return true + } + goto end5c767fada028c1cc96210af2cf098aff + end5c767fada028c1cc96210af2cf098aff: + ; case OpAMD64SETG: // match: (SETG (InvertFlags x)) // cond: @@ -719,6 +990,26 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endcca412bead06dc3d56ef034a82d184d6 endcca412bead06dc3d56ef034a82d184d6: ; + case OpAMD64SHRQ: + // match: (SHRQ x (MOVQconst [c])) + // cond: + // result: (SHRQconst [c] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVQconst { + goto endbb0d3a04dd2b810cb3dbdf7ef665f22b + } + c := v.Args[1].Aux + v.Op = OpAMD64SHRQconst + v.Aux = nil + v.resetArgs() + v.Aux = c + v.AddArg(x) + return true + } + goto endbb0d3a04dd2b810cb3dbdf7ef665f22b + endbb0d3a04dd2b810cb3dbdf7ef665f22b: + ; case OpAMD64SUBQ: // match: (SUBQ x (MOVQconst [c])) // cond: 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 0000000000..bba4f782dc --- /dev/null +++ b/src/cmd/compile/internal/ssa/shift_test.go @@ -0,0 +1,42 @@ +// 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 := NewConfig("amd64", DummyFrontend{}) + fun := makeConstShiftFunc(c, 18, OpLsh, TypeUInt64) + checkOpcodeCounts(t, fun.f, map[Op]int{OpAMD64SHLQconst: 1, OpAMD64CMPQconst: 0, OpAMD64ANDQconst: 0}) + fun = makeConstShiftFunc(c, 66, OpLsh, TypeUInt64) + checkOpcodeCounts(t, fun.f, map[Op]int{OpAMD64SHLQconst: 0, OpAMD64CMPQconst: 0, OpAMD64ANDQconst: 0}) + fun = makeConstShiftFunc(c, 18, OpRsh, TypeUInt64) + checkOpcodeCounts(t, fun.f, map[Op]int{OpAMD64SHRQconst: 1, OpAMD64CMPQconst: 0, OpAMD64ANDQconst: 0}) + fun = makeConstShiftFunc(c, 66, OpRsh, TypeUInt64) + checkOpcodeCounts(t, fun.f, map[Op]int{OpAMD64SHRQconst: 0, OpAMD64CMPQconst: 0, OpAMD64ANDQconst: 0}) + fun = makeConstShiftFunc(c, 18, OpRsh, TypeInt64) + checkOpcodeCounts(t, fun.f, map[Op]int{OpAMD64SARQconst: 1, OpAMD64CMPQconst: 0}) + fun = makeConstShiftFunc(c, 66, OpRsh, TypeInt64) + checkOpcodeCounts(t, fun.f, map[Op]int{OpAMD64SARQconst: 1, OpAMD64CMPQconst: 0}) +} + +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", OpArg, TypeMem, ".mem"), + Valu("FP", OpFP, TypeUInt64, nil), + Valu("argptr", OpOffPtr, ptyp, int64(8), "FP"), + Valu("resptr", OpOffPtr, ptyp, int64(16), "FP"), + Valu("load", OpLoad, typ, nil, "argptr", "mem"), + Valu("c", OpConst, TypeUInt64, amount), + Valu("shift", op, typ, nil, "load", "c"), + Valu("store", OpStore, TypeMem, nil, "resptr", "shift", "mem"), + Exit("store"))) + Compile(fun.f) + return fun +} diff --git a/src/cmd/compile/internal/ssa/stackalloc.go b/src/cmd/compile/internal/ssa/stackalloc.go index a4ce343b5d..d47c8c7b02 100644 --- a/src/cmd/compile/internal/ssa/stackalloc.go +++ b/src/cmd/compile/internal/ssa/stackalloc.go @@ -33,10 +33,9 @@ func stackalloc(f *Func) { if v.Type.IsMemory() { // TODO: only "regallocable" types continue } - n += v.Type.Size() - // a := v.Type.Align() - // n = (n + a - 1) / a * a TODO + n = align(n, v.Type.Alignment()) loc := &LocalSlot{n} + n += v.Type.Size() home = setloc(home, v, loc) for _, w := range v.Args { home = setloc(home, w, loc) @@ -60,15 +59,14 @@ func stackalloc(f *Func) { if len(v.Args) == 1 && (v.Args[0].Op == OpFP || v.Args[0].Op == OpSP || v.Args[0].Op == OpGlobal) { continue } - // a := v.Type.Align() - // n = (n + a - 1) / a * a TODO - n += v.Type.Size() + n = align(n, v.Type.Alignment()) loc := &LocalSlot{n} + n += v.Type.Size() home = setloc(home, v, loc) } } - // TODO: align n + n = align(n, f.Config.ptrSize) n += f.Config.ptrSize // space for return address. TODO: arch-dependent f.RegAlloc = home f.FrameSize = n @@ -114,3 +112,8 @@ func stackalloc(f *Func) { home[fp.ID] = ®isters[4] // TODO: arch-dependent } } + +// align increases n to the next multiple of a. a must be a power of 2. +func align(n int64, a int64) int64 { + return (n + a - 1) &^ (a - 1) +} diff --git a/src/cmd/compile/internal/ssa/type.go b/src/cmd/compile/internal/ssa/type.go index 1a61c75afa..e271131a40 100644 --- a/src/cmd/compile/internal/ssa/type.go +++ b/src/cmd/compile/internal/ssa/type.go @@ -10,6 +10,7 @@ package ssa // 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 @@ -30,6 +31,7 @@ type Type interface { // Stub implementation for now, until we are completely using ../gc:Type type TypeImpl struct { Size_ int64 + Align int64 Boolean bool Integer bool Signed bool @@ -43,32 +45,33 @@ type TypeImpl struct { Name string } -func (t *TypeImpl) Size() int64 { return t.Size_ } -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) IsPtr() bool { return t.Ptr } -func (t *TypeImpl) IsString() bool { return t.string } -func (t *TypeImpl) IsMemory() bool { return t.Memory } -func (t *TypeImpl) IsFlags() bool { return t.Flags } -func (t *TypeImpl) String() string { return t.Name } -func (t *TypeImpl) Elem() Type { panic("not implemented"); return nil } -func (t *TypeImpl) PtrTo() Type { panic("not implemented"); return nil } +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) IsPtr() bool { return t.Ptr } +func (t *TypeImpl) IsString() bool { return t.string } +func (t *TypeImpl) IsMemory() bool { return t.Memory } +func (t *TypeImpl) IsFlags() bool { return t.Flags } +func (t *TypeImpl) String() string { return t.Name } +func (t *TypeImpl) Elem() Type { panic("not implemented"); return nil } +func (t *TypeImpl) PtrTo() Type { panic("not implemented"); return nil } var ( // shortcuts for commonly used basic types - TypeInt8 = &TypeImpl{Size_: 1, Integer: true, Signed: true, Name: "int8"} - TypeInt16 = &TypeImpl{Size_: 2, Integer: true, Signed: true, Name: "int16"} - TypeInt32 = &TypeImpl{Size_: 4, Integer: true, Signed: true, Name: "int32"} - TypeInt64 = &TypeImpl{Size_: 8, Integer: true, Signed: true, Name: "int64"} - TypeUInt8 = &TypeImpl{Size_: 1, Integer: true, Name: "uint8"} - TypeUInt16 = &TypeImpl{Size_: 2, Integer: true, Name: "uint16"} - TypeUInt32 = &TypeImpl{Size_: 4, Integer: true, Name: "uint32"} - TypeUInt64 = &TypeImpl{Size_: 8, Integer: true, Name: "uint64"} - TypeBool = &TypeImpl{Size_: 1, Boolean: true, Name: "bool"} + 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"} + 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"} //TypeString = types.Typ[types.String] - TypeBytePtr = &TypeImpl{Size_: 8, Ptr: true, Name: "*byte"} + TypeBytePtr = &TypeImpl{Size_: 8, Align: 8, Ptr: true, Name: "*byte"} TypeInvalid = &TypeImpl{Name: "invalid"} -- cgit v1.3 From ba8a146af443205876b087a8adb499aa7d4dd455 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Thu, 11 Jun 2015 15:52:08 -0700 Subject: [dev.ssa] cmd/compile/ssa: print reg names in generated code Change-Id: I6c6196449dd3d5e036d420fa7ae90feb0cf8d417 Reviewed-on: https://go-review.googlesource.com/10928 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 2 +- src/cmd/compile/internal/ssa/gen/genericOps.go | 2 +- src/cmd/compile/internal/ssa/gen/main.go | 28 +++- src/cmd/compile/internal/ssa/opGen.go | 214 ++++++++++++------------- 4 files changed, 131 insertions(+), 115 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 8bb22d270d..bcb07392c7 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -175,5 +175,5 @@ func init() { {name: "UGE"}, } - archs = append(archs, arch{"AMD64", AMD64ops, AMD64blocks}) + archs = append(archs, arch{"AMD64", AMD64ops, AMD64blocks, regNamesAMD64}) } diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index e415f3d16b..4a691929b5 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -100,5 +100,5 @@ var genericBlocks = []blockData{ } func init() { - archs = append(archs, arch{"generic", genericOps, genericBlocks}) + 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 index 56b47bd99e..33b8be51d2 100644 --- a/src/cmd/compile/internal/ssa/gen/main.go +++ b/src/cmd/compile/internal/ssa/gen/main.go @@ -16,9 +16,10 @@ import ( ) type arch struct { - name string - ops []opData - blocks []blockData + name string + ops []opData + blocks []blockData + regnames []string } type opData struct { @@ -38,6 +39,21 @@ type regInfo struct { 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() { @@ -95,13 +111,13 @@ func genOp() { fmt.Fprintln(w, "reg:regInfo{") fmt.Fprintln(w, "inputs: []regMask{") for _, r := range v.reg.inputs { - fmt.Fprintf(w, "%d,\n", r) + fmt.Fprintf(w, "%d,%s\n", r, a.regMaskComment(r)) } fmt.Fprintln(w, "},") - fmt.Fprintf(w, "clobbers: %d,\n", v.reg.clobbers) + fmt.Fprintf(w, "clobbers: %d,%s\n", v.reg.clobbers, a.regMaskComment(v.reg.clobbers)) fmt.Fprintln(w, "outputs: []regMask{") for _, r := range v.reg.outputs { - fmt.Fprintf(w, "%d,\n", r) + fmt.Fprintf(w, "%d,%s\n", r, a.regMaskComment(r)) } fmt.Fprintln(w, "},") fmt.Fprintln(w, "},") diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index a18f0c748b..1115032c98 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -141,12 +141,12 @@ var opcodeTable = [...]opInfo{ name: "ADDQ", reg: regInfo{ inputs: []regMask{ - 4295032831, - 4295032831, + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP }, clobbers: 0, outputs: []regMask{ - 65519, + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, @@ -154,11 +154,11 @@ var opcodeTable = [...]opInfo{ name: "ADDQconst", reg: regInfo{ inputs: []regMask{ - 4295032831, + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP }, clobbers: 0, outputs: []regMask{ - 65519, + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, @@ -166,12 +166,12 @@ var opcodeTable = [...]opInfo{ name: "SUBQ", reg: regInfo{ inputs: []regMask{ - 4295032831, - 4295032831, + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP }, clobbers: 0, outputs: []regMask{ - 65519, + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, @@ -179,11 +179,11 @@ var opcodeTable = [...]opInfo{ name: "SUBQconst", reg: regInfo{ inputs: []regMask{ - 4295032831, + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP }, clobbers: 0, outputs: []regMask{ - 65519, + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, @@ -191,12 +191,12 @@ var opcodeTable = [...]opInfo{ name: "MULQ", reg: regInfo{ inputs: []regMask{ - 4295032831, - 4295032831, + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP }, clobbers: 0, outputs: []regMask{ - 65519, + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, @@ -204,11 +204,11 @@ var opcodeTable = [...]opInfo{ name: "MULQconst", reg: regInfo{ inputs: []regMask{ - 4295032831, + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP }, clobbers: 0, outputs: []regMask{ - 65519, + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, @@ -216,12 +216,12 @@ var opcodeTable = [...]opInfo{ name: "ANDQ", reg: regInfo{ inputs: []regMask{ - 4295032831, - 4295032831, + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP }, clobbers: 0, outputs: []regMask{ - 65519, + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, @@ -229,11 +229,11 @@ var opcodeTable = [...]opInfo{ name: "ANDQconst", reg: regInfo{ inputs: []regMask{ - 4295032831, + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP }, clobbers: 0, outputs: []regMask{ - 65519, + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, @@ -241,12 +241,12 @@ var opcodeTable = [...]opInfo{ name: "SHLQ", reg: regInfo{ inputs: []regMask{ - 4295032831, - 2, + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 2, // .CX }, clobbers: 0, outputs: []regMask{ - 65519, + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, @@ -254,11 +254,11 @@ var opcodeTable = [...]opInfo{ name: "SHLQconst", reg: regInfo{ inputs: []regMask{ - 4295032831, + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP }, clobbers: 0, outputs: []regMask{ - 65519, + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, @@ -266,12 +266,12 @@ var opcodeTable = [...]opInfo{ name: "SHRQ", reg: regInfo{ inputs: []regMask{ - 4295032831, - 2, + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 2, // .CX }, clobbers: 0, outputs: []regMask{ - 65519, + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, @@ -279,11 +279,11 @@ var opcodeTable = [...]opInfo{ name: "SHRQconst", reg: regInfo{ inputs: []regMask{ - 4295032831, + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP }, clobbers: 0, outputs: []regMask{ - 65519, + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, @@ -291,12 +291,12 @@ var opcodeTable = [...]opInfo{ name: "SARQ", reg: regInfo{ inputs: []regMask{ - 4295032831, - 2, + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 2, // .CX }, clobbers: 0, outputs: []regMask{ - 65519, + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, @@ -304,11 +304,11 @@ var opcodeTable = [...]opInfo{ name: "SARQconst", reg: regInfo{ inputs: []regMask{ - 4295032831, + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP }, clobbers: 0, outputs: []regMask{ - 65519, + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, @@ -316,11 +316,11 @@ var opcodeTable = [...]opInfo{ name: "NEGQ", reg: regInfo{ inputs: []regMask{ - 4295032831, + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP }, clobbers: 0, outputs: []regMask{ - 65519, + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, @@ -328,12 +328,12 @@ var opcodeTable = [...]opInfo{ name: "CMPQ", reg: regInfo{ inputs: []regMask{ - 4295032831, - 4295032831, + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP }, clobbers: 0, outputs: []regMask{ - 8589934592, + 8589934592, // .FLAGS }, }, }, @@ -341,11 +341,11 @@ var opcodeTable = [...]opInfo{ name: "CMPQconst", reg: regInfo{ inputs: []regMask{ - 4295032831, + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP }, clobbers: 0, outputs: []regMask{ - 8589934592, + 8589934592, // .FLAGS }, }, }, @@ -353,12 +353,12 @@ var opcodeTable = [...]opInfo{ name: "TESTQ", reg: regInfo{ inputs: []regMask{ - 4295032831, - 4295032831, + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP }, clobbers: 0, outputs: []regMask{ - 8589934592, + 8589934592, // .FLAGS }, }, }, @@ -366,12 +366,12 @@ var opcodeTable = [...]opInfo{ name: "TESTB", reg: regInfo{ inputs: []regMask{ - 4295032831, - 4295032831, + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP }, clobbers: 0, outputs: []regMask{ - 8589934592, + 8589934592, // .FLAGS }, }, }, @@ -379,11 +379,11 @@ var opcodeTable = [...]opInfo{ name: "SBBQcarrymask", reg: regInfo{ inputs: []regMask{ - 8589934592, + 8589934592, // .FLAGS }, clobbers: 0, outputs: []regMask{ - 65519, + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, @@ -391,11 +391,11 @@ var opcodeTable = [...]opInfo{ name: "SETEQ", reg: regInfo{ inputs: []regMask{ - 8589934592, + 8589934592, // .FLAGS }, clobbers: 0, outputs: []regMask{ - 65519, + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, @@ -403,11 +403,11 @@ var opcodeTable = [...]opInfo{ name: "SETNE", reg: regInfo{ inputs: []regMask{ - 8589934592, + 8589934592, // .FLAGS }, clobbers: 0, outputs: []regMask{ - 65519, + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, @@ -415,11 +415,11 @@ var opcodeTable = [...]opInfo{ name: "SETL", reg: regInfo{ inputs: []regMask{ - 8589934592, + 8589934592, // .FLAGS }, clobbers: 0, outputs: []regMask{ - 65519, + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, @@ -427,11 +427,11 @@ var opcodeTable = [...]opInfo{ name: "SETG", reg: regInfo{ inputs: []regMask{ - 8589934592, + 8589934592, // .FLAGS }, clobbers: 0, outputs: []regMask{ - 65519, + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, @@ -439,11 +439,11 @@ var opcodeTable = [...]opInfo{ name: "SETGE", reg: regInfo{ inputs: []regMask{ - 8589934592, + 8589934592, // .FLAGS }, clobbers: 0, outputs: []regMask{ - 65519, + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, @@ -451,11 +451,11 @@ var opcodeTable = [...]opInfo{ name: "SETB", reg: regInfo{ inputs: []regMask{ - 8589934592, + 8589934592, // .FLAGS }, clobbers: 0, outputs: []regMask{ - 65519, + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, @@ -463,13 +463,13 @@ var opcodeTable = [...]opInfo{ name: "CMOVQCC", reg: regInfo{ inputs: []regMask{ - 8589934592, - 65519, - 65519, + 8589934592, // .FLAGS + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, clobbers: 0, outputs: []regMask{ - 65519, + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, @@ -479,7 +479,7 @@ var opcodeTable = [...]opInfo{ inputs: []regMask{}, clobbers: 0, outputs: []regMask{ - 65519, + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, @@ -487,12 +487,12 @@ var opcodeTable = [...]opInfo{ name: "LEAQ", reg: regInfo{ inputs: []regMask{ - 4295032831, - 4295032831, + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP }, clobbers: 0, outputs: []regMask{ - 65519, + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, @@ -500,12 +500,12 @@ var opcodeTable = [...]opInfo{ name: "LEAQ2", reg: regInfo{ inputs: []regMask{ - 4295032831, - 4295032831, + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP }, clobbers: 0, outputs: []regMask{ - 65519, + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, @@ -513,12 +513,12 @@ var opcodeTable = [...]opInfo{ name: "LEAQ4", reg: regInfo{ inputs: []regMask{ - 4295032831, - 4295032831, + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP }, clobbers: 0, outputs: []regMask{ - 65519, + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, @@ -526,12 +526,12 @@ var opcodeTable = [...]opInfo{ name: "LEAQ8", reg: regInfo{ inputs: []regMask{ - 4295032831, - 4295032831, + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP }, clobbers: 0, outputs: []regMask{ - 65519, + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, @@ -541,7 +541,7 @@ var opcodeTable = [...]opInfo{ inputs: []regMask{}, clobbers: 0, outputs: []regMask{ - 65519, + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, @@ -549,12 +549,12 @@ var opcodeTable = [...]opInfo{ name: "MOVBload", reg: regInfo{ inputs: []regMask{ - 4295032831, + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP 0, }, clobbers: 0, outputs: []regMask{ - 65519, + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, @@ -562,12 +562,12 @@ var opcodeTable = [...]opInfo{ name: "MOVBQZXload", reg: regInfo{ inputs: []regMask{ - 4295032831, + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP 0, }, clobbers: 0, outputs: []regMask{ - 65519, + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, @@ -575,12 +575,12 @@ var opcodeTable = [...]opInfo{ name: "MOVBQSXload", reg: regInfo{ inputs: []regMask{ - 4295032831, + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP 0, }, clobbers: 0, outputs: []regMask{ - 65519, + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, @@ -588,12 +588,12 @@ var opcodeTable = [...]opInfo{ name: "MOVQload", reg: regInfo{ inputs: []regMask{ - 4295032831, + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP 0, }, clobbers: 0, outputs: []regMask{ - 65519, + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, @@ -601,13 +601,13 @@ var opcodeTable = [...]opInfo{ name: "MOVQloadidx8", reg: regInfo{ inputs: []regMask{ - 4295032831, - 4295032831, + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP 0, }, clobbers: 0, outputs: []regMask{ - 65519, + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, @@ -615,8 +615,8 @@ var opcodeTable = [...]opInfo{ name: "MOVBstore", reg: regInfo{ inputs: []regMask{ - 4295032831, - 4295032831, + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP 0, }, clobbers: 0, @@ -627,8 +627,8 @@ var opcodeTable = [...]opInfo{ name: "MOVQstore", reg: regInfo{ inputs: []regMask{ - 4295032831, - 4295032831, + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP 0, }, clobbers: 0, @@ -639,9 +639,9 @@ var opcodeTable = [...]opInfo{ name: "MOVQstoreidx8", reg: regInfo{ inputs: []regMask{ - 4295032831, - 4295032831, - 4295032831, + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP 0, }, clobbers: 0, @@ -676,8 +676,8 @@ var opcodeTable = [...]opInfo{ name: "CALLclosure", reg: regInfo{ inputs: []regMask{ - 4295032831, - 4, + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 4, // .DX 0, }, clobbers: 0, @@ -688,11 +688,11 @@ var opcodeTable = [...]opInfo{ name: "REPMOVSB", reg: regInfo{ inputs: []regMask{ - 128, - 64, - 2, + 128, // .DI + 64, // .SI + 2, // .CX }, - clobbers: 194, + clobbers: 194, // .CX .SI .DI outputs: []regMask{}, }, }, @@ -700,12 +700,12 @@ var opcodeTable = [...]opInfo{ name: "ADDL", reg: regInfo{ inputs: []regMask{ - 4295032831, - 4295032831, + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP }, clobbers: 0, outputs: []regMask{ - 65519, + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, -- cgit v1.3 From d5ad9ced1c82d4a1cb63d92f33552a064d7e8162 Mon Sep 17 00:00:00 2001 From: Daniel Morsing Date: Thu, 11 Jun 2015 20:37:01 +0100 Subject: [dev.ssa] clarify ODCL todo, remove irrelevant colas todo ODCL nodes are used as the point where the variable is allocated in the old pass. colas is irrelevant at this point of the compile. All the checks on it happen at parse time and an ODCL node will have been inserted right before it. Change-Id: I1aca053aaa4363bacd12e1156de86fa7b6190a55 Reviewed-on: https://go-review.googlesource.com/10901 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index b97764e0cf..131e97ff48 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -206,7 +206,8 @@ func (s *state) stmt(n *Node) { s.stmtList(n.List) case ODCL: - // TODO: ??? Assign 0? + // TODO: old gen pass uses dcl node as the point where + // escaping variables' new functions are called. Do that here case OLABEL, OGOTO: // get block at label, or make one @@ -225,7 +226,6 @@ func (s *state) stmt(n *Node) { } case OAS, OASWB: - // TODO(khr): colas? // TODO: do write barrier var val *ssa.Value if n.Right == nil { -- cgit v1.3 From 0ad9c8c720324b6c4e483ac7fe0e20f36274e2eb Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Fri, 12 Jun 2015 16:24:33 -0700 Subject: [dev.ssa] cmd/compile/internal/gc: Small fixes Allow labels to be unreachable via fallthrough from above. Implement OCONVNOP. Change-Id: I6869993cad8a27ad134dd637de89a40117daf47b Reviewed-on: https://go-review.googlesource.com/11001 Reviewed-by: Daniel Morsing --- src/cmd/compile/internal/gc/ssa.go | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 131e97ff48..ebb7f44a18 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -217,8 +217,9 @@ func (s *state) stmt(n *Node) { s.labels[n.Left.Sym.Name] = t } // go to that label (we pretend "label:" is preceded by "goto label") - b := s.endBlock() - addEdge(b, t) + if b := s.endBlock(); b != nil { + addEdge(b, t) + } if n.Op == OLABEL { // next we work on the label's target block @@ -358,6 +359,9 @@ func (s *state) expr(n *Node) *ssa.Value { log.Fatalf("unhandled OLITERAL %v", n.Val().Ctype()) return nil } + case OCONVNOP: + x := s.expr(n.Left) + return s.newValue1(ssa.OpConvNop, n.Type, nil, x) // binary ops case OLT: -- cgit v1.3 From 8f22b5292ffc01ea66bd92fa833d0ec25390173b Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Thu, 11 Jun 2015 21:29:25 -0700 Subject: [dev.ssa] cmd/compiler/internal/ssa: Add auxint field Add an additional int64 auxiliary field to Value. There are two main reasons for doing this: 1) Ints in interfaces require allocation, and we store ints in Aux a lot. 2) I'd like to have both *gc.Sym and int offsets included in lots of operations (e.g. MOVQloadidx8). It will be more efficient to store them as separate fields instead of a pointer to a sym/int pair. It also simplifies a bunch of code. This is just the refactoring. I'll start using this some more in a subsequent changelist. Change-Id: I1ca797ff572553986cf90cab3ac0a0c1d01ad241 Reviewed-on: https://go-review.googlesource.com/10929 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/gc/ssa.go | 163 +++++---- src/cmd/compile/internal/ssa/deadcode_test.go | 12 +- src/cmd/compile/internal/ssa/deadstore_test.go | 36 +- src/cmd/compile/internal/ssa/func.go | 115 +++++- src/cmd/compile/internal/ssa/func_test.go | 116 +++--- src/cmd/compile/internal/ssa/gen/AMD64.rules | 40 +-- src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 42 +-- src/cmd/compile/internal/ssa/gen/generic.rules | 21 +- src/cmd/compile/internal/ssa/gen/genericOps.go | 8 +- src/cmd/compile/internal/ssa/gen/rulegen.go | 60 ++-- src/cmd/compile/internal/ssa/generic.go | 424 ---------------------- src/cmd/compile/internal/ssa/op.go | 25 -- src/cmd/compile/internal/ssa/regalloc.go | 16 +- src/cmd/compile/internal/ssa/rewrite.go | 7 +- src/cmd/compile/internal/ssa/rewriteAMD64.go | 465 ++++++++++++++----------- src/cmd/compile/internal/ssa/rewritegeneric.go | 162 +++++---- src/cmd/compile/internal/ssa/schedule_test.go | 18 +- src/cmd/compile/internal/ssa/shift_test.go | 16 +- src/cmd/compile/internal/ssa/stackalloc.go | 4 +- src/cmd/compile/internal/ssa/value.go | 9 +- 20 files changed, 756 insertions(+), 1003 deletions(-) delete mode 100644 src/cmd/compile/internal/ssa/generic.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index ebb7f44a18..3110fad270 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -38,9 +38,9 @@ func buildssa(fn *Node) *ssa.Func { s.exit = s.f.NewBlock(ssa.BlockExit) // Allocate starting values - s.startmem = s.entryNewValue(ssa.OpArg, ssa.TypeMem, ".mem") - s.fp = s.entryNewValue(ssa.OpFP, s.config.Uintptr, nil) // TODO: use generic pointer type (unsafe.Pointer?) instead - s.sp = s.entryNewValue(ssa.OpSP, s.config.Uintptr, nil) + s.startmem = s.entryNewValue0(ssa.OpArg, ssa.TypeMem) + s.fp = s.entryNewValue0(ssa.OpFP, s.config.Uintptr) // TODO: use generic pointer type (unsafe.Pointer?) instead + s.sp = s.entryNewValue0(ssa.OpSP, s.config.Uintptr) s.vars = map[string]*ssa.Value{} s.labels = map[string]*ssa.Block{} @@ -147,39 +147,59 @@ func (s *state) peekLine() int32 { return s.line[len(s.line)-1] } -// newValue adds a new value with no argueents to the current block. -func (s *state) newValue(op ssa.Op, t ssa.Type, aux interface{}) *ssa.Value { - return s.curBlock.NewValue(s.peekLine(), op, t, aux) +// 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) } // newValue1 adds a new value with one argument to the current block. -func (s *state) newValue1(op ssa.Op, t ssa.Type, aux interface{}, arg *ssa.Value) *ssa.Value { - return s.curBlock.NewValue1(s.peekLine(), op, t, aux, arg) +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) } // newValue2 adds a new value with two arguments to the current block. -func (s *state) newValue2(op ssa.Op, t ssa.Type, aux interface{}, arg0, arg1 *ssa.Value) *ssa.Value { - return s.curBlock.NewValue2(s.peekLine(), op, t, aux, arg0, arg1) +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) } // newValue3 adds a new value with three arguments to the current block. -func (s *state) newValue3(op ssa.Op, t ssa.Type, aux interface{}, arg0, arg1, arg2 *ssa.Value) *ssa.Value { - return s.curBlock.NewValue3(s.peekLine(), op, t, aux, arg0, arg1, arg2) +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) } // entryNewValue adds a new value with no arguments to the entry block. -func (s *state) entryNewValue(op ssa.Op, t ssa.Type, aux interface{}) *ssa.Value { - return s.f.Entry.NewValue(s.peekLine(), op, t, aux) +func (s *state) entryNewValue0(op ssa.Op, t ssa.Type) *ssa.Value { + return s.f.Entry.NewValue0(s.peekLine(), op, t) +} + +// entryNewValue 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) } // entryNewValue1 adds a new value with one argument to the entry block. -func (s *state) entryNewValue1(op ssa.Op, t ssa.Type, aux interface{}, arg *ssa.Value) *ssa.Value { - return s.f.Entry.NewValue1(s.peekLine(), op, t, aux, arg) +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) } // entryNewValue2 adds a new value with two arguments to the entry block. -func (s *state) entryNewValue2(op ssa.Op, t ssa.Type, aux interface{}, arg0, arg1 *ssa.Value) *ssa.Value { - return s.f.Entry.NewValue2(s.peekLine(), op, t, aux, arg0, arg1) +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) } // constInt adds a new const int value to the entry block. @@ -234,11 +254,11 @@ func (s *state) stmt(n *Node) { t := n.Left.Type switch { case t.IsString(): - val = s.entryNewValue(ssa.OpConst, n.Left.Type, "") + val = s.entryNewValue0(ssa.OpConst, n.Left.Type) case t.IsInteger(): - val = s.entryNewValue(ssa.OpConst, n.Left.Type, int64(0)) + val = s.entryNewValue0(ssa.OpConst, n.Left.Type) case t.IsBoolean(): - val = s.entryNewValue(ssa.OpConst, n.Left.Type, false) + val = s.entryNewValue0A(ssa.OpConst, n.Left.Type, false) // TODO: store bools as 0/1 in AuxInt? default: log.Fatalf("zero for type %v not implemented", t) } @@ -252,7 +272,7 @@ func (s *state) stmt(n *Node) { } // not ssa-able. Treat as a store. addr := s.addr(n.Left) - s.vars[".mem"] = s.newValue3(ssa.OpStore, ssa.TypeMem, nil, addr, val, s.mem()) + s.vars[".mem"] = s.newValue3(ssa.OpStore, ssa.TypeMem, addr, val, s.mem()) case OIF: cond := s.expr(n.Left) b := s.endBlock() @@ -341,20 +361,20 @@ func (s *state) expr(n *Node) *ssa.Value { case ONAME: if n.Class == PFUNC { // "value" of a function is the address of the function's closure - return s.entryNewValue(ssa.OpGlobal, Ptrto(n.Type), funcsym(n.Sym)) + return s.entryNewValue0A(ssa.OpGlobal, Ptrto(n.Type), funcsym(n.Sym)) } s.argOffsets[n.Sym.Name] = n.Xoffset // TODO: remember this another way? if canSSA(n) { return s.variable(n.Sym.Name, n.Type) } addr := s.addr(n) - return s.newValue2(ssa.OpLoad, n.Type, nil, addr, s.mem()) + return s.newValue2(ssa.OpLoad, n.Type, addr, s.mem()) case OLITERAL: switch n.Val().Ctype() { case CTINT: return s.constInt(n.Type, Mpgetfix(n.Val().U.(*Mpint))) case CTSTR: - return s.entryNewValue(ssa.OpConst, n.Type, n.Val().U) + return s.entryNewValue0A(ssa.OpConst, n.Type, n.Val().U) default: log.Fatalf("unhandled OLITERAL %v", n.Val().Ctype()) return nil @@ -367,24 +387,24 @@ func (s *state) expr(n *Node) *ssa.Value { case OLT: a := s.expr(n.Left) b := s.expr(n.Right) - return s.newValue2(ssa.OpLess, ssa.TypeBool, nil, a, b) + return s.newValue2(ssa.OpLess, ssa.TypeBool, a, b) case OADD: a := s.expr(n.Left) b := s.expr(n.Right) - return s.newValue2(ssa.OpAdd, a.Type, nil, a, b) + return s.newValue2(ssa.OpAdd, a.Type, a, b) case OSUB: // TODO:(khr) fold code for all binary ops together somehow a := s.expr(n.Left) b := s.expr(n.Right) - return s.newValue2(ssa.OpSub, a.Type, nil, a, b) + return s.newValue2(ssa.OpSub, a.Type, a, b) case OLSH: a := s.expr(n.Left) b := s.expr(n.Right) - return s.newValue2(ssa.OpLsh, a.Type, nil, a, b) + return s.newValue2(ssa.OpLsh, a.Type, a, b) case ORSH: a := s.expr(n.Left) b := s.expr(n.Right) - return s.newValue2(ssa.OpRsh, a.Type, nil, a, b) + return s.newValue2(ssa.OpRsh, a.Type, a, b) case OADDR: return s.addr(n.Left) @@ -392,13 +412,13 @@ func (s *state) expr(n *Node) *ssa.Value { case OIND: p := s.expr(n.Left) s.nilCheck(p) - return s.newValue2(ssa.OpLoad, n.Type, nil, p, s.mem()) + return s.newValue2(ssa.OpLoad, n.Type, p, s.mem()) case ODOTPTR: p := s.expr(n.Left) s.nilCheck(p) - p = s.newValue2(ssa.OpAdd, p.Type, nil, p, s.constInt(s.config.Uintptr, n.Xoffset)) - return s.newValue2(ssa.OpLoad, n.Type, nil, p, s.mem()) + p = s.newValue2(ssa.OpAdd, p.Type, p, s.constInt(s.config.Uintptr, n.Xoffset)) + return s.newValue2(ssa.OpLoad, n.Type, p, s.mem()) case OINDEX: if n.Left.Type.Bound >= 0 { // array or string @@ -407,17 +427,17 @@ func (s *state) expr(n *Node) *ssa.Value { var elemtype *Type var len *ssa.Value if n.Left.Type.IsString() { - len = s.newValue1(ssa.OpStringLen, s.config.Uintptr, nil, a) + len = s.newValue1(ssa.OpStringLen, s.config.Uintptr, a) elemtype = Types[TUINT8] } else { len = s.constInt(s.config.Uintptr, n.Left.Type.Bound) elemtype = n.Left.Type.Type } s.boundsCheck(i, len) - return s.newValue2(ssa.OpArrayIndex, elemtype, nil, a, i) + return s.newValue2(ssa.OpArrayIndex, elemtype, a, i) } else { // slice p := s.addr(n) - return s.newValue2(ssa.OpLoad, n.Left.Type.Type, nil, p, s.mem()) + return s.newValue2(ssa.OpLoad, n.Left.Type.Type, p, s.mem()) } case OCALLFUNC: @@ -435,10 +455,10 @@ func (s *state) expr(n *Node) *ssa.Value { bNext := s.f.NewBlock(ssa.BlockPlain) var call *ssa.Value if static { - call = s.newValue1(ssa.OpStaticCall, ssa.TypeMem, n.Left.Sym, s.mem()) + call = s.newValue1A(ssa.OpStaticCall, ssa.TypeMem, n.Left.Sym, s.mem()) } else { - entry := s.newValue2(ssa.OpLoad, s.config.Uintptr, nil, closure, s.mem()) - call = s.newValue3(ssa.OpClosureCall, ssa.TypeMem, nil, entry, closure, s.mem()) + entry := s.newValue2(ssa.OpLoad, s.config.Uintptr, closure, s.mem()) + call = s.newValue3(ssa.OpClosureCall, ssa.TypeMem, entry, closure, s.mem()) } b := s.endBlock() b.Kind = ssa.BlockCall @@ -450,8 +470,8 @@ func (s *state) expr(n *Node) *ssa.Value { s.startBlock(bNext) var titer Iter fp := Structfirst(&titer, Getoutarg(n.Left.Type)) - a := s.entryNewValue1(ssa.OpOffPtr, Ptrto(fp.Type), fp.Width, s.sp) - return s.newValue2(ssa.OpLoad, fp.Type, nil, a, call) + a := s.entryNewValue1I(ssa.OpOffPtr, Ptrto(fp.Type), fp.Width, s.sp) + return s.newValue2(ssa.OpLoad, fp.Type, a, call) default: log.Fatalf("unhandled expr %s", opnames[n.Op]) return nil @@ -465,10 +485,10 @@ func (s *state) addr(n *Node) *ssa.Value { switch n.Class { case PEXTERN: // global variable - return s.entryNewValue(ssa.OpGlobal, Ptrto(n.Type), n.Sym) + return s.entryNewValue0A(ssa.OpGlobal, Ptrto(n.Type), n.Sym) case PPARAMOUT: // store to parameter slot - return s.entryNewValue1(ssa.OpOffPtr, Ptrto(n.Type), n.Xoffset, s.fp) + return s.entryNewValue1I(ssa.OpOffPtr, Ptrto(n.Type), n.Xoffset, s.fp) default: // TODO: address of locals log.Fatalf("variable address of %v not implemented", n) @@ -477,21 +497,21 @@ func (s *state) addr(n *Node) *ssa.Value { case OINDREG: // indirect off a register (TODO: always SP?) // used for storing/loading arguments/returns to/from callees - return s.entryNewValue1(ssa.OpOffPtr, Ptrto(n.Type), n.Xoffset, s.sp) + return s.entryNewValue1I(ssa.OpOffPtr, Ptrto(n.Type), n.Xoffset, s.sp) case OINDEX: if n.Left.Type.Bound >= 0 { // array a := s.addr(n.Left) i := s.expr(n.Right) len := s.constInt(s.config.Uintptr, n.Left.Type.Bound) s.boundsCheck(i, len) - return s.newValue2(ssa.OpPtrIndex, Ptrto(n.Left.Type.Type), nil, a, i) + return s.newValue2(ssa.OpPtrIndex, Ptrto(n.Left.Type.Type), a, i) } else { // slice a := s.expr(n.Left) i := s.expr(n.Right) - len := s.newValue1(ssa.OpSliceLen, s.config.Uintptr, nil, a) + len := s.newValue1(ssa.OpSliceLen, s.config.Uintptr, a) s.boundsCheck(i, len) - p := s.newValue1(ssa.OpSlicePtr, Ptrto(n.Left.Type.Type), nil, a) - return s.newValue2(ssa.OpPtrIndex, Ptrto(n.Left.Type.Type), nil, p, i) + p := s.newValue1(ssa.OpSlicePtr, Ptrto(n.Left.Type.Type), a) + return s.newValue2(ssa.OpPtrIndex, Ptrto(n.Left.Type.Type), p, i) } default: log.Fatalf("addr: bad op %v", Oconv(int(n.Op), 0)) @@ -524,7 +544,7 @@ func canSSA(n *Node) bool { // nilCheck generates nil pointer checking code. // Starts a new block on return. func (s *state) nilCheck(ptr *ssa.Value) { - c := s.newValue1(ssa.OpIsNonNil, ssa.TypeBool, nil, ptr) + c := s.newValue1(ssa.OpIsNonNil, ssa.TypeBool, ptr) b := s.endBlock() b.Kind = ssa.BlockIf b.Control = c @@ -543,7 +563,7 @@ func (s *state) boundsCheck(idx, len *ssa.Value) { // 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, ssa.TypeBool, nil, idx, len) + cmp := s.newValue2(ssa.OpIsInBounds, ssa.TypeBool, idx, len) b := s.endBlock() b.Kind = ssa.BlockIf b.Control = cmp @@ -562,7 +582,7 @@ func (s *state) variable(name string, t ssa.Type) *ssa.Value { v := s.vars[name] if v == nil { // TODO: get type? Take Sym as arg? - v = s.newValue(ssa.OpFwdRef, t, name) + v = s.newValue0A(ssa.OpFwdRef, t, name) s.vars[name] = v } return v @@ -601,8 +621,8 @@ func (s *state) lookupVarIncoming(b *ssa.Block, t ssa.Type, name string) *ssa.Va return s.startmem } // variable is live at the entry block. Load it. - addr := s.entryNewValue1(ssa.OpOffPtr, Ptrto(t.(*Type)), s.argOffsets[name], s.fp) - return s.entryNewValue2(ssa.OpLoad, t, nil, addr, s.startmem) + addr := s.entryNewValue1I(ssa.OpOffPtr, Ptrto(t.(*Type)), s.argOffsets[name], s.fp) + return s.entryNewValue2(ssa.OpLoad, t, addr, s.startmem) } var vals []*ssa.Value @@ -613,7 +633,7 @@ func (s *state) lookupVarIncoming(b *ssa.Block, t ssa.Type, name string) *ssa.Va for i := 1; i < len(vals); i++ { if vals[i] != v0 { // need a phi value - v := b.NewValue(s.peekLine(), ssa.OpPhi, t, nil) + v := b.NewValue0(s.peekLine(), ssa.OpPhi, t) v.AddArgs(vals...) return v } @@ -634,7 +654,7 @@ func (s *state) lookupVarOutgoing(b *ssa.Block, t ssa.Type, name string) *ssa.Va // Make v = copy(w). We need the extra copy to // prevent infinite recursion when looking up the // incoming value of the variable. - v := b.NewValue(s.peekLine(), ssa.OpCopy, t, nil) + v := b.NewValue0(s.peekLine(), ssa.OpCopy, t) m[name] = v v.AddArg(s.lookupVarIncoming(b, t, name)) return v @@ -728,7 +748,7 @@ func genValue(v *ssa.Value) { p := Prog(x86.ALEAQ) p.From.Type = obj.TYPE_MEM p.From.Reg = regnum(v.Args[0]) - p.From.Offset = v.Aux.(int64) + p.From.Offset = v.AuxInt p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v) case ssa.OpAMD64MULQconst: @@ -736,7 +756,7 @@ func genValue(v *ssa.Value) { // has ever been taught to compile imul $c, r1, r2. p := Prog(x86.AIMULQ) p.From.Type = obj.TYPE_CONST - p.From.Offset = v.Aux.(int64) + p.From.Offset = v.AuxInt p.From3.Type = obj.TYPE_REG p.From3.Reg = regnum(v.Args[0]) p.To.Type = obj.TYPE_REG @@ -756,7 +776,7 @@ func genValue(v *ssa.Value) { } p := Prog(x86.ASUBQ) p.From.Type = obj.TYPE_CONST - p.From.Offset = v.Aux.(int64) + p.From.Offset = v.AuxInt p.To.Type = obj.TYPE_REG p.To.Reg = r case ssa.OpAMD64SHLQ: @@ -829,7 +849,7 @@ func genValue(v *ssa.Value) { } p := Prog(x86.ASHLQ) p.From.Type = obj.TYPE_CONST - p.From.Offset = v.Aux.(int64) + p.From.Offset = v.AuxInt p.To.Type = obj.TYPE_REG p.To.Reg = r case ssa.OpAMD64SHRQconst: @@ -845,7 +865,7 @@ func genValue(v *ssa.Value) { } p := Prog(x86.ASHRQ) p.From.Type = obj.TYPE_CONST - p.From.Offset = v.Aux.(int64) + p.From.Offset = v.AuxInt p.To.Type = obj.TYPE_REG p.To.Reg = r case ssa.OpAMD64SARQconst: @@ -861,7 +881,7 @@ func genValue(v *ssa.Value) { } p := Prog(x86.ASARQ) p.From.Type = obj.TYPE_CONST - p.From.Offset = v.Aux.(int64) + p.From.Offset = v.AuxInt p.To.Type = obj.TYPE_REG p.To.Reg = r case ssa.OpAMD64SBBQcarrymask: @@ -921,7 +941,7 @@ func genValue(v *ssa.Value) { p.From.Reg = regnum(v.Args[0]) p.From.Scale = 1 p.From.Index = regnum(v.Args[1]) - p.From.Offset = v.Aux.(int64) + p.From.Offset = v.AuxInt p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v) case ssa.OpAMD64CMPQ: @@ -935,7 +955,7 @@ func genValue(v *ssa.Value) { p.From.Type = obj.TYPE_REG p.From.Reg = regnum(v.Args[0]) p.To.Type = obj.TYPE_CONST - p.To.Offset = v.Aux.(int64) + p.To.Offset = v.AuxInt case ssa.OpAMD64TESTB: p := Prog(x86.ATESTB) p.From.Type = obj.TYPE_REG @@ -946,28 +966,28 @@ func genValue(v *ssa.Value) { x := regnum(v) p := Prog(x86.AMOVQ) p.From.Type = obj.TYPE_CONST - p.From.Offset = v.Aux.(int64) + p.From.Offset = v.AuxInt p.To.Type = obj.TYPE_REG p.To.Reg = x case ssa.OpAMD64MOVQload: p := Prog(x86.AMOVQ) p.From.Type = obj.TYPE_MEM p.From.Reg = regnum(v.Args[0]) - p.From.Offset = v.Aux.(int64) + p.From.Offset = v.AuxInt p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v) case ssa.OpAMD64MOVBload: p := Prog(x86.AMOVB) p.From.Type = obj.TYPE_MEM p.From.Reg = regnum(v.Args[0]) - p.From.Offset = v.Aux.(int64) + p.From.Offset = v.AuxInt p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v) case ssa.OpAMD64MOVQloadidx8: p := Prog(x86.AMOVQ) p.From.Type = obj.TYPE_MEM p.From.Reg = regnum(v.Args[0]) - p.From.Offset = v.Aux.(int64) + p.From.Offset = v.AuxInt p.From.Scale = 8 p.From.Index = regnum(v.Args[1]) p.To.Type = obj.TYPE_REG @@ -978,7 +998,7 @@ func genValue(v *ssa.Value) { p.From.Reg = regnum(v.Args[1]) p.To.Type = obj.TYPE_MEM p.To.Reg = regnum(v.Args[0]) - p.To.Offset = v.Aux.(int64) + p.To.Offset = v.AuxInt case ssa.OpCopy: // TODO: lower to MOVQ earlier? if v.Type.IsMemory() { return @@ -1021,14 +1041,13 @@ func genValue(v *ssa.Value) { } case ssa.OpArg: // memory arg needs no code - // TODO: only mem arg goes here. + // TODO: check that only mem arg goes here. case ssa.OpAMD64LEAQglobal: - g := v.Aux.(ssa.GlobalOffset) p := Prog(x86.ALEAQ) p.From.Type = obj.TYPE_MEM p.From.Name = obj.NAME_EXTERN - p.From.Sym = Linksym(g.Global.(*Sym)) - p.From.Offset = g.Offset + p.From.Sym = Linksym(v.Aux.(*Sym)) + p.From.Offset = v.AuxInt p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v) case ssa.OpAMD64CALLstatic: diff --git a/src/cmd/compile/internal/ssa/deadcode_test.go b/src/cmd/compile/internal/ssa/deadcode_test.go index 10b8976e0f..edd38e1254 100644 --- a/src/cmd/compile/internal/ssa/deadcode_test.go +++ b/src/cmd/compile/internal/ssa/deadcode_test.go @@ -10,14 +10,14 @@ func TestDeadLoop(t *testing.T) { c := NewConfig("amd64", DummyFrontend{}) fun := Fun(c, "entry", Bloc("entry", - Valu("mem", OpArg, TypeMem, ".mem"), + Valu("mem", OpArg, TypeMem, 0, ".mem"), Goto("exit")), Bloc("exit", Exit("mem")), // dead loop Bloc("deadblock", // dead value in dead block - Valu("deadval", OpConst, TypeBool, true), + Valu("deadval", OpConst, TypeBool, 0, true), If("deadval", "deadblock", "exit"))) CheckFunc(fun.f) @@ -40,8 +40,8 @@ func TestDeadValue(t *testing.T) { c := NewConfig("amd64", DummyFrontend{}) fun := Fun(c, "entry", Bloc("entry", - Valu("mem", OpArg, TypeMem, ".mem"), - Valu("deadval", OpConst, TypeInt64, int64(37)), + Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("deadval", OpConst, TypeInt64, 37, nil), Goto("exit")), Bloc("exit", Exit("mem"))) @@ -63,8 +63,8 @@ func TestNeverTaken(t *testing.T) { c := NewConfig("amd64", DummyFrontend{}) fun := Fun(c, "entry", Bloc("entry", - Valu("cond", OpConst, TypeBool, false), - Valu("mem", OpArg, TypeMem, ".mem"), + Valu("cond", OpConst, TypeBool, 0, false), + Valu("mem", OpArg, TypeMem, 0, ".mem"), If("cond", "then", "else")), Bloc("then", Goto("exit")), diff --git a/src/cmd/compile/internal/ssa/deadstore_test.go b/src/cmd/compile/internal/ssa/deadstore_test.go index 70b2092ec3..5143afb6cb 100644 --- a/src/cmd/compile/internal/ssa/deadstore_test.go +++ b/src/cmd/compile/internal/ssa/deadstore_test.go @@ -13,13 +13,13 @@ func TestDeadStore(t *testing.T) { ptrType := &TypeImpl{Size_: 8, Ptr: true, Name: "testptr"} // dummy for testing fun := Fun(c, "entry", Bloc("entry", - Valu("start", OpArg, TypeMem, ".mem"), - Valu("v", OpConst, TypeBool, true), - Valu("addr1", OpGlobal, ptrType, nil), - Valu("addr2", OpGlobal, ptrType, nil), - Valu("store1", OpStore, TypeMem, nil, "addr1", "v", "start"), - Valu("store2", OpStore, TypeMem, nil, "addr2", "v", "store1"), - Valu("store3", OpStore, TypeMem, nil, "addr1", "v", "store2"), + Valu("start", OpArg, TypeMem, 0, ".mem"), + Valu("v", OpConst, TypeBool, 0, true), + Valu("addr1", OpGlobal, ptrType, 0, nil), + Valu("addr2", OpGlobal, ptrType, 0, nil), + Valu("store1", OpStore, TypeMem, 0, nil, "addr1", "v", "start"), + Valu("store2", OpStore, TypeMem, 0, nil, "addr2", "v", "store1"), + Valu("store3", OpStore, TypeMem, 0, nil, "addr1", "v", "store2"), Goto("exit")), Bloc("exit", Exit("store3"))) @@ -39,13 +39,13 @@ func TestDeadStorePhi(t *testing.T) { ptrType := &TypeImpl{Size_: 8, Ptr: true, Name: "testptr"} // dummy for testing fun := Fun(c, "entry", Bloc("entry", - Valu("start", OpArg, TypeMem, ".mem"), - Valu("v", OpConst, TypeBool, true), - Valu("addr", OpGlobal, ptrType, nil), + Valu("start", OpArg, TypeMem, 0, ".mem"), + Valu("v", OpConst, TypeBool, 0, true), + Valu("addr", OpGlobal, ptrType, 0, nil), Goto("loop")), Bloc("loop", - Valu("phi", OpPhi, TypeMem, nil, "start", "store"), - Valu("store", OpStore, TypeMem, nil, "addr", "v", "phi"), + Valu("phi", OpPhi, TypeMem, 0, nil, "start", "store"), + Valu("store", OpStore, TypeMem, 0, nil, "addr", "v", "phi"), If("v", "loop", "exit")), Bloc("exit", Exit("store"))) @@ -65,12 +65,12 @@ func TestDeadStoreTypes(t *testing.T) { t2 := &TypeImpl{Size_: 4, Ptr: true, Name: "t2"} fun := Fun(c, "entry", Bloc("entry", - Valu("start", OpArg, TypeMem, ".mem"), - Valu("v", OpConst, TypeBool, true), - Valu("addr1", OpGlobal, t1, nil), - Valu("addr2", OpGlobal, t2, nil), - Valu("store1", OpStore, TypeMem, nil, "addr1", "v", "start"), - Valu("store2", OpStore, TypeMem, nil, "addr2", "v", "store1"), + Valu("start", OpArg, TypeMem, 0, ".mem"), + Valu("v", OpConst, TypeBool, 0, true), + Valu("addr1", OpGlobal, t1, 0, nil), + Valu("addr2", OpGlobal, t2, 0, nil), + Valu("store1", OpStore, TypeMem, 0, nil, "addr1", "v", "start"), + Valu("store2", OpStore, TypeMem, 0, nil, "addr2", "v", "store1"), Goto("exit")), Bloc("exit", Exit("store2"))) diff --git a/src/cmd/compile/internal/ssa/func.go b/src/cmd/compile/internal/ssa/func.go index 06a2455e87..2e1b5990dc 100644 --- a/src/cmd/compile/internal/ssa/func.go +++ b/src/cmd/compile/internal/ssa/func.go @@ -4,6 +4,8 @@ package ssa +import "log" + // A Func represents a Go func declaration (or function literal) and // its body. This package compiles each Func independently. type Func struct { @@ -42,13 +44,12 @@ func (f *Func) NewBlock(kind BlockKind) *Block { return b } -// NewValue returns a new value in the block with no arguments. -func (b *Block) NewValue(line int32, op Op, t Type, aux interface{}) *Value { +// 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 := &Value{ ID: b.Func.vid.get(), Op: op, Type: t, - Aux: aux, Block: b, } v.Args = v.argstorage[:0] @@ -56,8 +57,28 @@ func (b *Block) NewValue(line int32, op Op, t Type, aux interface{}) *Value { return v } -// NewValue1 returns a new value in the block with one argument. -func (b *Block) NewValue1(line int32, op Op, t Type, aux interface{}, arg *Value) *Value { +// 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 := &Value{ + ID: b.Func.vid.get(), + Op: op, + Type: t, + AuxInt: auxint, + Block: b, + } + v.Args = v.argstorage[:0] + b.Values = append(b.Values, v) + 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. + log.Fatalf("aux field has int64 type op=%s type=%s aux=%v", op, t, aux) + } v := &Value{ ID: b.Func.vid.get(), Op: op, @@ -65,14 +86,57 @@ func (b *Block) NewValue1(line int32, op Op, t Type, aux interface{}, arg *Value Aux: aux, Block: b, } + v.Args = v.argstorage[:0] + b.Values = append(b.Values, v) + 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 := &Value{ + ID: b.Func.vid.get(), + Op: op, + Type: t, + AuxInt: auxint, + Aux: aux, + Block: b, + } + v.Args = v.argstorage[:0] + b.Values = append(b.Values, v) + 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 := &Value{ + ID: b.Func.vid.get(), + Op: op, + Type: t, + Block: b, + } v.Args = v.argstorage[:1] v.Args[0] = arg b.Values = append(b.Values, v) return v } -// NewValue2 returns a new value in the block with two arguments. -func (b *Block) NewValue2(line int32, op Op, t Type, aux interface{}, arg0, arg1 *Value) *Value { +// 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 := &Value{ + ID: b.Func.vid.get(), + Op: op, + Type: t, + AuxInt: auxint, + Block: b, + } + v.Args = v.argstorage[:1] + v.Args[0] = arg + b.Values = append(b.Values, v) + 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 := &Value{ ID: b.Func.vid.get(), Op: op, @@ -80,6 +144,36 @@ func (b *Block) NewValue2(line int32, op Op, t Type, aux interface{}, arg0, arg1 Aux: aux, Block: b, } + v.Args = v.argstorage[:1] + v.Args[0] = arg + b.Values = append(b.Values, v) + 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 := &Value{ + ID: b.Func.vid.get(), + Op: op, + Type: t, + AuxInt: auxint, + Aux: aux, + Block: b, + } + v.Args = v.argstorage[:1] + v.Args[0] = arg + b.Values = append(b.Values, v) + 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 := &Value{ + ID: b.Func.vid.get(), + Op: op, + Type: t, + Block: b, + } v.Args = v.argstorage[:2] v.Args[0] = arg0 v.Args[1] = arg1 @@ -87,13 +181,12 @@ func (b *Block) NewValue2(line int32, op Op, t Type, aux interface{}, arg0, arg1 return v } -// NewValue3 returns a new value in the block with three arguments. -func (b *Block) NewValue3(line int32, op Op, t Type, aux interface{}, arg0, arg1, arg2 *Value) *Value { +// 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 := &Value{ ID: b.Func.vid.get(), Op: op, Type: t, - Aux: aux, Block: b, } v.Args = []*Value{arg0, arg1, arg2} @@ -104,5 +197,5 @@ func (b *Block) NewValue3(line int32, op Op, t Type, aux interface{}, arg0, arg1 // ConstInt returns an int constant representing its argument. func (f *Func) ConstInt(line int32, t Type, c int64) *Value { // TODO: cache? - return f.Entry.NewValue(line, OpConst, t, c) + return f.Entry.NewValue0I(line, OpConst, t, c) } diff --git a/src/cmd/compile/internal/ssa/func_test.go b/src/cmd/compile/internal/ssa/func_test.go index 3f94589e8b..7cfc7324ac 100644 --- a/src/cmd/compile/internal/ssa/func_test.go +++ b/src/cmd/compile/internal/ssa/func_test.go @@ -18,12 +18,12 @@ // // fun := Fun("entry", // Bloc("entry", -// Valu("mem", OpArg, TypeMem, ".mem"), +// Valu("mem", OpArg, TypeMem, 0, ".mem"), // Goto("exit")), // Bloc("exit", // Exit("mem")), // Bloc("deadblock", -// Valu("deadval", OpConst, TypeBool, true), +// Valu("deadval", OpConst, TypeBool, 0, true), // If("deadval", "deadblock", "exit"))) // // and the Blocks or Values used in the Func can be accessed @@ -61,7 +61,7 @@ func Equiv(f, g *Func) bool { // 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 { + if fv.Op != gv.Op || fv.Type != gv.Type || fv.AuxInt != gv.AuxInt { return false } if !reflect.DeepEqual(fv.Aux, gv.Aux) { @@ -149,7 +149,7 @@ func Fun(c *Config, entry string, blocs ...bloc) fun { blocks[bloc.name] = b for _, valu := range bloc.valus { // args are filled in the second pass. - values[valu.name] = b.NewValue(0, valu.op, valu.t, valu.aux) + values[valu.name] = b.NewValue0IA(0, valu.op, valu.t, valu.auxint, valu.aux) } } // Connect the blocks together and specify control values. @@ -212,8 +212,8 @@ func Bloc(name string, entries ...interface{}) bloc { } // Valu defines a value in a block. -func Valu(name string, op Op, t Type, aux interface{}, args ...string) valu { - return valu{name, op, t, aux, args} +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. @@ -248,11 +248,12 @@ type ctrl struct { } type valu struct { - name string - op Op - t Type - aux interface{} - args []string + name string + op Op + t Type + auxint int64 + aux interface{} + args []string } func addEdge(b, c *Block) { @@ -264,10 +265,10 @@ func TestArgs(t *testing.T) { c := NewConfig("amd64", DummyFrontend{}) fun := Fun(c, "entry", Bloc("entry", - Valu("a", OpConst, TypeInt64, 14), - Valu("b", OpConst, TypeInt64, 26), - Valu("sum", OpAdd, TypeInt64, nil, "a", "b"), - Valu("mem", OpArg, TypeMem, ".mem"), + Valu("a", OpConst, TypeInt64, 14, nil), + Valu("b", OpConst, TypeInt64, 26, nil), + Valu("sum", OpAdd, TypeInt64, 0, nil, "a", "b"), + Valu("mem", OpArg, TypeMem, 0, ".mem"), Goto("exit")), Bloc("exit", Exit("mem"))) @@ -287,19 +288,19 @@ func TestEquiv(t *testing.T) { { Fun(c, "entry", Bloc("entry", - Valu("a", OpConst, TypeInt64, 14), - Valu("b", OpConst, TypeInt64, 26), - Valu("sum", OpAdd, TypeInt64, nil, "a", "b"), - Valu("mem", OpArg, TypeMem, ".mem"), + Valu("a", OpConst, TypeInt64, 14, nil), + Valu("b", OpConst, TypeInt64, 26, nil), + Valu("sum", OpAdd, TypeInt64, 0, nil, "a", "b"), + Valu("mem", OpArg, TypeMem, 0, ".mem"), Goto("exit")), Bloc("exit", Exit("mem"))), Fun(c, "entry", Bloc("entry", - Valu("a", OpConst, TypeInt64, 14), - Valu("b", OpConst, TypeInt64, 26), - Valu("sum", OpAdd, TypeInt64, nil, "a", "b"), - Valu("mem", OpArg, TypeMem, ".mem"), + Valu("a", OpConst, TypeInt64, 14, nil), + Valu("b", OpConst, TypeInt64, 26, nil), + Valu("sum", OpAdd, TypeInt64, 0, nil, "a", "b"), + Valu("mem", OpArg, TypeMem, 0, ".mem"), Goto("exit")), Bloc("exit", Exit("mem"))), @@ -308,10 +309,10 @@ func TestEquiv(t *testing.T) { { Fun(c, "entry", Bloc("entry", - Valu("a", OpConst, TypeInt64, 14), - Valu("b", OpConst, TypeInt64, 26), - Valu("sum", OpAdd, TypeInt64, nil, "a", "b"), - Valu("mem", OpArg, TypeMem, ".mem"), + Valu("a", OpConst, TypeInt64, 14, nil), + Valu("b", OpConst, TypeInt64, 26, nil), + Valu("sum", OpAdd, TypeInt64, 0, nil, "a", "b"), + Valu("mem", OpArg, TypeMem, 0, ".mem"), Goto("exit")), Bloc("exit", Exit("mem"))), @@ -319,10 +320,10 @@ func TestEquiv(t *testing.T) { Bloc("exit", Exit("mem")), Bloc("entry", - Valu("a", OpConst, TypeInt64, 14), - Valu("b", OpConst, TypeInt64, 26), - Valu("sum", OpAdd, TypeInt64, nil, "a", "b"), - Valu("mem", OpArg, TypeMem, ".mem"), + Valu("a", OpConst, TypeInt64, 14, nil), + Valu("b", OpConst, TypeInt64, 26, nil), + Valu("sum", OpAdd, TypeInt64, 0, nil, "a", "b"), + Valu("mem", OpArg, TypeMem, 0, ".mem"), Goto("exit"))), }, } @@ -339,58 +340,71 @@ func TestEquiv(t *testing.T) { { Fun(c, "entry", Bloc("entry", - Valu("mem", OpArg, TypeMem, ".mem"), + Valu("mem", OpArg, TypeMem, 0, ".mem"), Goto("exit")), Bloc("exit", Exit("mem"))), Fun(c, "entry", Bloc("entry", - Valu("mem", OpArg, TypeMem, ".mem"), + Valu("mem", OpArg, TypeMem, 0, ".mem"), Exit("mem"))), }, // value order changed { Fun(c, "entry", Bloc("entry", - Valu("mem", OpArg, TypeMem, ".mem"), - Valu("b", OpConst, TypeInt64, 26), - Valu("a", OpConst, TypeInt64, 14), + Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("b", OpConst, TypeInt64, 26, nil), + Valu("a", OpConst, TypeInt64, 14, nil), Exit("mem"))), Fun(c, "entry", Bloc("entry", - Valu("mem", OpArg, TypeMem, ".mem"), - Valu("a", OpConst, TypeInt64, 14), - Valu("b", OpConst, TypeInt64, 26), + Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("a", OpConst, TypeInt64, 14, nil), + Valu("b", OpConst, TypeInt64, 26, nil), + Exit("mem"))), + }, + // value auxint different + { + Fun(c, "entry", + Bloc("entry", + Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("a", OpConst, TypeInt64, 14, nil), + Exit("mem"))), + Fun(c, "entry", + Bloc("entry", + Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("a", OpConst, TypeInt64, 26, nil), Exit("mem"))), }, // value aux different { Fun(c, "entry", Bloc("entry", - Valu("mem", OpArg, TypeMem, ".mem"), - Valu("a", OpConst, TypeInt64, 14), + Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("a", OpConst, TypeInt64, 0, 14), Exit("mem"))), Fun(c, "entry", Bloc("entry", - Valu("mem", OpArg, TypeMem, ".mem"), - Valu("a", OpConst, TypeInt64, 26), + Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("a", OpConst, TypeInt64, 0, 26), Exit("mem"))), }, // value args different { Fun(c, "entry", Bloc("entry", - Valu("mem", OpArg, TypeMem, ".mem"), - Valu("a", OpConst, TypeInt64, 14), - Valu("b", OpConst, TypeInt64, 26), - Valu("sum", OpAdd, TypeInt64, nil, "a", "b"), + Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("a", OpConst, TypeInt64, 14, nil), + Valu("b", OpConst, TypeInt64, 26, nil), + Valu("sum", OpAdd, TypeInt64, 0, nil, "a", "b"), Exit("mem"))), Fun(c, "entry", Bloc("entry", - Valu("mem", OpArg, TypeMem, ".mem"), - Valu("a", OpConst, TypeInt64, 0), - Valu("b", OpConst, TypeInt64, 14), - Valu("sum", OpAdd, TypeInt64, nil, "b", "a"), + Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("a", OpConst, TypeInt64, 0, nil), + Valu("b", OpConst, TypeInt64, 14, nil), + Valu("sum", OpAdd, TypeInt64, 0, nil, "b", "a"), Exit("mem"))), }, } diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index e9744aed9c..58ab25b392 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -23,30 +23,30 @@ // mask = shift >= 64 ? 0 : 0xffffffffffffffff // result = mask & arg << shift (Lsh x y) && is64BitInt(t) -> - (ANDQ (SHLQ x y) (SBBQcarrymask (CMPQconst [int64(64)] y))) + (ANDQ (SHLQ x y) (SBBQcarrymask (CMPQconst [64] y))) (Rsh x y) && is64BitInt(t) && !t.IsSigned() -> - (ANDQ (SHRQ x y) (SBBQcarrymask (CMPQconst [int64(64)] y))) + (ANDQ (SHRQ x y) (SBBQcarrymask (CMPQconst [64] y))) // Note: signed right shift needs to return 0/-1 if shift amount is >= 64. // if shift > 63 { shift = 63 } // result = arg >> shift (Rsh x y) && is64BitInt(t) && t.IsSigned() -> (SARQ x (CMOVQCC - (CMPQconst [int64(64)] y) - (Const [int64(63)]) + (CMPQconst [64] y) + (Const [63]) y)) (Less x y) && is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type) -> (SETL (CMPQ x y)) -(Load ptr mem) && t.IsBoolean() -> (MOVBload [int64(0)] ptr mem) -(Load ptr mem) && (is64BitInt(t) || isPtr(t)) -> (MOVQload [int64(0)] ptr mem) -(Store ptr val mem) && (is64BitInt(val.Type) || isPtr(val.Type)) -> (MOVQstore [int64(0)] ptr val mem) +(Load ptr mem) && t.IsBoolean() -> (MOVBload ptr mem) +(Load ptr mem) && (is64BitInt(t) || isPtr(t)) -> (MOVQload ptr mem) +(Store ptr val mem) && (is64BitInt(val.Type) || isPtr(val.Type)) -> (MOVQstore ptr val mem) // checks (IsNonNil p) -> (SETNE (TESTQ p p)) (IsInBounds idx len) -> (SETB (CMPQ idx len)) -(Move [size] dst src mem) -> (REPMOVSB dst src (Const [size.(int64)]) mem) +(Move [size] dst src mem) -> (REPMOVSB dst src (Const [size]) mem) (OffPtr [off] ptr) -> (ADDQconst [off] ptr) @@ -65,14 +65,14 @@ // TODO: Should this be a separate pass? // global loads/stores -(Global [sym]) -> (LEAQglobal [GlobalOffset{sym,0}]) +(Global {sym}) -> (LEAQglobal {sym}) // fold constants into instructions (ADDQ x (MOVQconst [c])) -> (ADDQconst [c] x) // TODO: restrict c to int32 range? (ADDQ (MOVQconst [c]) x) -> (ADDQconst [c] x) (SUBQ x (MOVQconst [c])) -> (SUBQconst x [c]) (SUBQ (MOVQconst [c]) x) -> (NEGQ (SUBQconst x [c])) -(MULQ x (MOVQconst [c])) && c.(int64) == int64(int32(c.(int64))) -> (MULQconst [c] x) +(MULQ x (MOVQconst [c])) && c == int64(int32(c)) -> (MULQconst [c] x) (MULQ (MOVQconst [c]) x) -> (MULQconst [c] x) (ANDQ x (MOVQconst [c])) -> (ANDQconst [c] x) (ANDQ (MOVQconst [c]) x) -> (ANDQconst [c] x) @@ -84,11 +84,11 @@ // strength reduction // TODO: do this a lot more generically -(MULQconst [c] x) && c.(int64) == 8 -> (SHLQconst [int64(3)] x) -(MULQconst [c] x) && c.(int64) == 64 -> (SHLQconst [int64(5)] x) +(MULQconst [8] x) -> (SHLQconst [3] x) +(MULQconst [64] x) -> (SHLQconst [5] x) // fold add/shift into leaq -(ADDQ x (SHLQconst [shift] y)) && shift.(int64) == 3 -> (LEAQ8 [int64(0)] x y) +(ADDQ x (SHLQconst [3] y)) -> (LEAQ8 x y) (ADDQconst [c] (LEAQ8 [d] x y)) -> (LEAQ8 [addOff(c, d)] x y) // reverse ordering of compare instruction @@ -110,7 +110,7 @@ (MOVQloadidx8 [off1] (ADDQconst [off2] ptr) idx mem) -> (MOVQloadidx8 [addOff(off1, off2)] ptr idx mem) (MOVQstoreidx8 [off1] (ADDQconst [off2] ptr) idx val mem) -> (MOVQstoreidx8 [addOff(off1, off2)] ptr idx val mem) -(ADDQconst [off] x) && off.(int64) == 0 -> (Copy x) +(ADDQconst [0] x) -> (Copy x) // Absorb InvertFlags into branches. (LT (InvertFlags cmp) yes no) -> (GT cmp yes no) @@ -125,9 +125,9 @@ (NE (InvertFlags cmp) yes no) -> (NE cmp yes no) // get rid of >=64 code for constant shifts -(SBBQcarrymask (CMPQconst [c] (MOVQconst [d]))) && inBounds(d.(int64), c.(int64)) -> (Const [int64(-1)]) -(SBBQcarrymask (CMPQconst [c] (MOVQconst [d]))) && !inBounds(d.(int64), c.(int64)) -> (Const [int64(0)]) -(ANDQconst [c] _) && c.(int64) == 0 -> (MOVQconst [int64(0)]) -(ANDQconst [c] x) && c.(int64) == -1 -> (Copy x) -(CMOVQCC (CMPQconst [c] (MOVQconst [d])) _ x) && inBounds(d.(int64), c.(int64)) -> (Copy x) -(CMOVQCC (CMPQconst [c] (MOVQconst [d])) x _) && !inBounds(d.(int64), c.(int64)) -> (Copy x) +(SBBQcarrymask (CMPQconst [c] (MOVQconst [d]))) && inBounds(d, c) -> (Const [-1]) +(SBBQcarrymask (CMPQconst [c] (MOVQconst [d]))) && !inBounds(d, c) -> (Const [0]) +(ANDQconst [0] _) -> (MOVQconst [0]) +(ANDQconst [-1] x) -> (Copy x) +(CMOVQCC (CMPQconst [c] (MOVQconst [d])) _ x) && inBounds(d, c) -> (Copy x) +(CMOVQCC (CMPQconst [c] (MOVQconst [d])) x _) && !inBounds(d, c) -> (Copy x) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index bcb07392c7..13aff4cba7 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -93,24 +93,24 @@ func init() { // TODO: 2-address instructions. Mark ops as needing matching input/output regs. var AMD64ops = []opData{ {name: "ADDQ", reg: gp21}, // arg0 + arg1 - {name: "ADDQconst", reg: gp11}, // arg0 + aux.(int64) + {name: "ADDQconst", reg: gp11}, // arg0 + auxint {name: "SUBQ", reg: gp21}, // arg0 - arg1 - {name: "SUBQconst", reg: gp11}, // arg0 - aux.(int64) + {name: "SUBQconst", reg: gp11}, // arg0 - auxint {name: "MULQ", reg: gp21}, // arg0 * arg1 - {name: "MULQconst", reg: gp11}, // arg0 * aux.(int64) + {name: "MULQconst", reg: gp11}, // arg0 * auxint {name: "ANDQ", reg: gp21}, // arg0 & arg1 - {name: "ANDQconst", reg: gp11}, // arg0 & aux.(int64) + {name: "ANDQconst", reg: gp11}, // arg0 & auxint {name: "SHLQ", reg: gp21shift}, // arg0 << arg1, shift amount is mod 64 - {name: "SHLQconst", reg: gp11}, // arg0 << aux.(int64), shift amount 0-63 + {name: "SHLQconst", reg: gp11}, // arg0 << auxint, shift amount 0-63 {name: "SHRQ", reg: gp21shift}, // unsigned arg0 >> arg1, shift amount is mod 64 - {name: "SHRQconst", reg: gp11}, // unsigned arg0 >> aux.(int64), shift amount 0-63 + {name: "SHRQconst", reg: gp11}, // unsigned arg0 >> auxint, shift amount 0-63 {name: "SARQ", reg: gp21shift}, // signed arg0 >> arg1, shift amount is mod 64 - {name: "SARQconst", reg: gp11}, // signed arg0 >> aux.(int64), shift amount 0-63 + {name: "SARQconst", reg: gp11}, // signed arg0 >> auxint, shift amount 0-63 {name: "NEGQ", reg: gp11}, // -arg0 {name: "CMPQ", reg: gp2flags}, // arg0 compare to arg1 - {name: "CMPQconst", reg: gp1flags}, // arg0 compare to aux.(int64) + {name: "CMPQconst", reg: gp1flags}, // arg0 compare to auxint {name: "TESTQ", reg: gp2flags}, // (arg0 & arg1) compare to 0 {name: "TESTB", reg: gp2flags}, // (arg0 & arg1) compare to 0 @@ -125,21 +125,21 @@ func init() { {name: "CMOVQCC", reg: cmov}, // carry clear - {name: "MOVQconst", reg: gp01}, // aux.(int64) - {name: "LEAQ", reg: gp21}, // arg0 + arg1 + aux.(int64) - {name: "LEAQ2", reg: gp21}, // arg0 + 2*arg1 + aux.(int64) - {name: "LEAQ4", reg: gp21}, // arg0 + 4*arg1 + aux.(int64) - {name: "LEAQ8", reg: gp21}, // arg0 + 8*arg1 + aux.(int64) - {name: "LEAQglobal", reg: gp01}, // no args. address of aux.(GlobalOffset) + {name: "MOVQconst", reg: gp01}, // auxint + {name: "LEAQ", reg: gp21}, // arg0 + arg1 + auxint + {name: "LEAQ2", reg: gp21}, // arg0 + 2*arg1 + auxint + {name: "LEAQ4", reg: gp21}, // arg0 + 4*arg1 + auxint + {name: "LEAQ8", reg: gp21}, // arg0 + 8*arg1 + auxint + {name: "LEAQglobal", reg: gp01}, // no args. address of aux.(*gc.Sym) - {name: "MOVBload", reg: gpload}, // load byte from arg0+aux.(int64). arg1=mem + {name: "MOVBload", reg: gpload}, // load byte from arg0+auxint. arg1=mem {name: "MOVBQZXload", reg: gpload}, // ditto, extend to uint64 {name: "MOVBQSXload", reg: gpload}, // ditto, extend to int64 - {name: "MOVQload", reg: gpload}, // load 8 bytes from arg0+aux.(int64). arg1=mem - {name: "MOVQloadidx8", reg: gploadidx}, // load 8 bytes from arg0+8*arg1+aux.(int64). arg2=mem - {name: "MOVBstore", reg: gpstore}, // store byte in arg1 to arg0+aux.(int64). arg2=mem - {name: "MOVQstore", reg: gpstore}, // store 8 bytes in arg1 to arg0+aux.(int64). arg2=mem - {name: "MOVQstoreidx8", reg: gpstoreidx}, // store 8 bytes in arg2 to arg0+8*arg1+aux.(int64). arg3=mem + {name: "MOVQload", reg: gpload}, // load 8 bytes from arg0+auxint. arg1=mem + {name: "MOVQloadidx8", reg: gploadidx}, // load 8 bytes from arg0+8*arg1+auxint. arg2=mem + {name: "MOVBstore", reg: gpstore}, // store byte in arg1 to arg0+auxint. arg2=mem + {name: "MOVQstore", reg: gpstore}, // store 8 bytes in arg1 to arg0+auxint. arg2=mem + {name: "MOVQstoreidx8", reg: gpstoreidx}, // store 8 bytes in arg2 to arg0+8*arg1+auxint. arg3=mem // Load/store from global. Same as the above loads, but arg0 is missing and // aux is a GlobalOffset instead of an int64. @@ -147,7 +147,7 @@ func init() { {name: "MOVQstoreglobal"}, // store arg0 to aux.(GlobalOffset). arg1=memory, returns memory. //TODO: set register clobber to everything? - {name: "CALLstatic"}, // call static function. arg0=mem, returns mem + {name: "CALLstatic"}, // call static function aux.(*gc.Sym). arg0=mem, returns mem {name: "CALLclosure", reg: regInfo{[]regMask{gpsp, buildReg("DX"), 0}, 0, nil}}, // call function via closure. arg0=codeptr, arg1=closure, arg2=mem returns mem {name: "REPMOVSB", reg: regInfo{[]regMask{buildReg("DI"), buildReg("SI"), buildReg("CX")}, buildReg("DI SI CX"), nil}}, // move arg2 bytes from arg1 to arg0. arg3=mem, returns memory diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index b01952f402..e0bba1706f 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -3,13 +3,14 @@ // license that can be found in the LICENSE file. // values are specified using the following format: -// (op [aux] arg0 arg1 ...) +// (op [auxint] {aux} arg0 arg1 ...) // the type and aux fields are optional // on the matching side -// - the types and aux fields must match if they are specified. +// - 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: @@ -19,15 +20,15 @@ // For now, the generated successors must be a permutation of the matched successors. // constant folding -(Add (Const [c]) (Const [d])) && is64BitInt(t) -> (Const [{c.(int64)+d.(int64)}]) -(Mul (Const [c]) (Const [d])) && is64BitInt(t) -> (Const [{c.(int64)*d.(int64)}]) -(IsInBounds (Const [c]) (Const [d])) -> (Const [inBounds(c.(int64),d.(int64))]) +(Add (Const [c]) (Const [d])) && is64BitInt(t) -> (Const [c+d]) +(Mul (Const [c]) (Const [d])) && is64BitInt(t) -> (Const [c*d]) +(IsInBounds (Const [c]) (Const [d])) -> (Const {inBounds(c,d)}) // tear apart slices // TODO: anything that generates a slice needs to go in here. (SlicePtr (Load ptr mem)) -> (Load ptr mem) -(SliceLen (Load ptr mem)) -> (Load (Add ptr (Const [int64(config.ptrSize)])) mem) -(SliceCap (Load ptr mem)) -> (Load (Add ptr (Const [int64(config.ptrSize*2)])) mem) +(SliceLen (Load ptr mem)) -> (Load (Add ptr (Const [config.ptrSize])) mem) +(SliceCap (Load ptr mem)) -> (Load (Add ptr (Const [config.ptrSize*2])) mem) // indexing operations // Note: bounds check has already been done @@ -39,11 +40,11 @@ (Store dst (Load src mem) mem) && t.Size() > 8 -> (Move [t.Size()] dst src mem) // string ops -(Const [s]) && t.IsString() -> (StringMake (OffPtr [2*config.ptrSize] (Global [config.fe.StringSym(s.(string))])) (Const [int64(len(s.(string)))])) // TODO: ptr +(Const {s}) && t.IsString() -> (StringMake (OffPtr [2*config.ptrSize] (Global {config.fe.StringSym(s.(string))})) (Const [int64(len(s.(string)))])) // TODO: ptr (Load ptr mem) && t.IsString() -> (StringMake (Load ptr mem) (Load (OffPtr [config.ptrSize] ptr) mem)) (StringPtr (StringMake ptr _)) -> ptr (StringLen (StringMake _ len)) -> len (Store dst str mem) && str.Type.IsString() -> (Store (OffPtr [config.ptrSize] dst) (StringLen str) (Store dst (StringPtr str) mem)) -(If (Const [c]) yes no) && c.(bool) -> (Plain nil yes) -(If (Const [c]) yes no) && !c.(bool) -> (Plain nil no) +(If (Const {c}) yes no) && c.(bool) -> (Plain nil yes) +(If (Const {c}) yes no) && !c.(bool) -> (Plain nil no) diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 4a691929b5..c168f2af05 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -37,9 +37,9 @@ var genericOps = []opData{ {name: "Func"}, // entry address of a function // Memory operations - {name: "Load"}, // Load from arg0+aux.(int64). arg1=memory - {name: "Store"}, // Store arg1 to arg0+aux.(int64). arg2=memory. Returns memory. - {name: "Move"}, // arg0=destptr, arg1=srcptr, arg2=mem, aux.(int64)=size. Returns memory. + {name: "Load"}, // Load from arg0. arg1=memory + {name: "Store"}, // Store arg1 to arg0. arg2=memory. Returns memory. + {name: "Move"}, // arg0=destptr, arg1=srcptr, arg2=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 @@ -58,7 +58,7 @@ var genericOps = []opData{ // Indexing operations {name: "ArrayIndex"}, // arg0=array, arg1=index. Returns a[i] {name: "PtrIndex"}, // arg0=ptr, arg1=index. Computes ptr+sizeof(*v.type)*index, where index is extended to ptrwidth type - {name: "OffPtr"}, // arg0 + aux.(int64) (arg0 and result are pointers) + {name: "OffPtr"}, // arg0 + auxint (arg0 and result are pointers) // Slices {name: "SliceMake"}, // arg0=ptr, arg1=len, arg2=cap diff --git a/src/cmd/compile/internal/ssa/gen/rulegen.go b/src/cmd/compile/internal/ssa/gen/rulegen.go index 4f689199a0..1a4b2c1b85 100644 --- a/src/cmd/compile/internal/ssa/gen/rulegen.go +++ b/src/cmd/compile/internal/ssa/gen/rulegen.go @@ -19,6 +19,7 @@ import ( "io/ioutil" "log" "os" + "regexp" "sort" "strings" ) @@ -29,9 +30,9 @@ import ( // sexpr are s-expressions (lisp-like parenthesized groupings) // sexpr ::= (opcode sexpr*) // | variable -// | [aux] // | -// | {code} +// | [auxint] +// | {aux} // // aux ::= variable | {code} // type ::= variable | {code} @@ -310,9 +311,9 @@ func genMatch0(w io.Writer, arch arch, match, v, fail string, m map[string]strin if a[0] == '<' { // type restriction t := a[1 : len(a)-1] // remove <> - if t[0] == '{' { + if !isVariable(t) { // code. We must match the results of this code. - fmt.Fprintf(w, "if %s.Type != %s %s", v, t[1:len(t)-1], fail) + fmt.Fprintf(w, "if %s.Type != %s %s", v, t, fail) } else { // variable if u, ok := m[t]; ok { @@ -324,11 +325,26 @@ func genMatch0(w io.Writer, arch arch, match, v, fail string, m map[string]strin } } } else if a[0] == '[' { - // aux restriction + // auxint restriction x := a[1 : len(a)-1] // remove [] - if x[0] == '{' { + if !isVariable(x) { // code - fmt.Fprintf(w, "if %s.Aux != %s %s", v, x[1:len(x)-1], fail) + fmt.Fprintf(w, "if %s.AuxInt != %s %s", v, x, fail) + } else { + // variable + if y, ok := m[x]; ok { + fmt.Fprintf(w, "if %s.AuxInt != %s %s", v, y, fail) + } 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 %s", v, x, fail) } else { // variable if y, ok := m[x]; ok { @@ -338,9 +354,6 @@ func genMatch0(w io.Writer, arch arch, match, v, fail string, m map[string]strin fmt.Fprintf(w, "%s := %s.Aux\n", x, v) } } - } else if a[0] == '{' { - fmt.Fprintf(w, "if %s.Args[%d] != %s %s", v, argnum, a[1:len(a)-1], fail) - argnum++ } else { // variable or sexpr genMatch0(w, arch, a, fmt.Sprintf("%s.Args[%d]", v, argnum), fail, m, false) @@ -357,6 +370,7 @@ func genResult0(w io.Writer, arch arch, result string, alloc *int, top bool) str // variable if top { fmt.Fprintf(w, "v.Op = %s.Op\n", result) + fmt.Fprintf(w, "v.AuxInt = %s.AuxInt\n", result) fmt.Fprintf(w, "v.Aux = %s.Aux\n", result) fmt.Fprintf(w, "v.resetArgs()\n") fmt.Fprintf(w, "v.AddArgs(%s.Args...)\n", result) @@ -370,32 +384,29 @@ func genResult0(w io.Writer, arch arch, result string, alloc *int, top bool) str if top { v = "v" fmt.Fprintf(w, "v.Op = %s\n", opName(s[0], arch)) + fmt.Fprintf(w, "v.AuxInt = 0\n") fmt.Fprintf(w, "v.Aux = nil\n") fmt.Fprintf(w, "v.resetArgs()\n") hasType = true } else { v = fmt.Sprintf("v%d", *alloc) *alloc++ - fmt.Fprintf(w, "%s := v.Block.NewValue(v.Line, %s, TypeInvalid, nil)\n", v, opName(s[0], arch)) + fmt.Fprintf(w, "%s := v.Block.NewValue0(v.Line, %s, TypeInvalid)\n", v, opName(s[0], arch)) } for _, a := range s[1:] { if a[0] == '<' { // type restriction t := a[1 : len(a)-1] // remove <> - if t[0] == '{' { - t = t[1 : len(t)-1] // remove {} - } fmt.Fprintf(w, "%s.Type = %s\n", v, t) hasType = true } else if a[0] == '[' { - // aux restriction + // auxint restriction x := a[1 : len(a)-1] // remove [] - if x[0] == '{' { - x = x[1 : len(x)-1] // remove {} - } - fmt.Fprintf(w, "%s.Aux = %s\n", v, x) + fmt.Fprintf(w, "%s.AuxInt = %s\n", v, x) } else if a[0] == '{' { - fmt.Fprintf(w, "%s.AddArg(%s)\n", v, a[1:len(a)-1]) + // 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) @@ -504,3 +515,12 @@ func unbalanced(s string) bool { } 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/generic.go b/src/cmd/compile/internal/ssa/generic.go deleted file mode 100644 index ebbb1327d4..0000000000 --- a/src/cmd/compile/internal/ssa/generic.go +++ /dev/null @@ -1,424 +0,0 @@ -// autogenerated from rulegen/generic.rules: do not edit! -// generated with: go run rulegen/rulegen.go rulegen/generic.rules genericBlockRules genericValueRules generic.go -package ssa - -func genericValueRules(v *Value, config *Config) bool { - switch v.Op { - case OpAdd: - // match: (Add (Const [c]) (Const [d])) - // cond: is64BitInt(t) - // result: (Const [{c.(int64)+d.(int64)}]) - { - t := v.Type - if v.Args[0].Op != OpConst { - goto end8d047ed0ae9537b840adc79ea82c6e05 - } - c := v.Args[0].Aux - if v.Args[1].Op != OpConst { - goto end8d047ed0ae9537b840adc79ea82c6e05 - } - d := v.Args[1].Aux - if !(is64BitInt(t)) { - goto end8d047ed0ae9537b840adc79ea82c6e05 - } - v.Op = OpConst - v.Aux = nil - v.resetArgs() - v.Aux = c.(int64) + d.(int64) - return true - } - goto end8d047ed0ae9537b840adc79ea82c6e05 - end8d047ed0ae9537b840adc79ea82c6e05: - ; - case OpArrayIndex: - // match: (ArrayIndex (Load ptr mem) idx) - // cond: - // result: (Load (PtrIndex ptr idx) mem) - { - if v.Args[0].Op != OpLoad { - goto end3809f4c52270a76313e4ea26e6f0b753 - } - ptr := v.Args[0].Args[0] - mem := v.Args[0].Args[1] - idx := v.Args[1] - v.Op = OpLoad - v.Aux = nil - v.resetArgs() - v0 := v.Block.NewValue(v.Line, OpPtrIndex, TypeInvalid, nil) - v0.Type = ptr.Type.Elem().Elem().PtrTo() - v0.AddArg(ptr) - v0.AddArg(idx) - v.AddArg(v0) - v.AddArg(mem) - return true - } - goto end3809f4c52270a76313e4ea26e6f0b753 - end3809f4c52270a76313e4ea26e6f0b753: - ; - case OpConst: - // match: (Const [s]) - // cond: t.IsString() - // result: (StringMake (OffPtr [2*config.ptrSize] (Global [config.fe.StringSym(s.(string))])) (Const [int64(len(s.(string)))])) - { - t := v.Type - s := v.Aux - if !(t.IsString()) { - goto end8442aa5b3f4e5b840055475883110372 - } - v.Op = OpStringMake - v.Aux = nil - v.resetArgs() - v0 := v.Block.NewValue(v.Line, OpOffPtr, TypeInvalid, nil) - v0.Type = TypeBytePtr - v0.Aux = 2 * config.ptrSize - v1 := v.Block.NewValue(v.Line, OpGlobal, TypeInvalid, nil) - v1.Type = TypeBytePtr - v1.Aux = config.fe.StringSym(s.(string)) - v0.AddArg(v1) - v.AddArg(v0) - v2 := v.Block.NewValue(v.Line, OpConst, TypeInvalid, nil) - v2.Type = config.Uintptr - v2.Aux = int64(len(s.(string))) - v.AddArg(v2) - return true - } - goto end8442aa5b3f4e5b840055475883110372 - end8442aa5b3f4e5b840055475883110372: - ; - case OpIsInBounds: - // match: (IsInBounds (Const [c]) (Const [d])) - // cond: - // result: (Const [inBounds(c.(int64),d.(int64))]) - { - if v.Args[0].Op != OpConst { - goto enddbd1a394d9b71ee64335361b8384865c - } - c := v.Args[0].Aux - if v.Args[1].Op != OpConst { - goto enddbd1a394d9b71ee64335361b8384865c - } - d := v.Args[1].Aux - v.Op = OpConst - v.Aux = nil - v.resetArgs() - v.Aux = inBounds(c.(int64), d.(int64)) - return true - } - goto enddbd1a394d9b71ee64335361b8384865c - enddbd1a394d9b71ee64335361b8384865c: - ; - case OpLoad: - // match: (Load ptr mem) - // cond: t.IsString() - // result: (StringMake (Load ptr mem) (Load (OffPtr [config.ptrSize] ptr) mem)) - { - t := v.Type - ptr := v.Args[0] - mem := v.Args[1] - if !(t.IsString()) { - goto endd0afd003b70d726a1c5bbaf51fe06182 - } - v.Op = OpStringMake - v.Aux = nil - v.resetArgs() - v0 := v.Block.NewValue(v.Line, OpLoad, TypeInvalid, nil) - v0.Type = TypeBytePtr - v0.AddArg(ptr) - v0.AddArg(mem) - v.AddArg(v0) - v1 := v.Block.NewValue(v.Line, OpLoad, TypeInvalid, nil) - v1.Type = config.Uintptr - v2 := v.Block.NewValue(v.Line, OpOffPtr, TypeInvalid, nil) - v2.Type = TypeBytePtr - v2.Aux = config.ptrSize - v2.AddArg(ptr) - v1.AddArg(v2) - v1.AddArg(mem) - v.AddArg(v1) - return true - } - goto endd0afd003b70d726a1c5bbaf51fe06182 - endd0afd003b70d726a1c5bbaf51fe06182: - ; - case OpMul: - // match: (Mul (Const [c]) (Const [d])) - // cond: is64BitInt(t) - // result: (Const [{c.(int64)*d.(int64)}]) - { - t := v.Type - if v.Args[0].Op != OpConst { - goto end776610f88cf04f438242d76ed2b14f1c - } - c := v.Args[0].Aux - if v.Args[1].Op != OpConst { - goto end776610f88cf04f438242d76ed2b14f1c - } - d := v.Args[1].Aux - if !(is64BitInt(t)) { - goto end776610f88cf04f438242d76ed2b14f1c - } - v.Op = OpConst - v.Aux = nil - v.resetArgs() - v.Aux = c.(int64) * d.(int64) - return true - } - goto end776610f88cf04f438242d76ed2b14f1c - end776610f88cf04f438242d76ed2b14f1c: - ; - case OpPtrIndex: - // match: (PtrIndex ptr idx) - // cond: - // result: (Add ptr (Mul idx (Const [t.Elem().Size()]))) - { - t := v.Type - ptr := v.Args[0] - idx := v.Args[1] - v.Op = OpAdd - v.Aux = nil - v.resetArgs() - v.AddArg(ptr) - v0 := v.Block.NewValue(v.Line, OpMul, TypeInvalid, nil) - v0.Type = config.Uintptr - v0.AddArg(idx) - v1 := v.Block.NewValue(v.Line, OpConst, TypeInvalid, nil) - v1.Type = config.Uintptr - v1.Aux = t.Elem().Size() - v0.AddArg(v1) - v.AddArg(v0) - return true - } - goto end88c7c383675420d1581daeb899039fa8 - end88c7c383675420d1581daeb899039fa8: - ; - case OpSliceCap: - // match: (SliceCap (Load ptr mem)) - // cond: - // result: (Load (Add ptr (Const [int64(config.ptrSize*2)])) mem) - { - if v.Args[0].Op != OpLoad { - goto endc871dcd9a720b4290c9cae78fe147c8a - } - ptr := v.Args[0].Args[0] - mem := v.Args[0].Args[1] - v.Op = OpLoad - v.Aux = nil - v.resetArgs() - v0 := v.Block.NewValue(v.Line, OpAdd, TypeInvalid, nil) - v0.Type = ptr.Type - v0.AddArg(ptr) - v1 := v.Block.NewValue(v.Line, OpConst, TypeInvalid, nil) - v1.Type = config.Uintptr - v1.Aux = int64(config.ptrSize * 2) - v0.AddArg(v1) - v.AddArg(v0) - v.AddArg(mem) - return true - } - goto endc871dcd9a720b4290c9cae78fe147c8a - endc871dcd9a720b4290c9cae78fe147c8a: - ; - case OpSliceLen: - // match: (SliceLen (Load ptr mem)) - // cond: - // result: (Load (Add ptr (Const [int64(config.ptrSize)])) mem) - { - if v.Args[0].Op != OpLoad { - goto end1eec05e44f5fc8944e7c176f98a74d92 - } - ptr := v.Args[0].Args[0] - mem := v.Args[0].Args[1] - v.Op = OpLoad - v.Aux = nil - v.resetArgs() - v0 := v.Block.NewValue(v.Line, OpAdd, TypeInvalid, nil) - v0.Type = ptr.Type - v0.AddArg(ptr) - v1 := v.Block.NewValue(v.Line, OpConst, TypeInvalid, nil) - v1.Type = config.Uintptr - v1.Aux = int64(config.ptrSize) - v0.AddArg(v1) - v.AddArg(v0) - v.AddArg(mem) - return true - } - goto end1eec05e44f5fc8944e7c176f98a74d92 - end1eec05e44f5fc8944e7c176f98a74d92: - ; - case OpSlicePtr: - // match: (SlicePtr (Load ptr mem)) - // cond: - // result: (Load ptr mem) - { - if v.Args[0].Op != OpLoad { - goto end459613b83f95b65729d45c2ed663a153 - } - ptr := v.Args[0].Args[0] - mem := v.Args[0].Args[1] - v.Op = OpLoad - v.Aux = nil - v.resetArgs() - v.AddArg(ptr) - v.AddArg(mem) - return true - } - goto end459613b83f95b65729d45c2ed663a153 - end459613b83f95b65729d45c2ed663a153: - ; - case OpStore: - // match: (Store dst (Load src mem) mem) - // cond: t.Size() > 8 - // result: (Move [t.Size()] dst src mem) - { - dst := v.Args[0] - if v.Args[1].Op != OpLoad { - goto end324ffb6d2771808da4267f62c854e9c8 - } - t := v.Args[1].Type - src := v.Args[1].Args[0] - mem := v.Args[1].Args[1] - if v.Args[2] != v.Args[1].Args[1] { - goto end324ffb6d2771808da4267f62c854e9c8 - } - if !(t.Size() > 8) { - goto end324ffb6d2771808da4267f62c854e9c8 - } - v.Op = OpMove - v.Aux = nil - v.resetArgs() - v.Aux = t.Size() - v.AddArg(dst) - v.AddArg(src) - v.AddArg(mem) - return true - } - goto end324ffb6d2771808da4267f62c854e9c8 - end324ffb6d2771808da4267f62c854e9c8: - ; - // match: (Store dst str mem) - // cond: str.Type.IsString() - // result: (Store (OffPtr [config.ptrSize] dst) (StringLen str) (Store dst (StringPtr str) mem)) - { - dst := v.Args[0] - str := v.Args[1] - mem := v.Args[2] - if !(str.Type.IsString()) { - goto end410559d97aed8018f820cd88723de442 - } - v.Op = OpStore - v.Aux = nil - v.resetArgs() - v0 := v.Block.NewValue(v.Line, OpOffPtr, TypeInvalid, nil) - v0.Type = TypeBytePtr - v0.Aux = config.ptrSize - v0.AddArg(dst) - v.AddArg(v0) - v1 := v.Block.NewValue(v.Line, OpStringLen, TypeInvalid, nil) - v1.Type = config.Uintptr - v1.AddArg(str) - v.AddArg(v1) - v2 := v.Block.NewValue(v.Line, OpStore, TypeInvalid, nil) - v2.Type = TypeMem - v2.AddArg(dst) - v3 := v.Block.NewValue(v.Line, OpStringPtr, TypeInvalid, nil) - v3.Type = TypeBytePtr - v3.AddArg(str) - v2.AddArg(v3) - v2.AddArg(mem) - v.AddArg(v2) - return true - } - goto end410559d97aed8018f820cd88723de442 - end410559d97aed8018f820cd88723de442: - ; - case OpStringLen: - // match: (StringLen (StringMake _ len)) - // cond: - // result: len - { - if v.Args[0].Op != OpStringMake { - goto end0d922460b7e5ca88324034f4bd6c027c - } - len := v.Args[0].Args[1] - v.Op = len.Op - v.Aux = len.Aux - v.resetArgs() - v.AddArgs(len.Args...) - return true - } - goto end0d922460b7e5ca88324034f4bd6c027c - end0d922460b7e5ca88324034f4bd6c027c: - ; - case OpStringPtr: - // match: (StringPtr (StringMake ptr _)) - // cond: - // result: ptr - { - if v.Args[0].Op != OpStringMake { - goto end061edc5d85c73ad909089af2556d9380 - } - ptr := v.Args[0].Args[0] - v.Op = ptr.Op - v.Aux = ptr.Aux - v.resetArgs() - v.AddArgs(ptr.Args...) - return true - } - goto end061edc5d85c73ad909089af2556d9380 - end061edc5d85c73ad909089af2556d9380: - } - return false -} -func genericBlockRules(b *Block) bool { - switch b.Kind { - case BlockIf: - // match: (BlockIf (Const [c]) yes no) - // cond: c.(bool) - // result: (BlockPlain nil yes) - { - v := b.Control - if v.Op != OpConst { - goto endbe39807508a6192b4022c7293eb6e114 - } - c := v.Aux - yes := b.Succs[0] - no := b.Succs[1] - if !(c.(bool)) { - goto endbe39807508a6192b4022c7293eb6e114 - } - removePredecessor(b, no) - b.Kind = BlockPlain - b.Control = nil - b.Succs = b.Succs[:1] - b.Succs[0] = yes - return true - } - goto endbe39807508a6192b4022c7293eb6e114 - endbe39807508a6192b4022c7293eb6e114: - ; - // match: (BlockIf (Const [c]) yes no) - // cond: !c.(bool) - // result: (BlockPlain nil no) - { - v := b.Control - if v.Op != OpConst { - goto end69ac35957ebe0a77a5ef5103c1f79fbf - } - c := v.Aux - yes := b.Succs[0] - no := b.Succs[1] - if !(!c.(bool)) { - goto end69ac35957ebe0a77a5ef5103c1f79fbf - } - removePredecessor(b, yes) - b.Kind = BlockPlain - b.Control = nil - b.Succs = b.Succs[:1] - b.Succs[0] = no - return true - } - goto end69ac35957ebe0a77a5ef5103c1f79fbf - end69ac35957ebe0a77a5ef5103c1f79fbf: - } - return false -} diff --git a/src/cmd/compile/internal/ssa/op.go b/src/cmd/compile/internal/ssa/op.go index 19a3fddd49..1103a67d0b 100644 --- a/src/cmd/compile/internal/ssa/op.go +++ b/src/cmd/compile/internal/ssa/op.go @@ -4,11 +4,6 @@ package ssa -import ( - "fmt" - "log" -) - // 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. @@ -17,26 +12,6 @@ import ( // for each architecture. type Op int32 -// GlobalOffset represents a fixed offset within a global variable -type GlobalOffset struct { - Global interface{} // holds a *gc.Sym - Offset int64 -} - -// offset adds x to the location specified by g and returns it. -func (g GlobalOffset) offset(x int64) GlobalOffset { - y := g.Offset - z := x + y - if x^y >= 0 && x^z < 0 { - log.Panicf("offset overflow %d %d\n", x, y) - } - return GlobalOffset{g.Global, z} -} - -func (g GlobalOffset) String() string { - return fmt.Sprintf("%v+%d", g.Global, g.Offset) -} - type opInfo struct { name string reg regInfo diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index ed80a5b97d..6f7d619247 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -262,25 +262,23 @@ func regalloc(f *Func) { if len(w.Args) == 0 { // Materialize w if w.Op == OpFP || w.Op == OpSP || w.Op == OpGlobal { - c = b.NewValue1(w.Line, OpCopy, w.Type, nil, w) + c = b.NewValue1(w.Line, OpCopy, w.Type, w) } else { - c = b.NewValue(w.Line, w.Op, w.Type, w.Aux) + c = b.NewValue0IA(w.Line, w.Op, w.Type, w.AuxInt, w.Aux) } } else if len(w.Args) == 1 && (w.Args[0].Op == OpFP || w.Args[0].Op == OpSP || w.Args[0].Op == OpGlobal) { // Materialize offsets from SP/FP/Global - c = b.NewValue1(w.Line, w.Op, w.Type, w.Aux, w.Args[0]) + c = b.NewValue1IA(w.Line, w.Op, w.Type, w.AuxInt, w.Aux, w.Args[0]) } else if wreg != 0 { // Copy from another register. // Typically just an optimization, but this is // required if w is dirty. s := pickReg(wreg) // inv: s != r - c = b.NewValue(w.Line, OpCopy, w.Type, nil) - c.AddArg(regs[s].c) + c = b.NewValue1(w.Line, OpCopy, w.Type, regs[s].c) } else { // Load from home location - c = b.NewValue(w.Line, OpLoadReg8, w.Type, nil) - c.AddArg(w) + c = b.NewValue1(w.Line, OpLoadReg8, w.Type, w) } home = setloc(home, c, ®isters[r]) // Remember what we did @@ -337,7 +335,7 @@ func regalloc(f *Func) { } // Reissue v with new op, with r as its home. - c := b.NewValue(v.Line, v.Op, v.Type, v.Aux) + c := b.NewValue0IA(v.Line, v.Op, v.Type, v.AuxInt, v.Aux) c.AddArgs(v.Args...) home = setloc(home, c, ®isters[r]) @@ -406,7 +404,7 @@ func addPhiCopies(f *Func) { } for i, w := range v.Args { c := b.Preds[i] - cpy := c.NewValue1(w.Line, OpCopy, v.Type, nil, w) + cpy := c.NewValue1(w.Line, OpCopy, v.Type, w) v.Args[i] = cpy } } diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go index fd0fc7e1a7..08ee7a9824 100644 --- a/src/cmd/compile/internal/ssa/rewrite.go +++ b/src/cmd/compile/internal/ssa/rewrite.go @@ -82,11 +82,8 @@ func typeSize(t Type) int64 { return t.Size() } -// addOff adds two offset aux values. Each should be an int64. Fails if wraparound happens. -func addOff(a, b interface{}) interface{} { - return addOffset(a.(int64), b.(int64)) -} -func addOffset(x, y int64) int64 { +// 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 { diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index f57cf7f333..d466e154e7 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -13,11 +13,12 @@ func rewriteValueAMD64(v *Value, config *Config) bool { if v.Args[1].Op != OpAMD64MOVQconst { goto endacffd55e74ee0ff59ad58a18ddfc9973 } - c := v.Args[1].Aux + c := v.Args[1].AuxInt v.Op = OpAMD64ADDQconst + v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = c + v.AuxInt = c v.AddArg(x) return true } @@ -31,58 +32,59 @@ func rewriteValueAMD64(v *Value, config *Config) bool { if v.Args[0].Op != OpAMD64MOVQconst { goto end7166f476d744ab7a51125959d3d3c7e2 } - c := v.Args[0].Aux + c := v.Args[0].AuxInt x := v.Args[1] v.Op = OpAMD64ADDQconst + v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = c + v.AuxInt = c v.AddArg(x) return true } goto end7166f476d744ab7a51125959d3d3c7e2 end7166f476d744ab7a51125959d3d3c7e2: ; - // match: (ADDQ x (SHLQconst [shift] y)) - // cond: shift.(int64) == 3 - // result: (LEAQ8 [int64(0)] x y) + // match: (ADDQ x (SHLQconst [3] y)) + // cond: + // result: (LEAQ8 x y) { x := v.Args[0] if v.Args[1].Op != OpAMD64SHLQconst { - goto endaf4f724e1e17f2b116d336c07da0165d + goto endc02313d35a0525d1d680cd58992e820d } - shift := v.Args[1].Aux - y := v.Args[1].Args[0] - if !(shift.(int64) == 3) { - goto endaf4f724e1e17f2b116d336c07da0165d + if v.Args[1].AuxInt != 3 { + goto endc02313d35a0525d1d680cd58992e820d } + y := v.Args[1].Args[0] v.Op = OpAMD64LEAQ8 + v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = int64(0) v.AddArg(x) v.AddArg(y) return true } - goto endaf4f724e1e17f2b116d336c07da0165d - endaf4f724e1e17f2b116d336c07da0165d: + goto endc02313d35a0525d1d680cd58992e820d + endc02313d35a0525d1d680cd58992e820d: ; case OpAMD64ADDQconst: // match: (ADDQconst [c] (LEAQ8 [d] x y)) // cond: // result: (LEAQ8 [addOff(c, d)] x y) { - c := v.Aux + c := v.AuxInt if v.Args[0].Op != OpAMD64LEAQ8 { goto ende2cc681c9abf9913288803fb1b39e639 } - d := v.Args[0].Aux + d := v.Args[0].AuxInt x := v.Args[0].Args[0] y := v.Args[0].Args[1] v.Op = OpAMD64LEAQ8 + v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = addOff(c, d) + v.AuxInt = addOff(c, d) v.AddArg(x) v.AddArg(y) return true @@ -90,23 +92,23 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto ende2cc681c9abf9913288803fb1b39e639 ende2cc681c9abf9913288803fb1b39e639: ; - // match: (ADDQconst [off] x) - // cond: off.(int64) == 0 + // match: (ADDQconst [0] x) + // cond: // result: (Copy x) { - off := v.Aux - x := v.Args[0] - if !(off.(int64) == 0) { - goto endfa1c7cc5ac4716697e891376787f86ce + if v.AuxInt != 0 { + goto end288952f259d4a1842f1e8d5c389b3f28 } + x := v.Args[0] v.Op = OpCopy + v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AddArg(x) return true } - goto endfa1c7cc5ac4716697e891376787f86ce - endfa1c7cc5ac4716697e891376787f86ce: + goto end288952f259d4a1842f1e8d5c389b3f28 + end288952f259d4a1842f1e8d5c389b3f28: ; case OpAMD64ANDQ: // match: (ANDQ x (MOVQconst [c])) @@ -117,11 +119,12 @@ func rewriteValueAMD64(v *Value, config *Config) bool { if v.Args[1].Op != OpAMD64MOVQconst { goto endb98096e3bbb90933e39c88bf41c688a9 } - c := v.Args[1].Aux + c := v.Args[1].AuxInt v.Op = OpAMD64ANDQconst + v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = c + v.AuxInt = c v.AddArg(x) return true } @@ -135,12 +138,13 @@ func rewriteValueAMD64(v *Value, config *Config) bool { if v.Args[0].Op != OpAMD64MOVQconst { goto endd313fd1897a0d2bc79eff70159a81b6b } - c := v.Args[0].Aux + c := v.Args[0].AuxInt x := v.Args[1] v.Op = OpAMD64ANDQconst + v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = c + v.AuxInt = c v.AddArg(x) return true } @@ -148,40 +152,40 @@ func rewriteValueAMD64(v *Value, config *Config) bool { endd313fd1897a0d2bc79eff70159a81b6b: ; case OpAMD64ANDQconst: - // match: (ANDQconst [c] _) - // cond: c.(int64) == 0 - // result: (MOVQconst [int64(0)]) + // match: (ANDQconst [0] _) + // cond: + // result: (MOVQconst [0]) { - c := v.Aux - if !(c.(int64) == 0) { - goto end383ada81cd8ffa88918387cd221acf5c + if v.AuxInt != 0 { + goto endf2afa4d9d31c344d6638dcdced383cf1 } v.Op = OpAMD64MOVQconst + v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = int64(0) + v.AuxInt = 0 return true } - goto end383ada81cd8ffa88918387cd221acf5c - end383ada81cd8ffa88918387cd221acf5c: + goto endf2afa4d9d31c344d6638dcdced383cf1 + endf2afa4d9d31c344d6638dcdced383cf1: ; - // match: (ANDQconst [c] x) - // cond: c.(int64) == -1 + // match: (ANDQconst [-1] x) + // cond: // result: (Copy x) { - c := v.Aux - x := v.Args[0] - if !(c.(int64) == -1) { - goto end90aef368f20963a6ba27b3e9317ccf03 + if v.AuxInt != -1 { + goto end646afc7b328db89ad16ebfa156ae26e5 } + x := v.Args[0] v.Op = OpCopy + v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AddArg(x) return true } - goto end90aef368f20963a6ba27b3e9317ccf03 - end90aef368f20963a6ba27b3e9317ccf03: + goto end646afc7b328db89ad16ebfa156ae26e5 + end646afc7b328db89ad16ebfa156ae26e5: ; case OpAdd: // match: (Add x y) @@ -195,6 +199,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endf031c523d7dd08e4b8e7010a94cd94c9 } v.Op = OpAMD64ADDQ + v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AddArg(x) @@ -215,6 +220,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end35a02a1587264e40cf1055856ff8445a } v.Op = OpAMD64ADDL + v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AddArg(x) @@ -226,54 +232,56 @@ func rewriteValueAMD64(v *Value, config *Config) bool { ; case OpAMD64CMOVQCC: // match: (CMOVQCC (CMPQconst [c] (MOVQconst [d])) _ x) - // cond: inBounds(d.(int64), c.(int64)) + // cond: inBounds(d, c) // result: (Copy x) { if v.Args[0].Op != OpAMD64CMPQconst { - goto endb8f4f98b06c41e559bf0323e798c147a + goto endd5357f3fd5516dcc859c8c5b3c9efaa4 } - c := v.Args[0].Aux + c := v.Args[0].AuxInt if v.Args[0].Args[0].Op != OpAMD64MOVQconst { - goto endb8f4f98b06c41e559bf0323e798c147a + goto endd5357f3fd5516dcc859c8c5b3c9efaa4 } - d := v.Args[0].Args[0].Aux + d := v.Args[0].Args[0].AuxInt x := v.Args[2] - if !(inBounds(d.(int64), c.(int64))) { - goto endb8f4f98b06c41e559bf0323e798c147a + if !(inBounds(d, c)) { + goto endd5357f3fd5516dcc859c8c5b3c9efaa4 } v.Op = OpCopy + v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AddArg(x) return true } - goto endb8f4f98b06c41e559bf0323e798c147a - endb8f4f98b06c41e559bf0323e798c147a: + goto endd5357f3fd5516dcc859c8c5b3c9efaa4 + endd5357f3fd5516dcc859c8c5b3c9efaa4: ; // match: (CMOVQCC (CMPQconst [c] (MOVQconst [d])) x _) - // cond: !inBounds(d.(int64), c.(int64)) + // cond: !inBounds(d, c) // result: (Copy x) { if v.Args[0].Op != OpAMD64CMPQconst { - goto end29407b5c4731ac24b4c25600752cb895 + goto end6ad8b1758415a9afe758272b34970d5d } - c := v.Args[0].Aux + c := v.Args[0].AuxInt if v.Args[0].Args[0].Op != OpAMD64MOVQconst { - goto end29407b5c4731ac24b4c25600752cb895 + goto end6ad8b1758415a9afe758272b34970d5d } - d := v.Args[0].Args[0].Aux + d := v.Args[0].Args[0].AuxInt x := v.Args[1] - if !(!inBounds(d.(int64), c.(int64))) { - goto end29407b5c4731ac24b4c25600752cb895 + if !(!inBounds(d, c)) { + goto end6ad8b1758415a9afe758272b34970d5d } v.Op = OpCopy + v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AddArg(x) return true } - goto end29407b5c4731ac24b4c25600752cb895 - end29407b5c4731ac24b4c25600752cb895: + goto end6ad8b1758415a9afe758272b34970d5d + end6ad8b1758415a9afe758272b34970d5d: ; case OpAMD64CMPQ: // match: (CMPQ x (MOVQconst [c])) @@ -284,12 +292,13 @@ func rewriteValueAMD64(v *Value, config *Config) bool { if v.Args[1].Op != OpAMD64MOVQconst { goto end32ef1328af280ac18fa8045a3502dae9 } - c := v.Args[1].Aux + c := v.Args[1].AuxInt v.Op = OpAMD64CMPQconst + v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AddArg(x) - v.Aux = c + v.AuxInt = c return true } goto end32ef1328af280ac18fa8045a3502dae9 @@ -302,15 +311,16 @@ func rewriteValueAMD64(v *Value, config *Config) bool { if v.Args[0].Op != OpAMD64MOVQconst { goto endf8ca12fe79290bc82b11cfa463bc9413 } - c := v.Args[0].Aux + c := v.Args[0].AuxInt x := v.Args[1] v.Op = OpAMD64InvertFlags + v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue(v.Line, OpAMD64CMPQconst, TypeInvalid, nil) + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) - v0.Aux = c + v0.AuxInt = c v.AddArg(v0) return true } @@ -326,6 +336,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { closure := v.Args[1] mem := v.Args[2] v.Op = OpAMD64CALLclosure + v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AddArg(entry) @@ -342,33 +353,35 @@ func rewriteValueAMD64(v *Value, config *Config) bool { // result: (MOVQconst [val]) { t := v.Type - val := v.Aux + val := v.AuxInt if !(is64BitInt(t)) { goto end7f5c5b34093fbc6860524cb803ee51bf } v.Op = OpAMD64MOVQconst + v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = val + v.AuxInt = val return true } goto end7f5c5b34093fbc6860524cb803ee51bf end7f5c5b34093fbc6860524cb803ee51bf: ; case OpGlobal: - // match: (Global [sym]) + // match: (Global {sym}) // cond: - // result: (LEAQglobal [GlobalOffset{sym,0}]) + // result: (LEAQglobal {sym}) { sym := v.Aux v.Op = OpAMD64LEAQglobal + v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = GlobalOffset{sym, 0} + v.Aux = sym return true } - goto end3a3c76fac0e2e53c0e1c60b9524e6f1c - end3a3c76fac0e2e53c0e1c60b9524e6f1c: + goto end8f47b6f351fecaeded45abbe5c2beec0 + end8f47b6f351fecaeded45abbe5c2beec0: ; case OpIsInBounds: // match: (IsInBounds idx len) @@ -378,9 +391,10 @@ func rewriteValueAMD64(v *Value, config *Config) bool { idx := v.Args[0] len := v.Args[1] v.Op = OpAMD64SETB + v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue(v.Line, OpAMD64CMPQ, TypeInvalid, nil) + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) v0.Type = TypeFlags v0.AddArg(idx) v0.AddArg(len) @@ -397,9 +411,10 @@ func rewriteValueAMD64(v *Value, config *Config) bool { { p := v.Args[0] v.Op = OpAMD64SETNE + v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue(v.Line, OpAMD64TESTQ, TypeInvalid, nil) + v0 := v.Block.NewValue0(v.Line, OpAMD64TESTQ, TypeInvalid) v0.Type = TypeFlags v0.AddArg(p) v0.AddArg(p) @@ -420,9 +435,10 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endcecf13a952d4c6c2383561c7d68a3cf9 } v.Op = OpAMD64SETL + v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue(v.Line, OpAMD64CMPQ, TypeInvalid, nil) + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) @@ -435,94 +451,96 @@ func rewriteValueAMD64(v *Value, config *Config) bool { case OpLoad: // match: (Load ptr mem) // cond: t.IsBoolean() - // result: (MOVBload [int64(0)] ptr mem) + // result: (MOVBload ptr mem) { t := v.Type ptr := v.Args[0] mem := v.Args[1] if !(t.IsBoolean()) { - goto end73f21632e56c3614902d3c29c82dc4ea + goto endc119e594c7f8e8ce5ff97c00b501dba0 } v.Op = OpAMD64MOVBload + v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = int64(0) v.AddArg(ptr) v.AddArg(mem) return true } - goto end73f21632e56c3614902d3c29c82dc4ea - end73f21632e56c3614902d3c29c82dc4ea: + goto endc119e594c7f8e8ce5ff97c00b501dba0 + endc119e594c7f8e8ce5ff97c00b501dba0: ; // match: (Load ptr mem) // cond: (is64BitInt(t) || isPtr(t)) - // result: (MOVQload [int64(0)] ptr mem) + // result: (MOVQload ptr mem) { t := v.Type ptr := v.Args[0] mem := v.Args[1] if !(is64BitInt(t) || isPtr(t)) { - goto end581ce5a20901df1b8143448ba031685b + goto end7c4c53acf57ebc5f03273652ba1d5934 } v.Op = OpAMD64MOVQload + v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = int64(0) v.AddArg(ptr) v.AddArg(mem) return true } - goto end581ce5a20901df1b8143448ba031685b - end581ce5a20901df1b8143448ba031685b: + goto end7c4c53acf57ebc5f03273652ba1d5934 + end7c4c53acf57ebc5f03273652ba1d5934: ; case OpLsh: // match: (Lsh x y) // cond: is64BitInt(t) - // result: (ANDQ (SHLQ x y) (SBBQcarrymask (CMPQconst [int64(64)] y))) + // result: (ANDQ (SHLQ x y) (SBBQcarrymask (CMPQconst [64] y))) { t := v.Type x := v.Args[0] y := v.Args[1] if !(is64BitInt(t)) { - goto end7002b6d4becf7d1247e3756641ccb0c2 + goto end5d9e2211940fbc82536685578cf37d08 } v.Op = OpAMD64ANDQ + v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue(v.Line, OpAMD64SHLQ, TypeInvalid, nil) + v0 := v.Block.NewValue0(v.Line, OpAMD64SHLQ, TypeInvalid) v0.Type = t v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := v.Block.NewValue(v.Line, OpAMD64SBBQcarrymask, TypeInvalid, nil) + v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) v1.Type = t - v2 := v.Block.NewValue(v.Line, OpAMD64CMPQconst, TypeInvalid, nil) + v2 := v.Block.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) v2.Type = TypeFlags - v2.Aux = int64(64) + v2.AuxInt = 64 v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) return true } - goto end7002b6d4becf7d1247e3756641ccb0c2 - end7002b6d4becf7d1247e3756641ccb0c2: + goto end5d9e2211940fbc82536685578cf37d08 + end5d9e2211940fbc82536685578cf37d08: ; case OpAMD64MOVQload: // match: (MOVQload [off1] (ADDQconst [off2] ptr) mem) // cond: // result: (MOVQload [addOff(off1, off2)] ptr mem) { - off1 := v.Aux + off1 := v.AuxInt if v.Args[0].Op != OpAMD64ADDQconst { goto end843d29b538c4483b432b632e5666d6e3 } - off2 := v.Args[0].Aux + off2 := v.Args[0].AuxInt ptr := v.Args[0].Args[0] mem := v.Args[1] v.Op = OpAMD64MOVQload + v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = addOff(off1, off2) + v.AuxInt = addOff(off1, off2) v.AddArg(ptr) v.AddArg(mem) return true @@ -534,18 +552,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { // cond: // result: (MOVQloadidx8 [addOff(off1, off2)] ptr idx mem) { - off1 := v.Aux + off1 := v.AuxInt if v.Args[0].Op != OpAMD64LEAQ8 { goto end02f5ad148292c46463e7c20d3b821735 } - off2 := v.Args[0].Aux + off2 := v.Args[0].AuxInt ptr := v.Args[0].Args[0] idx := v.Args[0].Args[1] mem := v.Args[1] v.Op = OpAMD64MOVQloadidx8 + v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = addOff(off1, off2) + v.AuxInt = addOff(off1, off2) v.AddArg(ptr) v.AddArg(idx) v.AddArg(mem) @@ -559,18 +578,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { // cond: // result: (MOVQloadidx8 [addOff(off1, off2)] ptr idx mem) { - off1 := v.Aux + off1 := v.AuxInt if v.Args[0].Op != OpAMD64ADDQconst { goto ende81e44bcfb11f90916ccb440c590121f } - off2 := v.Args[0].Aux + off2 := v.Args[0].AuxInt ptr := v.Args[0].Args[0] idx := v.Args[1] mem := v.Args[2] v.Op = OpAMD64MOVQloadidx8 + v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = addOff(off1, off2) + v.AuxInt = addOff(off1, off2) v.AddArg(ptr) v.AddArg(idx) v.AddArg(mem) @@ -584,18 +604,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { // cond: // result: (MOVQstore [addOff(off1, off2)] ptr val mem) { - off1 := v.Aux + off1 := v.AuxInt if v.Args[0].Op != OpAMD64ADDQconst { goto end2108c693a43c79aed10b9246c39c80aa } - off2 := v.Args[0].Aux + off2 := v.Args[0].AuxInt ptr := v.Args[0].Args[0] val := v.Args[1] mem := v.Args[2] v.Op = OpAMD64MOVQstore + v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = addOff(off1, off2) + v.AuxInt = addOff(off1, off2) v.AddArg(ptr) v.AddArg(val) v.AddArg(mem) @@ -608,19 +629,20 @@ func rewriteValueAMD64(v *Value, config *Config) bool { // cond: // result: (MOVQstoreidx8 [addOff(off1, off2)] ptr idx val mem) { - off1 := v.Aux + off1 := v.AuxInt if v.Args[0].Op != OpAMD64LEAQ8 { goto endce1db8c8d37c8397c500a2068a65c215 } - off2 := v.Args[0].Aux + off2 := v.Args[0].AuxInt ptr := v.Args[0].Args[0] idx := v.Args[0].Args[1] val := v.Args[1] mem := v.Args[2] v.Op = OpAMD64MOVQstoreidx8 + v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = addOff(off1, off2) + v.AuxInt = addOff(off1, off2) v.AddArg(ptr) v.AddArg(idx) v.AddArg(val) @@ -635,19 +657,20 @@ func rewriteValueAMD64(v *Value, config *Config) bool { // cond: // result: (MOVQstoreidx8 [addOff(off1, off2)] ptr idx val mem) { - off1 := v.Aux + off1 := v.AuxInt if v.Args[0].Op != OpAMD64ADDQconst { goto end01c970657b0fdefeab82458c15022163 } - off2 := v.Args[0].Aux + off2 := v.Args[0].AuxInt ptr := v.Args[0].Args[0] idx := v.Args[1] val := v.Args[2] mem := v.Args[3] v.Op = OpAMD64MOVQstoreidx8 + v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = addOff(off1, off2) + v.AuxInt = addOff(off1, off2) v.AddArg(ptr) v.AddArg(idx) v.AddArg(val) @@ -659,26 +682,27 @@ func rewriteValueAMD64(v *Value, config *Config) bool { ; case OpAMD64MULQ: // match: (MULQ x (MOVQconst [c])) - // cond: c.(int64) == int64(int32(c.(int64))) + // cond: c == int64(int32(c)) // result: (MULQconst [c] x) { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVQconst { - goto ende8c09b194fcde7d9cdc69f2deff86304 + goto end680a32a37babfff4bfa7d23be592a131 } - c := v.Args[1].Aux - if !(c.(int64) == int64(int32(c.(int64)))) { - goto ende8c09b194fcde7d9cdc69f2deff86304 + c := v.Args[1].AuxInt + if !(c == int64(int32(c))) { + goto end680a32a37babfff4bfa7d23be592a131 } v.Op = OpAMD64MULQconst + v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = c + v.AuxInt = c v.AddArg(x) return true } - goto ende8c09b194fcde7d9cdc69f2deff86304 - ende8c09b194fcde7d9cdc69f2deff86304: + goto end680a32a37babfff4bfa7d23be592a131 + end680a32a37babfff4bfa7d23be592a131: ; // match: (MULQ (MOVQconst [c]) x) // cond: @@ -687,12 +711,13 @@ func rewriteValueAMD64(v *Value, config *Config) bool { if v.Args[0].Op != OpAMD64MOVQconst { goto endc6e18d6968175d6e58eafa6dcf40c1b8 } - c := v.Args[0].Aux + c := v.Args[0].AuxInt x := v.Args[1] v.Op = OpAMD64MULQconst + v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = c + v.AuxInt = c v.AddArg(x) return true } @@ -700,67 +725,68 @@ func rewriteValueAMD64(v *Value, config *Config) bool { endc6e18d6968175d6e58eafa6dcf40c1b8: ; case OpAMD64MULQconst: - // match: (MULQconst [c] x) - // cond: c.(int64) == 8 - // result: (SHLQconst [int64(3)] x) + // match: (MULQconst [8] x) + // cond: + // result: (SHLQconst [3] x) { - c := v.Aux - x := v.Args[0] - if !(c.(int64) == 8) { - goto end7e16978c56138324ff2abf91fd6d94d4 + if v.AuxInt != 8 { + goto ende8d313a52a134fb2e1c0beb54ea599fd } + x := v.Args[0] v.Op = OpAMD64SHLQconst + v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = int64(3) + v.AuxInt = 3 v.AddArg(x) return true } - goto end7e16978c56138324ff2abf91fd6d94d4 - end7e16978c56138324ff2abf91fd6d94d4: + goto ende8d313a52a134fb2e1c0beb54ea599fd + ende8d313a52a134fb2e1c0beb54ea599fd: ; - // match: (MULQconst [c] x) - // cond: c.(int64) == 64 - // result: (SHLQconst [int64(5)] x) + // match: (MULQconst [64] x) + // cond: + // result: (SHLQconst [5] x) { - c := v.Aux - x := v.Args[0] - if !(c.(int64) == 64) { - goto end2c7a02f230e4b311ac3a4e22f70a4f08 + if v.AuxInt != 64 { + goto end75c0c250c703f89e6c43d718dd5ea3c0 } + x := v.Args[0] v.Op = OpAMD64SHLQconst + v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = int64(5) + v.AuxInt = 5 v.AddArg(x) return true } - goto end2c7a02f230e4b311ac3a4e22f70a4f08 - end2c7a02f230e4b311ac3a4e22f70a4f08: + goto end75c0c250c703f89e6c43d718dd5ea3c0 + end75c0c250c703f89e6c43d718dd5ea3c0: ; case OpMove: // match: (Move [size] dst src mem) // cond: - // result: (REPMOVSB dst src (Const [size.(int64)]) mem) + // result: (REPMOVSB dst src (Const [size]) mem) { - size := v.Aux + size := v.AuxInt dst := v.Args[0] src := v.Args[1] mem := v.Args[2] v.Op = OpAMD64REPMOVSB + v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AddArg(dst) v.AddArg(src) - v0 := v.Block.NewValue(v.Line, OpConst, TypeInvalid, nil) + v0 := v.Block.NewValue0(v.Line, OpConst, TypeInvalid) v0.Type = TypeUInt64 - v0.Aux = size.(int64) + v0.AuxInt = size v.AddArg(v0) v.AddArg(mem) return true } - goto end48909259b265a6bb2a076bc2c2dc7d1f - end48909259b265a6bb2a076bc2c2dc7d1f: + goto end1b2d226705fd31dbbe74e3286af178ea + end1b2d226705fd31dbbe74e3286af178ea: ; case OpMul: // match: (Mul x y) @@ -774,6 +800,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endfab0d598f376ecba45a22587d50f7aff } v.Op = OpAMD64MULQ + v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AddArg(x) @@ -788,12 +815,13 @@ func rewriteValueAMD64(v *Value, config *Config) bool { // cond: // result: (ADDQconst [off] ptr) { - off := v.Aux + off := v.AuxInt ptr := v.Args[0] v.Op = OpAMD64ADDQconst + v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = off + v.AuxInt = off v.AddArg(ptr) return true } @@ -803,67 +831,69 @@ func rewriteValueAMD64(v *Value, config *Config) bool { case OpRsh: // match: (Rsh x y) // cond: is64BitInt(t) && !t.IsSigned() - // result: (ANDQ (SHRQ x y) (SBBQcarrymask (CMPQconst [int64(64)] y))) + // result: (ANDQ (SHRQ x y) (SBBQcarrymask (CMPQconst [64] y))) { t := v.Type x := v.Args[0] y := v.Args[1] if !(is64BitInt(t) && !t.IsSigned()) { - goto end9463ddaa21c75f8e15cb9f31472a2e23 + goto ende3e068773b8e6def1eaedb4f404ca6e5 } v.Op = OpAMD64ANDQ + v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue(v.Line, OpAMD64SHRQ, TypeInvalid, nil) + v0 := v.Block.NewValue0(v.Line, OpAMD64SHRQ, TypeInvalid) v0.Type = t v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := v.Block.NewValue(v.Line, OpAMD64SBBQcarrymask, TypeInvalid, nil) + v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) v1.Type = t - v2 := v.Block.NewValue(v.Line, OpAMD64CMPQconst, TypeInvalid, nil) + v2 := v.Block.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) v2.Type = TypeFlags - v2.Aux = int64(64) + v2.AuxInt = 64 v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) return true } - goto end9463ddaa21c75f8e15cb9f31472a2e23 - end9463ddaa21c75f8e15cb9f31472a2e23: + goto ende3e068773b8e6def1eaedb4f404ca6e5 + ende3e068773b8e6def1eaedb4f404ca6e5: ; // match: (Rsh x y) // cond: is64BitInt(t) && t.IsSigned() - // result: (SARQ x (CMOVQCC (CMPQconst [int64(64)] y) (Const [int64(63)]) y)) + // result: (SARQ x (CMOVQCC (CMPQconst [64] y) (Const [63]) y)) { t := v.Type x := v.Args[0] y := v.Args[1] if !(is64BitInt(t) && t.IsSigned()) { - goto endd297b9e569ac90bf815bd4c425d3b770 + goto end901ea4851cd5d2277a1ca1bee8f69d59 } v.Op = OpAMD64SARQ + v.AuxInt = 0 v.Aux = nil v.resetArgs() v.Type = t v.AddArg(x) - v0 := v.Block.NewValue(v.Line, OpAMD64CMOVQCC, TypeInvalid, nil) + v0 := v.Block.NewValue0(v.Line, OpAMD64CMOVQCC, TypeInvalid) v0.Type = t - v1 := v.Block.NewValue(v.Line, OpAMD64CMPQconst, TypeInvalid, nil) + v1 := v.Block.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) v1.Type = TypeFlags - v1.Aux = int64(64) + v1.AuxInt = 64 v1.AddArg(y) v0.AddArg(v1) - v2 := v.Block.NewValue(v.Line, OpConst, TypeInvalid, nil) + v2 := v.Block.NewValue0(v.Line, OpConst, TypeInvalid) v2.Type = t - v2.Aux = int64(63) + v2.AuxInt = 63 v0.AddArg(v2) v0.AddArg(y) v.AddArg(v0) return true } - goto endd297b9e569ac90bf815bd4c425d3b770 - endd297b9e569ac90bf815bd4c425d3b770: + goto end901ea4851cd5d2277a1ca1bee8f69d59 + end901ea4851cd5d2277a1ca1bee8f69d59: ; case OpAMD64SARQ: // match: (SARQ x (MOVQconst [c])) @@ -874,11 +904,12 @@ func rewriteValueAMD64(v *Value, config *Config) bool { if v.Args[1].Op != OpAMD64MOVQconst { goto end031712b4008075e25a5827dcb8dd3ebb } - c := v.Args[1].Aux + c := v.Args[1].AuxInt v.Op = OpAMD64SARQconst + v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = c + v.AuxInt = c v.AddArg(x) return true } @@ -887,52 +918,54 @@ func rewriteValueAMD64(v *Value, config *Config) bool { ; case OpAMD64SBBQcarrymask: // match: (SBBQcarrymask (CMPQconst [c] (MOVQconst [d]))) - // cond: inBounds(d.(int64), c.(int64)) - // result: (Const [int64(-1)]) + // cond: inBounds(d, c) + // result: (Const [-1]) { if v.Args[0].Op != OpAMD64CMPQconst { - goto end35e369f67ebb9423a1d36a808a16777c + goto endf67d323ecef000dbcd15d7e031c3475e } - c := v.Args[0].Aux + c := v.Args[0].AuxInt if v.Args[0].Args[0].Op != OpAMD64MOVQconst { - goto end35e369f67ebb9423a1d36a808a16777c + goto endf67d323ecef000dbcd15d7e031c3475e } - d := v.Args[0].Args[0].Aux - if !(inBounds(d.(int64), c.(int64))) { - goto end35e369f67ebb9423a1d36a808a16777c + d := v.Args[0].Args[0].AuxInt + if !(inBounds(d, c)) { + goto endf67d323ecef000dbcd15d7e031c3475e } v.Op = OpConst + v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = int64(-1) + v.AuxInt = -1 return true } - goto end35e369f67ebb9423a1d36a808a16777c - end35e369f67ebb9423a1d36a808a16777c: + goto endf67d323ecef000dbcd15d7e031c3475e + endf67d323ecef000dbcd15d7e031c3475e: ; // match: (SBBQcarrymask (CMPQconst [c] (MOVQconst [d]))) - // cond: !inBounds(d.(int64), c.(int64)) - // result: (Const [int64(0)]) + // cond: !inBounds(d, c) + // result: (Const [0]) { if v.Args[0].Op != OpAMD64CMPQconst { - goto end5c767fada028c1cc96210af2cf098aff + goto end4157ddea9c4f71bfabfd6fa50e1208ed } - c := v.Args[0].Aux + c := v.Args[0].AuxInt if v.Args[0].Args[0].Op != OpAMD64MOVQconst { - goto end5c767fada028c1cc96210af2cf098aff + goto end4157ddea9c4f71bfabfd6fa50e1208ed } - d := v.Args[0].Args[0].Aux - if !(!inBounds(d.(int64), c.(int64))) { - goto end5c767fada028c1cc96210af2cf098aff + d := v.Args[0].Args[0].AuxInt + if !(!inBounds(d, c)) { + goto end4157ddea9c4f71bfabfd6fa50e1208ed } v.Op = OpConst + v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = int64(0) + v.AuxInt = 0 return true } - goto end5c767fada028c1cc96210af2cf098aff - end5c767fada028c1cc96210af2cf098aff: + goto end4157ddea9c4f71bfabfd6fa50e1208ed + end4157ddea9c4f71bfabfd6fa50e1208ed: ; case OpAMD64SETG: // match: (SETG (InvertFlags x)) @@ -944,6 +977,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { } x := v.Args[0].Args[0] v.Op = OpAMD64SETL + v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AddArg(x) @@ -962,6 +996,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { } x := v.Args[0].Args[0] v.Op = OpAMD64SETG + v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AddArg(x) @@ -979,11 +1014,12 @@ func rewriteValueAMD64(v *Value, config *Config) bool { if v.Args[1].Op != OpAMD64MOVQconst { goto endcca412bead06dc3d56ef034a82d184d6 } - c := v.Args[1].Aux + c := v.Args[1].AuxInt v.Op = OpAMD64SHLQconst + v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = c + v.AuxInt = c v.AddArg(x) return true } @@ -999,11 +1035,12 @@ func rewriteValueAMD64(v *Value, config *Config) bool { if v.Args[1].Op != OpAMD64MOVQconst { goto endbb0d3a04dd2b810cb3dbdf7ef665f22b } - c := v.Args[1].Aux + c := v.Args[1].AuxInt v.Op = OpAMD64SHRQconst + v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = c + v.AuxInt = c v.AddArg(x) return true } @@ -1019,12 +1056,13 @@ func rewriteValueAMD64(v *Value, config *Config) bool { if v.Args[1].Op != OpAMD64MOVQconst { goto end5a74a63bd9ad15437717c6df3b25eebb } - c := v.Args[1].Aux + c := v.Args[1].AuxInt v.Op = OpAMD64SUBQconst + v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AddArg(x) - v.Aux = c + v.AuxInt = c return true } goto end5a74a63bd9ad15437717c6df3b25eebb @@ -1038,15 +1076,16 @@ func rewriteValueAMD64(v *Value, config *Config) bool { if v.Args[0].Op != OpAMD64MOVQconst { goto end78e66b6fc298684ff4ac8aec5ce873c9 } - c := v.Args[0].Aux + c := v.Args[0].AuxInt x := v.Args[1] v.Op = OpAMD64NEGQ + v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue(v.Line, OpAMD64SUBQconst, TypeInvalid, nil) + v0 := v.Block.NewValue0(v.Line, OpAMD64SUBQconst, TypeInvalid) v0.Type = t v0.AddArg(x) - v0.Aux = c + v0.AuxInt = c v.AddArg(v0) return true } @@ -1058,12 +1097,13 @@ func rewriteValueAMD64(v *Value, config *Config) bool { // cond: // result: (CALLstatic [target] mem) { - target := v.Aux + target := v.AuxInt mem := v.Args[0] v.Op = OpAMD64CALLstatic + v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = target + v.AuxInt = target v.AddArg(mem) return true } @@ -1073,25 +1113,25 @@ func rewriteValueAMD64(v *Value, config *Config) bool { case OpStore: // match: (Store ptr val mem) // cond: (is64BitInt(val.Type) || isPtr(val.Type)) - // result: (MOVQstore [int64(0)] ptr val mem) + // result: (MOVQstore ptr val mem) { ptr := v.Args[0] val := v.Args[1] mem := v.Args[2] if !(is64BitInt(val.Type) || isPtr(val.Type)) { - goto end9680b43f504bc06f9fab000823ce471a + goto endbaeb60123806948cd2433605820d5af1 } v.Op = OpAMD64MOVQstore + v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = int64(0) v.AddArg(ptr) v.AddArg(val) v.AddArg(mem) return true } - goto end9680b43f504bc06f9fab000823ce471a - end9680b43f504bc06f9fab000823ce471a: + goto endbaeb60123806948cd2433605820d5af1 + endbaeb60123806948cd2433605820d5af1: ; case OpSub: // match: (Sub x y) @@ -1105,6 +1145,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto ende6ef29f885a8ecf3058212bb95917323 } v.Op = OpAMD64SUBQ + v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AddArg(x) @@ -1254,7 +1295,7 @@ func rewriteBlockAMD64(b *Block) bool { goto end7e22019fb0effc80f85c05ea30bdb5d9 } b.Kind = BlockAMD64NE - v0 := v.Block.NewValue(v.Line, OpAMD64TESTB, TypeInvalid, nil) + v0 := v.Block.NewValue0(v.Line, OpAMD64TESTB, TypeInvalid) v0.Type = TypeFlags v0.AddArg(cond) v0.AddArg(cond) diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index e38439de14..0ecc436343 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -7,28 +7,29 @@ func rewriteValuegeneric(v *Value, config *Config) bool { case OpAdd: // match: (Add (Const [c]) (Const [d])) // cond: is64BitInt(t) - // result: (Const [{c.(int64)+d.(int64)}]) + // result: (Const [c+d]) { t := v.Type if v.Args[0].Op != OpConst { - goto end8d047ed0ae9537b840adc79ea82c6e05 + goto end279f4ea85ed10e5ffc5b53f9e060529b } - c := v.Args[0].Aux + c := v.Args[0].AuxInt if v.Args[1].Op != OpConst { - goto end8d047ed0ae9537b840adc79ea82c6e05 + goto end279f4ea85ed10e5ffc5b53f9e060529b } - d := v.Args[1].Aux + d := v.Args[1].AuxInt if !(is64BitInt(t)) { - goto end8d047ed0ae9537b840adc79ea82c6e05 + goto end279f4ea85ed10e5ffc5b53f9e060529b } v.Op = OpConst + v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = c.(int64) + d.(int64) + v.AuxInt = c + d return true } - goto end8d047ed0ae9537b840adc79ea82c6e05 - end8d047ed0ae9537b840adc79ea82c6e05: + goto end279f4ea85ed10e5ffc5b53f9e060529b + end279f4ea85ed10e5ffc5b53f9e060529b: ; case OpArrayIndex: // match: (ArrayIndex (Load ptr mem) idx) @@ -42,9 +43,10 @@ func rewriteValuegeneric(v *Value, config *Config) bool { mem := v.Args[0].Args[1] idx := v.Args[1] v.Op = OpLoad + v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue(v.Line, OpPtrIndex, TypeInvalid, nil) + v0 := v.Block.NewValue0(v.Line, OpPtrIndex, TypeInvalid) v0.Type = ptr.Type.Elem().Elem().PtrTo() v0.AddArg(ptr) v0.AddArg(idx) @@ -56,56 +58,58 @@ func rewriteValuegeneric(v *Value, config *Config) bool { end3809f4c52270a76313e4ea26e6f0b753: ; case OpConst: - // match: (Const [s]) + // match: (Const {s}) // cond: t.IsString() - // result: (StringMake (OffPtr [2*config.ptrSize] (Global [config.fe.StringSym(s.(string))])) (Const [int64(len(s.(string)))])) + // result: (StringMake (OffPtr [2*config.ptrSize] (Global {config.fe.StringSym(s.(string))})) (Const [int64(len(s.(string)))])) { t := v.Type s := v.Aux if !(t.IsString()) { - goto end8442aa5b3f4e5b840055475883110372 + goto end6d6321106a054a5984b2ed0acec52a5b } v.Op = OpStringMake + v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue(v.Line, OpOffPtr, TypeInvalid, nil) + v0 := v.Block.NewValue0(v.Line, OpOffPtr, TypeInvalid) v0.Type = TypeBytePtr - v0.Aux = 2 * config.ptrSize - v1 := v.Block.NewValue(v.Line, OpGlobal, TypeInvalid, nil) + v0.AuxInt = 2 * config.ptrSize + v1 := v.Block.NewValue0(v.Line, OpGlobal, TypeInvalid) v1.Type = TypeBytePtr v1.Aux = config.fe.StringSym(s.(string)) v0.AddArg(v1) v.AddArg(v0) - v2 := v.Block.NewValue(v.Line, OpConst, TypeInvalid, nil) + v2 := v.Block.NewValue0(v.Line, OpConst, TypeInvalid) v2.Type = config.Uintptr - v2.Aux = int64(len(s.(string))) + v2.AuxInt = int64(len(s.(string))) v.AddArg(v2) return true } - goto end8442aa5b3f4e5b840055475883110372 - end8442aa5b3f4e5b840055475883110372: + goto end6d6321106a054a5984b2ed0acec52a5b + end6d6321106a054a5984b2ed0acec52a5b: ; case OpIsInBounds: // match: (IsInBounds (Const [c]) (Const [d])) // cond: - // result: (Const [inBounds(c.(int64),d.(int64))]) + // result: (Const {inBounds(c,d)}) { if v.Args[0].Op != OpConst { - goto enddbd1a394d9b71ee64335361b8384865c + goto enda96ccac78df2d17ae96c8baf2af2e189 } - c := v.Args[0].Aux + c := v.Args[0].AuxInt if v.Args[1].Op != OpConst { - goto enddbd1a394d9b71ee64335361b8384865c + goto enda96ccac78df2d17ae96c8baf2af2e189 } - d := v.Args[1].Aux + d := v.Args[1].AuxInt v.Op = OpConst + v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = inBounds(c.(int64), d.(int64)) + v.Aux = inBounds(c, d) return true } - goto enddbd1a394d9b71ee64335361b8384865c - enddbd1a394d9b71ee64335361b8384865c: + goto enda96ccac78df2d17ae96c8baf2af2e189 + enda96ccac78df2d17ae96c8baf2af2e189: ; case OpLoad: // match: (Load ptr mem) @@ -119,18 +123,19 @@ func rewriteValuegeneric(v *Value, config *Config) bool { goto endd0afd003b70d726a1c5bbaf51fe06182 } v.Op = OpStringMake + v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue(v.Line, OpLoad, TypeInvalid, nil) + v0 := v.Block.NewValue0(v.Line, OpLoad, TypeInvalid) v0.Type = TypeBytePtr v0.AddArg(ptr) v0.AddArg(mem) v.AddArg(v0) - v1 := v.Block.NewValue(v.Line, OpLoad, TypeInvalid, nil) + v1 := v.Block.NewValue0(v.Line, OpLoad, TypeInvalid) v1.Type = config.Uintptr - v2 := v.Block.NewValue(v.Line, OpOffPtr, TypeInvalid, nil) + v2 := v.Block.NewValue0(v.Line, OpOffPtr, TypeInvalid) v2.Type = TypeBytePtr - v2.Aux = config.ptrSize + v2.AuxInt = config.ptrSize v2.AddArg(ptr) v1.AddArg(v2) v1.AddArg(mem) @@ -143,28 +148,29 @@ func rewriteValuegeneric(v *Value, config *Config) bool { case OpMul: // match: (Mul (Const [c]) (Const [d])) // cond: is64BitInt(t) - // result: (Const [{c.(int64)*d.(int64)}]) + // result: (Const [c*d]) { t := v.Type if v.Args[0].Op != OpConst { - goto end776610f88cf04f438242d76ed2b14f1c + goto endd82095c6a872974522d33aaff1ee07be } - c := v.Args[0].Aux + c := v.Args[0].AuxInt if v.Args[1].Op != OpConst { - goto end776610f88cf04f438242d76ed2b14f1c + goto endd82095c6a872974522d33aaff1ee07be } - d := v.Args[1].Aux + d := v.Args[1].AuxInt if !(is64BitInt(t)) { - goto end776610f88cf04f438242d76ed2b14f1c + goto endd82095c6a872974522d33aaff1ee07be } v.Op = OpConst + v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = c.(int64) * d.(int64) + v.AuxInt = c * d return true } - goto end776610f88cf04f438242d76ed2b14f1c - end776610f88cf04f438242d76ed2b14f1c: + goto endd82095c6a872974522d33aaff1ee07be + endd82095c6a872974522d33aaff1ee07be: ; case OpPtrIndex: // match: (PtrIndex ptr idx) @@ -175,15 +181,16 @@ func rewriteValuegeneric(v *Value, config *Config) bool { ptr := v.Args[0] idx := v.Args[1] v.Op = OpAdd + v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AddArg(ptr) - v0 := v.Block.NewValue(v.Line, OpMul, TypeInvalid, nil) + v0 := v.Block.NewValue0(v.Line, OpMul, TypeInvalid) v0.Type = config.Uintptr v0.AddArg(idx) - v1 := v.Block.NewValue(v.Line, OpConst, TypeInvalid, nil) + v1 := v.Block.NewValue0(v.Line, OpConst, TypeInvalid) v1.Type = config.Uintptr - v1.Aux = t.Elem().Size() + v1.AuxInt = t.Elem().Size() v0.AddArg(v1) v.AddArg(v0) return true @@ -194,56 +201,58 @@ func rewriteValuegeneric(v *Value, config *Config) bool { case OpSliceCap: // match: (SliceCap (Load ptr mem)) // cond: - // result: (Load (Add ptr (Const [int64(config.ptrSize*2)])) mem) + // result: (Load (Add ptr (Const [config.ptrSize*2])) mem) { if v.Args[0].Op != OpLoad { - goto endc871dcd9a720b4290c9cae78fe147c8a + goto end919cfa3d3539eb2e06a435d5f89654b9 } ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] v.Op = OpLoad + v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue(v.Line, OpAdd, TypeInvalid, nil) + v0 := v.Block.NewValue0(v.Line, OpAdd, TypeInvalid) v0.Type = ptr.Type v0.AddArg(ptr) - v1 := v.Block.NewValue(v.Line, OpConst, TypeInvalid, nil) + v1 := v.Block.NewValue0(v.Line, OpConst, TypeInvalid) v1.Type = config.Uintptr - v1.Aux = int64(config.ptrSize * 2) + v1.AuxInt = config.ptrSize * 2 v0.AddArg(v1) v.AddArg(v0) v.AddArg(mem) return true } - goto endc871dcd9a720b4290c9cae78fe147c8a - endc871dcd9a720b4290c9cae78fe147c8a: + goto end919cfa3d3539eb2e06a435d5f89654b9 + end919cfa3d3539eb2e06a435d5f89654b9: ; case OpSliceLen: // match: (SliceLen (Load ptr mem)) // cond: - // result: (Load (Add ptr (Const [int64(config.ptrSize)])) mem) + // result: (Load (Add ptr (Const [config.ptrSize])) mem) { if v.Args[0].Op != OpLoad { - goto end1eec05e44f5fc8944e7c176f98a74d92 + goto end3d74a5ef07180a709a91052da88bcd01 } ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] v.Op = OpLoad + v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue(v.Line, OpAdd, TypeInvalid, nil) + v0 := v.Block.NewValue0(v.Line, OpAdd, TypeInvalid) v0.Type = ptr.Type v0.AddArg(ptr) - v1 := v.Block.NewValue(v.Line, OpConst, TypeInvalid, nil) + v1 := v.Block.NewValue0(v.Line, OpConst, TypeInvalid) v1.Type = config.Uintptr - v1.Aux = int64(config.ptrSize) + v1.AuxInt = config.ptrSize v0.AddArg(v1) v.AddArg(v0) v.AddArg(mem) return true } - goto end1eec05e44f5fc8944e7c176f98a74d92 - end1eec05e44f5fc8944e7c176f98a74d92: + goto end3d74a5ef07180a709a91052da88bcd01 + end3d74a5ef07180a709a91052da88bcd01: ; case OpSlicePtr: // match: (SlicePtr (Load ptr mem)) @@ -256,6 +265,7 @@ func rewriteValuegeneric(v *Value, config *Config) bool { ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] v.Op = OpLoad + v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AddArg(ptr) @@ -284,9 +294,10 @@ func rewriteValuegeneric(v *Value, config *Config) bool { goto end324ffb6d2771808da4267f62c854e9c8 } v.Op = OpMove + v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = t.Size() + v.AuxInt = t.Size() v.AddArg(dst) v.AddArg(src) v.AddArg(mem) @@ -306,21 +317,22 @@ func rewriteValuegeneric(v *Value, config *Config) bool { goto end410559d97aed8018f820cd88723de442 } v.Op = OpStore + v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue(v.Line, OpOffPtr, TypeInvalid, nil) + v0 := v.Block.NewValue0(v.Line, OpOffPtr, TypeInvalid) v0.Type = TypeBytePtr - v0.Aux = config.ptrSize + v0.AuxInt = config.ptrSize v0.AddArg(dst) v.AddArg(v0) - v1 := v.Block.NewValue(v.Line, OpStringLen, TypeInvalid, nil) + v1 := v.Block.NewValue0(v.Line, OpStringLen, TypeInvalid) v1.Type = config.Uintptr v1.AddArg(str) v.AddArg(v1) - v2 := v.Block.NewValue(v.Line, OpStore, TypeInvalid, nil) + v2 := v.Block.NewValue0(v.Line, OpStore, TypeInvalid) v2.Type = TypeMem v2.AddArg(dst) - v3 := v.Block.NewValue(v.Line, OpStringPtr, TypeInvalid, nil) + v3 := v.Block.NewValue0(v.Line, OpStringPtr, TypeInvalid) v3.Type = TypeBytePtr v3.AddArg(str) v2.AddArg(v3) @@ -341,6 +353,7 @@ func rewriteValuegeneric(v *Value, config *Config) bool { } len := v.Args[0].Args[1] v.Op = len.Op + v.AuxInt = len.AuxInt v.Aux = len.Aux v.resetArgs() v.AddArgs(len.Args...) @@ -359,6 +372,7 @@ func rewriteValuegeneric(v *Value, config *Config) bool { } ptr := v.Args[0].Args[0] v.Op = ptr.Op + v.AuxInt = ptr.AuxInt v.Aux = ptr.Aux v.resetArgs() v.AddArgs(ptr.Args...) @@ -372,19 +386,19 @@ func rewriteValuegeneric(v *Value, config *Config) bool { func rewriteBlockgeneric(b *Block) bool { switch b.Kind { case BlockIf: - // match: (If (Const [c]) yes no) + // match: (If (Const {c}) yes no) // cond: c.(bool) // result: (Plain nil yes) { v := b.Control if v.Op != OpConst { - goto end60cde11c1be8092f493d9cda982445ca + goto end915e334b6388fed7d63e09aa69ecb05c } c := v.Aux yes := b.Succs[0] no := b.Succs[1] if !(c.(bool)) { - goto end60cde11c1be8092f493d9cda982445ca + goto end915e334b6388fed7d63e09aa69ecb05c } removePredecessor(b, no) b.Kind = BlockPlain @@ -393,22 +407,22 @@ func rewriteBlockgeneric(b *Block) bool { b.Succs[0] = yes return true } - goto end60cde11c1be8092f493d9cda982445ca - end60cde11c1be8092f493d9cda982445ca: + goto end915e334b6388fed7d63e09aa69ecb05c + end915e334b6388fed7d63e09aa69ecb05c: ; - // match: (If (Const [c]) yes no) + // match: (If (Const {c}) yes no) // cond: !c.(bool) // result: (Plain nil no) { v := b.Control if v.Op != OpConst { - goto endf2a5efbfd2d40dead087c33685c8f30b + goto end6452ee3a5bb02c708bddc3181c3ea3cb } c := v.Aux yes := b.Succs[0] no := b.Succs[1] if !(!c.(bool)) { - goto endf2a5efbfd2d40dead087c33685c8f30b + goto end6452ee3a5bb02c708bddc3181c3ea3cb } removePredecessor(b, yes) b.Kind = BlockPlain @@ -417,8 +431,8 @@ func rewriteBlockgeneric(b *Block) bool { b.Succs[0] = no return true } - goto endf2a5efbfd2d40dead087c33685c8f30b - endf2a5efbfd2d40dead087c33685c8f30b: + goto end6452ee3a5bb02c708bddc3181c3ea3cb + end6452ee3a5bb02c708bddc3181c3ea3cb: } return false } diff --git a/src/cmd/compile/internal/ssa/schedule_test.go b/src/cmd/compile/internal/ssa/schedule_test.go index 4830f79628..a7c33d9d59 100644 --- a/src/cmd/compile/internal/ssa/schedule_test.go +++ b/src/cmd/compile/internal/ssa/schedule_test.go @@ -11,15 +11,15 @@ func TestSchedule(t *testing.T) { cases := []fun{ Fun(c, "entry", Bloc("entry", - Valu("mem0", OpArg, TypeMem, ".mem"), - Valu("ptr", OpConst, TypeInt64, 0xABCD), - Valu("v", OpConst, TypeInt64, 12), - Valu("mem1", OpStore, TypeMem, 32, "ptr", "v", "mem0"), - Valu("mem2", OpStore, TypeMem, 32, "ptr", "v", "mem1"), - Valu("mem3", OpStore, TypeInt64, "ptr", "sum", "mem2"), - Valu("l1", OpLoad, TypeInt64, 16, "ptr", "mem1"), - Valu("l2", OpLoad, TypeInt64, 8, "ptr", "mem2"), - Valu("sum", OpAdd, TypeInt64, "l1", "l2"), + Valu("mem0", OpArg, TypeMem, 0, ".mem"), + Valu("ptr", OpConst, TypeInt64, 0xABCD, nil), + Valu("v", OpConst, TypeInt64, 12, nil), + Valu("mem1", OpStore, TypeMem, 0, nil, "ptr", "v", "mem0"), + Valu("mem2", OpStore, TypeMem, 0, nil, "ptr", "v", "mem1"), + Valu("mem3", OpStore, TypeInt64, 0, nil, "ptr", "sum", "mem2"), + Valu("l1", OpLoad, TypeInt64, 0, nil, "ptr", "mem1"), + Valu("l2", OpLoad, TypeInt64, 0, nil, "ptr", "mem2"), + Valu("sum", OpAdd, TypeInt64, 0, nil, "l1", "l2"), Goto("exit")), Bloc("exit", Exit("mem3"))), diff --git a/src/cmd/compile/internal/ssa/shift_test.go b/src/cmd/compile/internal/ssa/shift_test.go index bba4f782dc..b4b4f47ff0 100644 --- a/src/cmd/compile/internal/ssa/shift_test.go +++ b/src/cmd/compile/internal/ssa/shift_test.go @@ -28,14 +28,14 @@ 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", OpArg, TypeMem, ".mem"), - Valu("FP", OpFP, TypeUInt64, nil), - Valu("argptr", OpOffPtr, ptyp, int64(8), "FP"), - Valu("resptr", OpOffPtr, ptyp, int64(16), "FP"), - Valu("load", OpLoad, typ, nil, "argptr", "mem"), - Valu("c", OpConst, TypeUInt64, amount), - Valu("shift", op, typ, nil, "load", "c"), - Valu("store", OpStore, TypeMem, nil, "resptr", "shift", "mem"), + Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("FP", OpFP, TypeUInt64, 0, nil), + Valu("argptr", OpOffPtr, ptyp, 8, nil, "FP"), + Valu("resptr", OpOffPtr, ptyp, 16, nil, "FP"), + Valu("load", OpLoad, typ, 0, nil, "argptr", "mem"), + Valu("c", OpConst, TypeUInt64, amount, nil), + Valu("shift", op, typ, 0, nil, "load", "c"), + Valu("store", OpStore, TypeMem, 0, nil, "resptr", "shift", "mem"), Exit("store"))) Compile(fun.f) return fun diff --git a/src/cmd/compile/internal/ssa/stackalloc.go b/src/cmd/compile/internal/ssa/stackalloc.go index d47c8c7b02..cb1688f51c 100644 --- a/src/cmd/compile/internal/ssa/stackalloc.go +++ b/src/cmd/compile/internal/ssa/stackalloc.go @@ -92,14 +92,14 @@ func stackalloc(f *Func) { case OpAMD64ADDQ: // (ADDQ (FP) x) -> (LEAQ [n] (SP) x) v.Op = OpAMD64LEAQ - v.Aux = n + v.AuxInt = n case OpAMD64LEAQ, OpAMD64MOVQload, OpAMD64MOVQstore, OpAMD64MOVBload, OpAMD64MOVQloadidx8: if v.Op == OpAMD64MOVQloadidx8 && i == 1 { // Note: we could do it, but it is probably an error log.Panicf("can't do FP->SP adjust on index slot of load %s", v.Op) } // eg: (MOVQload [c] (FP) mem) -> (MOVQload [c+n] (SP) mem) - v.Aux = addOffset(v.Aux.(int64), n) + v.AuxInt = addOff(v.AuxInt, n) default: log.Panicf("can't do FP->SP adjust on %s", v.Op) // TODO: OpCopy -> ADDQ diff --git a/src/cmd/compile/internal/ssa/value.go b/src/cmd/compile/internal/ssa/value.go index f249bba43e..3ed1f3c2b9 100644 --- a/src/cmd/compile/internal/ssa/value.go +++ b/src/cmd/compile/internal/ssa/value.go @@ -22,7 +22,9 @@ type Value struct { Type Type // Auxiliary info for this value. The type of this information depends on the opcode and type. - Aux interface{} + // AuxInt is used for integer values, Aux is used for other values. + AuxInt int64 + Aux interface{} // Arguments of this value Args []*Value @@ -53,8 +55,11 @@ func (v *Value) String() string { func (v *Value) LongString() string { s := fmt.Sprintf("v%d = %s", v.ID, v.Op.String()) s += " <" + v.Type.String() + ">" + if v.AuxInt != 0 { + s += fmt.Sprintf(" [%d]", v.AuxInt) + } if v.Aux != nil { - s += fmt.Sprintf(" [%v]", v.Aux) + s += fmt.Sprintf(" {%v}", v.Aux) } for _, a := range v.Args { s += fmt.Sprintf(" %v", a) -- cgit v1.3 From 2efdaefdb034d463185b674eb3aa8dad5d1a907d Mon Sep 17 00:00:00 2001 From: Daniel Morsing Date: Sat, 13 Jun 2015 19:27:26 +0100 Subject: [dev.ssa] Protect control value from being moved away from end of block If there isn't a value dependency between the control value of a block and some other value, the schedule pass might move the control value to a spot that is not EOB. Fix by handling the control value specially like phis. Change-Id: Iddaf0924d98c5b3d9515c3ced927b0c85722818c Reviewed-on: https://go-review.googlesource.com/11071 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/schedule.go | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/schedule.go b/src/cmd/compile/internal/ssa/schedule.go index b93b0d8a45..60d2cd5460 100644 --- a/src/cmd/compile/internal/ssa/schedule.go +++ b/src/cmd/compile/internal/ssa/schedule.go @@ -57,6 +57,9 @@ func schedule(f *Func) { // Topologically sort the values in b. order = order[:0] for _, v := range b.Values { + if v == b.Control { + continue + } if v.Op == OpPhi { // Phis all go first. We handle phis specially // because they may have self edges "a = phi(a, b, c)" @@ -79,13 +82,13 @@ func schedule(f *Func) { // Note that v is not popped. We leave it in place // until all its children have been explored. for _, w := range v.Args { - if w.Block == b && w.Op != OpPhi && state[w.ID] == unmarked { + if w.Block == b && w.Op != OpPhi && w != b.Control && state[w.ID] == unmarked { state[w.ID] = found queue = append(queue, w) } } for _, w := range additionalEdges[v.ID] { - if w.Block == b && w.Op != OpPhi && state[w.ID] == unmarked { + if w.Block == b && w.Op != OpPhi && w != b.Control && state[w.ID] == unmarked { state[w.ID] = found queue = append(queue, w) } @@ -99,6 +102,9 @@ func schedule(f *Func) { } } } + if b.Control != nil { + order = append(order, b.Control) + } copy(b.Values, order) } // TODO: only allow one live flags type (x86) -- cgit v1.3 From 47791c1a1826aeada54987d7259de536f211fb22 Mon Sep 17 00:00:00 2001 From: Michael Matloob Date: Sat, 13 Jun 2015 10:22:21 -0700 Subject: [dev.ssa] cmd/compile/internal/gc: generate TESTQ instruction TESTQ is produced by the IsNonNil lowering. Change-Id: I9df8f17e6def7e34d07e3ddf2dd5dd8f0406aa04 Reviewed-on: https://go-review.googlesource.com/11053 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 6 ++++++ 1 file changed, 6 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 3110fad270..36352d009d 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -962,6 +962,12 @@ func genValue(v *ssa.Value) { p.From.Reg = regnum(v.Args[0]) p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v.Args[1]) + case ssa.OpAMD64TESTQ: + p := Prog(x86.ATESTQ) + p.From.Type = obj.TYPE_REG + p.From.Reg = regnum(v.Args[0]) + p.To.Type = obj.TYPE_REG + p.To.Reg = regnum(v.Args[1]) case ssa.OpAMD64MOVQconst: x := regnum(v) p := Prog(x86.AMOVQ) -- cgit v1.3 From 3a0df1f82a8f16c3ffca51bd0b6fbee9dfc62961 Mon Sep 17 00:00:00 2001 From: Michael Matloob Date: Sat, 13 Jun 2015 11:01:16 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: set Line in NewValue funcs In the previous line number CL the NewValue\d? functions took a line number argument but neglected to set the Line field on the value struct. Fix that. Change-Id: I53c79ff93703f66f5f0266178c94803719ae2074 Reviewed-on: https://go-review.googlesource.com/11054 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/func.go | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/func.go b/src/cmd/compile/internal/ssa/func.go index 2e1b5990dc..c71e6d4e38 100644 --- a/src/cmd/compile/internal/ssa/func.go +++ b/src/cmd/compile/internal/ssa/func.go @@ -85,6 +85,7 @@ func (b *Block) NewValue0A(line int32, op Op, t Type, aux interface{}) *Value { Type: t, Aux: aux, Block: b, + Line: line, } v.Args = v.argstorage[:0] b.Values = append(b.Values, v) @@ -143,6 +144,7 @@ func (b *Block) NewValue1A(line int32, op Op, t Type, aux interface{}, arg *Valu Type: t, Aux: aux, Block: b, + Line: line, } v.Args = v.argstorage[:1] v.Args[0] = arg @@ -173,6 +175,7 @@ func (b *Block) NewValue2(line int32, op Op, t Type, arg0, arg1 *Value) *Value { Op: op, Type: t, Block: b, + Line: line, } v.Args = v.argstorage[:2] v.Args[0] = arg0 @@ -188,6 +191,7 @@ func (b *Block) NewValue3(line int32, op Op, t Type, arg0, arg1, arg2 *Value) *V Op: op, Type: t, Block: b, + Line: line, } v.Args = []*Value{arg0, arg1, arg2} b.Values = append(b.Values, v) -- cgit v1.3 From ea5cd68646102e5de58eb6c5917cb1f4a6c04a84 Mon Sep 17 00:00:00 2001 From: Michael Matloob Date: Sun, 14 Jun 2015 10:27:50 -0700 Subject: [dev.ssa] cmd/compile/internal/gc: fix call to newValue1 Change-Id: I235a759e4688358adc088cf5a80f8ce7ad12d2f2 Reviewed-on: https://go-review.googlesource.com/11093 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 36352d009d..dec4de0e10 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -381,7 +381,7 @@ func (s *state) expr(n *Node) *ssa.Value { } case OCONVNOP: x := s.expr(n.Left) - return s.newValue1(ssa.OpConvNop, n.Type, nil, x) + return s.newValue1(ssa.OpConvNop, n.Type, x) // binary ops case OLT: -- cgit v1.3 From c31b6dd0be202698a142568d8a8762db74b4516d Mon Sep 17 00:00:00 2001 From: Daniel Morsing Date: Fri, 12 Jun 2015 14:23:29 +0100 Subject: [dev.ssa] initial implementation of PAUTO|PHEAP variables Call to the runtime to generate escaping variables and use the returned address when accessing these variables. Fix a couple of errors on the way. The rule for CALLstatic was missed during the Aux refactor and OCONVNOP wasn't converted. Change-Id: I2096beff92cca92d648bfb6e8ec0b120f02f44af Reviewed-on: https://go-review.googlesource.com/11072 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 79 ++++++++++++++++++---------- src/cmd/compile/internal/ssa/gen/AMD64.rules | 2 +- src/cmd/compile/internal/ssa/rewriteAMD64.go | 12 ++--- 3 files changed, 58 insertions(+), 35 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index dec4de0e10..1d7cb287a7 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -226,8 +226,23 @@ func (s *state) stmt(n *Node) { s.stmtList(n.List) case ODCL: - // TODO: old gen pass uses dcl node as the point where - // escaping variables' new functions are called. Do that here + if n.Left.Class&PHEAP == 0 { + return + } + if compiling_runtime != 0 { + log.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 + } + s.assign(OAS, n.Left.Name.Heapaddr, palloc) case OLABEL, OGOTO: // get block at label, or make one @@ -247,32 +262,8 @@ func (s *state) stmt(n *Node) { } case OAS, OASWB: - // TODO: do write barrier - var val *ssa.Value - if n.Right == nil { - // n.Right == nil means use the zero value of the assigned type. - t := n.Left.Type - switch { - case t.IsString(): - val = s.entryNewValue0(ssa.OpConst, n.Left.Type) - case t.IsInteger(): - val = s.entryNewValue0(ssa.OpConst, n.Left.Type) - case t.IsBoolean(): - val = s.entryNewValue0A(ssa.OpConst, n.Left.Type, false) // TODO: store bools as 0/1 in AuxInt? - default: - log.Fatalf("zero for type %v not implemented", t) - } - } else { - val = s.expr(n.Right) - } - if n.Left.Op == ONAME && canSSA(n.Left) { - // Update variable assignment. - s.vars[n.Left.Sym.Name] = val - return - } - // not ssa-able. Treat as a store. - addr := s.addr(n.Left) - s.vars[".mem"] = s.newValue3(ssa.OpStore, ssa.TypeMem, addr, val, s.mem()) + s.assign(n.Op, n.Left, n.Right) + case OIF: cond := s.expr(n.Left) b := s.endBlock() @@ -478,6 +469,36 @@ func (s *state) expr(n *Node) *ssa.Value { } } +func (s *state) assign(op uint8, left *Node, right *Node) { + // TODO: do write barrier + // if op == OASWB + var val *ssa.Value + if right == nil { + // right == nil means use the zero value of the assigned type. + t := left.Type + switch { + case t.IsString(): + val = s.entryNewValue0(ssa.OpConst, left.Type) + case t.IsInteger(): + val = s.entryNewValue0(ssa.OpConst, left.Type) + case t.IsBoolean(): + val = s.entryNewValue0A(ssa.OpConst, left.Type, false) // TODO: store bools as 0/1 in AuxInt? + default: + log.Fatalf("zero for type %v not implemented", t) + } + } else { + val = s.expr(right) + } + if left.Op == ONAME && canSSA(left) { + // Update variable assignment. + s.vars[left.Sym.Name] = val + return + } + // not ssa-able. Treat as a store. + addr := s.addr(left) + s.vars[".mem"] = s.newValue3(ssa.OpStore, ssa.TypeMem, addr, val, s.mem()) +} + // addr converts the address of the expression n to SSA, adds it to s and returns the SSA result. func (s *state) addr(n *Node) *ssa.Value { switch n.Op { @@ -489,6 +510,8 @@ func (s *state) addr(n *Node) *ssa.Value { case PPARAMOUT: // store to parameter slot return s.entryNewValue1I(ssa.OpOffPtr, Ptrto(n.Type), n.Xoffset, s.fp) + case PAUTO | PHEAP: + return s.expr(n.Name.Heapaddr) default: // TODO: address of locals log.Fatalf("variable address of %v not implemented", n) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 58ab25b392..b62c8767d1 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -58,7 +58,7 @@ (If (SETB cmp) yes no) -> (ULT cmp yes no) (If cond yes no) && cond.Op == OpAMD64MOVBload -> (NE (TESTB cond cond) yes no) -(StaticCall [target] mem) -> (CALLstatic [target] mem) +(StaticCall {target} mem) -> (CALLstatic {target} mem) (ClosureCall entry closure mem) -> (CALLclosure entry closure mem) // Rules below here apply some simple optimizations after lowering. diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index d466e154e7..a3ec3e7cc1 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -1093,22 +1093,22 @@ func rewriteValueAMD64(v *Value, config *Config) bool { end78e66b6fc298684ff4ac8aec5ce873c9: ; case OpStaticCall: - // match: (StaticCall [target] mem) + // match: (StaticCall {target} mem) // cond: - // result: (CALLstatic [target] mem) + // result: (CALLstatic {target} mem) { - target := v.AuxInt + target := v.Aux mem := v.Args[0] v.Op = OpAMD64CALLstatic v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = target + v.Aux = target v.AddArg(mem) return true } - goto endcf02eb60d90086f6c42bfdc5842b145d - endcf02eb60d90086f6c42bfdc5842b145d: + goto end1948857a7cfc2a4f905045e58d3b9ec1 + end1948857a7cfc2a4f905045e58d3b9ec1: ; case OpStore: // match: (Store ptr val mem) -- cgit v1.3 From 3b817ef8f8e377e741ffa94ff3a5154bebe206cd Mon Sep 17 00:00:00 2001 From: Daniel Morsing Date: Sun, 14 Jun 2015 23:06:39 +0100 Subject: [dev.ssa] fix equivalence class after aux/auxint refactor. This caused the following code snippet to be miscompiled var f int x := g(&f) f = 10 Moving the store of 10 above the function call. Change-Id: Ic6951f5e7781b122cd881df324a38e519d6d66f0 Reviewed-on: https://go-review.googlesource.com/11073 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/cse.go | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/cse.go b/src/cmd/compile/internal/ssa/cse.go index aba24aeabc..660712612a 100644 --- a/src/cmd/compile/internal/ssa/cse.go +++ b/src/cmd/compile/internal/ssa/cse.go @@ -26,15 +26,16 @@ func cse(f *Func) { // Make initial partition based on opcode/type/aux/nargs // TODO(khr): types are not canonical, so we may split unnecessarily. Fix that. type key struct { - op Op - typ Type - aux interface{} - nargs int + op Op + typ Type + aux interface{} + auxint int64 + nargs int } m := map[key]eqclass{} for _, b := range f.Blocks { for _, v := range b.Values { - k := key{v.Op, v.Type, v.Aux, len(v.Args)} + k := key{v.Op, v.Type, v.Aux, v.AuxInt, len(v.Args)} m[k] = append(m[k], v) } } -- cgit v1.3 From 703ef06039c031d99b7420d984fded0bef11b14d Mon Sep 17 00:00:00 2001 From: Michael Matloob Date: Tue, 16 Jun 2015 11:11:16 -0700 Subject: [dev.ssa] cmd/compile/internal/gc: reduce genValue redundancy Add an asm field to opcodeTable containing the Prog's as field. Then instructions that fill the Prog the same way can be collapsed into a single switch case. I'm still thinking of a better way to reduce redundancy, but I think this might be a good temporary solution to prevent duplication from getting out of control. What do you think? Change-Id: I0c4a0992741f908bd357ee2707edb82e76e4ce61 Reviewed-on: https://go-review.googlesource.com/11130 Reviewed-by: Josh Bleecher Snyder Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 106 ++------------------------- src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 61 +++++++-------- src/cmd/compile/internal/ssa/gen/main.go | 11 +++ src/cmd/compile/internal/ssa/op.go | 1 + src/cmd/compile/internal/ssa/opGen.go | 23 ++++++ 5 files changed, 75 insertions(+), 127 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 1d7cb287a7..3e898bb3a7 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -802,7 +802,7 @@ func genValue(v *ssa.Value) { p.From.Offset = v.AuxInt p.To.Type = obj.TYPE_REG p.To.Reg = r - case ssa.OpAMD64SHLQ: + case ssa.OpAMD64SHLQ, ssa.OpAMD64SHRQ, ssa.OpAMD64SARQ: x := regnum(v.Args[0]) r := regnum(v) if x != r { @@ -816,66 +816,12 @@ func genValue(v *ssa.Value) { p.To.Reg = r x = r } - p := Prog(x86.ASHLQ) + 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.OpAMD64SHRQ: - x := regnum(v.Args[0]) - r := regnum(v) - if x != r { - if r == x86.REG_CX { - log.Fatalf("can't implement %s, target and shift both in CX", v.LongString()) - } - p := Prog(x86.AMOVQ) - p.From.Type = obj.TYPE_REG - p.From.Reg = x - p.To.Type = obj.TYPE_REG - p.To.Reg = r - x = r - } - p := Prog(x86.ASHRQ) - 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.OpAMD64SARQ: - x := regnum(v.Args[0]) - r := regnum(v) - if x != r { - if r == x86.REG_CX { - log.Fatalf("can't implement %s, target and shift both in CX", v.LongString()) - } - p := Prog(x86.AMOVQ) - p.From.Type = obj.TYPE_REG - p.From.Reg = x - p.To.Type = obj.TYPE_REG - p.To.Reg = r - x = r - } - p := Prog(x86.ASARQ) - 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.OpAMD64SHLQconst: - x := regnum(v.Args[0]) - r := regnum(v) - if x != r { - p := Prog(x86.AMOVQ) - p.From.Type = obj.TYPE_REG - p.From.Reg = x - p.To.Type = obj.TYPE_REG - p.To.Reg = r - x = r - } - p := Prog(x86.ASHLQ) - p.From.Type = obj.TYPE_CONST - p.From.Offset = v.AuxInt - p.To.Type = obj.TYPE_REG - p.To.Reg = r - case ssa.OpAMD64SHRQconst: + case ssa.OpAMD64SHLQconst, ssa.OpAMD64SHRQconst, ssa.OpAMD64SARQconst: x := regnum(v.Args[0]) r := regnum(v) if x != r { @@ -886,27 +832,10 @@ func genValue(v *ssa.Value) { p.To.Reg = r x = r } - p := Prog(x86.ASHRQ) + p := Prog(v.Op.Asm()) p.From.Type = obj.TYPE_CONST p.From.Offset = v.AuxInt p.To.Type = obj.TYPE_REG - p.To.Reg = r - case ssa.OpAMD64SARQconst: - x := regnum(v.Args[0]) - r := regnum(v) - if x != r { - p := Prog(x86.AMOVQ) - p.From.Type = obj.TYPE_REG - p.From.Reg = x - p.To.Type = obj.TYPE_REG - p.To.Reg = r - x = r - } - p := Prog(x86.ASARQ) - p.From.Type = obj.TYPE_CONST - p.From.Offset = v.AuxInt - p.To.Type = obj.TYPE_REG - p.To.Reg = r case ssa.OpAMD64SBBQcarrymask: r := regnum(v) p := Prog(x86.ASBBQ) @@ -967,8 +896,8 @@ func genValue(v *ssa.Value) { p.From.Offset = v.AuxInt p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v) - case ssa.OpAMD64CMPQ: - p := Prog(x86.ACMPQ) + case ssa.OpAMD64CMPQ, ssa.OpAMD64TESTB, ssa.OpAMD64TESTQ: + p := Prog(v.Op.Asm()) p.From.Type = obj.TYPE_REG p.From.Reg = regnum(v.Args[0]) p.To.Type = obj.TYPE_REG @@ -979,18 +908,6 @@ func genValue(v *ssa.Value) { p.From.Reg = regnum(v.Args[0]) p.To.Type = obj.TYPE_CONST p.To.Offset = v.AuxInt - case ssa.OpAMD64TESTB: - p := Prog(x86.ATESTB) - p.From.Type = obj.TYPE_REG - p.From.Reg = regnum(v.Args[0]) - p.To.Type = obj.TYPE_REG - p.To.Reg = regnum(v.Args[1]) - case ssa.OpAMD64TESTQ: - p := Prog(x86.ATESTQ) - p.From.Type = obj.TYPE_REG - p.From.Reg = regnum(v.Args[0]) - p.To.Type = obj.TYPE_REG - p.To.Reg = regnum(v.Args[1]) case ssa.OpAMD64MOVQconst: x := regnum(v) p := Prog(x86.AMOVQ) @@ -998,15 +915,8 @@ func genValue(v *ssa.Value) { p.From.Offset = v.AuxInt p.To.Type = obj.TYPE_REG p.To.Reg = x - case ssa.OpAMD64MOVQload: - p := Prog(x86.AMOVQ) - p.From.Type = obj.TYPE_MEM - p.From.Reg = regnum(v.Args[0]) - p.From.Offset = v.AuxInt - p.To.Type = obj.TYPE_REG - p.To.Reg = regnum(v) - case ssa.OpAMD64MOVBload: - p := Prog(x86.AMOVB) + case ssa.OpAMD64MOVQload, ssa.OpAMD64MOVBload: + p := Prog(v.Op.Asm()) p.From.Type = obj.TYPE_MEM p.From.Reg = regnum(v.Args[0]) p.From.Offset = v.AuxInt diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 13aff4cba7..0b79a8247c 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -4,7 +4,10 @@ package main -import "strings" +import ( + "cmd/internal/obj/x86" + "strings" +) // copied from ../../amd64/reg.go var regNamesAMD64 = []string{ @@ -92,29 +95,29 @@ func init() { // TODO: 2-address instructions. Mark ops as needing matching input/output regs. var AMD64ops = []opData{ - {name: "ADDQ", reg: gp21}, // arg0 + arg1 - {name: "ADDQconst", reg: gp11}, // arg0 + auxint - {name: "SUBQ", reg: gp21}, // arg0 - arg1 - {name: "SUBQconst", reg: gp11}, // arg0 - auxint - {name: "MULQ", reg: gp21}, // arg0 * arg1 - {name: "MULQconst", reg: gp11}, // arg0 * auxint - {name: "ANDQ", reg: gp21}, // arg0 & arg1 - {name: "ANDQconst", reg: gp11}, // arg0 & auxint - {name: "SHLQ", reg: gp21shift}, // arg0 << arg1, shift amount is mod 64 - {name: "SHLQconst", reg: gp11}, // arg0 << auxint, shift amount 0-63 - {name: "SHRQ", reg: gp21shift}, // unsigned arg0 >> arg1, shift amount is mod 64 - {name: "SHRQconst", reg: gp11}, // unsigned arg0 >> auxint, shift amount 0-63 - {name: "SARQ", reg: gp21shift}, // signed arg0 >> arg1, shift amount is mod 64 - {name: "SARQconst", reg: gp11}, // signed arg0 >> auxint, shift amount 0-63 + {name: "ADDQ", reg: gp21}, // arg0 + arg1 + {name: "ADDQconst", reg: gp11}, // arg0 + auxint + {name: "SUBQ", reg: gp21, asm: x86.ASUBQ}, // arg0 - arg1 + {name: "SUBQconst", reg: gp11, asm: x86.ASUBQ}, // arg0 - auxint + {name: "MULQ", reg: gp21, asm: x86.AIMULQ}, // arg0 * arg1 + {name: "MULQconst", reg: gp11, asm: x86.AIMULQ}, // arg0 * auxint + {name: "ANDQ", reg: gp21, asm: x86.AANDQ}, // arg0 & arg1 + {name: "ANDQconst", reg: gp11, asm: x86.AANDQ}, // arg0 & auxint + {name: "SHLQ", reg: gp21shift, asm: x86.ASHLQ}, // arg0 << arg1, shift amount is mod 64 + {name: "SHLQconst", reg: gp11, asm: x86.ASHLQ}, // arg0 << auxint, shift amount 0-63 + {name: "SHRQ", reg: gp21shift, asm: x86.ASHRQ}, // unsigned arg0 >> arg1, shift amount is mod 64 + {name: "SHRQconst", reg: gp11, asm: x86.ASHRQ}, // unsigned arg0 >> auxint, shift amount 0-63 + {name: "SARQ", reg: gp21shift, asm: x86.ASARQ}, // signed arg0 >> arg1, shift amount is mod 64 + {name: "SARQconst", reg: gp11, asm: x86.ASARQ}, // signed arg0 >> auxint, shift amount 0-63 {name: "NEGQ", reg: gp11}, // -arg0 - {name: "CMPQ", reg: gp2flags}, // arg0 compare to arg1 - {name: "CMPQconst", reg: gp1flags}, // arg0 compare to auxint - {name: "TESTQ", reg: gp2flags}, // (arg0 & arg1) compare to 0 - {name: "TESTB", reg: gp2flags}, // (arg0 & arg1) compare to 0 + {name: "CMPQ", reg: gp2flags, asm: x86.ACMPQ}, // arg0 compare to arg1 + {name: "CMPQconst", reg: gp1flags, asm: x86.ACMPQ}, // arg0 compare to auxint + {name: "TESTQ", reg: gp2flags, asm: x86.ATESTQ}, // (arg0 & arg1) compare to 0 + {name: "TESTB", reg: gp2flags, asm: x86.ATESTB}, // (arg0 & arg1) compare to 0 - {name: "SBBQcarrymask", reg: flagsgp1}, // (int64)(-1) if carry is set, 0 if carry is clear. + {name: "SBBQcarrymask", reg: flagsgp1, asm: x86.ASBBQ}, // (int64)(-1) if carry is set, 0 if carry is clear. {name: "SETEQ", reg: flagsgp}, // extract == condition from arg0 {name: "SETNE", reg: flagsgp}, // extract != condition from arg0 @@ -132,14 +135,14 @@ func init() { {name: "LEAQ8", reg: gp21}, // arg0 + 8*arg1 + auxint {name: "LEAQglobal", reg: gp01}, // no args. address of aux.(*gc.Sym) - {name: "MOVBload", reg: gpload}, // load byte from arg0+auxint. arg1=mem - {name: "MOVBQZXload", reg: gpload}, // ditto, extend to uint64 - {name: "MOVBQSXload", reg: gpload}, // ditto, extend to int64 - {name: "MOVQload", reg: gpload}, // load 8 bytes from arg0+auxint. arg1=mem - {name: "MOVQloadidx8", reg: gploadidx}, // load 8 bytes from arg0+8*arg1+auxint. arg2=mem - {name: "MOVBstore", reg: gpstore}, // store byte in arg1 to arg0+auxint. arg2=mem - {name: "MOVQstore", reg: gpstore}, // store 8 bytes in arg1 to arg0+auxint. arg2=mem - {name: "MOVQstoreidx8", reg: gpstoreidx}, // store 8 bytes in arg2 to arg0+8*arg1+auxint. arg3=mem + {name: "MOVBload", reg: gpload}, // load byte from arg0+auxint. arg1=mem + {name: "MOVBQZXload", reg: gpload}, // ditto, extend to uint64 + {name: "MOVBQSXload", reg: gpload}, // ditto, extend to int64 + {name: "MOVQload", reg: gpload}, // load 8 bytes from arg0+auxint. arg1=mem + {name: "MOVQloadidx8", reg: gploadidx}, // load 8 bytes from arg0+8*arg1+auxint. arg2=mem + {name: "MOVBstore", reg: gpstore, asm: x86.AMOVB}, // store byte in arg1 to arg0+auxint. arg2=mem + {name: "MOVQstore", reg: gpstore, asm: x86.AMOVQ}, // store 8 bytes in arg1 to arg0+auxint. arg2=mem + {name: "MOVQstoreidx8", reg: gpstoreidx}, // store 8 bytes in arg2 to arg0+8*arg1+auxint. arg3=mem // Load/store from global. Same as the above loads, but arg0 is missing and // aux is a GlobalOffset instead of an int64. @@ -152,7 +155,7 @@ func init() { {name: "REPMOVSB", reg: regInfo{[]regMask{buildReg("DI"), buildReg("SI"), buildReg("CX")}, buildReg("DI SI CX"), nil}}, // move arg2 bytes from arg1 to arg0. arg3=mem, returns memory - {name: "ADDL", reg: gp21}, // arg0+arg1 + {name: "ADDL", reg: gp21, asm: x86.AADDL}, // arg0+arg1 // (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, diff --git a/src/cmd/compile/internal/ssa/gen/main.go b/src/cmd/compile/internal/ssa/gen/main.go index 33b8be51d2..a700964759 100644 --- a/src/cmd/compile/internal/ssa/gen/main.go +++ b/src/cmd/compile/internal/ssa/gen/main.go @@ -9,6 +9,8 @@ package main import ( "bytes" + "cmd/internal/obj" + "cmd/internal/obj/x86" "fmt" "go/format" "io/ioutil" @@ -25,6 +27,7 @@ type arch struct { type opData struct { name string reg regInfo + asm int16 } type blockData struct { @@ -60,12 +63,15 @@ func main() { 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, "package ssa") + fmt.Fprintln(w, "import \"cmd/internal/obj/x86\"") + // generate Block* declarations fmt.Fprintln(w, "const (") fmt.Fprintln(w, "blockInvalid BlockKind = iota") @@ -108,6 +114,9 @@ func genOp() { for _, v := range a.ops { fmt.Fprintln(w, "{") fmt.Fprintf(w, "name:\"%s\",\n", v.name) + if v.asm != 0 { + fmt.Fprintf(w, "asm: x86.A%s,\n", x86.Anames[v.asm-obj.ABaseAMD64]) + } fmt.Fprintln(w, "reg:regInfo{") fmt.Fprintln(w, "inputs: []regMask{") for _, r := range v.reg.inputs { @@ -129,6 +138,8 @@ func genOp() { } 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 }") diff --git a/src/cmd/compile/internal/ssa/op.go b/src/cmd/compile/internal/ssa/op.go index 1103a67d0b..4ca8c770cb 100644 --- a/src/cmd/compile/internal/ssa/op.go +++ b/src/cmd/compile/internal/ssa/op.go @@ -14,6 +14,7 @@ type Op int32 type opInfo struct { name string + asm int reg regInfo generic bool // this is a generic (arch-independent) opcode } diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 1115032c98..0b827cf4f0 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -2,6 +2,8 @@ // generated from gen/*Ops.go package ssa +import "cmd/internal/obj/x86" + const ( blockInvalid BlockKind = iota @@ -164,6 +166,7 @@ var opcodeTable = [...]opInfo{ }, { name: "SUBQ", + asm: x86.ASUBQ, reg: regInfo{ inputs: []regMask{ 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP @@ -177,6 +180,7 @@ var opcodeTable = [...]opInfo{ }, { name: "SUBQconst", + asm: x86.ASUBQ, reg: regInfo{ inputs: []regMask{ 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP @@ -189,6 +193,7 @@ var opcodeTable = [...]opInfo{ }, { name: "MULQ", + asm: x86.AIMULQ, reg: regInfo{ inputs: []regMask{ 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP @@ -202,6 +207,7 @@ var opcodeTable = [...]opInfo{ }, { name: "MULQconst", + asm: x86.AIMULQ, reg: regInfo{ inputs: []regMask{ 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP @@ -214,6 +220,7 @@ var opcodeTable = [...]opInfo{ }, { name: "ANDQ", + asm: x86.AANDQ, reg: regInfo{ inputs: []regMask{ 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP @@ -227,6 +234,7 @@ var opcodeTable = [...]opInfo{ }, { name: "ANDQconst", + asm: x86.AANDQ, reg: regInfo{ inputs: []regMask{ 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP @@ -239,6 +247,7 @@ var opcodeTable = [...]opInfo{ }, { name: "SHLQ", + asm: x86.ASHLQ, reg: regInfo{ inputs: []regMask{ 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP @@ -252,6 +261,7 @@ var opcodeTable = [...]opInfo{ }, { name: "SHLQconst", + asm: x86.ASHLQ, reg: regInfo{ inputs: []regMask{ 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP @@ -264,6 +274,7 @@ var opcodeTable = [...]opInfo{ }, { name: "SHRQ", + asm: x86.ASHRQ, reg: regInfo{ inputs: []regMask{ 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP @@ -277,6 +288,7 @@ var opcodeTable = [...]opInfo{ }, { name: "SHRQconst", + asm: x86.ASHRQ, reg: regInfo{ inputs: []regMask{ 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP @@ -289,6 +301,7 @@ var opcodeTable = [...]opInfo{ }, { name: "SARQ", + asm: x86.ASARQ, reg: regInfo{ inputs: []regMask{ 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP @@ -302,6 +315,7 @@ var opcodeTable = [...]opInfo{ }, { name: "SARQconst", + asm: x86.ASARQ, reg: regInfo{ inputs: []regMask{ 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP @@ -326,6 +340,7 @@ var opcodeTable = [...]opInfo{ }, { name: "CMPQ", + asm: x86.ACMPQ, reg: regInfo{ inputs: []regMask{ 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP @@ -339,6 +354,7 @@ var opcodeTable = [...]opInfo{ }, { name: "CMPQconst", + asm: x86.ACMPQ, reg: regInfo{ inputs: []regMask{ 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP @@ -351,6 +367,7 @@ var opcodeTable = [...]opInfo{ }, { name: "TESTQ", + asm: x86.ATESTQ, reg: regInfo{ inputs: []regMask{ 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP @@ -364,6 +381,7 @@ var opcodeTable = [...]opInfo{ }, { name: "TESTB", + asm: x86.ATESTB, reg: regInfo{ inputs: []regMask{ 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP @@ -377,6 +395,7 @@ var opcodeTable = [...]opInfo{ }, { name: "SBBQcarrymask", + asm: x86.ASBBQ, reg: regInfo{ inputs: []regMask{ 8589934592, // .FLAGS @@ -613,6 +632,7 @@ var opcodeTable = [...]opInfo{ }, { name: "MOVBstore", + asm: x86.AMOVB, reg: regInfo{ inputs: []regMask{ 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP @@ -625,6 +645,7 @@ var opcodeTable = [...]opInfo{ }, { name: "MOVQstore", + asm: x86.AMOVQ, reg: regInfo{ inputs: []regMask{ 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP @@ -698,6 +719,7 @@ var opcodeTable = [...]opInfo{ }, { name: "ADDL", + asm: x86.AADDL, reg: regInfo{ inputs: []regMask{ 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP @@ -1044,4 +1066,5 @@ var opcodeTable = [...]opInfo{ }, } +func (o Op) Asm() int { return opcodeTable[o].asm } func (o Op) String() string { return opcodeTable[o].name } -- cgit v1.3 From 50ceef26e6517a5785433cd73b9eda30159d03bb Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Tue, 16 Jun 2015 13:33:32 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: Fix bootstrap of ssa codegen The cmd/compile/internal/ssa/gen directory can't depend on cmd/internal/gc because that package doesn't exist in go1.4. Use strings instead of constants from that package. The asm fields seem somewhat redundant to the opcode names we conventionally use. Maybe we can just trim the lowercase from the end of the op name? At least by default? Change-Id: I96e8cda44833763951709e2721588fbd34580989 Reviewed-on: https://go-review.googlesource.com/11129 Reviewed-by: Michael Matloob --- src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 57 ++++++++++++++-------------- src/cmd/compile/internal/ssa/gen/main.go | 8 ++-- src/cmd/compile/internal/ssa/opGen.go | 2 + 3 files changed, 33 insertions(+), 34 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 0b79a8247c..d99f793179 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -5,7 +5,6 @@ package main import ( - "cmd/internal/obj/x86" "strings" ) @@ -95,29 +94,29 @@ func init() { // TODO: 2-address instructions. Mark ops as needing matching input/output regs. var AMD64ops = []opData{ - {name: "ADDQ", reg: gp21}, // arg0 + arg1 - {name: "ADDQconst", reg: gp11}, // arg0 + auxint - {name: "SUBQ", reg: gp21, asm: x86.ASUBQ}, // arg0 - arg1 - {name: "SUBQconst", reg: gp11, asm: x86.ASUBQ}, // arg0 - auxint - {name: "MULQ", reg: gp21, asm: x86.AIMULQ}, // arg0 * arg1 - {name: "MULQconst", reg: gp11, asm: x86.AIMULQ}, // arg0 * auxint - {name: "ANDQ", reg: gp21, asm: x86.AANDQ}, // arg0 & arg1 - {name: "ANDQconst", reg: gp11, asm: x86.AANDQ}, // arg0 & auxint - {name: "SHLQ", reg: gp21shift, asm: x86.ASHLQ}, // arg0 << arg1, shift amount is mod 64 - {name: "SHLQconst", reg: gp11, asm: x86.ASHLQ}, // arg0 << auxint, shift amount 0-63 - {name: "SHRQ", reg: gp21shift, asm: x86.ASHRQ}, // unsigned arg0 >> arg1, shift amount is mod 64 - {name: "SHRQconst", reg: gp11, asm: x86.ASHRQ}, // unsigned arg0 >> auxint, shift amount 0-63 - {name: "SARQ", reg: gp21shift, asm: x86.ASARQ}, // signed arg0 >> arg1, shift amount is mod 64 - {name: "SARQconst", reg: gp11, asm: x86.ASARQ}, // signed arg0 >> auxint, shift amount 0-63 + {name: "ADDQ", reg: gp21}, // arg0 + arg1 + {name: "ADDQconst", reg: gp11}, // arg0 + auxint + {name: "SUBQ", reg: gp21, asm: "SUBQ"}, // arg0 - arg1 + {name: "SUBQconst", reg: gp11, asm: "SUBQ"}, // arg0 - auxint + {name: "MULQ", reg: gp21, asm: "IMULQ"}, // arg0 * arg1 + {name: "MULQconst", reg: gp11, asm: "IMULQ"}, // arg0 * auxint + {name: "ANDQ", reg: gp21, asm: "ANDQ"}, // arg0 & arg1 + {name: "ANDQconst", reg: gp11, asm: "ANDQ"}, // arg0 & auxint + {name: "SHLQ", reg: gp21shift, asm: "SHLQ"}, // arg0 << arg1, shift amount is mod 64 + {name: "SHLQconst", reg: gp11, asm: "SHLQ"}, // arg0 << auxint, shift amount 0-63 + {name: "SHRQ", reg: gp21shift, asm: "SHRQ"}, // unsigned arg0 >> arg1, shift amount is mod 64 + {name: "SHRQconst", reg: gp11, asm: "SHRQ"}, // unsigned arg0 >> auxint, shift amount 0-63 + {name: "SARQ", reg: gp21shift, asm: "SARQ"}, // signed arg0 >> arg1, shift amount is mod 64 + {name: "SARQconst", reg: gp11, asm: "SARQ"}, // signed arg0 >> auxint, shift amount 0-63 {name: "NEGQ", reg: gp11}, // -arg0 - {name: "CMPQ", reg: gp2flags, asm: x86.ACMPQ}, // arg0 compare to arg1 - {name: "CMPQconst", reg: gp1flags, asm: x86.ACMPQ}, // arg0 compare to auxint - {name: "TESTQ", reg: gp2flags, asm: x86.ATESTQ}, // (arg0 & arg1) compare to 0 - {name: "TESTB", reg: gp2flags, asm: x86.ATESTB}, // (arg0 & arg1) compare to 0 + {name: "CMPQ", reg: gp2flags, asm: "CMPQ"}, // arg0 compare to arg1 + {name: "CMPQconst", reg: gp1flags, asm: "CMPQ"}, // arg0 compare to auxint + {name: "TESTQ", reg: gp2flags, asm: "TESTQ"}, // (arg0 & arg1) compare to 0 + {name: "TESTB", reg: gp2flags, asm: "TESTB"}, // (arg0 & arg1) compare to 0 - {name: "SBBQcarrymask", reg: flagsgp1, asm: x86.ASBBQ}, // (int64)(-1) if carry is set, 0 if carry is clear. + {name: "SBBQcarrymask", reg: flagsgp1, asm: "SBBQ"}, // (int64)(-1) if carry is set, 0 if carry is clear. {name: "SETEQ", reg: flagsgp}, // extract == condition from arg0 {name: "SETNE", reg: flagsgp}, // extract != condition from arg0 @@ -135,14 +134,14 @@ func init() { {name: "LEAQ8", reg: gp21}, // arg0 + 8*arg1 + auxint {name: "LEAQglobal", reg: gp01}, // no args. address of aux.(*gc.Sym) - {name: "MOVBload", reg: gpload}, // load byte from arg0+auxint. arg1=mem - {name: "MOVBQZXload", reg: gpload}, // ditto, extend to uint64 - {name: "MOVBQSXload", reg: gpload}, // ditto, extend to int64 - {name: "MOVQload", reg: gpload}, // load 8 bytes from arg0+auxint. arg1=mem - {name: "MOVQloadidx8", reg: gploadidx}, // load 8 bytes from arg0+8*arg1+auxint. arg2=mem - {name: "MOVBstore", reg: gpstore, asm: x86.AMOVB}, // store byte in arg1 to arg0+auxint. arg2=mem - {name: "MOVQstore", reg: gpstore, asm: x86.AMOVQ}, // store 8 bytes in arg1 to arg0+auxint. arg2=mem - {name: "MOVQstoreidx8", reg: gpstoreidx}, // store 8 bytes in arg2 to arg0+8*arg1+auxint. arg3=mem + {name: "MOVBload", reg: gpload, asm: "MOVB"}, // load byte from arg0+auxint. arg1=mem + {name: "MOVBQZXload", reg: gpload}, // ditto, extend to uint64 + {name: "MOVBQSXload", reg: gpload}, // ditto, extend to int64 + {name: "MOVQload", reg: gpload, asm: "MOVQ"}, // load 8 bytes from arg0+auxint. arg1=mem + {name: "MOVQloadidx8", reg: gploadidx}, // load 8 bytes from arg0+8*arg1+auxint. arg2=mem + {name: "MOVBstore", reg: gpstore, asm: "MOVB"}, // store byte in arg1 to arg0+auxint. arg2=mem + {name: "MOVQstore", reg: gpstore, asm: "MOVQ"}, // store 8 bytes in arg1 to arg0+auxint. arg2=mem + {name: "MOVQstoreidx8", reg: gpstoreidx}, // store 8 bytes in arg2 to arg0+8*arg1+auxint. arg3=mem // Load/store from global. Same as the above loads, but arg0 is missing and // aux is a GlobalOffset instead of an int64. @@ -155,7 +154,7 @@ func init() { {name: "REPMOVSB", reg: regInfo{[]regMask{buildReg("DI"), buildReg("SI"), buildReg("CX")}, buildReg("DI SI CX"), nil}}, // move arg2 bytes from arg1 to arg0. arg3=mem, returns memory - {name: "ADDL", reg: gp21, asm: x86.AADDL}, // arg0+arg1 + {name: "ADDL", reg: gp21, asm: "ADDL"}, // arg0+arg1 // (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, diff --git a/src/cmd/compile/internal/ssa/gen/main.go b/src/cmd/compile/internal/ssa/gen/main.go index a700964759..097f513347 100644 --- a/src/cmd/compile/internal/ssa/gen/main.go +++ b/src/cmd/compile/internal/ssa/gen/main.go @@ -9,8 +9,6 @@ package main import ( "bytes" - "cmd/internal/obj" - "cmd/internal/obj/x86" "fmt" "go/format" "io/ioutil" @@ -27,7 +25,7 @@ type arch struct { type opData struct { name string reg regInfo - asm int16 + asm string } type blockData struct { @@ -114,8 +112,8 @@ func genOp() { for _, v := range a.ops { fmt.Fprintln(w, "{") fmt.Fprintf(w, "name:\"%s\",\n", v.name) - if v.asm != 0 { - fmt.Fprintf(w, "asm: x86.A%s,\n", x86.Anames[v.asm-obj.ABaseAMD64]) + if v.asm != "" { + fmt.Fprintf(w, "asm: x86.A%s,\n", v.asm) } fmt.Fprintln(w, "reg:regInfo{") fmt.Fprintln(w, "inputs: []regMask{") diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 0b827cf4f0..dfe611e8f4 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -566,6 +566,7 @@ var opcodeTable = [...]opInfo{ }, { name: "MOVBload", + asm: x86.AMOVB, reg: regInfo{ inputs: []regMask{ 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP @@ -605,6 +606,7 @@ var opcodeTable = [...]opInfo{ }, { name: "MOVQload", + asm: x86.AMOVQ, reg: regInfo{ inputs: []regMask{ 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP -- cgit v1.3 From a5c3b6642bb01a96b59db1e55a3479549fbcca08 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Tue, 16 Jun 2015 16:16:23 -0700 Subject: [dev.ssa] cmd/compile/ssa: fix string compilation Compilation of f_ssa was broken by CL 10929. This CL does not include tests because I have a work in progress CL that will catch this and much more. package p func f_ssa() string { return "ABC" } Change-Id: I0ce0e905e4d30ec206cce808da406b9b7f0f38e9 Reviewed-on: https://go-review.googlesource.com/11136 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 3e898bb3a7..2f116464d4 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -478,7 +478,7 @@ func (s *state) assign(op uint8, left *Node, right *Node) { t := left.Type switch { case t.IsString(): - val = s.entryNewValue0(ssa.OpConst, left.Type) + val = s.entryNewValue0A(ssa.OpConst, left.Type, "") case t.IsInteger(): val = s.entryNewValue0(ssa.OpConst, left.Type) case t.IsBoolean(): -- cgit v1.3 From 0991ec454b8a53bf11c4c01f75dd2fa7a34362cc Mon Sep 17 00:00:00 2001 From: Michael Matloob Date: Sun, 14 Jun 2015 09:52:13 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: set line in newValue variants This CL sets line numbers on Values in the newValue variants introduced in cl/10929. Change-Id: Ibd15bc90631a1e948177878ea4191d995e8bb19b Reviewed-on: https://go-review.googlesource.com/11090 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/func.go | 6 ++++++ 1 file changed, 6 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/func.go b/src/cmd/compile/internal/ssa/func.go index c71e6d4e38..d73e0ea9e0 100644 --- a/src/cmd/compile/internal/ssa/func.go +++ b/src/cmd/compile/internal/ssa/func.go @@ -51,6 +51,7 @@ func (b *Block) NewValue0(line int32, op Op, t Type) *Value { Op: op, Type: t, Block: b, + Line: line, } v.Args = v.argstorage[:0] b.Values = append(b.Values, v) @@ -65,6 +66,7 @@ func (b *Block) NewValue0I(line int32, op Op, t Type, auxint int64) *Value { Type: t, AuxInt: auxint, Block: b, + Line: line, } v.Args = v.argstorage[:0] b.Values = append(b.Values, v) @@ -101,6 +103,7 @@ func (b *Block) NewValue0IA(line int32, op Op, t Type, auxint int64, aux interfa AuxInt: auxint, Aux: aux, Block: b, + Line: line, } v.Args = v.argstorage[:0] b.Values = append(b.Values, v) @@ -114,6 +117,7 @@ func (b *Block) NewValue1(line int32, op Op, t Type, arg *Value) *Value { Op: op, Type: t, Block: b, + Line: line, } v.Args = v.argstorage[:1] v.Args[0] = arg @@ -129,6 +133,7 @@ func (b *Block) NewValue1I(line int32, op Op, t Type, auxint int64, arg *Value) Type: t, AuxInt: auxint, Block: b, + Line: line, } v.Args = v.argstorage[:1] v.Args[0] = arg @@ -161,6 +166,7 @@ func (b *Block) NewValue1IA(line int32, op Op, t Type, auxint int64, aux interfa AuxInt: auxint, Aux: aux, Block: b, + Line: line, } v.Args = v.argstorage[:1] v.Args[0] = arg -- cgit v1.3 From 73054f572940c8d4c905f2ba996a3c6aaeeb28df Mon Sep 17 00:00:00 2001 From: Michael Matloob Date: Sun, 14 Jun 2015 11:38:46 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: adds for 8,16,32 bit ints Change-Id: I33025a4a41fd91f6ee317d33a6eebf27fa00ab51 Reviewed-on: https://go-review.googlesource.com/11115 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 73 ++++-- src/cmd/compile/internal/ssa/gen/AMD64.rules | 22 +- src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 30 ++- src/cmd/compile/internal/ssa/opGen.go | 131 ++++++++++ src/cmd/compile/internal/ssa/rewrite.go | 8 + src/cmd/compile/internal/ssa/rewriteAMD64.go | 359 +++++++++++++++++++++++++-- src/cmd/compile/internal/ssa/stackalloc.go | 5 +- 7 files changed, 565 insertions(+), 63 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 2f116464d4..81a55e4065 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -373,6 +373,9 @@ func (s *state) expr(n *Node) *ssa.Value { case OCONVNOP: x := s.expr(n.Left) return s.newValue1(ssa.OpConvNop, n.Type, x) + case OCONV: + x := s.expr(n.Left) + return s.newValue1(ssa.OpConvert, n.Type, x) // binary ops case OLT: @@ -766,6 +769,43 @@ func genValue(v *ssa.Value) { p.From.Index = regnum(v.Args[1]) p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v) + case ssa.OpAMD64ADDL: + p := Prog(x86.ALEAL) + p.From.Type = obj.TYPE_MEM + p.From.Reg = regnum(v.Args[0]) + p.From.Scale = 1 + p.From.Index = regnum(v.Args[1]) + p.To.Type = obj.TYPE_REG + p.To.Reg = regnum(v) + case ssa.OpAMD64ADDW: + p := Prog(x86.ALEAW) + p.From.Type = obj.TYPE_MEM + p.From.Reg = regnum(v.Args[0]) + p.From.Scale = 1 + p.From.Index = regnum(v.Args[1]) + p.To.Type = obj.TYPE_REG + p.To.Reg = regnum(v) + case ssa.OpAMD64ADDB, ssa.OpAMD64ANDQ: + r := regnum(v) + x := regnum(v.Args[0]) + y := regnum(v.Args[1]) + if x != r && y != r { + p := Prog(x86.AMOVQ) + p.From.Type = obj.TYPE_REG + p.From.Reg = x + p.To.Type = obj.TYPE_REG + p.To.Reg = r + 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 + } case ssa.OpAMD64ADDQconst: // TODO: use addq instead of leaq if target is in the right register. p := Prog(x86.ALEAQ) @@ -866,27 +906,6 @@ func genValue(v *ssa.Value) { p.From.Type = obj.TYPE_REG p.To.Type = obj.TYPE_REG p.To.Reg = r - case ssa.OpAMD64ANDQ: - r := regnum(v) - x := regnum(v.Args[0]) - y := regnum(v.Args[1]) - if x != r && y != r { - p := Prog(x86.AMOVQ) - p.From.Type = obj.TYPE_REG - p.From.Reg = x - p.To.Type = obj.TYPE_REG - p.To.Reg = r - x = r - } - p := Prog(x86.AANDQ) - 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 - } case ssa.OpAMD64LEAQ: p := Prog(x86.ALEAQ) p.From.Type = obj.TYPE_MEM @@ -915,7 +934,7 @@ func genValue(v *ssa.Value) { p.From.Offset = v.AuxInt p.To.Type = obj.TYPE_REG p.To.Reg = x - case ssa.OpAMD64MOVQload, ssa.OpAMD64MOVBload: + case ssa.OpAMD64MOVQload, ssa.OpAMD64MOVLload, ssa.OpAMD64MOVWload, ssa.OpAMD64MOVBload: p := Prog(v.Op.Asm()) p.From.Type = obj.TYPE_MEM p.From.Reg = regnum(v.Args[0]) @@ -931,13 +950,19 @@ func genValue(v *ssa.Value) { p.From.Index = regnum(v.Args[1]) p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v) - case ssa.OpAMD64MOVQstore: - p := Prog(x86.AMOVQ) + case ssa.OpAMD64MOVQstore, ssa.OpAMD64MOVLstore, ssa.OpAMD64MOVWstore, ssa.OpAMD64MOVBstore: + 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]) p.To.Offset = v.AuxInt + case ssa.OpAMD64MOVLQSX, ssa.OpAMD64MOVWQSX, ssa.OpAMD64MOVBQSX: + 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.OpCopy: // TODO: lower to MOVQ earlier? if v.Type.IsMemory() { return diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index b62c8767d1..aa4e807712 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -14,10 +14,21 @@ // Lowering arithmetic (Add x y) && (is64BitInt(t) || isPtr(t)) -> (ADDQ x y) -(Add x y) && is32BitInt(t) -> (ADDL x y) +(Add x y) && is32BitInt(t) && !isSigned(t) -> (ADDL x y) +(Add x y) && is32BitInt(t) && isSigned(t) -> (MOVLQSX (ADDL x y)) +(Add x y) && is16BitInt(t) && !isSigned(t) -> (ADDW x y) +(Add x y) && is16BitInt(t) && isSigned(t) -> (MOVWQSX (ADDW x y)) +(Add x y) && is8BitInt(t) && !isSigned(t) -> (ADDB x y) +(Add x y) && is8BitInt(t) && isSigned(t) -> (MOVBQSX (ADDB x y)) (Sub x y) && is64BitInt(t) -> (SUBQ x y) (Mul x y) && is64BitInt(t) -> (MULQ x y) +(MOVLstore ptr (MOVLQSX x) mem) -> (MOVLstore ptr x mem) +(MOVWstore ptr (MOVWQSX x) mem) -> (MOVWstore ptr x mem) +(MOVBstore ptr (MOVBQSX x) mem) -> (MOVBstore ptr x mem) + +(Convert x) && t.IsInteger() && x.Type.IsInteger() -> (Copy x) + // Lowering shifts // Note: unsigned shifts need to return 0 if shift amount is >= 64. // mask = shift >= 64 ? 0 : 0xffffffffffffffff @@ -38,9 +49,14 @@ (Less x y) && is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type) -> (SETL (CMPQ x y)) -(Load ptr mem) && t.IsBoolean() -> (MOVBload ptr mem) (Load ptr mem) && (is64BitInt(t) || isPtr(t)) -> (MOVQload ptr mem) +(Load ptr mem) && is32BitInt(t) -> (MOVLload ptr mem) +(Load ptr mem) && is16BitInt(t) -> (MOVWload ptr mem) +(Load ptr mem) && (t.IsBoolean() || is8BitInt(t)) -> (MOVBload ptr mem) (Store ptr val mem) && (is64BitInt(val.Type) || isPtr(val.Type)) -> (MOVQstore ptr val mem) +(Store ptr val mem) && is32BitInt(val.Type) -> (MOVLstore ptr val mem) +(Store ptr val mem) && is16BitInt(val.Type) -> (MOVWstore ptr val mem) +(Store ptr val mem) && is8BitInt(val.Type) -> (MOVBstore ptr val mem) // checks (IsNonNil p) -> (SETNE (TESTQ p p)) @@ -50,7 +66,7 @@ (OffPtr [off] ptr) -> (ADDQconst [off] ptr) -(Const [val]) && is64BitInt(t) -> (MOVQconst [val]) +(Const [val]) && t.IsInteger() -> (MOVQconst [val]) // block rewrites (If (SETL cmp) yes no) -> (LT cmp yes no) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index d99f793179..3733ba9721 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -4,9 +4,7 @@ package main -import ( - "strings" -) +import "strings" // copied from ../../amd64/reg.go var regNamesAMD64 = []string{ @@ -127,6 +125,10 @@ func init() { {name: "CMOVQCC", reg: cmov}, // carry clear + {name: "MOVLQSX", reg: gp11, asm: "MOVLQSX"}, // extend arg0 from int32 to int64 + {name: "MOVWQSX", reg: gp11, asm: "MOVWQSX"}, // extend arg0 from int16 to int64 + {name: "MOVBQSX", reg: gp11, asm: "MOVBQSX"}, // extend arg0 from int8 to int64 + {name: "MOVQconst", reg: gp01}, // auxint {name: "LEAQ", reg: gp21}, // arg0 + arg1 + auxint {name: "LEAQ2", reg: gp21}, // arg0 + 2*arg1 + auxint @@ -134,14 +136,18 @@ func init() { {name: "LEAQ8", reg: gp21}, // arg0 + 8*arg1 + auxint {name: "LEAQglobal", reg: gp01}, // no args. address of aux.(*gc.Sym) - {name: "MOVBload", reg: gpload, asm: "MOVB"}, // load byte from arg0+auxint. arg1=mem - {name: "MOVBQZXload", reg: gpload}, // ditto, extend to uint64 - {name: "MOVBQSXload", reg: gpload}, // ditto, extend to int64 - {name: "MOVQload", reg: gpload, asm: "MOVQ"}, // load 8 bytes from arg0+auxint. arg1=mem - {name: "MOVQloadidx8", reg: gploadidx}, // load 8 bytes from arg0+8*arg1+auxint. arg2=mem - {name: "MOVBstore", reg: gpstore, asm: "MOVB"}, // store byte in arg1 to arg0+auxint. arg2=mem - {name: "MOVQstore", reg: gpstore, asm: "MOVQ"}, // store 8 bytes in arg1 to arg0+auxint. arg2=mem - {name: "MOVQstoreidx8", reg: gpstoreidx}, // store 8 bytes in arg2 to arg0+8*arg1+auxint. arg3=mem + {name: "MOVBload", reg: gpload, asm: "MOVB"}, // load byte from arg0+auxint. arg1=mem + {name: "MOVBQZXload", reg: gpload}, // ditto, extend to uint64 + {name: "MOVBQSXload", reg: gpload}, // ditto, extend to int64 + {name: "MOVWload", reg: gpload, asm: "MOVW"}, // load 2 bytes from arg0+auxint. arg1=mem + {name: "MOVLload", reg: gpload, asm: "MOVL"}, // load 4 bytes from arg0+auxint. arg1=mem + {name: "MOVQload", reg: gpload, asm: "MOVQ"}, // load 8 bytes from arg0+auxint. arg1=mem + {name: "MOVQloadidx8", reg: gploadidx, asm: "MOVQ"}, // load 8 bytes from arg0+8*arg1+auxint. arg2=mem + {name: "MOVBstore", reg: gpstore, asm: "MOVB"}, // store byte in arg1 to arg0+auxint. arg2=mem + {name: "MOVWstore", reg: gpstore, asm: "MOVW"}, // store 2 bytes in arg1 to arg0+auxint. arg2=mem + {name: "MOVLstore", reg: gpstore, asm: "MOVL"}, // store 4 bytes in arg1 to arg0+auxint. arg2=mem + {name: "MOVQstore", reg: gpstore, asm: "MOVQ"}, // store 8 bytes in arg1 to arg0+auxint. arg2=mem + {name: "MOVQstoreidx8", reg: gpstoreidx}, // store 8 bytes in arg2 to arg0+8*arg1+auxint. arg3=mem // Load/store from global. Same as the above loads, but arg0 is missing and // aux is a GlobalOffset instead of an int64. @@ -155,6 +161,8 @@ func init() { {name: "REPMOVSB", reg: regInfo{[]regMask{buildReg("DI"), buildReg("SI"), buildReg("CX")}, buildReg("DI SI CX"), nil}}, // move arg2 bytes from arg1 to arg0. arg3=mem, returns memory {name: "ADDL", reg: gp21, asm: "ADDL"}, // arg0+arg1 + {name: "ADDW", reg: gp21, asm: "ADDW"}, // arg0+arg1 + {name: "ADDB", reg: gp21, asm: "ADDB"}, // arg0+arg1 // (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, diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index dfe611e8f4..1116be101c 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -76,6 +76,9 @@ const ( OpAMD64SETGE OpAMD64SETB OpAMD64CMOVQCC + OpAMD64MOVLQSX + OpAMD64MOVWQSX + OpAMD64MOVBQSX OpAMD64MOVQconst OpAMD64LEAQ OpAMD64LEAQ2 @@ -85,9 +88,13 @@ const ( OpAMD64MOVBload OpAMD64MOVBQZXload OpAMD64MOVBQSXload + OpAMD64MOVWload + OpAMD64MOVLload OpAMD64MOVQload OpAMD64MOVQloadidx8 OpAMD64MOVBstore + OpAMD64MOVWstore + OpAMD64MOVLstore OpAMD64MOVQstore OpAMD64MOVQstoreidx8 OpAMD64MOVQloadglobal @@ -96,6 +103,8 @@ const ( OpAMD64CALLclosure OpAMD64REPMOVSB OpAMD64ADDL + OpAMD64ADDW + OpAMD64ADDB OpAMD64InvertFlags OpAdd @@ -492,6 +501,45 @@ var opcodeTable = [...]opInfo{ }, }, }, + { + name: "MOVLQSX", + asm: x86.AMOVLQSX, + reg: regInfo{ + inputs: []regMask{ + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + }, + clobbers: 0, + outputs: []regMask{ + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + }, + }, + { + name: "MOVWQSX", + asm: x86.AMOVWQSX, + reg: regInfo{ + inputs: []regMask{ + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + }, + clobbers: 0, + outputs: []regMask{ + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + }, + }, + { + name: "MOVBQSX", + asm: x86.AMOVBQSX, + reg: regInfo{ + inputs: []regMask{ + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + }, + clobbers: 0, + outputs: []regMask{ + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + }, + }, { name: "MOVQconst", reg: regInfo{ @@ -604,6 +652,34 @@ var opcodeTable = [...]opInfo{ }, }, }, + { + name: "MOVWload", + asm: x86.AMOVW, + reg: regInfo{ + inputs: []regMask{ + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 0, + }, + clobbers: 0, + outputs: []regMask{ + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + }, + }, + { + name: "MOVLload", + asm: x86.AMOVL, + reg: regInfo{ + inputs: []regMask{ + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 0, + }, + clobbers: 0, + outputs: []regMask{ + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + }, + }, { name: "MOVQload", asm: x86.AMOVQ, @@ -620,6 +696,7 @@ var opcodeTable = [...]opInfo{ }, { name: "MOVQloadidx8", + asm: x86.AMOVQ, reg: regInfo{ inputs: []regMask{ 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP @@ -645,6 +722,32 @@ var opcodeTable = [...]opInfo{ outputs: []regMask{}, }, }, + { + name: "MOVWstore", + asm: x86.AMOVW, + reg: regInfo{ + inputs: []regMask{ + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 0, + }, + clobbers: 0, + outputs: []regMask{}, + }, + }, + { + name: "MOVLstore", + asm: x86.AMOVL, + reg: regInfo{ + inputs: []regMask{ + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 0, + }, + clobbers: 0, + outputs: []regMask{}, + }, + }, { name: "MOVQstore", asm: x86.AMOVQ, @@ -733,6 +836,34 @@ var opcodeTable = [...]opInfo{ }, }, }, + { + name: "ADDW", + asm: x86.AADDW, + reg: regInfo{ + inputs: []regMask{ + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + }, + clobbers: 0, + outputs: []regMask{ + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + }, + }, + { + name: "ADDB", + asm: x86.AADDB, + reg: regInfo{ + inputs: []regMask{ + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + }, + clobbers: 0, + outputs: []regMask{ + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + }, + }, { name: "InvertFlags", reg: regInfo{ diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go index 08ee7a9824..77aa2b07b4 100644 --- a/src/cmd/compile/internal/ssa/rewrite.go +++ b/src/cmd/compile/internal/ssa/rewrite.go @@ -70,6 +70,14 @@ 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() } diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index a3ec3e7cc1..3490adadd7 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -210,14 +210,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { endf031c523d7dd08e4b8e7010a94cd94c9: ; // match: (Add x y) - // cond: is32BitInt(t) + // cond: is32BitInt(t) && !isSigned(t) // result: (ADDL x y) { t := v.Type x := v.Args[0] y := v.Args[1] - if !(is32BitInt(t)) { - goto end35a02a1587264e40cf1055856ff8445a + if !(is32BitInt(t) && !isSigned(t)) { + goto endce1730b0a04d773ed8029e7eac4f3a50 } v.Op = OpAMD64ADDL v.AuxInt = 0 @@ -227,8 +227,122 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(y) return true } - goto end35a02a1587264e40cf1055856ff8445a - end35a02a1587264e40cf1055856ff8445a: + goto endce1730b0a04d773ed8029e7eac4f3a50 + endce1730b0a04d773ed8029e7eac4f3a50: + ; + // match: (Add x y) + // cond: is32BitInt(t) && isSigned(t) + // result: (MOVLQSX (ADDL x y)) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + if !(is32BitInt(t) && isSigned(t)) { + goto end86e07674e2e9d2e1fc5a8f5f74375513 + } + v.Op = OpAMD64MOVLQSX + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64ADDL, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto end86e07674e2e9d2e1fc5a8f5f74375513 + end86e07674e2e9d2e1fc5a8f5f74375513: + ; + // match: (Add x y) + // cond: is16BitInt(t) && !isSigned(t) + // result: (ADDW x y) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + if !(is16BitInt(t) && !isSigned(t)) { + goto end99632c2482f1963513f12a317c588800 + } + v.Op = OpAMD64ADDW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end99632c2482f1963513f12a317c588800 + end99632c2482f1963513f12a317c588800: + ; + // match: (Add x y) + // cond: is16BitInt(t) && isSigned(t) + // result: (MOVWQSX (ADDW x y)) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + if !(is16BitInt(t) && isSigned(t)) { + goto endd215b5658d14e7d1cb469a516aa554e9 + } + v.Op = OpAMD64MOVWQSX + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64ADDW, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto endd215b5658d14e7d1cb469a516aa554e9 + endd215b5658d14e7d1cb469a516aa554e9: + ; + // match: (Add x y) + // cond: is8BitInt(t) && !isSigned(t) + // result: (ADDB x y) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + if !(is8BitInt(t) && !isSigned(t)) { + goto end41d7f409a1e1076e9645e2e90b7220ce + } + v.Op = OpAMD64ADDB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end41d7f409a1e1076e9645e2e90b7220ce + end41d7f409a1e1076e9645e2e90b7220ce: + ; + // match: (Add x y) + // cond: is8BitInt(t) && isSigned(t) + // result: (MOVBQSX (ADDB x y)) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + if !(is8BitInt(t) && isSigned(t)) { + goto end858e823866524b81b4636f7dd7e8eefe + } + v.Op = OpAMD64MOVBQSX + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64ADDB, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto end858e823866524b81b4636f7dd7e8eefe + end858e823866524b81b4636f7dd7e8eefe: ; case OpAMD64CMOVQCC: // match: (CMOVQCC (CMPQconst [c] (MOVQconst [d])) _ x) @@ -349,13 +463,13 @@ func rewriteValueAMD64(v *Value, config *Config) bool { ; case OpConst: // match: (Const [val]) - // cond: is64BitInt(t) + // cond: t.IsInteger() // result: (MOVQconst [val]) { t := v.Type val := v.AuxInt - if !(is64BitInt(t)) { - goto end7f5c5b34093fbc6860524cb803ee51bf + if !(t.IsInteger()) { + goto end4c8bfe9df26fc5aa2bd76b211792732a } v.Op = OpAMD64MOVQconst v.AuxInt = 0 @@ -364,8 +478,28 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = val return true } - goto end7f5c5b34093fbc6860524cb803ee51bf - end7f5c5b34093fbc6860524cb803ee51bf: + goto end4c8bfe9df26fc5aa2bd76b211792732a + end4c8bfe9df26fc5aa2bd76b211792732a: + ; + case OpConvert: + // match: (Convert x) + // cond: t.IsInteger() && x.Type.IsInteger() + // result: (Copy x) + { + t := v.Type + x := v.Args[0] + if !(t.IsInteger() && x.Type.IsInteger()) { + goto endcc7894224d4f6b0bcabcece5d0185912 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto endcc7894224d4f6b0bcabcece5d0185912 + endcc7894224d4f6b0bcabcece5d0185912: ; case OpGlobal: // match: (Global {sym}) @@ -450,16 +584,16 @@ func rewriteValueAMD64(v *Value, config *Config) bool { ; case OpLoad: // match: (Load ptr mem) - // cond: t.IsBoolean() - // result: (MOVBload ptr mem) + // cond: (is64BitInt(t) || isPtr(t)) + // result: (MOVQload ptr mem) { t := v.Type ptr := v.Args[0] mem := v.Args[1] - if !(t.IsBoolean()) { - goto endc119e594c7f8e8ce5ff97c00b501dba0 + if !(is64BitInt(t) || isPtr(t)) { + goto end7c4c53acf57ebc5f03273652ba1d5934 } - v.Op = OpAMD64MOVBload + v.Op = OpAMD64MOVQload v.AuxInt = 0 v.Aux = nil v.resetArgs() @@ -467,20 +601,20 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto endc119e594c7f8e8ce5ff97c00b501dba0 - endc119e594c7f8e8ce5ff97c00b501dba0: + goto end7c4c53acf57ebc5f03273652ba1d5934 + end7c4c53acf57ebc5f03273652ba1d5934: ; // match: (Load ptr mem) - // cond: (is64BitInt(t) || isPtr(t)) - // result: (MOVQload ptr mem) + // cond: is32BitInt(t) + // result: (MOVLload ptr mem) { t := v.Type ptr := v.Args[0] mem := v.Args[1] - if !(is64BitInt(t) || isPtr(t)) { - goto end7c4c53acf57ebc5f03273652ba1d5934 + if !(is32BitInt(t)) { + goto ende1cfcb15bfbcfd448ce303d0882a4057 } - v.Op = OpAMD64MOVQload + v.Op = OpAMD64MOVLload v.AuxInt = 0 v.Aux = nil v.resetArgs() @@ -488,8 +622,50 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto end7c4c53acf57ebc5f03273652ba1d5934 - end7c4c53acf57ebc5f03273652ba1d5934: + goto ende1cfcb15bfbcfd448ce303d0882a4057 + ende1cfcb15bfbcfd448ce303d0882a4057: + ; + // match: (Load ptr mem) + // cond: is16BitInt(t) + // result: (MOVWload ptr mem) + { + t := v.Type + ptr := v.Args[0] + mem := v.Args[1] + if !(is16BitInt(t)) { + goto end2d0a1304501ed9f4e9e2d288505a9c7c + } + v.Op = OpAMD64MOVWload + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto end2d0a1304501ed9f4e9e2d288505a9c7c + end2d0a1304501ed9f4e9e2d288505a9c7c: + ; + // match: (Load ptr mem) + // cond: (t.IsBoolean() || is8BitInt(t)) + // result: (MOVBload ptr mem) + { + t := v.Type + ptr := v.Args[0] + mem := v.Args[1] + if !(t.IsBoolean() || is8BitInt(t)) { + goto end8f83bf72293670e75b22d6627bd13f0b + } + v.Op = OpAMD64MOVBload + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto end8f83bf72293670e75b22d6627bd13f0b + end8f83bf72293670e75b22d6627bd13f0b: ; case OpLsh: // match: (Lsh x y) @@ -524,6 +700,52 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end5d9e2211940fbc82536685578cf37d08 end5d9e2211940fbc82536685578cf37d08: ; + case OpAMD64MOVBstore: + // match: (MOVBstore ptr (MOVBQSX x) mem) + // cond: + // result: (MOVBstore ptr x mem) + { + ptr := v.Args[0] + if v.Args[1].Op != OpAMD64MOVBQSX { + goto endc356ef104095b9217b36b594f85171c6 + } + x := v.Args[1].Args[0] + mem := v.Args[2] + v.Op = OpAMD64MOVBstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v.AddArg(x) + v.AddArg(mem) + return true + } + goto endc356ef104095b9217b36b594f85171c6 + endc356ef104095b9217b36b594f85171c6: + ; + case OpAMD64MOVLstore: + // match: (MOVLstore ptr (MOVLQSX x) mem) + // cond: + // result: (MOVLstore ptr x mem) + { + ptr := v.Args[0] + if v.Args[1].Op != OpAMD64MOVLQSX { + goto endf79c699f70cb356abb52dc28f4abf46b + } + x := v.Args[1].Args[0] + mem := v.Args[2] + v.Op = OpAMD64MOVLstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v.AddArg(x) + v.AddArg(mem) + return true + } + goto endf79c699f70cb356abb52dc28f4abf46b + endf79c699f70cb356abb52dc28f4abf46b: + ; case OpAMD64MOVQload: // match: (MOVQload [off1] (ADDQconst [off2] ptr) mem) // cond: @@ -680,6 +902,29 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end01c970657b0fdefeab82458c15022163 end01c970657b0fdefeab82458c15022163: ; + case OpAMD64MOVWstore: + // match: (MOVWstore ptr (MOVWQSX x) mem) + // cond: + // result: (MOVWstore ptr x mem) + { + ptr := v.Args[0] + if v.Args[1].Op != OpAMD64MOVWQSX { + goto endcc13af07a951a61fcfec3299342f7e1f + } + x := v.Args[1].Args[0] + mem := v.Args[2] + v.Op = OpAMD64MOVWstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v.AddArg(x) + v.AddArg(mem) + return true + } + goto endcc13af07a951a61fcfec3299342f7e1f + endcc13af07a951a61fcfec3299342f7e1f: + ; case OpAMD64MULQ: // match: (MULQ x (MOVQconst [c])) // cond: c == int64(int32(c)) @@ -1133,6 +1378,72 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endbaeb60123806948cd2433605820d5af1 endbaeb60123806948cd2433605820d5af1: ; + // match: (Store ptr val mem) + // cond: is32BitInt(val.Type) + // result: (MOVLstore ptr val mem) + { + ptr := v.Args[0] + val := v.Args[1] + mem := v.Args[2] + if !(is32BitInt(val.Type)) { + goto end582e895008657c728c141c6b95070de7 + } + v.Op = OpAMD64MOVLstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto end582e895008657c728c141c6b95070de7 + end582e895008657c728c141c6b95070de7: + ; + // match: (Store ptr val mem) + // cond: is16BitInt(val.Type) + // result: (MOVWstore ptr val mem) + { + ptr := v.Args[0] + val := v.Args[1] + mem := v.Args[2] + if !(is16BitInt(val.Type)) { + goto enda3f6a985b6ebb277665f80ad30b178df + } + v.Op = OpAMD64MOVWstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto enda3f6a985b6ebb277665f80ad30b178df + enda3f6a985b6ebb277665f80ad30b178df: + ; + // match: (Store ptr val mem) + // cond: is8BitInt(val.Type) + // result: (MOVBstore ptr val mem) + { + ptr := v.Args[0] + val := v.Args[1] + mem := v.Args[2] + if !(is8BitInt(val.Type)) { + goto ende2dee0bc82f631e3c6b0031bf8d224c1 + } + v.Op = OpAMD64MOVBstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto ende2dee0bc82f631e3c6b0031bf8d224c1 + ende2dee0bc82f631e3c6b0031bf8d224c1: + ; case OpSub: // match: (Sub x y) // cond: is64BitInt(t) diff --git a/src/cmd/compile/internal/ssa/stackalloc.go b/src/cmd/compile/internal/ssa/stackalloc.go index cb1688f51c..5db7316dca 100644 --- a/src/cmd/compile/internal/ssa/stackalloc.go +++ b/src/cmd/compile/internal/ssa/stackalloc.go @@ -93,7 +93,10 @@ func stackalloc(f *Func) { // (ADDQ (FP) x) -> (LEAQ [n] (SP) x) v.Op = OpAMD64LEAQ v.AuxInt = n - case OpAMD64LEAQ, OpAMD64MOVQload, OpAMD64MOVQstore, OpAMD64MOVBload, OpAMD64MOVQloadidx8: + case OpAMD64ADDQconst: + // TODO(matloob): Add LEAQconst op + v.AuxInt = addOff(v.AuxInt, n) + case OpAMD64LEAQ, OpAMD64MOVQload, OpAMD64MOVQstore, OpAMD64MOVLload, OpAMD64MOVLstore, OpAMD64MOVWload, OpAMD64MOVWstore, OpAMD64MOVBload, OpAMD64MOVBstore, OpAMD64MOVQloadidx8: if v.Op == OpAMD64MOVQloadidx8 && i == 1 { // Note: we could do it, but it is probably an error log.Panicf("can't do FP->SP adjust on index slot of load %s", v.Op) -- cgit v1.3 From 2aabacdb5aa4176f3c2916a096d8ac6934113562 Mon Sep 17 00:00:00 2001 From: Michael Matloob Date: Tue, 16 Jun 2015 17:58:03 -0700 Subject: [dev.ssa] cmd/compile/internal/gc: support CALLFUNC as statement I don't have strong understanding of the AST structure, so I'm not sure if this is the right way to handle function call statements. Change-Id: Ib526f667ab483b32d9fd17da800b5d6f4b26c4c9 Reviewed-on: https://go-review.googlesource.com/11139 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 7 +++++++ 1 file changed, 7 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 81a55e4065..f2dbabe6ad 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -335,6 +335,9 @@ func (s *state) stmt(n *Node) { s.startBlock(bEnd) + case OCALLFUNC: + s.expr(n) + case OVARKILL: // TODO(khr): ??? anything to do here? Only for addrtaken variables? // Maybe just link it in the store chain? @@ -464,6 +467,10 @@ func (s *state) expr(n *Node) *ssa.Value { s.startBlock(bNext) var titer Iter fp := Structfirst(&titer, Getoutarg(n.Left.Type)) + if fp == nil { + // CALLFUNC has no return value. Continue with the next statement. + return nil + } a := s.entryNewValue1I(ssa.OpOffPtr, Ptrto(fp.Type), fp.Width, s.sp) return s.newValue2(ssa.OpLoad, fp.Type, a, call) default: -- cgit v1.3 From 8c6abfeacb27f1bcce8fb01f7da95950590943e3 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Fri, 12 Jun 2015 11:01:13 -0700 Subject: [dev.ssa] cmd/compile/ssa: separate logging, work in progress, and fatal errors The SSA implementation logs for three purposes: * debug logging * fatal errors * unimplemented features Separating these three uses lets us attempt an SSA implementation for all functions, not just _ssa functions. This turns the entire standard library into a compilation test, and makes it easy to figure out things like "how much coverage does SSA have now" and "what should we do next to get more coverage?". Functions called _ssa are still special. They log profusely by default and the output of the SSA implementation is used. For all other functions, logging is off, and the implementation is built and discarded, due to lack of support for the runtime. While we're here, fix a few minor bugs and add some extra Unimplementeds to allow all.bash to pass. As of now, SSA handles 20.79% of the functions in the standard library (689 of 3314). The top missing features are: 10.03% 2597 SSA unimplemented: zero for type error not implemented 7.79% 2016 SSA unimplemented: addr: bad op DOTPTR 7.33% 1898 SSA unimplemented: unhandled expr EQ 6.10% 1579 SSA unimplemented: unhandled expr OROR 4.91% 1271 SSA unimplemented: unhandled expr NE 4.49% 1163 SSA unimplemented: unhandled expr LROT 4.00% 1036 SSA unimplemented: unhandled expr LEN 3.56% 923 SSA unimplemented: unhandled stmt CALLFUNC 2.37% 615 SSA unimplemented: zero for type []byte not implemented 1.90% 492 SSA unimplemented: unhandled stmt CALLMETH 1.74% 450 SSA unimplemented: unhandled expr CALLINTER 1.74% 450 SSA unimplemented: unhandled expr DOT 1.71% 444 SSA unimplemented: unhandled expr ANDAND 1.65% 426 SSA unimplemented: unhandled expr CLOSUREVAR 1.54% 400 SSA unimplemented: unhandled expr CALLMETH 1.51% 390 SSA unimplemented: unhandled stmt SWITCH 1.47% 380 SSA unimplemented: unhandled expr CONV 1.33% 345 SSA unimplemented: addr: bad op * 1.30% 336 SSA unimplemented: unhandled OLITERAL 6 Change-Id: I4ca07951e276714dc13c31de28640aead17a1be7 Reviewed-on: https://go-review.googlesource.com/11160 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/pgen.go | 13 +-- src/cmd/compile/internal/gc/ssa.go | 126 ++++++++++++++++++++----- src/cmd/compile/internal/ssa/TODO | 1 - src/cmd/compile/internal/ssa/block.go | 4 + src/cmd/compile/internal/ssa/check.go | 44 +++++---- src/cmd/compile/internal/ssa/compile.go | 13 +-- src/cmd/compile/internal/ssa/config.go | 18 +++- src/cmd/compile/internal/ssa/deadcode.go | 6 +- src/cmd/compile/internal/ssa/deadcode_test.go | 6 +- src/cmd/compile/internal/ssa/deadstore.go | 6 +- src/cmd/compile/internal/ssa/deadstore_test.go | 6 +- src/cmd/compile/internal/ssa/dom.go | 6 +- src/cmd/compile/internal/ssa/export_test.go | 12 ++- src/cmd/compile/internal/ssa/func.go | 8 +- src/cmd/compile/internal/ssa/func_test.go | 14 +-- src/cmd/compile/internal/ssa/gen/generic.rules | 2 +- src/cmd/compile/internal/ssa/layout.go | 4 +- src/cmd/compile/internal/ssa/lower.go | 4 +- src/cmd/compile/internal/ssa/print.go | 3 +- src/cmd/compile/internal/ssa/regalloc.go | 10 +- src/cmd/compile/internal/ssa/rewrite.go | 11 +-- src/cmd/compile/internal/ssa/rewritegeneric.go | 10 +- src/cmd/compile/internal/ssa/schedule_test.go | 2 +- src/cmd/compile/internal/ssa/shift_test.go | 2 +- src/cmd/compile/internal/ssa/stackalloc.go | 8 +- src/cmd/compile/internal/ssa/value.go | 4 + 26 files changed, 211 insertions(+), 132 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/pgen.go index e6b670f7a2..6a6c213b84 100644 --- a/src/cmd/compile/internal/gc/pgen.go +++ b/src/cmd/compile/internal/gc/pgen.go @@ -355,6 +355,7 @@ func compile(fn *Node) { var gcargs *Sym var gclocals *Sym var ssafn *ssa.Func + var usessa bool if fn.Nbody == nil { if pure_go != 0 || strings.HasPrefix(fn.Func.Nname.Sym.Name, "init.") { Yyerror("missing function body for %q", fn.Func.Nname.Sym.Name) @@ -406,13 +407,9 @@ func compile(fn *Node) { goto ret } - // Build an SSA backend function - { - name := Curfn.Func.Nname.Sym.Name - if len(name) > 4 && name[len(name)-4:] == "_ssa" { - ssafn = buildssa(Curfn) - } - } + // Build an SSA backend function. + // TODO: get rid of usessa. + ssafn, usessa = buildssa(Curfn) continpc = nil breakpc = nil @@ -475,7 +472,7 @@ func compile(fn *Node) { } } - if ssafn != nil { + if ssafn != nil && usessa { genssa(ssafn, ptxt, gcargs, gclocals) return } diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index f2dbabe6ad..1218a23488 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -5,26 +5,48 @@ package gc import ( - "log" + "fmt" "cmd/compile/internal/ssa" "cmd/internal/obj" "cmd/internal/obj/x86" // TODO: remove ) -func buildssa(fn *Node) *ssa.Func { - dumplist("buildssa-enter", fn.Func.Enter) - dumplist("buildssa-body", fn.Nbody) +// buildssa builds an SSA function +// and reports whether it should be used. +// Once the SSA implementation is complete, +// it will never return nil, and the bool can be removed. +func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { + name := fn.Func.Nname.Sym.Name + usessa = len(name) > 4 && name[len(name)-4:] == "_ssa" + + if usessa { + dumplist("buildssa-enter", fn.Func.Enter) + dumplist("buildssa-body", fn.Nbody) + } var s state - s.pushLine(fn.Lineno) defer s.popLine() // TODO(khr): build config just once at the start of the compiler binary - s.config = ssa.NewConfig(Thearch.Thestring, ssaExport{}) + + var e ssaExport + e.log = usessa + s.config = ssa.NewConfig(Thearch.Thestring, &e) s.f = s.config.NewFunc() - s.f.Name = fn.Func.Nname.Sym.Name + s.f.Name = name + + // If SSA support for the function is incomplete, + // assume that any panics are due to violated + // invariants. Swallow them silently. + defer func() { + if err := recover(); err != nil { + if !e.unimplemented { + panic(err) + } + } + }() // We construct SSA using an algorithm similar to // Brau, Buchwald, Hack, Leißa, Mallon, and Zwinkau @@ -67,7 +89,15 @@ func buildssa(fn *Node) *ssa.Func { // Main call to ssa package to compile function ssa.Compile(s.f) - return s.f + // Calculate stats about what percentage of functions SSA handles. + if false { + fmt.Printf("SSA implemented: %t\n", !e.unimplemented) + } + + if e.unimplemented { + return nil, false + } + return s.f, usessa // TODO: return s.f, true once runtime support is in (gc maps, write barriers, etc.) } type state struct { @@ -105,10 +135,13 @@ type state struct { line []int32 } +func (s *state) Fatal(msg string, args ...interface{}) { s.config.Fatal(msg, args...) } +func (s *state) Unimplemented(msg string, args ...interface{}) { s.config.Unimplemented(msg, args...) } + // startBlock sets the current block we're generating code in to b. func (s *state) startBlock(b *ssa.Block) { if s.curBlock != nil { - log.Fatalf("starting block %v when block %v has not ended", b, s.curBlock) + s.Fatal("starting block %v when block %v has not ended", b, s.curBlock) } s.curBlock = b s.vars = map[string]*ssa.Value{} @@ -230,7 +263,7 @@ func (s *state) stmt(n *Node) { return } if compiling_runtime != 0 { - log.Fatalf("%v escapes to heap, not allowed in runtime.", n) + Fatal("%v escapes to heap, not allowed in runtime.", n) } // TODO: the old pass hides the details of PHEAP @@ -260,6 +293,9 @@ func (s *state) stmt(n *Node) { // next we work on the label's target block s.startBlock(t) } + if n.Op == OGOTO && s.curBlock == nil { + s.Unimplemented("goto at start of function; see test/goto.go") + } case OAS, OASWB: s.assign(n.Op, n.Left, n.Right) @@ -317,6 +353,9 @@ func (s *state) stmt(n *Node) { // generate code to test condition // TODO(khr): Left == nil exception + if n.Left == nil { + s.Unimplemented("cond n.Left == nil: %v", n) + } s.startBlock(bCond) cond := s.expr(n.Left) b = s.endBlock() @@ -342,7 +381,7 @@ func (s *state) stmt(n *Node) { // TODO(khr): ??? anything to do here? Only for addrtaken variables? // Maybe just link it in the store chain? default: - log.Fatalf("unhandled stmt %s", opnames[n.Op]) + s.Unimplemented("unhandled stmt %s", opnames[n.Op]) } } @@ -370,7 +409,7 @@ func (s *state) expr(n *Node) *ssa.Value { case CTSTR: return s.entryNewValue0A(ssa.OpConst, n.Type, n.Val().U) default: - log.Fatalf("unhandled OLITERAL %v", n.Val().Ctype()) + s.Unimplemented("unhandled OLITERAL %v", n.Val().Ctype()) return nil } case OCONVNOP: @@ -474,7 +513,7 @@ func (s *state) expr(n *Node) *ssa.Value { a := s.entryNewValue1I(ssa.OpOffPtr, Ptrto(fp.Type), fp.Width, s.sp) return s.newValue2(ssa.OpLoad, fp.Type, a, call) default: - log.Fatalf("unhandled expr %s", opnames[n.Op]) + s.Unimplemented("unhandled expr %s", opnames[n.Op]) return nil } } @@ -494,7 +533,7 @@ func (s *state) assign(op uint8, left *Node, right *Node) { case t.IsBoolean(): val = s.entryNewValue0A(ssa.OpConst, left.Type, false) // TODO: store bools as 0/1 in AuxInt? default: - log.Fatalf("zero for type %v not implemented", t) + s.Unimplemented("zero for type %v not implemented", t) } } else { val = s.expr(right) @@ -524,7 +563,7 @@ func (s *state) addr(n *Node) *ssa.Value { return s.expr(n.Name.Heapaddr) default: // TODO: address of locals - log.Fatalf("variable address of %v not implemented", n) + s.Unimplemented("variable address of %v not implemented", n) return nil } case OINDREG: @@ -547,7 +586,7 @@ func (s *state) addr(n *Node) *ssa.Value { return s.newValue2(ssa.OpPtrIndex, Ptrto(n.Left.Type.Type), p, i) } default: - log.Fatalf("addr: bad op %v", Oconv(int(n.Op), 0)) + s.Unimplemented("addr: bad op %v", Oconv(int(n.Op), 0)) return nil } } @@ -556,7 +595,7 @@ func (s *state) addr(n *Node) *ssa.Value { // n must be an ONAME. func canSSA(n *Node) bool { if n.Op != ONAME { - log.Fatalf("canSSA passed a non-ONAME %s %v", Oconv(int(n.Op), 0), n) + Fatal("canSSA passed a non-ONAME %s %v", Oconv(int(n.Op), 0), n) } if n.Addrtaken { return false @@ -610,7 +649,7 @@ func (s *state) boundsCheck(idx, len *ssa.Value) { // variable returns the value of a variable at the current location. func (s *state) variable(name string, t ssa.Type) *ssa.Value { if s.curBlock == nil { - log.Fatalf("nil curblock!") + s.Fatal("nil curblock!") } v := s.vars[name] if v == nil { @@ -662,6 +701,10 @@ func (s *state) lookupVarIncoming(b *ssa.Block, t ssa.Type, name string) *ssa.Va for _, p := range b.Preds { vals = append(vals, s.lookupVarOutgoing(p, t, name)) } + if len(vals) == 0 { + s.Unimplemented("TODO: Handle fixedbugs/bug076.go") + return nil + } v0 := vals[0] for i := 1; i < len(vals); i++ { if vals[i] != v0 { @@ -822,11 +865,14 @@ func genValue(v *ssa.Value) { p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v) case ssa.OpAMD64MULQconst: + v.Unimplemented("IMULQ doasm") + return // TODO: this isn't right. doasm fails on it. I don't think obj // has ever been taught to compile imul $c, r1, r2. p := Prog(x86.AIMULQ) p.From.Type = obj.TYPE_CONST p.From.Offset = v.AuxInt + p.From3 = new(obj.Addr) p.From3.Type = obj.TYPE_REG p.From3.Reg = regnum(v.Args[0]) p.To.Type = obj.TYPE_REG @@ -854,7 +900,7 @@ func genValue(v *ssa.Value) { r := regnum(v) if x != r { if r == x86.REG_CX { - log.Fatalf("can't implement %s, target and shift both in CX", v.LongString()) + v.Fatal("can't implement %s, target and shift both in CX", v.LongString()) } p := Prog(x86.AMOVQ) p.From.Type = obj.TYPE_REG @@ -1003,12 +1049,12 @@ func genValue(v *ssa.Value) { loc := f.RegAlloc[v.ID] for _, a := range v.Args { if f.RegAlloc[a.ID] != loc { // TODO: .Equal() instead? - log.Fatalf("phi arg at different location than phi %v %v %v %v", v, loc, a, f.RegAlloc[a.ID]) + v.Fatal("phi arg at different location than phi %v %v %v %v", v, loc, a, f.RegAlloc[a.ID]) } } case ssa.OpConst: if v.Block.Func.RegAlloc[v.ID] != nil { - log.Fatalf("const value %v shouldn't have a location", v) + v.Fatal("const value %v shouldn't have a location", v) } case ssa.OpArg: // memory arg needs no code @@ -1033,7 +1079,7 @@ func genValue(v *ssa.Value) { case ssa.OpFP, ssa.OpSP: // nothing to do default: - log.Fatalf("value %s not implemented", v.LongString()) + v.Unimplemented("value %s not implemented", v.LongString()) } } @@ -1141,7 +1187,7 @@ func genBlock(b, next *ssa.Block, branches []branch) []branch { } default: - log.Fatalf("branch %s not implemented", b.LongString()) + b.Unimplemented("branch %s not implemented", b.LongString()) } return branches } @@ -1183,10 +1229,40 @@ func localOffset(v *ssa.Value) int64 { } // ssaExport exports a bunch of compiler services for the ssa backend. -type ssaExport struct{} +type ssaExport struct { + log bool + unimplemented bool +} // StringSym returns a symbol (a *Sym wrapped in an interface) which // is a global string constant containing s. -func (serv ssaExport) StringSym(s string) interface{} { +func (*ssaExport) StringSym(s string) interface{} { return stringsym(s) } + +// Log logs a message from the compiler. +func (e *ssaExport) Log(msg string, args ...interface{}) { + // If e was marked as unimplemented, anything could happen. Ignore. + if e.log && !e.unimplemented { + fmt.Printf(msg, args...) + } +} + +// Fatal reports a compiler error and exits. +func (e *ssaExport) Fatal(msg string, args ...interface{}) { + // If e was marked as unimplemented, anything could happen. Ignore. + if !e.unimplemented { + Fatal(msg, args...) + } +} + +// Unimplemented reports that the function cannot be compiled. +// It will be removed once SSA work is complete. +func (e *ssaExport) Unimplemented(msg string, args ...interface{}) { + 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 +} diff --git a/src/cmd/compile/internal/ssa/TODO b/src/cmd/compile/internal/ssa/TODO index e9b7553534..64b581fac0 100644 --- a/src/cmd/compile/internal/ssa/TODO +++ b/src/cmd/compile/internal/ssa/TODO @@ -42,7 +42,6 @@ Common-Subexpression Elimination - Can we move control values out of their basic block? Other - - Use gc.Fatal for errors. Add a callback to Frontend? - Write barriers - For testing, do something more sophisticated than checkOpcodeCounts. Michael Matloob suggests using a similar diff --git a/src/cmd/compile/internal/ssa/block.go b/src/cmd/compile/internal/ssa/block.go index db16fb4a53..e0d5c1a55e 100644 --- a/src/cmd/compile/internal/ssa/block.go +++ b/src/cmd/compile/internal/ssa/block.go @@ -69,3 +69,7 @@ func (b *Block) LongString() string { } return s } + +func (b *Block) Log(msg string, args ...interface{}) { b.Func.Log(msg, args...) } +func (b *Block) Fatal(msg string, args ...interface{}) { b.Func.Fatal(msg, args...) } +func (b *Block) Unimplemented(msg string, args ...interface{}) { b.Func.Unimplemented(msg, args...) } diff --git a/src/cmd/compile/internal/ssa/check.go b/src/cmd/compile/internal/ssa/check.go index 667313ad9f..230d0ec111 100644 --- a/src/cmd/compile/internal/ssa/check.go +++ b/src/cmd/compile/internal/ssa/check.go @@ -4,8 +4,6 @@ package ssa -import "log" - // checkFunc checks invariants of f. func checkFunc(f *Func) { blockMark := make([]bool, f.NumBlocks()) @@ -13,17 +11,17 @@ func checkFunc(f *Func) { for _, b := range f.Blocks { if blockMark[b.ID] { - log.Panicf("block %s appears twice in %s!", b, f.Name) + f.Fatal("block %s appears twice in %s!", b, f.Name) } blockMark[b.ID] = true if b.Func != f { - log.Panicf("%s.Func=%s, want %s", b, b.Func.Name, f.Name) + f.Fatal("%s.Func=%s, want %s", b, b.Func.Name, f.Name) } for i, c := range b.Succs { for j, d := range b.Succs { if i != j && c == d { - log.Panicf("%s.Succs has duplicate block %s", b, c) + f.Fatal("%s.Succs has duplicate block %s", b, c) } } } @@ -46,64 +44,64 @@ func checkFunc(f *Func) { } } if !found { - log.Panicf("block %s is not a succ of its pred block %s", b, p) + f.Fatal("block %s is not a succ of its pred block %s", b, p) } } switch b.Kind { case BlockExit: if len(b.Succs) != 0 { - log.Panicf("exit block %s has successors", b) + f.Fatal("exit block %s has successors", b) } if b.Control == nil { - log.Panicf("exit block %s has no control value", b) + f.Fatal("exit block %s has no control value", b) } if !b.Control.Type.IsMemory() { - log.Panicf("exit block %s has non-memory control value %s", b, b.Control.LongString()) + f.Fatal("exit block %s has non-memory control value %s", b, b.Control.LongString()) } case BlockPlain: if len(b.Succs) != 1 { - log.Panicf("plain block %s len(Succs)==%d, want 1", b, len(b.Succs)) + f.Fatal("plain block %s len(Succs)==%d, want 1", b, len(b.Succs)) } if b.Control != nil { - log.Panicf("plain block %s has non-nil control %s", b, b.Control.LongString()) + f.Fatal("plain block %s has non-nil control %s", b, b.Control.LongString()) } case BlockIf: if len(b.Succs) != 2 { - log.Panicf("if block %s len(Succs)==%d, want 2", b, len(b.Succs)) + f.Fatal("if block %s len(Succs)==%d, want 2", b, len(b.Succs)) } if b.Control == nil { - log.Panicf("if block %s has no control value", b) + f.Fatal("if block %s has no control value", b) } if !b.Control.Type.IsBoolean() { - log.Panicf("if block %s has non-bool control value %s", b, b.Control.LongString()) + f.Fatal("if block %s has non-bool control value %s", b, b.Control.LongString()) } case BlockCall: if len(b.Succs) != 2 { - log.Panicf("call block %s len(Succs)==%d, want 2", b, len(b.Succs)) + f.Fatal("call block %s len(Succs)==%d, want 2", b, len(b.Succs)) } if b.Control == nil { - log.Panicf("call block %s has no control value", b) + f.Fatal("call block %s has no control value", b) } if !b.Control.Type.IsMemory() { - log.Panicf("call block %s has non-memory control value %s", b, b.Control.LongString()) + f.Fatal("call block %s has non-memory control value %s", b, b.Control.LongString()) } if b.Succs[1].Kind != BlockExit { - log.Panicf("exception edge from call block %s does not go to exit but %s", b, b.Succs[1]) + f.Fatal("exception edge from call block %s does not go to exit but %s", b, b.Succs[1]) } } for _, v := range b.Values { if valueMark[v.ID] { - log.Panicf("value %s appears twice!", v.LongString()) + f.Fatal("value %s appears twice!", v.LongString()) } valueMark[v.ID] = true if v.Block != b { - log.Panicf("%s.block != %s", v, b) + f.Fatal("%s.block != %s", v, b) } if v.Op == OpPhi && len(v.Args) != len(b.Preds) { - log.Panicf("phi length %s does not match pred length %d for block %s", v.LongString(), len(b.Preds), b) + f.Fatal("phi length %s does not match pred length %d for block %s", v.LongString(), len(b.Preds), b) } // TODO: check for cycles in values @@ -113,12 +111,12 @@ func checkFunc(f *Func) { for _, id := range f.bid.free { if blockMark[id] { - log.Panicf("used block b%d in free list", id) + f.Fatal("used block b%d in free list", id) } } for _, id := range f.vid.free { if valueMark[id] { - log.Panicf("used value v%d in free list", id) + f.Fatal("used value v%d in free list", id) } } } diff --git a/src/cmd/compile/internal/ssa/compile.go b/src/cmd/compile/internal/ssa/compile.go index 02c9b5a4a9..896be01b68 100644 --- a/src/cmd/compile/internal/ssa/compile.go +++ b/src/cmd/compile/internal/ssa/compile.go @@ -4,10 +4,7 @@ package ssa -import ( - "fmt" - "log" -) +import "log" // Compile is the main entry point for this package. // Compile modifies f so that on return: @@ -18,13 +15,13 @@ import ( func Compile(f *Func) { // TODO: debugging - set flags to control verbosity of compiler, // which phases to dump IR before/after, etc. - fmt.Printf("compiling %s\n", f.Name) + f.Log("compiling %s\n", f.Name) // hook to print function & phase if panic happens phaseName := "init" defer func() { if phaseName != "" { - fmt.Printf("panic during %s while compiling %s\n", phaseName, f.Name) + f.Fatal("panic during %s while compiling %s\n", phaseName, f.Name) } }() @@ -33,9 +30,9 @@ func Compile(f *Func) { checkFunc(f) for _, p := range passes { phaseName = p.name - fmt.Printf(" pass %s begin\n", p.name) + f.Log(" pass %s begin\n", p.name) p.fn(f) - fmt.Printf(" pass %s end\n", p.name) + f.Log(" pass %s end\n", p.name) printFunc(f) checkFunc(f) } diff --git a/src/cmd/compile/internal/ssa/config.go b/src/cmd/compile/internal/ssa/config.go index db2d80a7c4..60c1a5a50b 100644 --- a/src/cmd/compile/internal/ssa/config.go +++ b/src/cmd/compile/internal/ssa/config.go @@ -4,8 +4,6 @@ package ssa -import "log" - type Config struct { arch string // "amd64", etc. ptrSize int64 // 4 or 8 @@ -22,6 +20,16 @@ type Frontend interface { // Strings are laid out in read-only memory with one word of pointer, // one word of length, then the contents of the string. StringSym(string) interface{} // returns *gc.Sym + + // Log logs a message from the compiler. + Log(string, ...interface{}) + + // Fatal reports a compiler error and exits. + Fatal(string, ...interface{}) + + // Unimplemented reports that the function cannot be compiled. + // It will be removed once SSA work is complete. + Unimplemented(msg string, args ...interface{}) } // NewConfig returns a new configuration object for the given architecture. @@ -37,7 +45,7 @@ func NewConfig(arch string, fe Frontend) *Config { c.lowerBlock = rewriteBlockAMD64 c.lowerValue = rewriteValueAMD64 // TODO(khr): full 32-bit support default: - log.Fatalf("arch %s not implemented", arch) + fe.Unimplemented("arch %s not implemented", arch) } // cache the intptr type in the config @@ -55,5 +63,9 @@ func (c *Config) NewFunc() *Func { return &Func{Config: c} } +func (c *Config) Log(msg string, args ...interface{}) { c.fe.Log(msg, args...) } +func (c *Config) Fatal(msg string, args ...interface{}) { c.fe.Fatal(msg, args...) } +func (c *Config) Unimplemented(msg string, args ...interface{}) { c.fe.Unimplemented(msg, args...) } + // TODO(khr): do we really need a separate Config, or can we just // store all its fields inside a Func? diff --git a/src/cmd/compile/internal/ssa/deadcode.go b/src/cmd/compile/internal/ssa/deadcode.go index 1a5589cd0a..f4884520de 100644 --- a/src/cmd/compile/internal/ssa/deadcode.go +++ b/src/cmd/compile/internal/ssa/deadcode.go @@ -4,8 +4,6 @@ package ssa -import "log" - // deadcode removes dead code from f. func deadcode(f *Func) { @@ -82,7 +80,7 @@ func deadcode(f *Func) { i++ } else { if len(b.Values) > 0 { - log.Panicf("live values in unreachable block %v: %v", b, b.Values) + b.Fatal("live values in unreachable block %v: %v", b, b.Values) } f.bid.put(b.ID) } @@ -105,7 +103,7 @@ func removePredecessor(b, c *Block) { if n == 0 { // c is now dead - don't bother working on it if c.Preds[0] != b { - log.Panicf("%s.Preds[0]==%s, want %s", c, c.Preds[0], b) + b.Fatal("%s.Preds[0]==%s, want %s", c, c.Preds[0], b) } return } diff --git a/src/cmd/compile/internal/ssa/deadcode_test.go b/src/cmd/compile/internal/ssa/deadcode_test.go index edd38e1254..ff9e6800da 100644 --- a/src/cmd/compile/internal/ssa/deadcode_test.go +++ b/src/cmd/compile/internal/ssa/deadcode_test.go @@ -7,7 +7,7 @@ package ssa import "testing" func TestDeadLoop(t *testing.T) { - c := NewConfig("amd64", DummyFrontend{}) + c := NewConfig("amd64", DummyFrontend{t}) fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), @@ -37,7 +37,7 @@ func TestDeadLoop(t *testing.T) { } func TestDeadValue(t *testing.T) { - c := NewConfig("amd64", DummyFrontend{}) + c := NewConfig("amd64", DummyFrontend{t}) fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), @@ -60,7 +60,7 @@ func TestDeadValue(t *testing.T) { } func TestNeverTaken(t *testing.T) { - c := NewConfig("amd64", DummyFrontend{}) + c := NewConfig("amd64", DummyFrontend{t}) fun := Fun(c, "entry", Bloc("entry", Valu("cond", OpConst, TypeBool, 0, false), diff --git a/src/cmd/compile/internal/ssa/deadstore.go b/src/cmd/compile/internal/ssa/deadstore.go index b02b35460a..e4d73e7226 100644 --- a/src/cmd/compile/internal/ssa/deadstore.go +++ b/src/cmd/compile/internal/ssa/deadstore.go @@ -4,8 +4,6 @@ package ssa -import "log" - // 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. @@ -58,12 +56,12 @@ func dse(f *Func) { continue } if last != nil { - log.Fatalf("two final stores - simultaneous live stores", last, v) + b.Fatal("two final stores - simultaneous live stores", last, v) } last = v } if last == nil { - log.Fatalf("no last store found - cycle?") + b.Fatal("no last store found - cycle?") } // Walk backwards looking for dead stores. Keep track of shadowed addresses. diff --git a/src/cmd/compile/internal/ssa/deadstore_test.go b/src/cmd/compile/internal/ssa/deadstore_test.go index 5143afb6cb..48ea066aa3 100644 --- a/src/cmd/compile/internal/ssa/deadstore_test.go +++ b/src/cmd/compile/internal/ssa/deadstore_test.go @@ -9,7 +9,7 @@ import ( ) func TestDeadStore(t *testing.T) { - c := NewConfig("amd64", DummyFrontend{}) + c := NewConfig("amd64", DummyFrontend{t}) ptrType := &TypeImpl{Size_: 8, Ptr: true, Name: "testptr"} // dummy for testing fun := Fun(c, "entry", Bloc("entry", @@ -35,7 +35,7 @@ func TestDeadStore(t *testing.T) { } func TestDeadStorePhi(t *testing.T) { // make sure we don't get into an infinite loop with phi values. - c := NewConfig("amd64", DummyFrontend{}) + c := NewConfig("amd64", DummyFrontend{t}) ptrType := &TypeImpl{Size_: 8, Ptr: true, Name: "testptr"} // dummy for testing fun := Fun(c, "entry", Bloc("entry", @@ -60,7 +60,7 @@ func TestDeadStoreTypes(t *testing.T) { // 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 := NewConfig("amd64", DummyFrontend{}) + c := NewConfig("amd64", DummyFrontend{t}) t1 := &TypeImpl{Size_: 8, Ptr: true, Name: "t1"} t2 := &TypeImpl{Size_: 4, Ptr: true, Name: "t2"} fun := Fun(c, "entry", diff --git a/src/cmd/compile/internal/ssa/dom.go b/src/cmd/compile/internal/ssa/dom.go index aaf3ab3da1..fac2798a60 100644 --- a/src/cmd/compile/internal/ssa/dom.go +++ b/src/cmd/compile/internal/ssa/dom.go @@ -7,8 +7,6 @@ package ssa // This file contains code to compute the dominator tree // of a control-flow graph. -import "log" - // postorder computes a postorder traversal ordering for the // basic blocks in f. Unreachable blocks will not appear. func postorder(f *Func) []*Block { @@ -47,7 +45,7 @@ func postorder(f *Func) []*Block { } } default: - log.Fatalf("bad stack state %v %d", b, mark[b.ID]) + b.Fatal("bad stack state %v %d", b, mark[b.ID]) } } return order @@ -73,7 +71,7 @@ func dominators(f *Func) []*Block { // Make the entry block a self-loop idom[f.Entry.ID] = f.Entry if postnum[f.Entry.ID] != len(post)-1 { - log.Fatalf("entry block %v not last in postorder", f.Entry) + f.Fatal("entry block %v not last in postorder", f.Entry) } // Compute relaxation of idom entries diff --git a/src/cmd/compile/internal/ssa/export_test.go b/src/cmd/compile/internal/ssa/export_test.go index 103945a73e..6b006e9238 100644 --- a/src/cmd/compile/internal/ssa/export_test.go +++ b/src/cmd/compile/internal/ssa/export_test.go @@ -4,13 +4,21 @@ package ssa +import "testing" + var CheckFunc = checkFunc var PrintFunc = printFunc var Opt = opt var Deadcode = deadcode -type DummyFrontend struct{} +type DummyFrontend struct { + t *testing.T +} -func (d DummyFrontend) StringSym(s string) interface{} { +func (DummyFrontend) StringSym(s string) interface{} { return nil } + +func (d DummyFrontend) Log(msg string, args ...interface{}) { d.t.Logf(msg, args...) } +func (d DummyFrontend) Fatal(msg string, args ...interface{}) { d.t.Fatalf(msg, args...) } +func (d DummyFrontend) Unimplemented(msg string, args ...interface{}) { d.t.Fatalf(msg, args...) } diff --git a/src/cmd/compile/internal/ssa/func.go b/src/cmd/compile/internal/ssa/func.go index d73e0ea9e0..56bee1aa3f 100644 --- a/src/cmd/compile/internal/ssa/func.go +++ b/src/cmd/compile/internal/ssa/func.go @@ -4,8 +4,6 @@ package ssa -import "log" - // A Func represents a Go func declaration (or function literal) and // its body. This package compiles each Func independently. type Func struct { @@ -79,7 +77,7 @@ func (b *Block) NewValue0A(line int32, op Op, t Type, aux interface{}) *Value { // 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. - log.Fatalf("aux field has int64 type op=%s type=%s aux=%v", op, t, aux) + b.Fatal("aux field has int64 type op=%s type=%s aux=%v", op, t, aux) } v := &Value{ ID: b.Func.vid.get(), @@ -209,3 +207,7 @@ func (f *Func) ConstInt(line int32, t Type, c int64) *Value { // TODO: cache? return f.Entry.NewValue0I(line, OpConst, t, c) } + +func (f *Func) Log(msg string, args ...interface{}) { f.Config.Log(msg, args...) } +func (f *Func) Fatal(msg string, args ...interface{}) { f.Config.Fatal(msg, args...) } +func (f *Func) Unimplemented(msg string, args ...interface{}) { f.Config.Unimplemented(msg, args...) } diff --git a/src/cmd/compile/internal/ssa/func_test.go b/src/cmd/compile/internal/ssa/func_test.go index 7cfc7324ac..b52d470e24 100644 --- a/src/cmd/compile/internal/ssa/func_test.go +++ b/src/cmd/compile/internal/ssa/func_test.go @@ -37,7 +37,7 @@ package ssa // the parser can be used instead of Fun. import ( - "log" + "fmt" "reflect" "testing" ) @@ -161,7 +161,7 @@ func Fun(c *Config, entry string, blocs ...bloc) fun { if c.control != "" { cval, ok := values[c.control] if !ok { - log.Panicf("control value for block %s missing", bloc.name) + f.Fatal("control value for block %s missing", bloc.name) } b.Control = cval } @@ -171,7 +171,7 @@ func Fun(c *Config, entry string, blocs ...bloc) fun { for _, arg := range valu.args { a, ok := values[arg] if !ok { - log.Panicf("arg %s missing for value %s in block %s", + b.Fatal("arg %s missing for value %s in block %s", arg, valu.name, bloc.name) } v.AddArg(a) @@ -197,7 +197,7 @@ func Bloc(name string, entries ...interface{}) bloc { case ctrl: // there should be exactly one Ctrl entry. if seenCtrl { - log.Panicf("already seen control for block %s", name) + panic(fmt.Sprintf("already seen control for block %s", name)) } b.control = v seenCtrl = true @@ -206,7 +206,7 @@ func Bloc(name string, entries ...interface{}) bloc { } } if !seenCtrl { - log.Panicf("block %s doesn't have control", b.name) + panic(fmt.Sprintf("block %s doesn't have control", b.name)) } return b } @@ -262,7 +262,7 @@ func addEdge(b, c *Block) { } func TestArgs(t *testing.T) { - c := NewConfig("amd64", DummyFrontend{}) + c := NewConfig("amd64", DummyFrontend{t}) fun := Fun(c, "entry", Bloc("entry", Valu("a", OpConst, TypeInt64, 14, nil), @@ -282,7 +282,7 @@ func TestArgs(t *testing.T) { } func TestEquiv(t *testing.T) { - c := NewConfig("amd64", DummyFrontend{}) + c := NewConfig("amd64", DummyFrontend{t}) equivalentCases := []struct{ f, g fun }{ // simple case { diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index e0bba1706f..9d08a35f1f 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -32,7 +32,7 @@ // indexing operations // Note: bounds check has already been done -(ArrayIndex (Load ptr mem) idx) -> (Load (PtrIndex ptr idx) mem) +(ArrayIndex (Load ptr mem) idx) -> (Load (PtrIndex ptr idx) mem) (PtrIndex ptr idx) -> (Add ptr (Mul idx (Const [t.Elem().Size()]))) // big-object moves diff --git a/src/cmd/compile/internal/ssa/layout.go b/src/cmd/compile/internal/ssa/layout.go index 7123397c4c..0a271b39ad 100644 --- a/src/cmd/compile/internal/ssa/layout.go +++ b/src/cmd/compile/internal/ssa/layout.go @@ -4,8 +4,6 @@ package ssa -import "log" - // 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. @@ -82,7 +80,7 @@ blockloop: continue blockloop } } - log.Panicf("no block available for layout") + b.Fatal("no block available for layout") } f.Blocks = order } diff --git a/src/cmd/compile/internal/ssa/lower.go b/src/cmd/compile/internal/ssa/lower.go index 2ca1db784e..768ac124be 100644 --- a/src/cmd/compile/internal/ssa/lower.go +++ b/src/cmd/compile/internal/ssa/lower.go @@ -4,8 +4,6 @@ package ssa -import "log" - // convert to machine-dependent ops func lower(f *Func) { // repeat rewrites until we find no more rewrites @@ -15,7 +13,7 @@ func lower(f *Func) { for _, b := range f.Blocks { for _, v := range b.Values { if opcodeTable[v.Op].generic && v.Op != OpFP && v.Op != OpSP && v.Op != OpArg && v.Op != OpCopy && v.Op != OpPhi { - log.Panicf("%s not lowered", v.LongString()) + f.Unimplemented("%s not lowered", v.LongString()) } } } diff --git a/src/cmd/compile/internal/ssa/print.go b/src/cmd/compile/internal/ssa/print.go index b9a958c18e..c1b97d2b8f 100644 --- a/src/cmd/compile/internal/ssa/print.go +++ b/src/cmd/compile/internal/ssa/print.go @@ -8,11 +8,10 @@ import ( "bytes" "fmt" "io" - "os" ) func printFunc(f *Func) { - fprintFunc(os.Stdout, f) + f.Log("%s", f.String()) } func (f *Func) String() string { diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index 6f7d619247..d1489b20f2 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -4,11 +4,7 @@ package ssa -import ( - "fmt" - "log" - "sort" -) +import "sort" func setloc(home []Location, v *Value, loc Location) []Location { for v.ID >= ID(len(home)) { @@ -353,7 +349,7 @@ func regalloc(f *Func) { if b.Kind == BlockCall { call = b.Control if call != b.Values[len(b.Values)-1] { - log.Fatalf("call not at end of block %b %v", b, call) + b.Fatal("call not at end of block %b %v", b, call) } b.Values = b.Values[:len(b.Values)-1] // TODO: do this for all control types? @@ -423,7 +419,7 @@ func live(f *Func) [][]ID { t := newSparseSet(f.NumValues()) for { for _, b := range f.Blocks { - fmt.Printf("live %s %v\n", b, live[b.ID]) + f.Log("live %s %v\n", b, live[b.ID]) } changed := false diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go index 77aa2b07b4..2bfd3813ed 100644 --- a/src/cmd/compile/internal/ssa/rewrite.go +++ b/src/cmd/compile/internal/ssa/rewrite.go @@ -4,7 +4,7 @@ package ssa -import "log" +import "fmt" func applyRewrite(f *Func, rb func(*Block) bool, rv func(*Value, *Config) bool) { // repeat rewrites until we find no more rewrites @@ -12,11 +12,10 @@ func applyRewrite(f *Func, rb func(*Block) bool, rv func(*Value, *Config) bool) var curv *Value defer func() { if curb != nil { - log.Printf("panic during rewrite of block %s\n", curb.LongString()) + curb.Fatal("panic during rewrite of block %s\n", curb.LongString()) } if curv != nil { - log.Printf("panic during rewrite of value %s\n", curv.LongString()) - panic("rewrite failed") + curv.Fatal("panic during rewrite of value %s\n", curv.LongString()) // TODO(khr): print source location also } }() @@ -90,12 +89,12 @@ func typeSize(t Type) int64 { return t.Size() } -// addOff adds two int64 offsets. Fails if wraparound happens. +// 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 { - log.Panicf("offset overflow %d %d\n", x, y) + panic(fmt.Sprintf("offset overflow %d %d", x, y)) } return z } diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index 0ecc436343..ac4f009881 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -34,10 +34,10 @@ func rewriteValuegeneric(v *Value, config *Config) bool { case OpArrayIndex: // match: (ArrayIndex (Load ptr mem) idx) // cond: - // result: (Load (PtrIndex ptr idx) mem) + // result: (Load (PtrIndex ptr idx) mem) { if v.Args[0].Op != OpLoad { - goto end3809f4c52270a76313e4ea26e6f0b753 + goto end4894dd7b58383fee5f8a92be08437c33 } ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] @@ -47,15 +47,15 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := v.Block.NewValue0(v.Line, OpPtrIndex, TypeInvalid) - v0.Type = ptr.Type.Elem().Elem().PtrTo() + v0.Type = v.Type.PtrTo() v0.AddArg(ptr) v0.AddArg(idx) v.AddArg(v0) v.AddArg(mem) return true } - goto end3809f4c52270a76313e4ea26e6f0b753 - end3809f4c52270a76313e4ea26e6f0b753: + goto end4894dd7b58383fee5f8a92be08437c33 + end4894dd7b58383fee5f8a92be08437c33: ; case OpConst: // match: (Const {s}) diff --git a/src/cmd/compile/internal/ssa/schedule_test.go b/src/cmd/compile/internal/ssa/schedule_test.go index a7c33d9d59..a9432579f7 100644 --- a/src/cmd/compile/internal/ssa/schedule_test.go +++ b/src/cmd/compile/internal/ssa/schedule_test.go @@ -7,7 +7,7 @@ package ssa import "testing" func TestSchedule(t *testing.T) { - c := NewConfig("amd64", DummyFrontend{}) + c := NewConfig("amd64", DummyFrontend{t}) cases := []fun{ Fun(c, "entry", Bloc("entry", diff --git a/src/cmd/compile/internal/ssa/shift_test.go b/src/cmd/compile/internal/ssa/shift_test.go index b4b4f47ff0..52ddbbe42d 100644 --- a/src/cmd/compile/internal/ssa/shift_test.go +++ b/src/cmd/compile/internal/ssa/shift_test.go @@ -9,7 +9,7 @@ import ( ) func TestShiftConstAMD64(t *testing.T) { - c := NewConfig("amd64", DummyFrontend{}) + c := NewConfig("amd64", DummyFrontend{t}) fun := makeConstShiftFunc(c, 18, OpLsh, TypeUInt64) checkOpcodeCounts(t, fun.f, map[Op]int{OpAMD64SHLQconst: 1, OpAMD64CMPQconst: 0, OpAMD64ANDQconst: 0}) fun = makeConstShiftFunc(c, 66, OpLsh, TypeUInt64) diff --git a/src/cmd/compile/internal/ssa/stackalloc.go b/src/cmd/compile/internal/ssa/stackalloc.go index 5db7316dca..452d0c75a1 100644 --- a/src/cmd/compile/internal/ssa/stackalloc.go +++ b/src/cmd/compile/internal/ssa/stackalloc.go @@ -4,8 +4,6 @@ package ssa -import "log" - // stackalloc allocates storage in the stack frame for // all Values that did not get a register. func stackalloc(f *Func) { @@ -79,7 +77,7 @@ func stackalloc(f *Func) { for _, v := range b.Values { if v.Op == OpFP { if fp != nil { - log.Panicf("multiple FP ops: %s %s", fp, v) + b.Fatal("multiple FP ops: %s %s", fp, v) } fp = v } @@ -99,12 +97,12 @@ func stackalloc(f *Func) { case OpAMD64LEAQ, OpAMD64MOVQload, OpAMD64MOVQstore, OpAMD64MOVLload, OpAMD64MOVLstore, OpAMD64MOVWload, OpAMD64MOVWstore, OpAMD64MOVBload, OpAMD64MOVBstore, OpAMD64MOVQloadidx8: if v.Op == OpAMD64MOVQloadidx8 && i == 1 { // Note: we could do it, but it is probably an error - log.Panicf("can't do FP->SP adjust on index slot of load %s", v.Op) + f.Fatal("can't do FP->SP adjust on index slot of load %s", v.Op) } // eg: (MOVQload [c] (FP) mem) -> (MOVQload [c+n] (SP) mem) v.AuxInt = addOff(v.AuxInt, n) default: - log.Panicf("can't do FP->SP adjust on %s", v.Op) + f.Unimplemented("can't do FP->SP adjust on %s", v.Op) // TODO: OpCopy -> ADDQ } } diff --git a/src/cmd/compile/internal/ssa/value.go b/src/cmd/compile/internal/ssa/value.go index 3ed1f3c2b9..bfba8dc369 100644 --- a/src/cmd/compile/internal/ssa/value.go +++ b/src/cmd/compile/internal/ssa/value.go @@ -106,3 +106,7 @@ func (v *Value) resetArgs() { v.argstorage[1] = nil v.Args = v.argstorage[:0] } + +func (v *Value) Log(msg string, args ...interface{}) { v.Block.Log(msg, args...) } +func (v *Value) Fatal(msg string, args ...interface{}) { v.Block.Fatal(msg, args...) } +func (v *Value) Unimplemented(msg string, args ...interface{}) { v.Block.Unimplemented(msg, args...) } -- cgit v1.3 From 2a846d2bd36a74d971ad6d009a05d2ca64bba8a9 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Wed, 3 Jun 2015 12:31:47 -0700 Subject: [dev.ssa] cmd/compile/ssa: add nilcheckelim pass The nilcheckelim pass eliminates unnecessary nil checks. The initial implementation removes redundant nil checks. See the comments in nilcheck.go for ideas for future improvements. The efficacy of the cse pass has a significant impact on this efficacy of this pass. There are 886 nil checks in the parts of the standard library that SSA can currently compile (~20%). This pass eliminates 75 (~8.5%) of them. As a data point, with a more aggressive but unsound cse pass that treats many more types as identical, this pass eliminates 115 (~13%) of the nil checks. Change-Id: I13e567a39f5f6909fc33434d55c17a7e3884a704 Reviewed-on: https://go-review.googlesource.com/11430 Reviewed-by: Alan Donovan --- src/cmd/compile/internal/ssa/TODO | 5 +++ src/cmd/compile/internal/ssa/compile.go | 7 ++++ src/cmd/compile/internal/ssa/cse.go | 6 ++- src/cmd/compile/internal/ssa/nilcheck.go | 72 ++++++++++++++++++++++++++++++++ 4 files changed, 89 insertions(+), 1 deletion(-) create mode 100644 src/cmd/compile/internal/ssa/nilcheck.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/TODO b/src/cmd/compile/internal/ssa/TODO index 64b581fac0..66841c36f0 100644 --- a/src/cmd/compile/internal/ssa/TODO +++ b/src/cmd/compile/internal/ssa/TODO @@ -35,11 +35,16 @@ Rewrites - (MOVLstore x m) to get rid of most of the MOVLQSX. + - Determine which nil checks can be done implicitly (by faulting) + and which need code generated, and do the code generation. Common-Subexpression Elimination + - Canonicalize types. - Make better decision about which value in an equivalence class we should choose to replace other values in that class. - Can we move control values out of their basic block? + This would break nilcheckelim as currently implemented, + but it could be replaced by a similar CFG simplication pass. Other - Write barriers diff --git a/src/cmd/compile/internal/ssa/compile.go b/src/cmd/compile/internal/ssa/compile.go index 896be01b68..27cc0d0609 100644 --- a/src/cmd/compile/internal/ssa/compile.go +++ b/src/cmd/compile/internal/ssa/compile.go @@ -52,6 +52,7 @@ var passes = [...]pass{ {"copyelim", copyelim}, {"opt", opt}, {"generic cse", cse}, + {"nilcheckelim", nilcheckelim}, {"generic deadcode", deadcode}, {"dse", dse}, {"fuse", fuse}, @@ -77,6 +78,12 @@ var passOrder = [...]constraint{ // 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"}, // don't layout blocks until critical edges have been removed {"critical", "layout"}, // regalloc requires the removal of all critical edges diff --git a/src/cmd/compile/internal/ssa/cse.go b/src/cmd/compile/internal/ssa/cse.go index 660712612a..403c845152 100644 --- a/src/cmd/compile/internal/ssa/cse.go +++ b/src/cmd/compile/internal/ssa/cse.go @@ -24,7 +24,11 @@ func cse(f *Func) { // until it reaches a fixed point. // Make initial partition based on opcode/type/aux/nargs - // TODO(khr): types are not canonical, so we may split unnecessarily. Fix that. + // TODO(khr): types are not canonical, so we split unnecessarily. + // For example, all pointer types are distinct. Fix this. + // As a data point, using v.Type.String() instead of + // v.Type here (which is unsound) allows removal of + // about 50% more nil checks in the nilcheck elim pass. type key struct { op Op typ Type diff --git a/src/cmd/compile/internal/ssa/nilcheck.go b/src/cmd/compile/internal/ssa/nilcheck.go new file mode 100644 index 0000000000..28544d5900 --- /dev/null +++ b/src/cmd/compile/internal/ssa/nilcheck.go @@ -0,0 +1,72 @@ +// 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 + +// nilcheckelim eliminates unnecessary nil checks. +func nilcheckelim(f *Func) { + // Exit early if there are no nil checks to eliminate. + var found bool + for _, b := range f.Blocks { + if checkedptr(b) != nil { + found = true + break + } + } + if !found { + return + } + + // Eliminate redundant nil checks. + // A nil check is redundant if the same + // nil check has been performed by a + // dominating block. + // The efficacy of this pass depends + // heavily on the efficacy of the cse pass. + idom := dominators(f) // TODO: cache the dominator tree in the function, clearing when the CFG changes? + for _, b := range f.Blocks { + ptr := checkedptr(b) + if ptr == nil { + continue + } + var elim bool + // Walk up the dominator tree, + // looking for identical nil checks. + for c := idom[b.ID]; c != nil; c = idom[c.ID] { + if checkedptr(c) == ptr { + elim = true + break + } + } + if elim { + // Eliminate the nil check. + // The deadcode pass will remove vestigial values, + // and the fuse pass will join this block with its successor. + b.Kind = BlockPlain + b.Control = nil + removePredecessor(b, b.Succs[1]) + b.Succs = b.Succs[:1] + } + } + + // TODO: Eliminate more nil checks. + // For example, pointers to function arguments + // and pointers to static values cannot be nil. + // We could also track pointers constructed by + // taking the address of another value. + // We can also 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. +} + +// 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 == BlockIf && b.Control.Op == OpIsNonNil { + return b.Control.Args[0] + } + return nil +} -- cgit v1.3 From 44be0e9c601cbb40a2ac8cf74cb0c57b1292825d Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Wed, 24 Jun 2015 13:29:05 -0700 Subject: [dev.ssa] cmd/compile/ssa: fix build Somehow I missed this in CL 11160. Without it, all.bash fails on fixedbugs/bug303.go. The right fix is probably to discard the variable and keep going, even though the code is dead. For now, defer the decision by declaring such situations unimplemented and get the build fixed. Change-Id: I679197f780c7a3d3eb7d05e91c86a4cdc3b70131 Reviewed-on: https://go-review.googlesource.com/11440 Reviewed-by: Brad Fitzpatrick --- src/cmd/compile/internal/gc/ssa.go | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 1218a23488..569b985052 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -649,7 +649,10 @@ func (s *state) boundsCheck(idx, len *ssa.Value) { // variable returns the value of a variable at the current location. func (s *state) variable(name string, t ssa.Type) *ssa.Value { if s.curBlock == nil { - s.Fatal("nil curblock!") + // Unimplemented instead of Fatal because fixedbugs/bug303.go + // demonstrates a case in which this appears to happen legitimately. + // TODO: decide on the correct behavior here. + s.Unimplemented("nil curblock adding variable %v (%v)", name, t) } v := s.vars[name] if v == nil { -- cgit v1.3 From d779b20cd2f435709cfbbbfa8af88f5e556866d8 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Tue, 23 Jun 2015 16:44:06 -0700 Subject: [dev.ssa] cmd/compile/ssa: improve comments, logging, and debug output Change-Id: Id949db82ddaf802c1aa245a337081d4d46fd914f Reviewed-on: https://go-review.googlesource.com/11380 Reviewed-by: Alan Donovan --- src/cmd/compile/internal/ssa/cse.go | 3 ++- src/cmd/compile/internal/ssa/value.go | 6 +++++- 2 files changed, 7 insertions(+), 2 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/cse.go b/src/cmd/compile/internal/ssa/cse.go index 403c845152..7a1cf53ccb 100644 --- a/src/cmd/compile/internal/ssa/cse.go +++ b/src/cmd/compile/internal/ssa/cse.go @@ -15,6 +15,7 @@ func cse(f *Func) { // v.op == w.op // v.type == w.type // v.aux == w.aux + // v.auxint == w.auxint // len(v.args) == len(w.args) // equivalent(v.args[i], w.args[i]) for i in 0..len(v.args)-1 @@ -23,7 +24,7 @@ func cse(f *Func) { // It starts with a coarse partition and iteratively refines it // until it reaches a fixed point. - // Make initial partition based on opcode/type/aux/nargs + // Make initial partition based on opcode/type/aux/auxint/nargs // TODO(khr): types are not canonical, so we split unnecessarily. // For example, all pointer types are distinct. Fix this. // As a data point, using v.Type.String() instead of diff --git a/src/cmd/compile/internal/ssa/value.go b/src/cmd/compile/internal/ssa/value.go index bfba8dc369..ef10fb20cd 100644 --- a/src/cmd/compile/internal/ssa/value.go +++ b/src/cmd/compile/internal/ssa/value.go @@ -59,7 +59,11 @@ func (v *Value) LongString() string { s += fmt.Sprintf(" [%d]", v.AuxInt) } if v.Aux != nil { - s += fmt.Sprintf(" {%v}", v.Aux) + if _, ok := v.Aux.(string); ok { + s += fmt.Sprintf(" {%q}", v.Aux) + } else { + s += fmt.Sprintf(" {%v}", v.Aux) + } } for _, a := range v.Args { s += fmt.Sprintf(" %v", a) -- cgit v1.3 From 37ddc270ca5360ccde000fd373d49b3450ee8e6e Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Wed, 24 Jun 2015 14:03:39 -0700 Subject: [dev.ssa] cmd/compile/ssa: add -f suffix to logging methods Requested in CL 11380. Change-Id: Icf0d23fb8d383c76272401e363cc9b2169d11403 Reviewed-on: https://go-review.googlesource.com/11450 Reviewed-by: Alan Donovan --- src/cmd/compile/internal/gc/ssa.go | 44 ++++++++++++++--------------- src/cmd/compile/internal/ssa/block.go | 6 ++-- src/cmd/compile/internal/ssa/check.go | 42 +++++++++++++-------------- src/cmd/compile/internal/ssa/compile.go | 8 +++--- src/cmd/compile/internal/ssa/config.go | 14 ++++----- src/cmd/compile/internal/ssa/deadcode.go | 4 +-- src/cmd/compile/internal/ssa/deadstore.go | 4 +-- src/cmd/compile/internal/ssa/dom.go | 4 +-- src/cmd/compile/internal/ssa/export_test.go | 6 ++-- src/cmd/compile/internal/ssa/func.go | 8 +++--- src/cmd/compile/internal/ssa/func_test.go | 4 +-- src/cmd/compile/internal/ssa/layout.go | 2 +- src/cmd/compile/internal/ssa/lower.go | 2 +- src/cmd/compile/internal/ssa/print.go | 2 +- src/cmd/compile/internal/ssa/regalloc.go | 4 +-- src/cmd/compile/internal/ssa/rewrite.go | 4 +-- src/cmd/compile/internal/ssa/stackalloc.go | 6 ++-- src/cmd/compile/internal/ssa/value.go | 6 ++-- 18 files changed, 85 insertions(+), 85 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 569b985052..0dd2e44ec5 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -135,13 +135,13 @@ type state struct { line []int32 } -func (s *state) Fatal(msg string, args ...interface{}) { s.config.Fatal(msg, args...) } -func (s *state) Unimplemented(msg string, args ...interface{}) { s.config.Unimplemented(msg, args...) } +func (s *state) Fatalf(msg string, args ...interface{}) { s.config.Fatalf(msg, args...) } +func (s *state) Unimplementedf(msg string, args ...interface{}) { s.config.Unimplementedf(msg, args...) } // startBlock sets the current block we're generating code in to b. func (s *state) startBlock(b *ssa.Block) { if s.curBlock != nil { - s.Fatal("starting block %v when block %v has not ended", b, s.curBlock) + s.Fatalf("starting block %v when block %v has not ended", b, s.curBlock) } s.curBlock = b s.vars = map[string]*ssa.Value{} @@ -294,7 +294,7 @@ func (s *state) stmt(n *Node) { s.startBlock(t) } if n.Op == OGOTO && s.curBlock == nil { - s.Unimplemented("goto at start of function; see test/goto.go") + s.Unimplementedf("goto at start of function; see test/goto.go") } case OAS, OASWB: @@ -354,7 +354,7 @@ func (s *state) stmt(n *Node) { // generate code to test condition // TODO(khr): Left == nil exception if n.Left == nil { - s.Unimplemented("cond n.Left == nil: %v", n) + s.Unimplementedf("cond n.Left == nil: %v", n) } s.startBlock(bCond) cond := s.expr(n.Left) @@ -381,7 +381,7 @@ func (s *state) stmt(n *Node) { // TODO(khr): ??? anything to do here? Only for addrtaken variables? // Maybe just link it in the store chain? default: - s.Unimplemented("unhandled stmt %s", opnames[n.Op]) + s.Unimplementedf("unhandled stmt %s", opnames[n.Op]) } } @@ -409,7 +409,7 @@ func (s *state) expr(n *Node) *ssa.Value { case CTSTR: return s.entryNewValue0A(ssa.OpConst, n.Type, n.Val().U) default: - s.Unimplemented("unhandled OLITERAL %v", n.Val().Ctype()) + s.Unimplementedf("unhandled OLITERAL %v", n.Val().Ctype()) return nil } case OCONVNOP: @@ -513,7 +513,7 @@ func (s *state) expr(n *Node) *ssa.Value { a := s.entryNewValue1I(ssa.OpOffPtr, Ptrto(fp.Type), fp.Width, s.sp) return s.newValue2(ssa.OpLoad, fp.Type, a, call) default: - s.Unimplemented("unhandled expr %s", opnames[n.Op]) + s.Unimplementedf("unhandled expr %s", opnames[n.Op]) return nil } } @@ -533,7 +533,7 @@ func (s *state) assign(op uint8, left *Node, right *Node) { case t.IsBoolean(): val = s.entryNewValue0A(ssa.OpConst, left.Type, false) // TODO: store bools as 0/1 in AuxInt? default: - s.Unimplemented("zero for type %v not implemented", t) + s.Unimplementedf("zero for type %v not implemented", t) } } else { val = s.expr(right) @@ -563,7 +563,7 @@ func (s *state) addr(n *Node) *ssa.Value { return s.expr(n.Name.Heapaddr) default: // TODO: address of locals - s.Unimplemented("variable address of %v not implemented", n) + s.Unimplementedf("variable address of %v not implemented", n) return nil } case OINDREG: @@ -586,7 +586,7 @@ func (s *state) addr(n *Node) *ssa.Value { return s.newValue2(ssa.OpPtrIndex, Ptrto(n.Left.Type.Type), p, i) } default: - s.Unimplemented("addr: bad op %v", Oconv(int(n.Op), 0)) + s.Unimplementedf("addr: bad op %v", Oconv(int(n.Op), 0)) return nil } } @@ -652,7 +652,7 @@ func (s *state) variable(name string, t ssa.Type) *ssa.Value { // Unimplemented instead of Fatal because fixedbugs/bug303.go // demonstrates a case in which this appears to happen legitimately. // TODO: decide on the correct behavior here. - s.Unimplemented("nil curblock adding variable %v (%v)", name, t) + s.Unimplementedf("nil curblock adding variable %v (%v)", name, t) } v := s.vars[name] if v == nil { @@ -705,7 +705,7 @@ func (s *state) lookupVarIncoming(b *ssa.Block, t ssa.Type, name string) *ssa.Va vals = append(vals, s.lookupVarOutgoing(p, t, name)) } if len(vals) == 0 { - s.Unimplemented("TODO: Handle fixedbugs/bug076.go") + s.Unimplementedf("TODO: Handle fixedbugs/bug076.go") return nil } v0 := vals[0] @@ -868,7 +868,7 @@ func genValue(v *ssa.Value) { p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v) case ssa.OpAMD64MULQconst: - v.Unimplemented("IMULQ doasm") + v.Unimplementedf("IMULQ doasm") return // TODO: this isn't right. doasm fails on it. I don't think obj // has ever been taught to compile imul $c, r1, r2. @@ -903,7 +903,7 @@ func genValue(v *ssa.Value) { r := regnum(v) if x != r { if r == x86.REG_CX { - v.Fatal("can't implement %s, target and shift both in CX", v.LongString()) + v.Fatalf("can't implement %s, target and shift both in CX", v.LongString()) } p := Prog(x86.AMOVQ) p.From.Type = obj.TYPE_REG @@ -1052,12 +1052,12 @@ func genValue(v *ssa.Value) { loc := f.RegAlloc[v.ID] for _, a := range v.Args { if f.RegAlloc[a.ID] != loc { // TODO: .Equal() instead? - v.Fatal("phi arg at different location than phi %v %v %v %v", v, loc, a, f.RegAlloc[a.ID]) + v.Fatalf("phi arg at different location than phi %v %v %v %v", v, loc, a, f.RegAlloc[a.ID]) } } case ssa.OpConst: if v.Block.Func.RegAlloc[v.ID] != nil { - v.Fatal("const value %v shouldn't have a location", v) + v.Fatalf("const value %v shouldn't have a location", v) } case ssa.OpArg: // memory arg needs no code @@ -1082,7 +1082,7 @@ func genValue(v *ssa.Value) { case ssa.OpFP, ssa.OpSP: // nothing to do default: - v.Unimplemented("value %s not implemented", v.LongString()) + v.Unimplementedf("value %s not implemented", v.LongString()) } } @@ -1190,7 +1190,7 @@ func genBlock(b, next *ssa.Block, branches []branch) []branch { } default: - b.Unimplemented("branch %s not implemented", b.LongString()) + b.Unimplementedf("branch %s not implemented", b.LongString()) } return branches } @@ -1244,7 +1244,7 @@ func (*ssaExport) StringSym(s string) interface{} { } // Log logs a message from the compiler. -func (e *ssaExport) Log(msg string, args ...interface{}) { +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...) @@ -1252,7 +1252,7 @@ func (e *ssaExport) Log(msg string, args ...interface{}) { } // Fatal reports a compiler error and exits. -func (e *ssaExport) Fatal(msg string, args ...interface{}) { +func (e *ssaExport) Fatalf(msg string, args ...interface{}) { // If e was marked as unimplemented, anything could happen. Ignore. if !e.unimplemented { Fatal(msg, args...) @@ -1261,7 +1261,7 @@ func (e *ssaExport) Fatal(msg string, args ...interface{}) { // Unimplemented reports that the function cannot be compiled. // It will be removed once SSA work is complete. -func (e *ssaExport) Unimplemented(msg string, args ...interface{}) { +func (e *ssaExport) Unimplementedf(msg string, args ...interface{}) { const alwaysLog = false // enable to calculate top unimplemented features if !e.unimplemented && (e.log || alwaysLog) { // first implementation failure, print explanation diff --git a/src/cmd/compile/internal/ssa/block.go b/src/cmd/compile/internal/ssa/block.go index e0d5c1a55e..b788031fce 100644 --- a/src/cmd/compile/internal/ssa/block.go +++ b/src/cmd/compile/internal/ssa/block.go @@ -70,6 +70,6 @@ func (b *Block) LongString() string { return s } -func (b *Block) Log(msg string, args ...interface{}) { b.Func.Log(msg, args...) } -func (b *Block) Fatal(msg string, args ...interface{}) { b.Func.Fatal(msg, args...) } -func (b *Block) Unimplemented(msg string, args ...interface{}) { b.Func.Unimplemented(msg, args...) } +func (b *Block) Logf(msg string, args ...interface{}) { b.Func.Logf(msg, args...) } +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...) } diff --git a/src/cmd/compile/internal/ssa/check.go b/src/cmd/compile/internal/ssa/check.go index 230d0ec111..672aeda96a 100644 --- a/src/cmd/compile/internal/ssa/check.go +++ b/src/cmd/compile/internal/ssa/check.go @@ -11,17 +11,17 @@ func checkFunc(f *Func) { for _, b := range f.Blocks { if blockMark[b.ID] { - f.Fatal("block %s appears twice in %s!", b, f.Name) + f.Fatalf("block %s appears twice in %s!", b, f.Name) } blockMark[b.ID] = true if b.Func != f { - f.Fatal("%s.Func=%s, want %s", b, b.Func.Name, f.Name) + f.Fatalf("%s.Func=%s, want %s", b, b.Func.Name, f.Name) } for i, c := range b.Succs { for j, d := range b.Succs { if i != j && c == d { - f.Fatal("%s.Succs has duplicate block %s", b, c) + f.Fatalf("%s.Succs has duplicate block %s", b, c) } } } @@ -44,64 +44,64 @@ func checkFunc(f *Func) { } } if !found { - f.Fatal("block %s is not a succ of its pred block %s", b, p) + 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.Fatal("exit block %s has successors", b) + f.Fatalf("exit block %s has successors", b) } if b.Control == nil { - f.Fatal("exit block %s has no control value", b) + f.Fatalf("exit block %s has no control value", b) } if !b.Control.Type.IsMemory() { - f.Fatal("exit block %s has non-memory control value %s", b, b.Control.LongString()) + f.Fatalf("exit block %s has non-memory control value %s", b, b.Control.LongString()) } case BlockPlain: if len(b.Succs) != 1 { - f.Fatal("plain block %s len(Succs)==%d, want 1", b, len(b.Succs)) + f.Fatalf("plain block %s len(Succs)==%d, want 1", b, len(b.Succs)) } if b.Control != nil { - f.Fatal("plain block %s has non-nil control %s", b, b.Control.LongString()) + f.Fatalf("plain block %s has non-nil control %s", b, b.Control.LongString()) } case BlockIf: if len(b.Succs) != 2 { - f.Fatal("if block %s len(Succs)==%d, want 2", b, len(b.Succs)) + f.Fatalf("if block %s len(Succs)==%d, want 2", b, len(b.Succs)) } if b.Control == nil { - f.Fatal("if block %s has no control value", b) + f.Fatalf("if block %s has no control value", b) } if !b.Control.Type.IsBoolean() { - f.Fatal("if block %s has non-bool control value %s", b, b.Control.LongString()) + f.Fatalf("if block %s has non-bool control value %s", b, b.Control.LongString()) } case BlockCall: if len(b.Succs) != 2 { - f.Fatal("call block %s len(Succs)==%d, want 2", b, len(b.Succs)) + f.Fatalf("call block %s len(Succs)==%d, want 2", b, len(b.Succs)) } if b.Control == nil { - f.Fatal("call block %s has no control value", b) + f.Fatalf("call block %s has no control value", b) } if !b.Control.Type.IsMemory() { - f.Fatal("call block %s has non-memory control value %s", b, b.Control.LongString()) + f.Fatalf("call block %s has non-memory control value %s", b, b.Control.LongString()) } if b.Succs[1].Kind != BlockExit { - f.Fatal("exception edge from call block %s does not go to exit but %s", b, b.Succs[1]) + f.Fatalf("exception edge from call block %s does not go to exit but %s", b, b.Succs[1]) } } for _, v := range b.Values { if valueMark[v.ID] { - f.Fatal("value %s appears twice!", v.LongString()) + f.Fatalf("value %s appears twice!", v.LongString()) } valueMark[v.ID] = true if v.Block != b { - f.Fatal("%s.block != %s", v, b) + f.Fatalf("%s.block != %s", v, b) } if v.Op == OpPhi && len(v.Args) != len(b.Preds) { - f.Fatal("phi length %s does not match pred length %d for block %s", v.LongString(), len(b.Preds), b) + f.Fatalf("phi length %s does not match pred length %d for block %s", v.LongString(), len(b.Preds), b) } // TODO: check for cycles in values @@ -111,12 +111,12 @@ func checkFunc(f *Func) { for _, id := range f.bid.free { if blockMark[id] { - f.Fatal("used block b%d in free list", id) + f.Fatalf("used block b%d in free list", id) } } for _, id := range f.vid.free { if valueMark[id] { - f.Fatal("used value v%d in free list", id) + f.Fatalf("used value v%d in free list", id) } } } diff --git a/src/cmd/compile/internal/ssa/compile.go b/src/cmd/compile/internal/ssa/compile.go index 27cc0d0609..b02c10a745 100644 --- a/src/cmd/compile/internal/ssa/compile.go +++ b/src/cmd/compile/internal/ssa/compile.go @@ -15,13 +15,13 @@ import "log" func Compile(f *Func) { // TODO: debugging - set flags to control verbosity of compiler, // which phases to dump IR before/after, etc. - f.Log("compiling %s\n", f.Name) + f.Logf("compiling %s\n", f.Name) // hook to print function & phase if panic happens phaseName := "init" defer func() { if phaseName != "" { - f.Fatal("panic during %s while compiling %s\n", phaseName, f.Name) + f.Fatalf("panic during %s while compiling %s\n", phaseName, f.Name) } }() @@ -30,9 +30,9 @@ func Compile(f *Func) { checkFunc(f) for _, p := range passes { phaseName = p.name - f.Log(" pass %s begin\n", p.name) + f.Logf(" pass %s begin\n", p.name) p.fn(f) - f.Log(" pass %s end\n", p.name) + f.Logf(" pass %s end\n", p.name) printFunc(f) checkFunc(f) } diff --git a/src/cmd/compile/internal/ssa/config.go b/src/cmd/compile/internal/ssa/config.go index 60c1a5a50b..53eb5e8eb5 100644 --- a/src/cmd/compile/internal/ssa/config.go +++ b/src/cmd/compile/internal/ssa/config.go @@ -22,14 +22,14 @@ type Frontend interface { StringSym(string) interface{} // returns *gc.Sym // Log logs a message from the compiler. - Log(string, ...interface{}) + Logf(string, ...interface{}) // Fatal reports a compiler error and exits. - Fatal(string, ...interface{}) + Fatalf(string, ...interface{}) // Unimplemented reports that the function cannot be compiled. // It will be removed once SSA work is complete. - Unimplemented(msg string, args ...interface{}) + Unimplementedf(msg string, args ...interface{}) } // NewConfig returns a new configuration object for the given architecture. @@ -45,7 +45,7 @@ func NewConfig(arch string, fe Frontend) *Config { c.lowerBlock = rewriteBlockAMD64 c.lowerValue = rewriteValueAMD64 // TODO(khr): full 32-bit support default: - fe.Unimplemented("arch %s not implemented", arch) + fe.Unimplementedf("arch %s not implemented", arch) } // cache the intptr type in the config @@ -63,9 +63,9 @@ func (c *Config) NewFunc() *Func { return &Func{Config: c} } -func (c *Config) Log(msg string, args ...interface{}) { c.fe.Log(msg, args...) } -func (c *Config) Fatal(msg string, args ...interface{}) { c.fe.Fatal(msg, args...) } -func (c *Config) Unimplemented(msg string, args ...interface{}) { c.fe.Unimplemented(msg, args...) } +func (c *Config) Logf(msg string, args ...interface{}) { c.fe.Logf(msg, args...) } +func (c *Config) Fatalf(msg string, args ...interface{}) { c.fe.Fatalf(msg, args...) } +func (c *Config) Unimplementedf(msg string, args ...interface{}) { c.fe.Unimplementedf(msg, args...) } // TODO(khr): do we really need a separate Config, or can we just // store all its fields inside a Func? diff --git a/src/cmd/compile/internal/ssa/deadcode.go b/src/cmd/compile/internal/ssa/deadcode.go index f4884520de..48d6fd6938 100644 --- a/src/cmd/compile/internal/ssa/deadcode.go +++ b/src/cmd/compile/internal/ssa/deadcode.go @@ -80,7 +80,7 @@ func deadcode(f *Func) { i++ } else { if len(b.Values) > 0 { - b.Fatal("live values in unreachable block %v: %v", b, b.Values) + b.Fatalf("live values in unreachable block %v: %v", b, b.Values) } f.bid.put(b.ID) } @@ -103,7 +103,7 @@ func removePredecessor(b, c *Block) { if n == 0 { // c is now dead - don't bother working on it if c.Preds[0] != b { - b.Fatal("%s.Preds[0]==%s, want %s", c, c.Preds[0], b) + b.Fatalf("%s.Preds[0]==%s, want %s", c, c.Preds[0], b) } return } diff --git a/src/cmd/compile/internal/ssa/deadstore.go b/src/cmd/compile/internal/ssa/deadstore.go index e4d73e7226..9d138e3ac1 100644 --- a/src/cmd/compile/internal/ssa/deadstore.go +++ b/src/cmd/compile/internal/ssa/deadstore.go @@ -56,12 +56,12 @@ func dse(f *Func) { continue } if last != nil { - b.Fatal("two final stores - simultaneous live stores", last, v) + b.Fatalf("two final stores - simultaneous live stores", last, v) } last = v } if last == nil { - b.Fatal("no last store found - cycle?") + b.Fatalf("no last store found - cycle?") } // Walk backwards looking for dead stores. Keep track of shadowed addresses. diff --git a/src/cmd/compile/internal/ssa/dom.go b/src/cmd/compile/internal/ssa/dom.go index fac2798a60..343df76b22 100644 --- a/src/cmd/compile/internal/ssa/dom.go +++ b/src/cmd/compile/internal/ssa/dom.go @@ -45,7 +45,7 @@ func postorder(f *Func) []*Block { } } default: - b.Fatal("bad stack state %v %d", b, mark[b.ID]) + b.Fatalf("bad stack state %v %d", b, mark[b.ID]) } } return order @@ -71,7 +71,7 @@ func dominators(f *Func) []*Block { // Make the entry block a self-loop idom[f.Entry.ID] = f.Entry if postnum[f.Entry.ID] != len(post)-1 { - f.Fatal("entry block %v not last in postorder", f.Entry) + f.Fatalf("entry block %v not last in postorder", f.Entry) } // Compute relaxation of idom entries diff --git a/src/cmd/compile/internal/ssa/export_test.go b/src/cmd/compile/internal/ssa/export_test.go index 6b006e9238..f254e066ac 100644 --- a/src/cmd/compile/internal/ssa/export_test.go +++ b/src/cmd/compile/internal/ssa/export_test.go @@ -19,6 +19,6 @@ func (DummyFrontend) StringSym(s string) interface{} { return nil } -func (d DummyFrontend) Log(msg string, args ...interface{}) { d.t.Logf(msg, args...) } -func (d DummyFrontend) Fatal(msg string, args ...interface{}) { d.t.Fatalf(msg, args...) } -func (d DummyFrontend) Unimplemented(msg string, args ...interface{}) { d.t.Fatalf(msg, args...) } +func (d DummyFrontend) Logf(msg string, args ...interface{}) { d.t.Logf(msg, args...) } +func (d DummyFrontend) Fatalf(msg string, args ...interface{}) { d.t.Fatalf(msg, args...) } +func (d DummyFrontend) Unimplementedf(msg string, args ...interface{}) { d.t.Fatalf(msg, args...) } diff --git a/src/cmd/compile/internal/ssa/func.go b/src/cmd/compile/internal/ssa/func.go index 56bee1aa3f..046c068eb9 100644 --- a/src/cmd/compile/internal/ssa/func.go +++ b/src/cmd/compile/internal/ssa/func.go @@ -77,7 +77,7 @@ func (b *Block) NewValue0A(line int32, op Op, t Type, aux interface{}) *Value { // 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.Fatal("aux field has int64 type op=%s type=%s aux=%v", op, t, aux) + b.Fatalf("aux field has int64 type op=%s type=%s aux=%v", op, t, aux) } v := &Value{ ID: b.Func.vid.get(), @@ -208,6 +208,6 @@ func (f *Func) ConstInt(line int32, t Type, c int64) *Value { return f.Entry.NewValue0I(line, OpConst, t, c) } -func (f *Func) Log(msg string, args ...interface{}) { f.Config.Log(msg, args...) } -func (f *Func) Fatal(msg string, args ...interface{}) { f.Config.Fatal(msg, args...) } -func (f *Func) Unimplemented(msg string, args ...interface{}) { f.Config.Unimplemented(msg, args...) } +func (f *Func) Logf(msg string, args ...interface{}) { f.Config.Logf(msg, args...) } +func (f *Func) Fatalf(msg string, args ...interface{}) { f.Config.Fatalf(msg, args...) } +func (f *Func) Unimplementedf(msg string, args ...interface{}) { f.Config.Unimplementedf(msg, args...) } diff --git a/src/cmd/compile/internal/ssa/func_test.go b/src/cmd/compile/internal/ssa/func_test.go index b52d470e24..a620e8f602 100644 --- a/src/cmd/compile/internal/ssa/func_test.go +++ b/src/cmd/compile/internal/ssa/func_test.go @@ -161,7 +161,7 @@ func Fun(c *Config, entry string, blocs ...bloc) fun { if c.control != "" { cval, ok := values[c.control] if !ok { - f.Fatal("control value for block %s missing", bloc.name) + f.Fatalf("control value for block %s missing", bloc.name) } b.Control = cval } @@ -171,7 +171,7 @@ func Fun(c *Config, entry string, blocs ...bloc) fun { for _, arg := range valu.args { a, ok := values[arg] if !ok { - b.Fatal("arg %s missing for value %s in block %s", + b.Fatalf("arg %s missing for value %s in block %s", arg, valu.name, bloc.name) } v.AddArg(a) diff --git a/src/cmd/compile/internal/ssa/layout.go b/src/cmd/compile/internal/ssa/layout.go index 0a271b39ad..c2d72267b1 100644 --- a/src/cmd/compile/internal/ssa/layout.go +++ b/src/cmd/compile/internal/ssa/layout.go @@ -80,7 +80,7 @@ blockloop: continue blockloop } } - b.Fatal("no block available for layout") + b.Fatalf("no block available for layout") } f.Blocks = order } diff --git a/src/cmd/compile/internal/ssa/lower.go b/src/cmd/compile/internal/ssa/lower.go index 768ac124be..a72006ab2f 100644 --- a/src/cmd/compile/internal/ssa/lower.go +++ b/src/cmd/compile/internal/ssa/lower.go @@ -13,7 +13,7 @@ func lower(f *Func) { for _, b := range f.Blocks { for _, v := range b.Values { if opcodeTable[v.Op].generic && v.Op != OpFP && v.Op != OpSP && v.Op != OpArg && v.Op != OpCopy && v.Op != OpPhi { - f.Unimplemented("%s not lowered", v.LongString()) + f.Unimplementedf("%s not lowered", v.LongString()) } } } diff --git a/src/cmd/compile/internal/ssa/print.go b/src/cmd/compile/internal/ssa/print.go index c1b97d2b8f..23fdbca7c4 100644 --- a/src/cmd/compile/internal/ssa/print.go +++ b/src/cmd/compile/internal/ssa/print.go @@ -11,7 +11,7 @@ import ( ) func printFunc(f *Func) { - f.Log("%s", f.String()) + f.Logf("%s", f.String()) } func (f *Func) String() string { diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index d1489b20f2..fde1cf457b 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -349,7 +349,7 @@ func regalloc(f *Func) { if b.Kind == BlockCall { call = b.Control if call != b.Values[len(b.Values)-1] { - b.Fatal("call not at end of block %b %v", b, call) + b.Fatalf("call not at end of block %b %v", b, call) } b.Values = b.Values[:len(b.Values)-1] // TODO: do this for all control types? @@ -419,7 +419,7 @@ func live(f *Func) [][]ID { t := newSparseSet(f.NumValues()) for { for _, b := range f.Blocks { - f.Log("live %s %v\n", b, live[b.ID]) + f.Logf("live %s %v\n", b, live[b.ID]) } changed := false diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go index 2bfd3813ed..0de8830fb2 100644 --- a/src/cmd/compile/internal/ssa/rewrite.go +++ b/src/cmd/compile/internal/ssa/rewrite.go @@ -12,10 +12,10 @@ func applyRewrite(f *Func, rb func(*Block) bool, rv func(*Value, *Config) bool) var curv *Value defer func() { if curb != nil { - curb.Fatal("panic during rewrite of block %s\n", curb.LongString()) + curb.Fatalf("panic during rewrite of block %s\n", curb.LongString()) } if curv != nil { - curv.Fatal("panic during rewrite of value %s\n", curv.LongString()) + curv.Fatalf("panic during rewrite of value %s\n", curv.LongString()) // TODO(khr): print source location also } }() diff --git a/src/cmd/compile/internal/ssa/stackalloc.go b/src/cmd/compile/internal/ssa/stackalloc.go index 452d0c75a1..e39a3e7a59 100644 --- a/src/cmd/compile/internal/ssa/stackalloc.go +++ b/src/cmd/compile/internal/ssa/stackalloc.go @@ -77,7 +77,7 @@ func stackalloc(f *Func) { for _, v := range b.Values { if v.Op == OpFP { if fp != nil { - b.Fatal("multiple FP ops: %s %s", fp, v) + b.Fatalf("multiple FP ops: %s %s", fp, v) } fp = v } @@ -97,12 +97,12 @@ func stackalloc(f *Func) { case OpAMD64LEAQ, OpAMD64MOVQload, OpAMD64MOVQstore, OpAMD64MOVLload, OpAMD64MOVLstore, OpAMD64MOVWload, OpAMD64MOVWstore, OpAMD64MOVBload, OpAMD64MOVBstore, OpAMD64MOVQloadidx8: if v.Op == OpAMD64MOVQloadidx8 && i == 1 { // Note: we could do it, but it is probably an error - f.Fatal("can't do FP->SP adjust on index slot of load %s", v.Op) + f.Fatalf("can't do FP->SP adjust on index slot of load %s", v.Op) } // eg: (MOVQload [c] (FP) mem) -> (MOVQload [c+n] (SP) mem) v.AuxInt = addOff(v.AuxInt, n) default: - f.Unimplemented("can't do FP->SP adjust on %s", v.Op) + f.Unimplementedf("can't do FP->SP adjust on %s", v.Op) // TODO: OpCopy -> ADDQ } } diff --git a/src/cmd/compile/internal/ssa/value.go b/src/cmd/compile/internal/ssa/value.go index ef10fb20cd..9c7f148a79 100644 --- a/src/cmd/compile/internal/ssa/value.go +++ b/src/cmd/compile/internal/ssa/value.go @@ -111,6 +111,6 @@ func (v *Value) resetArgs() { v.Args = v.argstorage[:0] } -func (v *Value) Log(msg string, args ...interface{}) { v.Block.Log(msg, args...) } -func (v *Value) Fatal(msg string, args ...interface{}) { v.Block.Fatal(msg, args...) } -func (v *Value) Unimplemented(msg string, args ...interface{}) { v.Block.Unimplemented(msg, args...) } +func (v *Value) Logf(msg string, args ...interface{}) { v.Block.Logf(msg, args...) } +func (v *Value) Fatalf(msg string, args ...interface{}) { v.Block.Fatalf(msg, args...) } +func (v *Value) Unimplementedf(msg string, args ...interface{}) { v.Block.Unimplementedf(msg, args...) } -- cgit v1.3 From 8c46aa54817063a39dc25bad343d6322e65f8598 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Fri, 19 Jun 2015 21:02:28 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: Handle variables correctly Use *Node of type ONAME instead of string as the key for variable maps. This will prevent aliasing between two identically named but differently scoped variables. Introduce an Aux value that encodes the offset of a variable from a base pointer (either global base pointer or stack pointer). Allow LEAQ and derivatives (MOVQ, etc.) to also have such an Aux field. Allocate space for AUTO variables in stackalloc. Change-Id: Ibdccdaea4bbc63a1f4882959ac374f2b467e3acd Reviewed-on: https://go-review.googlesource.com/11238 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/gc/ssa.go | 171 ++++++++++++++++++------- src/cmd/compile/internal/ssa/TODO | 8 ++ src/cmd/compile/internal/ssa/check.go | 6 + src/cmd/compile/internal/ssa/deadstore.go | 2 +- src/cmd/compile/internal/ssa/deadstore_test.go | 10 +- src/cmd/compile/internal/ssa/gen/AMD64.rules | 10 +- src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 27 ++-- src/cmd/compile/internal/ssa/gen/generic.rules | 2 +- src/cmd/compile/internal/ssa/gen/genericOps.go | 16 ++- src/cmd/compile/internal/ssa/lower.go | 2 +- src/cmd/compile/internal/ssa/opGen.go | 156 +++++++++++----------- src/cmd/compile/internal/ssa/regalloc.go | 22 ++-- src/cmd/compile/internal/ssa/rewrite.go | 11 ++ src/cmd/compile/internal/ssa/rewriteAMD64.go | 94 +++++++++++--- src/cmd/compile/internal/ssa/rewritegeneric.go | 21 +-- src/cmd/compile/internal/ssa/shift_test.go | 6 +- src/cmd/compile/internal/ssa/stackalloc.go | 58 +++------ src/cmd/compile/internal/ssa/value.go | 37 ++++++ 18 files changed, 425 insertions(+), 234 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 0dd2e44ec5..4e0f4b0cc6 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -9,7 +9,7 @@ import ( "cmd/compile/internal/ssa" "cmd/internal/obj" - "cmd/internal/obj/x86" // TODO: remove + "cmd/internal/obj/x86" ) // buildssa builds an SSA function @@ -60,13 +60,28 @@ func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { s.exit = s.f.NewBlock(ssa.BlockExit) // Allocate starting values + s.vars = map[*Node]*ssa.Value{} + s.labels = map[string]*ssa.Block{} s.startmem = s.entryNewValue0(ssa.OpArg, ssa.TypeMem) - s.fp = s.entryNewValue0(ssa.OpFP, s.config.Uintptr) // TODO: use generic pointer type (unsafe.Pointer?) instead - s.sp = s.entryNewValue0(ssa.OpSP, s.config.Uintptr) + s.sp = s.entryNewValue0(ssa.OpSP, s.config.Uintptr) // TODO: use generic pointer type (unsafe.Pointer?) instead + s.sb = s.entryNewValue0(ssa.OpSB, s.config.Uintptr) - s.vars = map[string]*ssa.Value{} - s.labels = map[string]*ssa.Block{} - s.argOffsets = map[string]int64{} + // Generate addresses of local declarations + s.decladdrs = map[*Node]*ssa.Value{} + for d := fn.Func.Dcl; d != nil; d = d.Next { + n := d.N + switch n.Class { + case PPARAM, PPARAMOUT: + aux := &ssa.ArgSymbol{Typ: n.Type, Offset: n.Xoffset, Sym: n.Sym} + s.decladdrs[n] = s.entryNewValue1A(ssa.OpAddr, Ptrto(n.Type), aux, s.sp) + case PAUTO: + aux := &ssa.AutoSymbol{Typ: n.Type, Offset: -1, Sym: n.Sym} // offset TBD by SSA pass + s.decladdrs[n] = s.entryNewValue1A(ssa.OpAddr, Ptrto(n.Type), aux, s.sp) + } + } + // nodfp is a special argument which is the function's FP. + aux := &ssa.ArgSymbol{Typ: s.config.Uintptr, Offset: 0, Sym: nodfp.Sym} + s.decladdrs[nodfp] = s.entryNewValue1A(ssa.OpAddr, s.config.Uintptr, aux, s.sp) // Convert the AST-based IR to the SSA-based IR s.startBlock(s.f.Entry) @@ -116,20 +131,20 @@ type state struct { // current location where we're interpreting the AST curBlock *ssa.Block - // variable assignments in the current block (map from variable name to ssa value) - vars map[string]*ssa.Value + // 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[string]*ssa.Value + defvars []map[*Node]*ssa.Value - // offsets of argument slots - // unnamed and unused args are not listed. - argOffsets map[string]int64 + // addresses of PPARAM, PPARAMOUT, and PAUTO variables. + decladdrs map[*Node]*ssa.Value // starting values. Memory, frame pointer, and stack pointer startmem *ssa.Value - fp *ssa.Value sp *ssa.Value + sb *ssa.Value // line number stack. The current line number is top of stack line []int32 @@ -138,13 +153,16 @@ type state struct { func (s *state) Fatalf(msg string, args ...interface{}) { s.config.Fatalf(msg, args...) } func (s *state) Unimplementedf(msg string, args ...interface{}) { s.config.Unimplementedf(msg, args...) } +// dummy node for the memory variable +var memvar = Node{Op: ONAME, Sym: &Sym{Name: "mem"}} + // 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[string]*ssa.Value{} + s.vars = map[*Node]*ssa.Value{} } // endBlock marks the end of generating code for the current block. @@ -230,6 +248,11 @@ func (s *state) entryNewValue1I(op ssa.Op, t ssa.Type, auxint int64, arg *ssa.Va 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) @@ -394,11 +417,12 @@ func (s *state) expr(n *Node) *ssa.Value { case ONAME: if n.Class == PFUNC { // "value" of a function is the address of the function's closure - return s.entryNewValue0A(ssa.OpGlobal, Ptrto(n.Type), funcsym(n.Sym)) + sym := funcsym(n.Sym) + aux := &ssa.ExternSymbol{n.Type, sym} + return s.entryNewValue1A(ssa.OpAddr, Ptrto(n.Type), aux, s.sb) } - s.argOffsets[n.Sym.Name] = n.Xoffset // TODO: remember this another way? if canSSA(n) { - return s.variable(n.Sym.Name, n.Type) + return s.variable(n, n.Type) } addr := s.addr(n) return s.newValue2(ssa.OpLoad, n.Type, addr, s.mem()) @@ -540,12 +564,12 @@ func (s *state) assign(op uint8, left *Node, right *Node) { } if left.Op == ONAME && canSSA(left) { // Update variable assignment. - s.vars[left.Sym.Name] = val + s.vars[left] = val return } // not ssa-able. Treat as a store. addr := s.addr(left) - s.vars[".mem"] = s.newValue3(ssa.OpStore, ssa.TypeMem, addr, val, s.mem()) + s.vars[&memvar] = s.newValue3(ssa.OpStore, ssa.TypeMem, addr, val, s.mem()) } // addr converts the address of the expression n to SSA, adds it to s and returns the SSA result. @@ -555,14 +579,14 @@ func (s *state) addr(n *Node) *ssa.Value { switch n.Class { case PEXTERN: // global variable - return s.entryNewValue0A(ssa.OpGlobal, Ptrto(n.Type), n.Sym) - case PPARAMOUT: - // store to parameter slot - return s.entryNewValue1I(ssa.OpOffPtr, Ptrto(n.Type), n.Xoffset, s.fp) + aux := &ssa.ExternSymbol{n.Type, n.Sym} + return s.entryNewValue1A(ssa.OpAddr, Ptrto(n.Type), aux, s.sb) + case PPARAM, PPARAMOUT, PAUTO: + // parameter/result slot or local variable + return s.decladdrs[n] case PAUTO | PHEAP: return s.expr(n.Name.Heapaddr) default: - // TODO: address of locals s.Unimplementedf("variable address of %v not implemented", n) return nil } @@ -647,7 +671,7 @@ func (s *state) boundsCheck(idx, len *ssa.Value) { } // variable returns the value of a variable at the current location. -func (s *state) variable(name string, t ssa.Type) *ssa.Value { +func (s *state) variable(name *Node, t ssa.Type) *ssa.Value { if s.curBlock == nil { // Unimplemented instead of Fatal because fixedbugs/bug303.go // demonstrates a case in which this appears to happen legitimately. @@ -664,7 +688,7 @@ func (s *state) variable(name string, t ssa.Type) *ssa.Value { } func (s *state) mem() *ssa.Value { - return s.variable(".mem", ssa.TypeMem) + return s.variable(&memvar, ssa.TypeMem) } func (s *state) linkForwardReferences() { @@ -679,7 +703,7 @@ func (s *state) linkForwardReferences() { if v.Op != ssa.OpFwdRef { continue } - name := v.Aux.(string) + name := v.Aux.(*Node) v.Op = ssa.OpCopy v.Aux = nil v.SetArgs1(s.lookupVarIncoming(b, v.Type, name)) @@ -688,17 +712,23 @@ func (s *state) linkForwardReferences() { } // lookupVarIncoming finds the variable's value at the start of block b. -func (s *state) lookupVarIncoming(b *ssa.Block, t ssa.Type, name string) *ssa.Value { +func (s *state) lookupVarIncoming(b *ssa.Block, t ssa.Type, name *Node) *ssa.Value { // TODO(khr): have lookupVarIncoming overwrite the fwdRef or copy it // will be used in, instead of having the result used in a copy value. if b == s.f.Entry { - if name == ".mem" { + if name == &memvar { return s.startmem } // variable is live at the entry block. Load it. - addr := s.entryNewValue1I(ssa.OpOffPtr, Ptrto(t.(*Type)), s.argOffsets[name], s.fp) + addr := s.decladdrs[name] + if addr == nil { + // TODO: closure args reach here. + s.Unimplementedf("variable %s not found", 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) + } return s.entryNewValue2(ssa.OpLoad, t, addr, s.startmem) - } var vals []*ssa.Value for _, p := range b.Preds { @@ -721,7 +751,7 @@ func (s *state) lookupVarIncoming(b *ssa.Block, t ssa.Type, name string) *ssa.Va } // lookupVarOutgoing finds the variable's value at the end of block b. -func (s *state) lookupVarOutgoing(b *ssa.Block, t ssa.Type, name string) *ssa.Value { +func (s *state) lookupVarOutgoing(b *ssa.Block, t ssa.Type, name *Node) *ssa.Value { m := s.defvars[b.ID] if v, ok := m[name]; ok { return v @@ -962,13 +992,20 @@ func genValue(v *ssa.Value) { p.From.Type = obj.TYPE_REG p.To.Type = obj.TYPE_REG p.To.Reg = r - case ssa.OpAMD64LEAQ: + case ssa.OpAMD64LEAQ1: p := Prog(x86.ALEAQ) p.From.Type = obj.TYPE_MEM p.From.Reg = regnum(v.Args[0]) p.From.Scale = 1 p.From.Index = regnum(v.Args[1]) - p.From.Offset = v.AuxInt + 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.OpAMD64TESTB, ssa.OpAMD64TESTQ: @@ -994,14 +1031,14 @@ func genValue(v *ssa.Value) { p := Prog(v.Op.Asm()) p.From.Type = obj.TYPE_MEM p.From.Reg = regnum(v.Args[0]) - p.From.Offset = v.AuxInt + addAux(&p.From, v) p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v) case ssa.OpAMD64MOVQloadidx8: p := Prog(x86.AMOVQ) p.From.Type = obj.TYPE_MEM p.From.Reg = regnum(v.Args[0]) - p.From.Offset = v.AuxInt + addAux(&p.From, v) p.From.Scale = 8 p.From.Index = regnum(v.Args[1]) p.To.Type = obj.TYPE_REG @@ -1012,7 +1049,7 @@ func genValue(v *ssa.Value) { p.From.Reg = regnum(v.Args[1]) p.To.Type = obj.TYPE_MEM p.To.Reg = regnum(v.Args[0]) - p.To.Offset = v.AuxInt + addAux(&p.To, v) case ssa.OpAMD64MOVLQSX, ssa.OpAMD64MOVWQSX, ssa.OpAMD64MOVBQSX: p := Prog(v.Op.Asm()) p.From.Type = obj.TYPE_REG @@ -1062,14 +1099,6 @@ func genValue(v *ssa.Value) { case ssa.OpArg: // memory arg needs no code // TODO: check that only mem arg goes here. - case ssa.OpAMD64LEAQglobal: - p := Prog(x86.ALEAQ) - p.From.Type = obj.TYPE_MEM - p.From.Name = obj.NAME_EXTERN - p.From.Sym = Linksym(v.Aux.(*Sym)) - p.From.Offset = v.AuxInt - p.To.Type = obj.TYPE_REG - p.To.Reg = regnum(v) case ssa.OpAMD64CALLstatic: p := Prog(obj.ACALL) p.To.Type = obj.TYPE_MEM @@ -1079,7 +1108,7 @@ func genValue(v *ssa.Value) { p := Prog(obj.ACALL) p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v.Args[0]) - case ssa.OpFP, ssa.OpSP: + case ssa.OpSP, ssa.OpSB: // nothing to do default: v.Unimplementedf("value %s not implemented", v.LongString()) @@ -1195,6 +1224,35 @@ func genBlock(b, next *ssa.Block, branches []branch) []branch { return branches } +// addAux adds the offset in the aux fields (AuxInt and Aux) of v to a. +func addAux(a *obj.Addr, v *ssa.Value) { + if a.Type != obj.TYPE_MEM { + v.Fatalf("bad addAux addr %s", a) + } + // add integer offset + a.Offset += v.AuxInt + + // 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: + a.Offset += v.Block.Func.FrameSize + sym.Offset + case *ssa.AutoSymbol: + if sym.Offset == -1 { + v.Fatalf("auto symbol %s offset not calculated", sym.Sym) + } + a.Offset += sym.Offset + default: + v.Fatalf("aux in %s not implemented %#v", v, v.Aux) + } +} + // ssaRegToReg maps ssa register numbers to obj register numbers. var ssaRegToReg = [...]int16{ x86.REG_AX, @@ -1213,7 +1271,23 @@ var ssaRegToReg = [...]int16{ x86.REG_R13, x86.REG_R14, x86.REG_R15, - // TODO: more + 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 } @@ -1240,7 +1314,8 @@ type ssaExport struct { // StringSym returns a symbol (a *Sym wrapped in an interface) which // is a global string constant containing s. func (*ssaExport) StringSym(s string) interface{} { - return stringsym(s) + // TODO: is idealstring correct? It might not matter... + return &ssa.ExternSymbol{Typ: idealstring, Sym: stringsym(s)} } // Log logs a message from the compiler. diff --git a/src/cmd/compile/internal/ssa/TODO b/src/cmd/compile/internal/ssa/TODO index 66841c36f0..30d49044e1 100644 --- a/src/cmd/compile/internal/ssa/TODO +++ b/src/cmd/compile/internal/ssa/TODO @@ -28,6 +28,14 @@ Regalloc - Floating point registers - Make calls clobber all registers +StackAlloc: + - Compute size of outargs section correctly + - Sort variables so all ptr-containing ones are first (so stack + maps are smaller) + - Reuse stack slots for noninterfering and type-compatible variables + (both AUTOs and spilled Values). But see issue 8740 for what + "type-compatible variables" mean and what DWARF information provides. + Rewrites - Strength reduction (both arch-indep and arch-dependent?) - Start another architecture (arm?) diff --git a/src/cmd/compile/internal/ssa/check.go b/src/cmd/compile/internal/ssa/check.go index 672aeda96a..1ca6e36ae7 100644 --- a/src/cmd/compile/internal/ssa/check.go +++ b/src/cmd/compile/internal/ssa/check.go @@ -104,6 +104,12 @@ func checkFunc(f *Func) { 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 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 } diff --git a/src/cmd/compile/internal/ssa/deadstore.go b/src/cmd/compile/internal/ssa/deadstore.go index 9d138e3ac1..db3808639a 100644 --- a/src/cmd/compile/internal/ssa/deadstore.go +++ b/src/cmd/compile/internal/ssa/deadstore.go @@ -56,7 +56,7 @@ func dse(f *Func) { continue } if last != nil { - b.Fatalf("two final stores - simultaneous live stores", last, v) + b.Fatalf("two final stores - simultaneous live stores %s %s", last, v) } last = v } diff --git a/src/cmd/compile/internal/ssa/deadstore_test.go b/src/cmd/compile/internal/ssa/deadstore_test.go index 48ea066aa3..042e7f66ff 100644 --- a/src/cmd/compile/internal/ssa/deadstore_test.go +++ b/src/cmd/compile/internal/ssa/deadstore_test.go @@ -15,8 +15,8 @@ func TestDeadStore(t *testing.T) { Bloc("entry", Valu("start", OpArg, TypeMem, 0, ".mem"), Valu("v", OpConst, TypeBool, 0, true), - Valu("addr1", OpGlobal, ptrType, 0, nil), - Valu("addr2", OpGlobal, ptrType, 0, nil), + Valu("addr1", OpAddr, ptrType, 0, nil), + Valu("addr2", OpAddr, ptrType, 0, nil), Valu("store1", OpStore, TypeMem, 0, nil, "addr1", "v", "start"), Valu("store2", OpStore, TypeMem, 0, nil, "addr2", "v", "store1"), Valu("store3", OpStore, TypeMem, 0, nil, "addr1", "v", "store2"), @@ -41,7 +41,7 @@ func TestDeadStorePhi(t *testing.T) { Bloc("entry", Valu("start", OpArg, TypeMem, 0, ".mem"), Valu("v", OpConst, TypeBool, 0, true), - Valu("addr", OpGlobal, ptrType, 0, nil), + Valu("addr", OpAddr, ptrType, 0, nil), Goto("loop")), Bloc("loop", Valu("phi", OpPhi, TypeMem, 0, nil, "start", "store"), @@ -67,8 +67,8 @@ func TestDeadStoreTypes(t *testing.T) { Bloc("entry", Valu("start", OpArg, TypeMem, 0, ".mem"), Valu("v", OpConst, TypeBool, 0, true), - Valu("addr1", OpGlobal, t1, 0, nil), - Valu("addr2", OpGlobal, t2, 0, nil), + Valu("addr1", OpAddr, t1, 0, nil), + Valu("addr2", OpAddr, t2, 0, nil), Valu("store1", OpStore, TypeMem, 0, nil, "addr1", "v", "start"), Valu("store2", OpStore, TypeMem, 0, nil, "addr2", "v", "store1"), Goto("exit")), diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index aa4e807712..124b13b6f2 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -68,6 +68,8 @@ (Const [val]) && t.IsInteger() -> (MOVQconst [val]) +(Addr {sym} base) -> (LEAQ {sym} base) + // block rewrites (If (SETL cmp) yes no) -> (LT cmp yes no) (If (SETNE cmp) yes no) -> (NE cmp yes no) @@ -80,9 +82,6 @@ // Rules below here apply some simple optimizations after lowering. // TODO: Should this be a separate pass? -// global loads/stores -(Global {sym}) -> (LEAQglobal {sym}) - // fold constants into instructions (ADDQ x (MOVQconst [c])) -> (ADDQconst [c] x) // TODO: restrict c to int32 range? (ADDQ (MOVQconst [c]) x) -> (ADDQconst [c] x) @@ -119,6 +118,11 @@ (MOVQload [off1] (ADDQconst [off2] ptr) mem) -> (MOVQload [addOff(off1, off2)] ptr mem) (MOVQstore [off1] (ADDQconst [off2] ptr) val mem) -> (MOVQstore [addOff(off1, off2)] ptr val mem) +(MOVQload [off1] {sym1} (LEAQ [off2] {sym2} base) mem) && (sym1 == nil || sym2 == nil) -> + (MOVQload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem) +(MOVQstore [off1] {sym1} (LEAQ [off2] {sym2} base) val mem) && (sym1 == nil || sym2 == nil) -> + (MOVQstore [addOff(off1,off2)] {mergeSym(sym1,sym2)} base val mem) + // indexed loads and stores (MOVQload [off1] (LEAQ8 [off2] ptr idx) mem) -> (MOVQloadidx8 [addOff(off1, off2)] ptr idx mem) (MOVQstore [off1] (LEAQ8 [off2] ptr idx) val mem) -> (MOVQstoreidx8 [addOff(off1, off2)] ptr idx val mem) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 3733ba9721..c0f36b51b3 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -42,7 +42,7 @@ var regNamesAMD64 = []string{ ".X15", // pseudo-registers - ".FP", + ".SB", ".FLAGS", } @@ -71,19 +71,22 @@ func init() { } gp := buildReg("AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15") - gpsp := gp | buildReg("SP FP") + gpsp := gp | buildReg("SP") + gpspsb := gpsp | buildReg("SB") flags := buildReg("FLAGS") gp01 := regInfo{[]regMask{}, 0, []regMask{gp}} gp11 := regInfo{[]regMask{gpsp}, 0, []regMask{gp}} + gp11sb := regInfo{[]regMask{gpspsb}, 0, []regMask{gp}} gp21 := regInfo{[]regMask{gpsp, gpsp}, 0, []regMask{gp}} + gp21sb := regInfo{[]regMask{gpspsb, gpsp}, 0, []regMask{gp}} gp21shift := regInfo{[]regMask{gpsp, buildReg("CX")}, 0, []regMask{gp}} gp2flags := regInfo{[]regMask{gpsp, gpsp}, 0, []regMask{flags}} gp1flags := regInfo{[]regMask{gpsp}, 0, []regMask{flags}} flagsgp1 := regInfo{[]regMask{flags}, 0, []regMask{gp}} - gpload := regInfo{[]regMask{gpsp, 0}, 0, []regMask{gp}} - gploadidx := regInfo{[]regMask{gpsp, gpsp, 0}, 0, []regMask{gp}} - gpstore := regInfo{[]regMask{gpsp, gpsp, 0}, 0, nil} - gpstoreidx := regInfo{[]regMask{gpsp, gpsp, gpsp, 0}, 0, nil} + gpload := regInfo{[]regMask{gpspsb, 0}, 0, []regMask{gp}} + gploadidx := regInfo{[]regMask{gpspsb, gpsp, 0}, 0, []regMask{gp}} + gpstore := regInfo{[]regMask{gpspsb, gpsp, 0}, 0, nil} + gpstoreidx := regInfo{[]regMask{gpspsb, gpsp, gpsp, 0}, 0, nil} flagsgp := regInfo{[]regMask{flags}, 0, []regMask{gp}} cmov := regInfo{[]regMask{flags, gp, gp}, 0, []regMask{gp}} @@ -129,12 +132,12 @@ func init() { {name: "MOVWQSX", reg: gp11, asm: "MOVWQSX"}, // extend arg0 from int16 to int64 {name: "MOVBQSX", reg: gp11, asm: "MOVBQSX"}, // extend arg0 from int8 to int64 - {name: "MOVQconst", reg: gp01}, // auxint - {name: "LEAQ", reg: gp21}, // arg0 + arg1 + auxint - {name: "LEAQ2", reg: gp21}, // arg0 + 2*arg1 + auxint - {name: "LEAQ4", reg: gp21}, // arg0 + 4*arg1 + auxint - {name: "LEAQ8", reg: gp21}, // arg0 + 8*arg1 + auxint - {name: "LEAQglobal", reg: gp01}, // no args. address of aux.(*gc.Sym) + {name: "MOVQconst", reg: gp01}, // auxint + {name: "LEAQ", reg: gp11sb}, // arg0 + auxint + offset encoded in aux + {name: "LEAQ1", reg: gp21sb}, // arg0 + arg1 + auxint + {name: "LEAQ2", reg: gp21sb}, // arg0 + 2*arg1 + auxint + {name: "LEAQ4", reg: gp21sb}, // arg0 + 4*arg1 + auxint + {name: "LEAQ8", reg: gp21sb}, // arg0 + 8*arg1 + auxint {name: "MOVBload", reg: gpload, asm: "MOVB"}, // load byte from arg0+auxint. arg1=mem {name: "MOVBQZXload", reg: gpload}, // ditto, extend to uint64 diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index 9d08a35f1f..9f11a60a6b 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -40,7 +40,7 @@ (Store dst (Load src mem) mem) && t.Size() > 8 -> (Move [t.Size()] dst src mem) // string ops -(Const {s}) && t.IsString() -> (StringMake (OffPtr [2*config.ptrSize] (Global {config.fe.StringSym(s.(string))})) (Const [int64(len(s.(string)))])) // TODO: ptr +(Const {s}) && t.IsString() -> (StringMake (OffPtr [2*config.ptrSize] (Addr {config.fe.StringSym(s.(string))} (SB ))) (Const [int64(len(s.(string)))])) // TODO: ptr (Load ptr mem) && t.IsString() -> (StringMake (Load ptr mem) (Load (OffPtr [config.ptrSize] ptr) mem)) (StringPtr (StringMake ptr _)) -> ptr (StringLen (StringMake _ len)) -> len diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index c168f2af05..e7c4de8eb1 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -30,11 +30,17 @@ var genericOps = []opData{ {name: "Const"}, // Constant-like things - {name: "Arg"}, // address of a function parameter/result. Memory input is an arg called ".mem". aux is a string (TODO: make it something other than a string?) - {name: "Global"}, // the address of a global variable aux.(*gc.Sym) - {name: "SP"}, // stack pointer - {name: "FP"}, // frame pointer - {name: "Func"}, // entry address of a function + {name: "Arg"}, // memory input to the function. + + // 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"}, // Address of a variable. Arg0=SP or SB. Aux identifies the variable. + + {name: "SP"}, // stack pointer + {name: "SB"}, // static base pointer (a.k.a. globals pointer) + {name: "Func"}, // entry address of a function // Memory operations {name: "Load"}, // Load from arg0. arg1=memory diff --git a/src/cmd/compile/internal/ssa/lower.go b/src/cmd/compile/internal/ssa/lower.go index a72006ab2f..6499dc8565 100644 --- a/src/cmd/compile/internal/ssa/lower.go +++ b/src/cmd/compile/internal/ssa/lower.go @@ -12,7 +12,7 @@ func lower(f *Func) { // Check for unlowered opcodes, fail if we find one. for _, b := range f.Blocks { for _, v := range b.Values { - if opcodeTable[v.Op].generic && v.Op != OpFP && v.Op != OpSP && v.Op != OpArg && v.Op != OpCopy && v.Op != OpPhi { + if opcodeTable[v.Op].generic && v.Op != OpSP && v.Op != OpSB && v.Op != OpArg && v.Op != OpCopy && v.Op != OpPhi { f.Unimplementedf("%s not lowered", v.LongString()) } } diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 1116be101c..20adc62958 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -81,10 +81,10 @@ const ( OpAMD64MOVBQSX OpAMD64MOVQconst OpAMD64LEAQ + OpAMD64LEAQ1 OpAMD64LEAQ2 OpAMD64LEAQ4 OpAMD64LEAQ8 - OpAMD64LEAQglobal OpAMD64MOVBload OpAMD64MOVBQZXload OpAMD64MOVBQSXload @@ -117,9 +117,9 @@ const ( OpCopy OpConst OpArg - OpGlobal + OpAddr OpSP - OpFP + OpSB OpFunc OpLoad OpStore @@ -152,8 +152,8 @@ var opcodeTable = [...]opInfo{ name: "ADDQ", reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, clobbers: 0, outputs: []regMask{ @@ -165,7 +165,7 @@ var opcodeTable = [...]opInfo{ name: "ADDQconst", reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, clobbers: 0, outputs: []regMask{ @@ -178,8 +178,8 @@ var opcodeTable = [...]opInfo{ asm: x86.ASUBQ, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, clobbers: 0, outputs: []regMask{ @@ -192,7 +192,7 @@ var opcodeTable = [...]opInfo{ asm: x86.ASUBQ, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, clobbers: 0, outputs: []regMask{ @@ -205,8 +205,8 @@ var opcodeTable = [...]opInfo{ asm: x86.AIMULQ, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, clobbers: 0, outputs: []regMask{ @@ -219,7 +219,7 @@ var opcodeTable = [...]opInfo{ asm: x86.AIMULQ, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, clobbers: 0, outputs: []regMask{ @@ -232,8 +232,8 @@ var opcodeTable = [...]opInfo{ asm: x86.AANDQ, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, clobbers: 0, outputs: []regMask{ @@ -246,7 +246,7 @@ var opcodeTable = [...]opInfo{ asm: x86.AANDQ, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, clobbers: 0, outputs: []regMask{ @@ -259,8 +259,8 @@ var opcodeTable = [...]opInfo{ asm: x86.ASHLQ, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP - 2, // .CX + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 2, // .CX }, clobbers: 0, outputs: []regMask{ @@ -273,7 +273,7 @@ var opcodeTable = [...]opInfo{ asm: x86.ASHLQ, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, clobbers: 0, outputs: []regMask{ @@ -286,8 +286,8 @@ var opcodeTable = [...]opInfo{ asm: x86.ASHRQ, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP - 2, // .CX + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 2, // .CX }, clobbers: 0, outputs: []regMask{ @@ -300,7 +300,7 @@ var opcodeTable = [...]opInfo{ asm: x86.ASHRQ, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, clobbers: 0, outputs: []regMask{ @@ -313,8 +313,8 @@ var opcodeTable = [...]opInfo{ asm: x86.ASARQ, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP - 2, // .CX + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 2, // .CX }, clobbers: 0, outputs: []regMask{ @@ -327,7 +327,7 @@ var opcodeTable = [...]opInfo{ asm: x86.ASARQ, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, clobbers: 0, outputs: []regMask{ @@ -339,7 +339,7 @@ var opcodeTable = [...]opInfo{ name: "NEGQ", reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, clobbers: 0, outputs: []regMask{ @@ -352,8 +352,8 @@ var opcodeTable = [...]opInfo{ asm: x86.ACMPQ, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, clobbers: 0, outputs: []regMask{ @@ -366,7 +366,7 @@ var opcodeTable = [...]opInfo{ asm: x86.ACMPQ, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, clobbers: 0, outputs: []regMask{ @@ -379,8 +379,8 @@ var opcodeTable = [...]opInfo{ asm: x86.ATESTQ, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, clobbers: 0, outputs: []regMask{ @@ -393,8 +393,8 @@ var opcodeTable = [...]opInfo{ asm: x86.ATESTB, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, clobbers: 0, outputs: []regMask{ @@ -506,7 +506,7 @@ var opcodeTable = [...]opInfo{ asm: x86.AMOVLQSX, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, clobbers: 0, outputs: []regMask{ @@ -519,7 +519,7 @@ var opcodeTable = [...]opInfo{ asm: x86.AMOVWQSX, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, clobbers: 0, outputs: []regMask{ @@ -532,7 +532,7 @@ var opcodeTable = [...]opInfo{ asm: x86.AMOVBQSX, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, clobbers: 0, outputs: []regMask{ @@ -554,8 +554,7 @@ var opcodeTable = [...]opInfo{ name: "LEAQ", reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB }, clobbers: 0, outputs: []regMask{ @@ -564,11 +563,11 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "LEAQ2", + name: "LEAQ1", reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, clobbers: 0, outputs: []regMask{ @@ -577,11 +576,11 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "LEAQ4", + name: "LEAQ2", reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, clobbers: 0, outputs: []regMask{ @@ -590,11 +589,11 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "LEAQ8", + name: "LEAQ4", reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, clobbers: 0, outputs: []regMask{ @@ -603,9 +602,12 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "LEAQglobal", + name: "LEAQ8", reg: regInfo{ - inputs: []regMask{}, + inputs: []regMask{ + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -617,7 +619,7 @@ var opcodeTable = [...]opInfo{ asm: x86.AMOVB, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB 0, }, clobbers: 0, @@ -630,7 +632,7 @@ var opcodeTable = [...]opInfo{ name: "MOVBQZXload", reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB 0, }, clobbers: 0, @@ -643,7 +645,7 @@ var opcodeTable = [...]opInfo{ name: "MOVBQSXload", reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB 0, }, clobbers: 0, @@ -657,7 +659,7 @@ var opcodeTable = [...]opInfo{ asm: x86.AMOVW, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB 0, }, clobbers: 0, @@ -671,7 +673,7 @@ var opcodeTable = [...]opInfo{ asm: x86.AMOVL, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB 0, }, clobbers: 0, @@ -685,7 +687,7 @@ var opcodeTable = [...]opInfo{ asm: x86.AMOVQ, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB 0, }, clobbers: 0, @@ -699,8 +701,8 @@ var opcodeTable = [...]opInfo{ asm: x86.AMOVQ, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 0, }, clobbers: 0, @@ -714,8 +716,8 @@ var opcodeTable = [...]opInfo{ asm: x86.AMOVB, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 0, }, clobbers: 0, @@ -727,8 +729,8 @@ var opcodeTable = [...]opInfo{ asm: x86.AMOVW, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 0, }, clobbers: 0, @@ -740,8 +742,8 @@ var opcodeTable = [...]opInfo{ asm: x86.AMOVL, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 0, }, clobbers: 0, @@ -753,8 +755,8 @@ var opcodeTable = [...]opInfo{ asm: x86.AMOVQ, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 0, }, clobbers: 0, @@ -765,9 +767,9 @@ var opcodeTable = [...]opInfo{ name: "MOVQstoreidx8", reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 0, }, clobbers: 0, @@ -802,8 +804,8 @@ var opcodeTable = [...]opInfo{ name: "CALLclosure", reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP - 4, // .DX + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 4, // .DX 0, }, clobbers: 0, @@ -827,8 +829,8 @@ var opcodeTable = [...]opInfo{ asm: x86.AADDL, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, clobbers: 0, outputs: []regMask{ @@ -841,8 +843,8 @@ var opcodeTable = [...]opInfo{ asm: x86.AADDW, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, clobbers: 0, outputs: []regMask{ @@ -855,8 +857,8 @@ var opcodeTable = [...]opInfo{ asm: x86.AADDB, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .FP + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, clobbers: 0, outputs: []regMask{ @@ -964,7 +966,7 @@ var opcodeTable = [...]opInfo{ generic: true, }, { - name: "Global", + name: "Addr", reg: regInfo{ inputs: []regMask{}, clobbers: 0, @@ -982,7 +984,7 @@ var opcodeTable = [...]opInfo{ generic: true, }, { - name: "FP", + name: "SB", reg: regInfo{ inputs: []regMask{}, clobbers: 0, diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index fde1cf457b..27e4f754d1 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -54,7 +54,7 @@ var registers = [...]Register{ Register{29, "X13"}, Register{30, "X14"}, Register{31, "X15"}, - Register{32, "FP"}, // pseudo-register, actually a constant offset from SP + Register{32, "SB"}, // pseudo-register for global base pointer (aka %rip) Register{33, "FLAGS"}, // TODO: make arch-dependent @@ -101,15 +101,15 @@ func regalloc(f *Func) { var oldSched []*Value - // Hack to find fp, sp Values and assign them a register. (TODO: make not so hacky) - var fp, sp *Value + // Hack to find sp and sb Values and assign them a register. (TODO: make not so hacky) + var sp, sb *Value for _, v := range f.Entry.Values { switch v.Op { case OpSP: sp = v home = setloc(home, v, ®isters[4]) // TODO: arch-dependent - case OpFP: - fp = v + case OpSB: + sb = v home = setloc(home, v, ®isters[32]) // TODO: arch-dependent } } @@ -147,7 +147,7 @@ func regalloc(f *Func) { // TODO: hack: initialize fixed registers regs[4] = regInfo{sp, sp, false} - regs[32] = regInfo{fp, fp, false} + regs[32] = regInfo{sb, sb, false} var used regMask // has a 1 for each non-nil entry in regs var dirty regMask // has a 1 for each dirty entry in regs @@ -193,7 +193,7 @@ func regalloc(f *Func) { // nospill contains registers that we can't spill because // we already set them up for use by the current instruction. var nospill regMask - nospill |= 0x100000010 // SP and FP can't be spilled (TODO: arch-specific) + nospill |= 0x100000010 // SP & SB can't be spilled (TODO: arch-specific) // Move inputs into registers for _, o := range order { @@ -257,13 +257,15 @@ func regalloc(f *Func) { var c *Value if len(w.Args) == 0 { // Materialize w - if w.Op == OpFP || w.Op == OpSP || w.Op == OpGlobal { + if w.Op == OpSB { + c = w + } else if w.Op == OpSP { c = b.NewValue1(w.Line, OpCopy, w.Type, w) } else { c = b.NewValue0IA(w.Line, w.Op, w.Type, w.AuxInt, w.Aux) } - } else if len(w.Args) == 1 && (w.Args[0].Op == OpFP || w.Args[0].Op == OpSP || w.Args[0].Op == OpGlobal) { - // Materialize offsets from SP/FP/Global + } else if len(w.Args) == 1 && (w.Args[0].Op == OpSP || w.Args[0].Op == OpSB) { + // Materialize offsets from SP/SB c = b.NewValue1IA(w.Line, w.Op, w.Type, w.AuxInt, w.Aux, w.Args[0]) } else if wreg != 0 { // Copy from another register. diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go index 0de8830fb2..b2c45969e4 100644 --- a/src/cmd/compile/internal/ssa/rewrite.go +++ b/src/cmd/compile/internal/ssa/rewrite.go @@ -99,6 +99,17 @@ func addOff(x, y int64) int64 { return z } +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 inBounds(idx, len int64) bool { return idx >= 0 && idx < len } diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 3490adadd7..dfed084875 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -344,6 +344,24 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end858e823866524b81b4636f7dd7e8eefe end858e823866524b81b4636f7dd7e8eefe: ; + case OpAddr: + // match: (Addr {sym} base) + // cond: + // result: (LEAQ {sym} base) + { + sym := v.Aux + base := v.Args[0] + v.Op = OpAMD64LEAQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Aux = sym + v.AddArg(base) + return true + } + goto end53cad0c3c9daa5575680e77c14e05e72 + end53cad0c3c9daa5575680e77c14e05e72: + ; case OpAMD64CMOVQCC: // match: (CMOVQCC (CMPQconst [c] (MOVQconst [d])) _ x) // cond: inBounds(d, c) @@ -501,22 +519,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endcc7894224d4f6b0bcabcece5d0185912 endcc7894224d4f6b0bcabcece5d0185912: ; - case OpGlobal: - // match: (Global {sym}) - // cond: - // result: (LEAQglobal {sym}) - { - sym := v.Aux - v.Op = OpAMD64LEAQglobal - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Aux = sym - return true - } - goto end8f47b6f351fecaeded45abbe5c2beec0 - end8f47b6f351fecaeded45abbe5c2beec0: - ; case OpIsInBounds: // match: (IsInBounds idx len) // cond: @@ -769,6 +771,35 @@ func rewriteValueAMD64(v *Value, config *Config) bool { } goto end843d29b538c4483b432b632e5666d6e3 end843d29b538c4483b432b632e5666d6e3: + ; + // match: (MOVQload [off1] {sym1} (LEAQ [off2] {sym2} base) mem) + // cond: (sym1 == nil || sym2 == nil) + // result: (MOVQload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem) + { + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ { + goto end227426af95e74caddcf59fdcd30ca8bc + } + off2 := v.Args[0].AuxInt + sym2 := v.Args[0].Aux + base := v.Args[0].Args[0] + mem := v.Args[1] + if !(sym1 == nil || sym2 == nil) { + goto end227426af95e74caddcf59fdcd30ca8bc + } + v.Op = OpAMD64MOVQload + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(base) + v.AddArg(mem) + return true + } + goto end227426af95e74caddcf59fdcd30ca8bc + end227426af95e74caddcf59fdcd30ca8bc: ; // match: (MOVQload [off1] (LEAQ8 [off2] ptr idx) mem) // cond: @@ -846,6 +877,37 @@ func rewriteValueAMD64(v *Value, config *Config) bool { } goto end2108c693a43c79aed10b9246c39c80aa end2108c693a43c79aed10b9246c39c80aa: + ; + // match: (MOVQstore [off1] {sym1} (LEAQ [off2] {sym2} base) val mem) + // cond: (sym1 == nil || sym2 == nil) + // result: (MOVQstore [addOff(off1,off2)] {mergeSym(sym1,sym2)} base val mem) + { + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ { + goto end5061f48193268a5eb1e1740bdd23c43d + } + 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 !(sym1 == nil || sym2 == nil) { + goto end5061f48193268a5eb1e1740bdd23c43d + } + v.Op = OpAMD64MOVQstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(base) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto end5061f48193268a5eb1e1740bdd23c43d + end5061f48193268a5eb1e1740bdd23c43d: ; // match: (MOVQstore [off1] (LEAQ8 [off2] ptr idx) val mem) // cond: diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index ac4f009881..e2feeb53cc 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -60,12 +60,12 @@ func rewriteValuegeneric(v *Value, config *Config) bool { case OpConst: // match: (Const {s}) // cond: t.IsString() - // result: (StringMake (OffPtr [2*config.ptrSize] (Global {config.fe.StringSym(s.(string))})) (Const [int64(len(s.(string)))])) + // result: (StringMake (OffPtr [2*config.ptrSize] (Addr {config.fe.StringSym(s.(string))} (SB ))) (Const [int64(len(s.(string)))])) { t := v.Type s := v.Aux if !(t.IsString()) { - goto end6d6321106a054a5984b2ed0acec52a5b + goto end55cd8fd3b98a2459d0ee9d6cbb456b01 } v.Op = OpStringMake v.AuxInt = 0 @@ -74,19 +74,22 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v0 := v.Block.NewValue0(v.Line, OpOffPtr, TypeInvalid) v0.Type = TypeBytePtr v0.AuxInt = 2 * config.ptrSize - v1 := v.Block.NewValue0(v.Line, OpGlobal, TypeInvalid) + v1 := v.Block.NewValue0(v.Line, OpAddr, TypeInvalid) v1.Type = TypeBytePtr v1.Aux = config.fe.StringSym(s.(string)) + v2 := v.Block.NewValue0(v.Line, OpSB, TypeInvalid) + v2.Type = config.Uintptr + v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) - v2 := v.Block.NewValue0(v.Line, OpConst, TypeInvalid) - v2.Type = config.Uintptr - v2.AuxInt = int64(len(s.(string))) - v.AddArg(v2) + v3 := v.Block.NewValue0(v.Line, OpConst, TypeInvalid) + v3.Type = config.Uintptr + v3.AuxInt = int64(len(s.(string))) + v.AddArg(v3) return true } - goto end6d6321106a054a5984b2ed0acec52a5b - end6d6321106a054a5984b2ed0acec52a5b: + goto end55cd8fd3b98a2459d0ee9d6cbb456b01 + end55cd8fd3b98a2459d0ee9d6cbb456b01: ; case OpIsInBounds: // match: (IsInBounds (Const [c]) (Const [d])) diff --git a/src/cmd/compile/internal/ssa/shift_test.go b/src/cmd/compile/internal/ssa/shift_test.go index 52ddbbe42d..29b47c125e 100644 --- a/src/cmd/compile/internal/ssa/shift_test.go +++ b/src/cmd/compile/internal/ssa/shift_test.go @@ -29,9 +29,9 @@ func makeConstShiftFunc(c *Config, amount int64, op Op, typ Type) fun { fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), - Valu("FP", OpFP, TypeUInt64, 0, nil), - Valu("argptr", OpOffPtr, ptyp, 8, nil, "FP"), - Valu("resptr", OpOffPtr, ptyp, 16, nil, "FP"), + 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", OpConst, TypeUInt64, amount, nil), Valu("shift", op, typ, 0, nil, "load", "c"), diff --git a/src/cmd/compile/internal/ssa/stackalloc.go b/src/cmd/compile/internal/ssa/stackalloc.go index e39a3e7a59..85a55ece7c 100644 --- a/src/cmd/compile/internal/ssa/stackalloc.go +++ b/src/cmd/compile/internal/ssa/stackalloc.go @@ -54,7 +54,7 @@ func stackalloc(f *Func) { // v will have been materialized wherever it is needed. continue } - if len(v.Args) == 1 && (v.Args[0].Op == OpFP || v.Args[0].Op == OpSP || v.Args[0].Op == OpGlobal) { + if len(v.Args) == 1 && (v.Args[0].Op == OpSP || v.Args[0].Op == OpSB) { continue } n = align(n, v.Type.Alignment()) @@ -64,54 +64,26 @@ func stackalloc(f *Func) { } } + // Finally, allocate space for all autos that we used + for _, b := range f.Blocks { + for _, v := range b.Values { + s, ok := v.Aux.(*AutoSymbol) + if !ok || s.Offset >= 0 { + continue + } + t := s.Typ + n = align(n, t.Alignment()) + s.Offset = n + n += t.Size() + } + } + n = align(n, f.Config.ptrSize) n += f.Config.ptrSize // space for return address. TODO: arch-dependent f.RegAlloc = home f.FrameSize = n // TODO: share stack slots among noninterfering (& gc type compatible) values - - // adjust all uses of FP to SP now that we have the frame size. - var fp *Value - for _, b := range f.Blocks { - for _, v := range b.Values { - if v.Op == OpFP { - if fp != nil { - b.Fatalf("multiple FP ops: %s %s", fp, v) - } - fp = v - } - for i, a := range v.Args { - if a.Op != OpFP { - continue - } - // TODO: do this with arch-specific rewrite rules somehow? - switch v.Op { - case OpAMD64ADDQ: - // (ADDQ (FP) x) -> (LEAQ [n] (SP) x) - v.Op = OpAMD64LEAQ - v.AuxInt = n - case OpAMD64ADDQconst: - // TODO(matloob): Add LEAQconst op - v.AuxInt = addOff(v.AuxInt, n) - case OpAMD64LEAQ, OpAMD64MOVQload, OpAMD64MOVQstore, OpAMD64MOVLload, OpAMD64MOVLstore, OpAMD64MOVWload, OpAMD64MOVWstore, OpAMD64MOVBload, OpAMD64MOVBstore, OpAMD64MOVQloadidx8: - if v.Op == OpAMD64MOVQloadidx8 && i == 1 { - // Note: we could do it, but it is probably an error - f.Fatalf("can't do FP->SP adjust on index slot of load %s", v.Op) - } - // eg: (MOVQload [c] (FP) mem) -> (MOVQload [c+n] (SP) mem) - v.AuxInt = addOff(v.AuxInt, n) - default: - f.Unimplementedf("can't do FP->SP adjust on %s", v.Op) - // TODO: OpCopy -> ADDQ - } - } - } - } - if fp != nil { - fp.Op = OpSP - home[fp.ID] = ®isters[4] // TODO: arch-dependent - } } // align increases n to the next multiple of a. a must be a power of 2. diff --git a/src/cmd/compile/internal/ssa/value.go b/src/cmd/compile/internal/ssa/value.go index 9c7f148a79..e6e23d5270 100644 --- a/src/cmd/compile/internal/ssa/value.go +++ b/src/cmd/compile/internal/ssa/value.go @@ -114,3 +114,40 @@ func (v *Value) resetArgs() { func (v *Value) Logf(msg string, args ...interface{}) { v.Block.Logf(msg, args...) } func (v *Value) Fatalf(msg string, args ...interface{}) { v.Block.Fatalf(msg, args...) } func (v *Value) Unimplementedf(msg string, args ...interface{}) { v.Block.Unimplementedf(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 + Offset int64 // Distance above frame pointer + Sym fmt.Stringer // A *gc.Sym 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 + Offset int64 // Distance above stack pointer. Set by stackalloc in SSA. + Sym fmt.Stringer // A *gc.Sym referring to a local (auto) variable. +} + +func (s *ExternSymbol) String() string { + return s.Sym.String() +} + +func (s *ArgSymbol) String() string { + return s.Sym.String() +} + +func (s *AutoSymbol) String() string { + return s.Sym.String() +} -- cgit v1.3 From 929c2aa2aec07ec774683da56758d885176cff81 Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Thu, 25 Jun 2015 18:03:50 -0500 Subject: [dev.ssa] cmd/compile/ssa: fix unit tests Fix out of bounds array panic due to CL 11238. Change-Id: Id8a46f1ee20cb1f46775d0c04cc4944d729dfceb Reviewed-on: https://go-review.googlesource.com/11540 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/check.go | 3 +++ src/cmd/compile/internal/ssa/deadstore_test.go | 13 ++++++++----- 2 files changed, 11 insertions(+), 5 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/check.go b/src/cmd/compile/internal/ssa/check.go index 1ca6e36ae7..e889177841 100644 --- a/src/cmd/compile/internal/ssa/check.go +++ b/src/cmd/compile/internal/ssa/check.go @@ -105,6 +105,9 @@ func checkFunc(f *Func) { } 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) } diff --git a/src/cmd/compile/internal/ssa/deadstore_test.go b/src/cmd/compile/internal/ssa/deadstore_test.go index 042e7f66ff..3b29e1c430 100644 --- a/src/cmd/compile/internal/ssa/deadstore_test.go +++ b/src/cmd/compile/internal/ssa/deadstore_test.go @@ -14,9 +14,10 @@ func TestDeadStore(t *testing.T) { fun := Fun(c, "entry", Bloc("entry", Valu("start", OpArg, TypeMem, 0, ".mem"), + Valu("sb", OpSB, TypeInvalid, 0, nil), Valu("v", OpConst, TypeBool, 0, true), - Valu("addr1", OpAddr, ptrType, 0, nil), - Valu("addr2", OpAddr, ptrType, 0, nil), + Valu("addr1", OpAddr, ptrType, 0, nil, "sb"), + Valu("addr2", OpAddr, ptrType, 0, nil, "sb"), Valu("store1", OpStore, TypeMem, 0, nil, "addr1", "v", "start"), Valu("store2", OpStore, TypeMem, 0, nil, "addr2", "v", "store1"), Valu("store3", OpStore, TypeMem, 0, nil, "addr1", "v", "store2"), @@ -40,8 +41,9 @@ func TestDeadStorePhi(t *testing.T) { fun := Fun(c, "entry", Bloc("entry", Valu("start", OpArg, TypeMem, 0, ".mem"), + Valu("sb", OpSB, TypeInvalid, 0, nil), Valu("v", OpConst, TypeBool, 0, true), - Valu("addr", OpAddr, ptrType, 0, nil), + Valu("addr", OpAddr, ptrType, 0, nil, "sb"), Goto("loop")), Bloc("loop", Valu("phi", OpPhi, TypeMem, 0, nil, "start", "store"), @@ -66,9 +68,10 @@ func TestDeadStoreTypes(t *testing.T) { fun := Fun(c, "entry", Bloc("entry", Valu("start", OpArg, TypeMem, 0, ".mem"), + Valu("sb", OpSB, TypeInvalid, 0, nil), Valu("v", OpConst, TypeBool, 0, true), - Valu("addr1", OpAddr, t1, 0, nil), - Valu("addr2", OpAddr, t2, 0, nil), + Valu("addr1", OpAddr, t1, 0, nil, "sb"), + Valu("addr2", OpAddr, t2, 0, nil, "sb"), Valu("store1", OpStore, TypeMem, 0, nil, "addr1", "v", "start"), Valu("store2", OpStore, TypeMem, 0, nil, "addr2", "v", "store1"), Goto("exit")), -- cgit v1.3 From 7b858018b396b9a4d491ba112122605c0122a2e0 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Thu, 25 Jun 2015 20:01:45 -0700 Subject: [dev.ssa] cmd/compile/internal/gc: Interpret init list of OFOR conditions Fixes build. Some variables are initialized in this list. Q: How do we tell that we've included all the required Ninit lists? Change-Id: I96b3f03c291440130303a2b95a651e97e4d8113c Reviewed-on: https://go-review.googlesource.com/11542 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/gc/ssa.go | 1 + 1 file changed, 1 insertion(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 4e0f4b0cc6..8a81dbd57f 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -380,6 +380,7 @@ func (s *state) stmt(n *Node) { s.Unimplementedf("cond n.Left == nil: %v", n) } s.startBlock(bCond) + s.stmtList(n.Left.Ninit) cond := s.expr(n.Left) b = s.endBlock() b.Kind = ssa.BlockIf -- cgit v1.3 From dbd83c4464ed37b350deae313eddf7babc3e4c41 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Sun, 28 Jun 2015 06:08:50 -0700 Subject: [dev.ssa] cmd/compile/internal/gc: Fix constant shift generation Change-Id: Ib142185de3f6e4d2f4983511c063492529d8fb8a Reviewed-on: https://go-review.googlesource.com/11656 Reviewed-by: Michael Matloob --- src/cmd/compile/internal/gc/ssa.go | 1 + 1 file changed, 1 insertion(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 8a81dbd57f..51e4735520 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -963,6 +963,7 @@ func genValue(v *ssa.Value) { p.From.Type = obj.TYPE_CONST p.From.Offset = v.AuxInt p.To.Type = obj.TYPE_REG + p.To.Reg = r case ssa.OpAMD64SBBQcarrymask: r := regnum(v) p := Prog(x86.ASBBQ) -- cgit v1.3 From d9a704cd40e8d248b473a831f099d8d4ca4c409b Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Wed, 24 Jun 2015 14:34:28 -0700 Subject: [dev.ssa] cmd/compile/ssa: refine type equality in cse The correct way to compare gc.Types is Eqtype, rather than pointer equality. Introduce an Equal method for ssa.Type to allow us to use it. In the cse pass, use a type's string to build the coarse partition, and then use Type.Equal during refinement. This lets the cse pass do a better job. In the ~20% of the standard library that SSA can compile, the number of common subexpressions recognized by the cse pass increases from 27,550 to 32,199 (+17%). The number of nil checks eliminated increases from 75 to 115 (+50%). Change-Id: I0bdbfcf613ca6bc2ec987eb19b6b1217b51f3008 Reviewed-on: https://go-review.googlesource.com/11451 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/type.go | 8 ++++++++ src/cmd/compile/internal/ssa/TODO | 1 - src/cmd/compile/internal/ssa/cse.go | 13 ++++--------- src/cmd/compile/internal/ssa/type.go | 9 +++++++++ 4 files changed, 21 insertions(+), 10 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/type.go b/src/cmd/compile/internal/gc/type.go index 1417bfc196..11635d8929 100644 --- a/src/cmd/compile/internal/gc/type.go +++ b/src/cmd/compile/internal/gc/type.go @@ -23,6 +23,14 @@ func (t *Type) Alignment() int64 { return int64(t.Align) } +func (t *Type) Equal(u ssa.Type) bool { + x, ok := u.(*Type) + if !ok { + return false + } + return Eqtype(t, x) +} + func (t *Type) IsBoolean() bool { return t.Etype == TBOOL } diff --git a/src/cmd/compile/internal/ssa/TODO b/src/cmd/compile/internal/ssa/TODO index 30d49044e1..e2e3fb8a57 100644 --- a/src/cmd/compile/internal/ssa/TODO +++ b/src/cmd/compile/internal/ssa/TODO @@ -47,7 +47,6 @@ Rewrites and which need code generated, and do the code generation. Common-Subexpression Elimination - - Canonicalize types. - Make better decision about which value in an equivalence class we should choose to replace other values in that class. - Can we move control values out of their basic block? diff --git a/src/cmd/compile/internal/ssa/cse.go b/src/cmd/compile/internal/ssa/cse.go index 7a1cf53ccb..a64e993e2a 100644 --- a/src/cmd/compile/internal/ssa/cse.go +++ b/src/cmd/compile/internal/ssa/cse.go @@ -24,15 +24,10 @@ func cse(f *Func) { // It starts with a coarse partition and iteratively refines it // until it reaches a fixed point. - // Make initial partition based on opcode/type/aux/auxint/nargs - // TODO(khr): types are not canonical, so we split unnecessarily. - // For example, all pointer types are distinct. Fix this. - // As a data point, using v.Type.String() instead of - // v.Type here (which is unsound) allows removal of - // about 50% more nil checks in the nilcheck elim pass. + // Make initial partition based on opcode/type-name/aux/auxint/nargs type key struct { op Op - typ Type + typ string aux interface{} auxint int64 nargs int @@ -40,7 +35,7 @@ func cse(f *Func) { m := map[key]eqclass{} for _, b := range f.Blocks { for _, v := range b.Values { - k := key{v.Op, v.Type, v.Aux, v.AuxInt, len(v.Args)} + k := key{v.Op, v.Type.String(), v.Aux, v.AuxInt, len(v.Args)} m[k] = append(m[k], v) } } @@ -74,7 +69,7 @@ func cse(f *Func) { for j := 1; j < len(e); { w := e[j] for i := 0; i < len(v.Args); i++ { - if valueEqClass[v.Args[i].ID] != valueEqClass[w.Args[i].ID] { + if valueEqClass[v.Args[i].ID] != valueEqClass[w.Args[i].ID] || !v.Type.Equal(w.Type) { // w is not equivalent to v. // remove w from e e, e[j] = e[:len(e)-1], e[len(e)-1] diff --git a/src/cmd/compile/internal/ssa/type.go b/src/cmd/compile/internal/ssa/type.go index e271131a40..370137da71 100644 --- a/src/cmd/compile/internal/ssa/type.go +++ b/src/cmd/compile/internal/ssa/type.go @@ -26,6 +26,7 @@ type Type interface { PtrTo() Type // given T, return *T String() string + Equal(Type) bool } // Stub implementation for now, until we are completely using ../gc:Type @@ -59,6 +60,14 @@ func (t *TypeImpl) String() string { return t.Name } func (t *TypeImpl) Elem() Type { panic("not implemented"); return nil } func (t *TypeImpl) PtrTo() Type { panic("not implemented"); return nil } +func (t *TypeImpl) Equal(u Type) bool { + x, ok := u.(*TypeImpl) + if !ok { + return false + } + return x == t +} + var ( // shortcuts for commonly used basic types TypeInt8 = &TypeImpl{Size_: 1, Align: 1, Integer: true, Signed: true, Name: "int8"} -- cgit v1.3 From 1746e711ad7429248af4d17a57413aeaab0c2095 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Thu, 25 Jun 2015 14:04:55 -0700 Subject: [dev.ssa] cmd/compile/ssa: add nilcheckelim benchmarks These benchmarks demonstrate that the nilcheckelim pass is roughly O(n^2): BenchmarkNilCheckDeep1 2000000 741 ns/op 1.35 MB/s BenchmarkNilCheckDeep10 1000000 2237 ns/op 4.47 MB/s BenchmarkNilCheckDeep100 20000 60713 ns/op 1.65 MB/s BenchmarkNilCheckDeep1000 200 7925198 ns/op 0.13 MB/s BenchmarkNilCheckDeep10000 1 1220104252 ns/op 0.01 MB/s Profiling suggests that building the dominator tree is also O(n^2), and before size factors take over, considerably more expensive than nilcheckelim. Change-Id: If966b38ec52243a25f355dab871300d29db02e16 Reviewed-on: https://go-review.googlesource.com/11520 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/dom.go | 3 ++ src/cmd/compile/internal/ssa/export_test.go | 2 +- src/cmd/compile/internal/ssa/nilcheck.go | 1 + src/cmd/compile/internal/ssa/nilcheck_test.go | 56 +++++++++++++++++++++++++++ 4 files changed, 61 insertions(+), 1 deletion(-) create mode 100644 src/cmd/compile/internal/ssa/nilcheck_test.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/dom.go b/src/cmd/compile/internal/ssa/dom.go index 343df76b22..6f700ec7e9 100644 --- a/src/cmd/compile/internal/ssa/dom.go +++ b/src/cmd/compile/internal/ssa/dom.go @@ -55,6 +55,8 @@ func postorder(f *Func) []*Block { // 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 { + // TODO: Benchmarks. See BenchmarkNilCheckDeep* for an example. + // A simple algorithm for now // Cooper, Harvey, Kennedy idom := make([]*Block, f.NumBlocks()) @@ -108,6 +110,7 @@ func dominators(f *Func) []*Block { // 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] diff --git a/src/cmd/compile/internal/ssa/export_test.go b/src/cmd/compile/internal/ssa/export_test.go index f254e066ac..cec4abff56 100644 --- a/src/cmd/compile/internal/ssa/export_test.go +++ b/src/cmd/compile/internal/ssa/export_test.go @@ -12,7 +12,7 @@ var Opt = opt var Deadcode = deadcode type DummyFrontend struct { - t *testing.T + t testing.TB } func (DummyFrontend) StringSym(s string) interface{} { diff --git a/src/cmd/compile/internal/ssa/nilcheck.go b/src/cmd/compile/internal/ssa/nilcheck.go index 28544d5900..1265ee9971 100644 --- a/src/cmd/compile/internal/ssa/nilcheck.go +++ b/src/cmd/compile/internal/ssa/nilcheck.go @@ -33,6 +33,7 @@ func nilcheckelim(f *Func) { var elim bool // Walk up the dominator tree, // looking for identical nil checks. + // TODO: This loop is O(n^2). See BenchmarkNilCheckDeep*. for c := idom[b.ID]; c != nil; c = idom[c.ID] { if checkedptr(c) == ptr { elim = true 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 0000000000..2d60957d49 --- /dev/null +++ b/src/cmd/compile/internal/ssa/nilcheck_test.go @@ -0,0 +1,56 @@ +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", OpArg, TypeMem, 0, ".mem"), + Goto(blockn(0)), + ), + ) + for i := 0; i < depth; i++ { + blocs = append(blocs, + Bloc(blockn(i), + Valu(ptrn(i), OpGlobal, ptrType, 0, nil), + 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}) + fun := Fun(c, "entry", blocs...) + + CheckFunc(fun.f) + b.SetBytes(int64(depth)) // helps for eyeballing linearity + b.ResetTimer() + + 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) } -- cgit v1.3 From 46815b9f6236771b85f85e3105e37e65937d03aa Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Wed, 24 Jun 2015 17:48:22 -0700 Subject: [dev.ssa] cmd/compile/ssa: add comparison ops Increase SSA coverage of functions in the standard library from 20.79% to 27.81%. The most significant unimplemented items are now: 10.16% 2597 SSA unimplemented: zero for type error not implemented 8.44% 2157 SSA unimplemented: addr: bad op DOTPTR 7.98% 2039 SSA unimplemented: unhandled OLITERAL 7 6.29% 1607 SSA unimplemented: unhandled expr OROR 4.73% 1209 SSA unimplemented: unhandled expr LEN 4.55% 1163 SSA unimplemented: unhandled expr LROT 3.42% 874 SSA unimplemented: unhandled OLITERAL 6 2.46% 629 SSA unimplemented: unhandled expr DOT 2.41% 615 SSA unimplemented: zero for type []byte not implemented 2.02% 516 SSA unimplemented: unhandled stmt CALLMETH 1.90% 486 SSA unimplemented: unhandled expr ANDAND 1.79% 458 SSA unimplemented: unhandled expr CALLINTER 1.69% 433 SSA unimplemented: unhandled stmt SWITCH 1.67% 428 SSA unimplemented: unhandled expr CALLMETH 1.67% 426 SSA unimplemented: unhandled expr CLOSUREVAR Change-Id: I40959b22993c4f70784b4eca472cae752347879c Reviewed-on: https://go-review.googlesource.com/11452 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 42 +++++---- src/cmd/compile/internal/ssa/gen/AMD64.rules | 5 ++ src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 1 + src/cmd/compile/internal/ssa/gen/genericOps.go | 7 +- src/cmd/compile/internal/ssa/nilcheck_test.go | 3 +- src/cmd/compile/internal/ssa/opGen.go | 63 +++++++++++++ src/cmd/compile/internal/ssa/rewriteAMD64.go | 120 +++++++++++++++++++++++++ 7 files changed, 220 insertions(+), 21 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 51e4735520..f9c8c9b62b 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -392,7 +392,9 @@ func (s *state) stmt(n *Node) { // generate body s.startBlock(bBody) s.stmtList(n.Nbody) - s.stmt(n.Right) + if n.Right != nil { + s.stmt(n.Right) + } b = s.endBlock() addEdge(b, bCond) @@ -409,6 +411,21 @@ func (s *state) stmt(n *Node) { } } +var binOpToSSA = [...]ssa.Op{ + // Comparisons + OEQ: ssa.OpEq, + ONE: ssa.OpNeq, + OLT: ssa.OpLess, + OLE: ssa.OpLeq, + OGT: ssa.OpGreater, + OGE: ssa.OpGeq, + // Arithmetic + OADD: ssa.OpAdd, + OSUB: ssa.OpSub, + OLSH: ssa.OpLsh, + ORSH: ssa.OpRsh, +} + // 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) @@ -444,28 +461,15 @@ func (s *state) expr(n *Node) *ssa.Value { x := s.expr(n.Left) return s.newValue1(ssa.OpConvert, n.Type, x) - // binary ops - case OLT: - a := s.expr(n.Left) - b := s.expr(n.Right) - return s.newValue2(ssa.OpLess, ssa.TypeBool, a, b) - case OADD: - a := s.expr(n.Left) - b := s.expr(n.Right) - return s.newValue2(ssa.OpAdd, a.Type, a, b) - case OSUB: - // TODO:(khr) fold code for all binary ops together somehow - a := s.expr(n.Left) - b := s.expr(n.Right) - return s.newValue2(ssa.OpSub, a.Type, a, b) - case OLSH: + // binary ops + case OLT, OEQ, ONE, OLE, OGE, OGT: a := s.expr(n.Left) b := s.expr(n.Right) - return s.newValue2(ssa.OpLsh, a.Type, a, b) - case ORSH: + return s.newValue2(binOpToSSA[n.Op], ssa.TypeBool, a, b) + case OADD, OSUB, OLSH, ORSH: a := s.expr(n.Left) b := s.expr(n.Right) - return s.newValue2(ssa.OpRsh, a.Type, a, b) + return s.newValue2(binOpToSSA[n.Op], a.Type, a, b) case OADDR: return s.addr(n.Left) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 124b13b6f2..d3d14c3a0f 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -48,6 +48,11 @@ y)) (Less x y) && is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type) -> (SETL (CMPQ x y)) +(Leq x y) && is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type) -> (SETLE (CMPQ x y)) +(Greater x y) && is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type) -> (SETG (CMPQ x y)) +(Geq x y) && is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type) -> (SETGE (CMPQ x y)) +(Eq x y) && is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type) -> (SETEQ (CMPQ x y)) +(Neq x y) && is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type) -> (SETNE (CMPQ x y)) (Load ptr mem) && (is64BitInt(t) || isPtr(t)) -> (MOVQload ptr mem) (Load ptr mem) && is32BitInt(t) -> (MOVLload ptr mem) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index c0f36b51b3..6d0b4ece3c 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -122,6 +122,7 @@ func init() { {name: "SETEQ", reg: flagsgp}, // extract == condition from arg0 {name: "SETNE", reg: flagsgp}, // extract != condition from arg0 {name: "SETL", reg: flagsgp}, // extract signed < condition from arg0 + {name: "SETLE", reg: flagsgp}, // extract signed <= condition from arg0 {name: "SETG", reg: flagsgp}, // extract signed > condition from arg0 {name: "SETGE", reg: flagsgp}, // extract signed >= condition from arg0 {name: "SETB", reg: flagsgp}, // extract unsigned < condition from arg0 diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index e7c4de8eb1..151e8e13e3 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -15,7 +15,12 @@ var genericOps = []opData{ {name: "Rsh"}, // arg0 >> arg1 (signed/unsigned depending on signedness of type) // 2-input comparisons - {name: "Less"}, // arg0 < arg1 + {name: "Eq"}, // arg0 == arg1 + {name: "Neq"}, // arg0 != arg1 + {name: "Less"}, // arg0 < arg1 + {name: "Leq"}, // arg0 <= arg1 + {name: "Greater"}, // arg0 > arg1 + {name: "Geq"}, // arg0 <= arg1 // Data movement {name: "Phi"}, // select an argument based on which predecessor block we came from diff --git a/src/cmd/compile/internal/ssa/nilcheck_test.go b/src/cmd/compile/internal/ssa/nilcheck_test.go index 2d60957d49..272fd0c027 100644 --- a/src/cmd/compile/internal/ssa/nilcheck_test.go +++ b/src/cmd/compile/internal/ssa/nilcheck_test.go @@ -22,13 +22,14 @@ func benchmarkNilCheckDeep(b *testing.B, depth int) { blocs = append(blocs, Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("sb", OpSB, TypeInvalid, 0, nil), Goto(blockn(0)), ), ) for i := 0; i < depth; i++ { blocs = append(blocs, Bloc(blockn(i), - Valu(ptrn(i), OpGlobal, ptrType, 0, nil), + Valu(ptrn(i), OpAddr, ptrType, 0, nil, "sb"), Valu(booln(i), OpIsNonNil, TypeBool, 0, nil, ptrn(i)), If(booln(i), blockn(i+1), "exit"), ), diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 20adc62958..997522037c 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -72,6 +72,7 @@ const ( OpAMD64SETEQ OpAMD64SETNE OpAMD64SETL + OpAMD64SETLE OpAMD64SETG OpAMD64SETGE OpAMD64SETB @@ -112,7 +113,12 @@ const ( OpMul OpLsh OpRsh + OpEq + OpNeq OpLess + OpLeq + OpGreater + OpGeq OpPhi OpCopy OpConst @@ -451,6 +457,18 @@ var opcodeTable = [...]opInfo{ }, }, }, + { + name: "SETLE", + reg: regInfo{ + inputs: []regMask{ + 8589934592, // .FLAGS + }, + clobbers: 0, + outputs: []regMask{ + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + }, + }, { name: "SETG", reg: regInfo{ @@ -920,6 +938,24 @@ var opcodeTable = [...]opInfo{ }, generic: true, }, + { + name: "Eq", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Neq", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, { name: "Less", reg: regInfo{ @@ -929,6 +965,33 @@ var opcodeTable = [...]opInfo{ }, generic: true, }, + { + name: "Leq", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Greater", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Geq", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, { name: "Phi", reg: regInfo{ diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index dfed084875..599203c119 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -519,6 +519,78 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endcc7894224d4f6b0bcabcece5d0185912 endcc7894224d4f6b0bcabcece5d0185912: ; + case OpEq: + // match: (Eq x y) + // cond: is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type) + // result: (SETEQ (CMPQ x y)) + { + x := v.Args[0] + y := v.Args[1] + if !(is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type)) { + goto endad64a62086703de09f52315e190bdf0e + } + v.Op = OpAMD64SETEQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto endad64a62086703de09f52315e190bdf0e + endad64a62086703de09f52315e190bdf0e: + ; + case OpGeq: + // match: (Geq x y) + // cond: is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type) + // result: (SETGE (CMPQ x y)) + { + x := v.Args[0] + y := v.Args[1] + if !(is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type)) { + goto end31ba1968829a3b451a35431111140fec + } + v.Op = OpAMD64SETGE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto end31ba1968829a3b451a35431111140fec + end31ba1968829a3b451a35431111140fec: + ; + case OpGreater: + // match: (Greater x y) + // cond: is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type) + // result: (SETG (CMPQ x y)) + { + x := v.Args[0] + y := v.Args[1] + if !(is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type)) { + goto end1cff30b1bf40104e5e30ab73d6568f7f + } + v.Op = OpAMD64SETG + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto end1cff30b1bf40104e5e30ab73d6568f7f + end1cff30b1bf40104e5e30ab73d6568f7f: + ; case OpIsInBounds: // match: (IsInBounds idx len) // cond: @@ -560,6 +632,30 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endff508c3726edfb573abc6128c177e76c endff508c3726edfb573abc6128c177e76c: ; + case OpLeq: + // match: (Leq x y) + // cond: is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type) + // result: (SETLE (CMPQ x y)) + { + x := v.Args[0] + y := v.Args[1] + if !(is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type)) { + goto enddb4f100c01cdd95d69d399ffc37e33e7 + } + v.Op = OpAMD64SETLE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto enddb4f100c01cdd95d69d399ffc37e33e7 + enddb4f100c01cdd95d69d399ffc37e33e7: + ; case OpLess: // match: (Less x y) // cond: is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type) @@ -1117,6 +1213,30 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endfab0d598f376ecba45a22587d50f7aff endfab0d598f376ecba45a22587d50f7aff: ; + case OpNeq: + // match: (Neq x y) + // cond: is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type) + // result: (SETNE (CMPQ x y)) + { + x := v.Args[0] + y := v.Args[1] + if !(is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type)) { + goto enddccbd4e7581ae8d9916b933d3501987b + } + v.Op = OpAMD64SETNE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto enddccbd4e7581ae8d9916b933d3501987b + enddccbd4e7581ae8d9916b933d3501987b: + ; case OpOffPtr: // match: (OffPtr [off] ptr) // cond: -- cgit v1.3 From c9372619f2b6cfc7edff790b20b67e2ce5d8e044 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Tue, 30 Jun 2015 21:16:51 -0700 Subject: [dev.ssa] cmd/compile/internal/gc: fix stringsym call Forgot to add this in the tip merge. Change-Id: I0e5a2681133f4ae7a7c360ae2c2d71d46420c693 Reviewed-on: https://go-review.googlesource.com/11793 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index f9c8c9b62b..d8b7cdf660 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1321,7 +1321,8 @@ type ssaExport struct { // is a global string constant containing s. func (*ssaExport) StringSym(s string) interface{} { // TODO: is idealstring correct? It might not matter... - return &ssa.ExternSymbol{Typ: idealstring, Sym: stringsym(s)} + hdr, _ := stringsym(s) + return &ssa.ExternSymbol{Typ: idealstring, Sym: hdr} } // Log logs a message from the compiler. -- cgit v1.3 From 66b47812eb2753eb874a622d8820dee351c4ffeb Mon Sep 17 00:00:00 2001 From: Daniel Morsing Date: Sat, 27 Jun 2015 15:45:20 +0100 Subject: [dev.ssa] cmd/compile/internal/ssa: Initial implementation of memory zeroing This will make it possible for us to start implementing interfaces and other stack allocated types which are more than one machine word. Change-Id: I52b187a791cf1919cb70ed6dabdc9f57b317ea83 Reviewed-on: https://go-review.googlesource.com/11631 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 46 ++++++- src/cmd/compile/internal/ssa/TODO | 2 + src/cmd/compile/internal/ssa/func.go | 17 +++ src/cmd/compile/internal/ssa/gen/AMD64.rules | 12 ++ src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 5 + src/cmd/compile/internal/ssa/gen/genericOps.go | 1 + src/cmd/compile/internal/ssa/opGen.go | 34 +++++ src/cmd/compile/internal/ssa/rewriteAMD64.go | 171 +++++++++++++++++++++++++ 8 files changed, 287 insertions(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index d8b7cdf660..d31d895f43 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -223,6 +223,11 @@ func (s *state) newValue2(op ssa.Op, t ssa.Type, arg0, arg1 *ssa.Value) *ssa.Val 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) @@ -554,6 +559,12 @@ func (s *state) assign(op uint8, left *Node, right *Node) { if right == nil { // right == nil means use the zero value of the assigned type. t := left.Type + if !canSSA(left) { + // if we can't ssa this memory, treat it as just zeroing out the backing memory + addr := s.addr(left) + s.vars[&memvar] = s.newValue2I(ssa.OpZero, ssa.TypeMem, t.Size(), addr, s.mem()) + return + } switch { case t.IsString(): val = s.entryNewValue0A(ssa.OpConst, left.Type, "") @@ -624,7 +635,7 @@ func (s *state) addr(n *Node) *ssa.Value { // n must be an ONAME. func canSSA(n *Node) bool { if n.Op != ONAME { - Fatal("canSSA passed a non-ONAME %s %v", Oconv(int(n.Op), 0), n) + return false } if n.Addrtaken { return false @@ -638,6 +649,9 @@ func canSSA(n *Node) bool { if n.Class == PPARAMOUT { return false } + if Isfat(n.Type) { + return false + } return true // TODO: try to make more variables SSAable. } @@ -1062,6 +1076,22 @@ func genValue(v *ssa.Value) { p.From.Reg = regnum(v.Args[0]) p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v) + case ssa.OpAMD64MOVXzero: + nb := v.AuxInt + offset := int64(0) + reg := regnum(v.Args[0]) + for nb >= 8 { + nb, offset = movZero(x86.AMOVQ, 8, nb, offset, reg) + } + for nb >= 4 { + nb, offset = movZero(x86.AMOVL, 4, nb, offset, reg) + } + for nb >= 2 { + nb, offset = movZero(x86.AMOVW, 2, nb, offset, reg) + } + for nb >= 1 { + nb, offset = movZero(x86.AMOVB, 1, nb, offset, reg) + } case ssa.OpCopy: // TODO: lower to MOVQ earlier? if v.Type.IsMemory() { return @@ -1121,6 +1151,20 @@ func genValue(v *ssa.Value) { } } +// 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 +} + func genBlock(b, next *ssa.Block, branches []branch) []branch { lineno = b.Line switch b.Kind { diff --git a/src/cmd/compile/internal/ssa/TODO b/src/cmd/compile/internal/ssa/TODO index e2e3fb8a57..340c905654 100644 --- a/src/cmd/compile/internal/ssa/TODO +++ b/src/cmd/compile/internal/ssa/TODO @@ -59,3 +59,5 @@ Other checkOpcodeCounts. Michael Matloob suggests using a similar pattern matcher to the rewrite engine to check for certain expression subtrees in the output. + - Implement memory zeroing with REPSTOSQ and DuffZero + - make deadstore work with zeroing. diff --git a/src/cmd/compile/internal/ssa/func.go b/src/cmd/compile/internal/ssa/func.go index 046c068eb9..f746861050 100644 --- a/src/cmd/compile/internal/ssa/func.go +++ b/src/cmd/compile/internal/ssa/func.go @@ -188,6 +188,23 @@ func (b *Block) NewValue2(line int32, op Op, t Type, arg0, arg1 *Value) *Value { 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, aux int64, arg0, arg1 *Value) *Value { + v := &Value{ + ID: b.Func.vid.get(), + Op: op, + Type: t, + AuxInt: aux, + Block: b, + Line: line, + } + v.Args = v.argstorage[:2] + v.Args[0] = arg0 + v.Args[1] = arg1 + b.Values = append(b.Values, v) + 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 := &Value{ diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index d3d14c3a0f..d03da723b7 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -137,6 +137,18 @@ (ADDQconst [0] x) -> (Copy x) +// lower Zero instructions with word sizes +(Zero [0] _ mem) -> (Copy mem) +(Zero [1] destptr mem) -> (MOVBstore destptr (Const [0]) mem) +(Zero [2] destptr mem) -> (MOVWstore destptr (Const [0]) mem) +(Zero [4] destptr mem) -> (MOVLstore destptr (Const [0]) mem) +(Zero [8] destptr mem) -> (MOVQstore destptr (Const [0]) mem) + +// rewrite anything less than 4 words into a series of MOV[BWLQ] $0, ptr(off) instructions +(Zero [size] destptr mem) && size < 4*8 -> (MOVXzero [size] destptr mem) +// Use STOSQ to zero memory. Rewrite this into storing the words with REPSTOSQ and then filling in the remainder with linear moves +(Zero [size] destptr mem) && size >= 4*8 -> (Zero [size%8] (OffPtr [size-(size%8)] destptr) (REPSTOSQ destptr (Const [size/8]) mem)) + // Absorb InvertFlags into branches. (LT (InvertFlags cmp) yes no) -> (GT cmp yes no) (GT (InvertFlags cmp) yes no) -> (LT cmp yes no) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 6d0b4ece3c..5706b9fcef 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -86,6 +86,7 @@ func init() { gpload := regInfo{[]regMask{gpspsb, 0}, 0, []regMask{gp}} gploadidx := regInfo{[]regMask{gpspsb, gpsp, 0}, 0, []regMask{gp}} gpstore := regInfo{[]regMask{gpspsb, gpsp, 0}, 0, nil} + gpstoreconst := regInfo{[]regMask{gpspsb, 0}, 0, nil} gpstoreidx := regInfo{[]regMask{gpspsb, gpsp, gpsp, 0}, 0, nil} flagsgp := regInfo{[]regMask{flags}, 0, []regMask{gp}} cmov := regInfo{[]regMask{flags, gp, gp}, 0, []regMask{gp}} @@ -153,6 +154,10 @@ func init() { {name: "MOVQstore", reg: gpstore, asm: "MOVQ"}, // store 8 bytes in arg1 to arg0+auxint. arg2=mem {name: "MOVQstoreidx8", reg: gpstoreidx}, // store 8 bytes in arg2 to arg0+8*arg1+auxint. arg3=mem + {name: "MOVXzero", reg: gpstoreconst}, // store auxint 0 bytes into arg0 using a series of MOV instructions. arg1=mem. + // TODO: implement this when register clobbering works + {name: "REPSTOSQ", reg: regInfo{[]regMask{buildReg("DI"), buildReg("CX")}, buildReg("DI AX CX"), nil}}, // store arg1 8-byte words containing zero into arg0 using STOSQ. arg2=mem. + // Load/store from global. Same as the above loads, but arg0 is missing and // aux is a GlobalOffset instead of an int64. {name: "MOVQloadglobal"}, // Load from aux.(GlobalOffset). arg0 = memory diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 151e8e13e3..a6e6c93fc5 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -51,6 +51,7 @@ var genericOps = []opData{ {name: "Load"}, // Load from arg0. arg1=memory {name: "Store"}, // Store arg1 to arg0. arg2=memory. Returns memory. {name: "Move"}, // arg0=destptr, arg1=srcptr, arg2=mem, auxint=size. Returns memory. + {name: "Zero"}, // 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 diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 997522037c..a6fb0b06e2 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -98,6 +98,8 @@ const ( OpAMD64MOVLstore OpAMD64MOVQstore OpAMD64MOVQstoreidx8 + OpAMD64MOVXzero + OpAMD64REPSTOSQ OpAMD64MOVQloadglobal OpAMD64MOVQstoreglobal OpAMD64CALLstatic @@ -130,6 +132,7 @@ const ( OpLoad OpStore OpMove + OpZero OpClosureCall OpStaticCall OpConvert @@ -794,6 +797,28 @@ var opcodeTable = [...]opInfo{ outputs: []regMask{}, }, }, + { + name: "MOVXzero", + reg: regInfo{ + inputs: []regMask{ + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB + 0, + }, + clobbers: 0, + outputs: []regMask{}, + }, + }, + { + name: "REPSTOSQ", + reg: regInfo{ + inputs: []regMask{ + 128, // .DI + 2, // .CX + }, + clobbers: 131, // .AX .CX .DI + outputs: []regMask{}, + }, + }, { name: "MOVQloadglobal", reg: regInfo{ @@ -1091,6 +1116,15 @@ var opcodeTable = [...]opInfo{ }, generic: true, }, + { + name: "Zero", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, { name: "ClosureCall", reg: regInfo{ diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 599203c119..a781740b9b 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -1647,6 +1647,177 @@ func rewriteValueAMD64(v *Value, config *Config) bool { } goto ende6ef29f885a8ecf3058212bb95917323 ende6ef29f885a8ecf3058212bb95917323: + ; + case OpZero: + // match: (Zero [0] _ mem) + // cond: + // result: (Copy mem) + { + if v.AuxInt != 0 { + goto endb85a34a7d102b0e0d801454f437db5bf + } + mem := v.Args[1] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(mem) + return true + } + goto endb85a34a7d102b0e0d801454f437db5bf + endb85a34a7d102b0e0d801454f437db5bf: + ; + // match: (Zero [1] destptr mem) + // cond: + // result: (MOVBstore destptr (Const [0]) mem) + { + if v.AuxInt != 1 { + goto end09ec7b1fc5ad40534e0e25c896323f5c + } + destptr := v.Args[0] + mem := v.Args[1] + v.Op = OpAMD64MOVBstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(destptr) + v0 := v.Block.NewValue0(v.Line, OpConst, TypeInvalid) + v0.Type = TypeInt8 + v0.AuxInt = 0 + v.AddArg(v0) + v.AddArg(mem) + return true + } + goto end09ec7b1fc5ad40534e0e25c896323f5c + end09ec7b1fc5ad40534e0e25c896323f5c: + ; + // match: (Zero [2] destptr mem) + // cond: + // result: (MOVWstore destptr (Const [0]) mem) + { + if v.AuxInt != 2 { + goto end2dee246789dbd305bb1eaec768bdae14 + } + destptr := v.Args[0] + mem := v.Args[1] + v.Op = OpAMD64MOVWstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(destptr) + v0 := v.Block.NewValue0(v.Line, OpConst, TypeInvalid) + v0.Type = TypeInt16 + v0.AuxInt = 0 + v.AddArg(v0) + v.AddArg(mem) + return true + } + goto end2dee246789dbd305bb1eaec768bdae14 + end2dee246789dbd305bb1eaec768bdae14: + ; + // match: (Zero [4] destptr mem) + // cond: + // result: (MOVLstore destptr (Const [0]) mem) + { + if v.AuxInt != 4 { + goto ende2bf4ecf21bc9e76700a9c5f62546e78 + } + destptr := v.Args[0] + mem := v.Args[1] + v.Op = OpAMD64MOVLstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(destptr) + v0 := v.Block.NewValue0(v.Line, OpConst, TypeInvalid) + v0.Type = TypeInt32 + v0.AuxInt = 0 + v.AddArg(v0) + v.AddArg(mem) + return true + } + goto ende2bf4ecf21bc9e76700a9c5f62546e78 + ende2bf4ecf21bc9e76700a9c5f62546e78: + ; + // match: (Zero [8] destptr mem) + // cond: + // result: (MOVQstore destptr (Const [0]) mem) + { + if v.AuxInt != 8 { + goto enda65d5d60783daf9b9405f04c44f7adaf + } + destptr := v.Args[0] + mem := v.Args[1] + v.Op = OpAMD64MOVQstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(destptr) + v0 := v.Block.NewValue0(v.Line, OpConst, TypeInvalid) + v0.Type = TypeInt64 + v0.AuxInt = 0 + v.AddArg(v0) + v.AddArg(mem) + return true + } + goto enda65d5d60783daf9b9405f04c44f7adaf + enda65d5d60783daf9b9405f04c44f7adaf: + ; + // match: (Zero [size] destptr mem) + // cond: size < 4*8 + // result: (MOVXzero [size] destptr mem) + { + size := v.AuxInt + destptr := v.Args[0] + mem := v.Args[1] + if !(size < 4*8) { + goto endf0a22f1506977610ac0a310eee152075 + } + v.Op = OpAMD64MOVXzero + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = size + v.AddArg(destptr) + v.AddArg(mem) + return true + } + goto endf0a22f1506977610ac0a310eee152075 + endf0a22f1506977610ac0a310eee152075: + ; + // match: (Zero [size] destptr mem) + // cond: size >= 4*8 + // result: (Zero [size%8] (OffPtr [size-(size%8)] destptr) (REPSTOSQ destptr (Const [size/8]) mem)) + { + size := v.AuxInt + destptr := v.Args[0] + mem := v.Args[1] + if !(size >= 4*8) { + goto end7a358169d20d6834b21f2e03fbf351b2 + } + v.Op = OpZero + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = size % 8 + v0 := v.Block.NewValue0(v.Line, OpOffPtr, TypeInvalid) + v0.Type = TypeUInt64 + v0.AuxInt = size - (size % 8) + v0.AddArg(destptr) + v.AddArg(v0) + v1 := v.Block.NewValue0(v.Line, OpAMD64REPSTOSQ, TypeInvalid) + v1.Type = TypeMem + v1.AddArg(destptr) + v2 := v.Block.NewValue0(v.Line, OpConst, TypeInvalid) + v2.Type = TypeUInt64 + v2.AuxInt = size / 8 + v1.AddArg(v2) + v1.AddArg(mem) + v.AddArg(v1) + return true + } + goto end7a358169d20d6834b21f2e03fbf351b2 + end7a358169d20d6834b21f2e03fbf351b2: } return false } -- cgit v1.3 From 596ddf4368bcaac06d80a282bc968bc986d6bd7c Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Mon, 29 Jun 2015 11:56:28 -0700 Subject: [dev.ssa] cmd/compile/ssa: add checks for nil args in values These additional checks were useful in tracking down the broken build (CL 11238). This CL does not fix the build, sadly. Change-Id: I34de3bed223f450aaa97c1cadaba2e4e5850050b Reviewed-on: https://go-review.googlesource.com/11681 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 6 +++++- src/cmd/compile/internal/ssa/check.go | 6 ++++++ src/cmd/compile/internal/ssa/print.go | 4 +++- 3 files changed, 14 insertions(+), 2 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index d31d895f43..389d2868e8 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -599,7 +599,11 @@ func (s *state) addr(n *Node) *ssa.Value { return s.entryNewValue1A(ssa.OpAddr, Ptrto(n.Type), aux, s.sb) case PPARAM, PPARAMOUT, PAUTO: // parameter/result slot or local variable - return s.decladdrs[n] + v := s.decladdrs[n] + if v == nil { + s.Fatalf("addr of undeclared ONAME %v. declared: %v", n, s.decladdrs) + } + return v case PAUTO | PHEAP: return s.expr(n.Name.Heapaddr) default: diff --git a/src/cmd/compile/internal/ssa/check.go b/src/cmd/compile/internal/ssa/check.go index e889177841..a27e1bc653 100644 --- a/src/cmd/compile/internal/ssa/check.go +++ b/src/cmd/compile/internal/ssa/check.go @@ -92,6 +92,12 @@ func checkFunc(f *Func) { } for _, v := range b.Values { + 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()) } diff --git a/src/cmd/compile/internal/ssa/print.go b/src/cmd/compile/internal/ssa/print.go index 23fdbca7c4..286152a001 100644 --- a/src/cmd/compile/internal/ssa/print.go +++ b/src/cmd/compile/internal/ssa/print.go @@ -49,7 +49,9 @@ func fprintFunc(w io.Writer, f *Func) { continue } for _, w := range v.Args { - if w.Block == b && !printed[w.ID] { + // 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 } } -- cgit v1.3 From be2a3e2ac9de4a5f3587c3a4e150e700f0216347 Mon Sep 17 00:00:00 2001 From: Daniel Morsing Date: Wed, 1 Jul 2015 20:37:25 +0100 Subject: [dev.ssa] cmd/compile/internal/gc: mark unimplemented variable classes as such Doesn't fix the build entirely, but does make it get to the race detector tests. Change-Id: Ie986d52374936855b7ee975dc68742306527eb15 Reviewed-on: https://go-review.googlesource.com/11835 Reviewed-by: Josh Bleecher Snyder Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 6 ++++++ 1 file changed, 6 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 389d2868e8..1dba9b22a5 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -77,6 +77,12 @@ func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { case PAUTO: aux := &ssa.AutoSymbol{Typ: n.Type, Offset: -1, Sym: n.Sym} // offset TBD by SSA pass s.decladdrs[n] = s.entryNewValue1A(ssa.OpAddr, Ptrto(n.Type), aux, s.sp) + default: + str := "" + if n.Class&PHEAP != 0 { + str = ",heap" + } + s.Unimplementedf("local variable %v with class %s%s unimplemented", n, classnames[n.Class&^PHEAP], str) } } // nodfp is a special argument which is the function's FP. -- cgit v1.3 From 1edf4897df1000c240682ffa92fc4649c1c4bfb3 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Fri, 3 Jul 2015 20:29:11 -0700 Subject: [dev.ssa] cmd/compile/ssa: add Logf state helper Change-Id: I4e4200b0fa847a1ff8a8b7d1e318bbc1c5e26b5b Reviewed-on: https://go-review.googlesource.com/11874 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 1 + 1 file changed, 1 insertion(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 1dba9b22a5..5e254c265b 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -156,6 +156,7 @@ type state struct { line []int32 } +func (s *state) Logf(msg string, args ...interface{}) { s.config.Logf(msg, args...) } func (s *state) Fatalf(msg string, args ...interface{}) { s.config.Fatalf(msg, args...) } func (s *state) Unimplementedf(msg string, args ...interface{}) { s.config.Unimplementedf(msg, args...) } -- cgit v1.3 From 0a133cddd5f74760dac2171788cee29bada83ca7 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Fri, 3 Jul 2015 20:28:56 -0700 Subject: [dev.ssa] cmd/compile/ssa: mark race/nodfp as unimplemented Partly fixes the build, by punting. Other things have broken in the meantime. Change-Id: I1e2b8310057cbbbd9ffc501ef51e744690e00726 Reviewed-on: https://go-review.googlesource.com/11875 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 3 +++ 1 file changed, 3 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 5e254c265b..9ad2890003 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -608,6 +608,9 @@ func (s *state) addr(n *Node) *ssa.Value { // parameter/result slot or local variable v := s.decladdrs[n] if v == nil { + if flag_race != 0 && n.String() == ".fp" { + s.Unimplementedf("race detector mishandles nodfp") + } s.Fatalf("addr of undeclared ONAME %v. declared: %v", n, s.decladdrs) } return v -- cgit v1.3 From d465f049cd364c3e445fe189ae0fac0dffda2a67 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Sat, 4 Jul 2015 13:01:04 -0700 Subject: [dev.ssa] cmd/compile/ssa: stop compilation immediately on leading goto There is clearly work to do to fix labels and gotos. The compiler currently hangs on ken/label.go. For the moment, stop the bleeding. Fixes the build. Change-Id: Ib68360d583cf53e1a8ca4acff50644b570382728 Reviewed-on: https://go-review.googlesource.com/11877 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 1 + 1 file changed, 1 insertion(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 9ad2890003..b21b4137dc 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -330,6 +330,7 @@ func (s *state) stmt(n *Node) { } if n.Op == OGOTO && s.curBlock == nil { s.Unimplementedf("goto at start of function; see test/goto.go") + panic("stop compiling here, on pain of infinite loops") } case OAS, OASWB: -- cgit v1.3 From 6c14059e65b180e3aaf34774b67ddffa461cf3c2 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Sat, 4 Jul 2015 09:07:54 -0700 Subject: [dev.ssa] cmd/compile/ssa: handle loops that don't loop Loops such as func f(c chan int) int { for x := range c { return x } return 0 } don't loop. Remove the assumption that they must. Partly fixes the build. Change-Id: I766cebeec8e36d14512bea26f54c06c8eaf95e23 Reviewed-on: https://go-review.googlesource.com/11876 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index b21b4137dc..14c39d337f 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -409,8 +409,11 @@ func (s *state) stmt(n *Node) { s.stmt(n.Right) } b = s.endBlock() - addEdge(b, bCond) - + // If the body ends in a return statement, + // the condition check and loop are unreachable. + if b != nil { + addEdge(b, bCond) + } s.startBlock(bEnd) case OCALLFUNC: -- cgit v1.3 From cc3f031a319195928e2dbf2b65bff59e8d9226ca Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Fri, 3 Jul 2015 18:41:28 -0700 Subject: [dev.ssa] cmd/compile/ssa: implement OLEN Change-Id: Ie23b13142fd820d7071a348a8370175e58b76d64 Reviewed-on: https://go-review.googlesource.com/11878 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 10 ++++++++++ 1 file changed, 10 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 14c39d337f..1be5f0cb85 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -521,6 +521,16 @@ func (s *state) expr(n *Node) *ssa.Value { return s.newValue2(ssa.OpLoad, n.Left.Type.Type, p, s.mem()) } + case OLEN: + switch { + case n.Left.Type.Bound < 0: // slice + return s.newValue1(ssa.OpSliceLen, s.config.Uintptr, s.expr(n.Left)) + case n.Left.Type.IsString(): // string + return s.newValue1(ssa.OpStringLen, s.config.Uintptr, s.expr(n.Left)) + default: // array + return s.constInt(s.config.Uintptr, n.Left.Type.Bound) + } + case OCALLFUNC: static := n.Left.Op == ONAME && n.Left.Class == PFUNC -- cgit v1.3 From 7d10a2c04a28ac09448a3a890141a56870f86232 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Mon, 6 Jul 2015 14:13:17 -0700 Subject: [dev.ssa] cmd/compile/ssa: implement constant booleans The removal of if false { ... } blocks in the opt pass exposed that removePredecessor needed to do more cleaning, on pain of failing later consistency checks. Change-Id: I45d4ff7e1f7f1486fdd99f867867ce6ea006a288 Reviewed-on: https://go-review.googlesource.com/11879 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 2 +- src/cmd/compile/internal/ssa/deadcode.go | 69 +++++++++++++++----------- src/cmd/compile/internal/ssa/gen/rulegen.go | 2 +- src/cmd/compile/internal/ssa/nilcheck.go | 2 +- src/cmd/compile/internal/ssa/rewritegeneric.go | 4 +- 5 files changed, 46 insertions(+), 33 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 1be5f0cb85..866db610b8 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -464,7 +464,7 @@ func (s *state) expr(n *Node) *ssa.Value { switch n.Val().Ctype() { case CTINT: return s.constInt(n.Type, Mpgetfix(n.Val().U.(*Mpint))) - case CTSTR: + case CTSTR, CTBOOL: return s.entryNewValue0A(ssa.OpConst, n.Type, n.Val().U) default: s.Unimplementedf("unhandled OLITERAL %v", n.Val().Ctype()) diff --git a/src/cmd/compile/internal/ssa/deadcode.go b/src/cmd/compile/internal/ssa/deadcode.go index 48d6fd6938..a5d0fe0f34 100644 --- a/src/cmd/compile/internal/ssa/deadcode.go +++ b/src/cmd/compile/internal/ssa/deadcode.go @@ -98,38 +98,51 @@ func deadcode(f *Func) { // There was an edge b->c. It has been removed from b's successors. // Fix up c to handle that fact. -func removePredecessor(b, c *Block) { - n := len(c.Preds) - 1 - if n == 0 { - // c is now dead - don't bother working on it - if c.Preds[0] != b { - b.Fatalf("%s.Preds[0]==%s, want %s", c, c.Preds[0], b) - } - return - } +func (f *Func) removePredecessor(b, c *Block) { + work := [][2]*Block{{b, c}} + + for len(work) > 0 { + b, c := work[0][0], work[0][1] + work = work[1:] + + n := len(c.Preds) - 1 - // find index of b in c's predecessor list - var i int - for j, p := range c.Preds { - if p == b { - i = j - break + // find index of b in c's predecessor list + var i int + for j, p := range c.Preds { + if p == b { + i = j + break + } } - } - c.Preds[i] = c.Preds[n] - c.Preds[n] = nil // aid GC - c.Preds = c.Preds[:n] - // rewrite phi ops to match the new predecessor list - for _, v := range c.Values { - if v.Op != OpPhi { - continue + c.Preds[i] = c.Preds[n] + c.Preds[n] = nil // aid GC + c.Preds = c.Preds[:n] + + // rewrite phi ops to match the new predecessor list + for _, v := range c.Values { + if v.Op != OpPhi { + continue + } + v.Args[i] = v.Args[n] + v.Args[n] = nil // aid GC + v.Args = v.Args[:n] + if n == 1 { + v.Op = OpCopy + } } - v.Args[i] = v.Args[n] - v.Args[n] = nil // aid GC - v.Args = v.Args[:n] - if n == 1 { - v.Op = OpCopy + + if n == 0 { + // c is now dead--recycle its values + for _, v := range c.Values { + f.vid.put(v.ID) + } + c.Values = nil + // Also kill any successors of c now, to spare later processing. + for _, succ := range c.Succs { + work = append(work, [2]*Block{c, succ}) + } } } } diff --git a/src/cmd/compile/internal/ssa/gen/rulegen.go b/src/cmd/compile/internal/ssa/gen/rulegen.go index 1a4b2c1b85..46e0e507c4 100644 --- a/src/cmd/compile/internal/ssa/gen/rulegen.go +++ b/src/cmd/compile/internal/ssa/gen/rulegen.go @@ -232,7 +232,7 @@ func genRules(arch arch) { // Modify predecessor lists for no-longer-reachable blocks for succ := range m { - fmt.Fprintf(w, "removePredecessor(b, %s)\n", succ) + fmt.Fprintf(w, "v.Block.Func.removePredecessor(b, %s)\n", succ) } fmt.Fprintf(w, "b.Kind = %s\n", blockName(t[0], arch)) diff --git a/src/cmd/compile/internal/ssa/nilcheck.go b/src/cmd/compile/internal/ssa/nilcheck.go index 1265ee9971..d24340e630 100644 --- a/src/cmd/compile/internal/ssa/nilcheck.go +++ b/src/cmd/compile/internal/ssa/nilcheck.go @@ -46,7 +46,7 @@ func nilcheckelim(f *Func) { // and the fuse pass will join this block with its successor. b.Kind = BlockPlain b.Control = nil - removePredecessor(b, b.Succs[1]) + f.removePredecessor(b, b.Succs[1]) b.Succs = b.Succs[:1] } } diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index e2feeb53cc..78cb2c8ebb 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -403,7 +403,7 @@ func rewriteBlockgeneric(b *Block) bool { if !(c.(bool)) { goto end915e334b6388fed7d63e09aa69ecb05c } - removePredecessor(b, no) + v.Block.Func.removePredecessor(b, no) b.Kind = BlockPlain b.Control = nil b.Succs = b.Succs[:1] @@ -427,7 +427,7 @@ func rewriteBlockgeneric(b *Block) bool { if !(!c.(bool)) { goto end6452ee3a5bb02c708bddc3181c3ea3cb } - removePredecessor(b, yes) + v.Block.Func.removePredecessor(b, yes) b.Kind = BlockPlain b.Control = nil b.Succs = b.Succs[:1] -- cgit v1.3 From 41dafe6ecc358f294e0e91b739b352858d0c01b4 Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Thu, 25 Jun 2015 23:13:57 -0500 Subject: [dev.ssa] cmd/compile/ssa: dominator tests and benchmarks This change has some tests verifying functionality and an assortment of benchmarks of various block lists. It modifies NewBlock to allocate in contiguous blocks improving the performance of intersect() for extremely large graphs by 30-40%. benchmark old ns/op new ns/op delta BenchmarkDominatorsLinear-8 1185619 901154 -23.99% BenchmarkDominatorsFwdBack-8 1302138 863537 -33.68% BenchmarkDominatorsManyPred-8 404670521 247450911 -38.85% BenchmarkDominatorsMaxPred-8 455809002 471675119 +3.48% BenchmarkDominatorsMaxPredVal-8 819315864 468257300 -42.85% BenchmarkNilCheckDeep1-8 766 706 -7.83% BenchmarkNilCheckDeep10-8 2553 2209 -13.47% BenchmarkNilCheckDeep100-8 58606 57545 -1.81% BenchmarkNilCheckDeep1000-8 7753012 8025750 +3.52% BenchmarkNilCheckDeep10000-8 1224165946 789995184 -35.47% Change-Id: Id3d6bc9cb1138e8177934441073ac7873ddf7ade Reviewed-on: https://go-review.googlesource.com/11716 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/dom.go | 1 - src/cmd/compile/internal/ssa/dom_test.go | 321 +++++++++++++++++++++++++++++++ src/cmd/compile/internal/ssa/func.go | 37 +++- 3 files changed, 353 insertions(+), 6 deletions(-) create mode 100644 src/cmd/compile/internal/ssa/dom_test.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/dom.go b/src/cmd/compile/internal/ssa/dom.go index 6f700ec7e9..b4d47c1350 100644 --- a/src/cmd/compile/internal/ssa/dom.go +++ b/src/cmd/compile/internal/ssa/dom.go @@ -55,7 +55,6 @@ func postorder(f *Func) []*Block { // 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 { - // TODO: Benchmarks. See BenchmarkNilCheckDeep* for an example. // A simple algorithm for now // Cooper, Harvey, Kennedy 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 0000000000..3197a5cc0e --- /dev/null +++ b/src/cmd/compile/internal/ssa/dom_test.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. + +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", OpArg, TypeMem, 0, ".mem"), + 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", OpArg, TypeMem, 0, ".mem"), + Valu("p", OpConst, TypeBool, 0, true), + 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", OpArg, TypeMem, 0, ".mem"), + Valu("p", OpConst, TypeBool, 0, true), + 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", OpConst, TypeBool, 0, true), + Goto(blockn(i+1)))) + case 1: + blocs = append(blocs, Bloc(blockn(i), + Valu("a", OpConst, TypeBool, 0, true), + If("p", blockn(i+1), blockn(0)))) + case 2: + blocs = append(blocs, Bloc(blockn(i), + Valu("a", OpConst, TypeBool, 0, true), + 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", OpArg, TypeMem, 0, ".mem"), + Valu("p", OpConst, TypeBool, 0, true), + 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", OpArg, TypeMem, 0, ".mem"), + Valu("p", OpConst, TypeBool, 0, true), + Goto(blockn(0)), + ), + ) + + for i := 0; i < size; i++ { + blocs = append(blocs, Bloc(blockn(i), + Valu("a", OpConst, TypeBool, 0, true), + 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}) + 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) + } +} + +func verifyDominators(t *testing.T, f fun, doms map[string]string) { + blockNames := map[*Block]string{} + for n, b := range f.blocks { + blockNames[b] = n + } + + calcDom := dominators(f.f) + + for n, d := range doms { + nblk, ok := f.blocks[n] + if !ok { + t.Errorf("invalid block name %s", n) + } + dblk, ok := f.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 f.blocks { + if int(b.ID) == id { + t.Errorf("unexpected dominator of %s for %s", blockNames[d], blockNames[b]) + } + } + } + +} + +func TestDominatorsSimple(t *testing.T) { + c := NewConfig("amd64", DummyFrontend{t}) + fun := Fun(c, "entry", + Bloc("entry", + Valu("mem", OpArg, TypeMem, 0, ".mem"), + 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", + } + + verifyDominators(t, fun, doms) + +} + +func TestDominatorsMultPredFwd(t *testing.T) { + c := NewConfig("amd64", DummyFrontend{t}) + fun := Fun(c, "entry", + Bloc("entry", + Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("p", OpConst, TypeBool, 0, true), + 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", + } + + verifyDominators(t, fun, doms) + +} + +func TestDominatorsMultPredRev(t *testing.T) { + c := NewConfig("amd64", DummyFrontend{t}) + fun := Fun(c, "entry", + Bloc("entry", + Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("p", OpConst, TypeBool, 0, true), + Goto("a")), + Bloc("a", + If("p", "b", "entry")), + Bloc("b", + Goto("c")), + Bloc("c", + If("p", "exit", "b")), + Bloc("exit", + Exit("mem"))) + + doms := map[string]string{ + "a": "entry", + "b": "a", + "c": "b", + "exit": "c", + } + verifyDominators(t, fun, doms) +} + +func TestDominatorsMultPred(t *testing.T) { + c := NewConfig("amd64", DummyFrontend{t}) + fun := Fun(c, "entry", + Bloc("entry", + Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("p", OpConst, TypeBool, 0, true), + 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", + } + verifyDominators(t, fun, doms) +} diff --git a/src/cmd/compile/internal/ssa/func.go b/src/cmd/compile/internal/ssa/func.go index f746861050..bd2b74c151 100644 --- a/src/cmd/compile/internal/ssa/func.go +++ b/src/cmd/compile/internal/ssa/func.go @@ -4,6 +4,8 @@ package ssa +import "sync" + // A Func represents a Go func declaration (or function literal) and // its body. This package compiles each Func independently. type Func struct { @@ -31,13 +33,38 @@ func (f *Func) NumValues() int { return f.vid.num() } +const ( + blockSize = 100 +) + +// blockPool provides a contiguous array of Blocks which +// improves the speed of traversing dominator trees. +type blockPool struct { + blocks []Block + mu sync.Mutex +} + +func (bp *blockPool) newBlock() *Block { + bp.mu.Lock() + defer bp.mu.Unlock() + + if len(bp.blocks) <= 0 { + bp.blocks = make([]Block, blockSize, blockSize) + } + + res := &bp.blocks[0] + bp.blocks = bp.blocks[1:] + return res +} + +var bp blockPool + // NewBlock returns a new block of the given kind and appends it to f.Blocks. func (f *Func) NewBlock(kind BlockKind) *Block { - b := &Block{ - ID: f.bid.get(), - Kind: kind, - Func: f, - } + b := bp.newBlock() + b.ID = f.bid.get() + b.Kind = kind + b.Func = f f.Blocks = append(f.Blocks, b) return b } -- cgit v1.3 From 517386832582a54e6b4170252e52f1a13c001e83 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Mon, 6 Jul 2015 15:29:39 -0700 Subject: [dev.ssa] cmd/compile/ssa: place for loop incr in a separate block This is a prerequisite for implementing break and continue; blocks ending in break or continue need to have the increment block as a successor. While we're here, implement for loops with no condition. Change-Id: I85d8ba020628d805bfd0bd583dfd16e1be6f6fae Reviewed-on: https://go-review.googlesource.com/11941 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 26 ++++++++++++++++---------- 1 file changed, 16 insertions(+), 10 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 866db610b8..96ae49a179 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -379,8 +379,10 @@ func (s *state) stmt(n *Node) { addEdge(b, s.exit) 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 @@ -388,13 +390,14 @@ func (s *state) stmt(n *Node) { addEdge(b, bCond) // generate code to test condition - // TODO(khr): Left == nil exception - if n.Left == nil { - s.Unimplementedf("cond n.Left == nil: %v", n) - } s.startBlock(bCond) - s.stmtList(n.Left.Ninit) - cond := s.expr(n.Left) + var cond *ssa.Value + if n.Left != nil { + s.stmtList(n.Left.Ninit) + cond = s.expr(n.Left) + } else { + cond = s.entryNewValue0A(ssa.OpConst, Types[TBOOL], true) + } b = s.endBlock() b.Kind = ssa.BlockIf b.Control = cond @@ -405,13 +408,16 @@ func (s *state) stmt(n *Node) { // generate body s.startBlock(bBody) s.stmtList(n.Nbody) + if b := s.endBlock(); b != nil { + addEdge(b, bIncr) + } + + // generate incr + s.startBlock(bIncr) if n.Right != nil { s.stmt(n.Right) } - b = s.endBlock() - // If the body ends in a return statement, - // the condition check and loop are unreachable. - if b != nil { + if b := s.endBlock(); b != nil { addEdge(b, bCond) } s.startBlock(bEnd) -- cgit v1.3 From 9201c86b57b9dcbf3da09028a17be00263762967 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Fri, 10 Jul 2015 09:31:28 -0600 Subject: [dev.ssa] cmd/compile/ssa: print lazily Reduces 'go run run.go 64bit.go' from 23s to 8s on my machine. Change-Id: Ie5b642d0abb56e8eb3899d69472bc88a85a1c985 Reviewed-on: https://go-review.googlesource.com/12023 Reviewed-by: Brad Fitzpatrick --- src/cmd/compile/internal/ssa/print.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/print.go b/src/cmd/compile/internal/ssa/print.go index 286152a001..14d88dccd5 100644 --- a/src/cmd/compile/internal/ssa/print.go +++ b/src/cmd/compile/internal/ssa/print.go @@ -11,7 +11,7 @@ import ( ) func printFunc(f *Func) { - f.Logf("%s", f.String()) + f.Logf("%s", f) } func (f *Func) String() string { -- cgit v1.3 From 9b048527db4122732795211291a02357d995c898 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Thu, 9 Jul 2015 21:24:12 -0600 Subject: [dev.ssa] cmd/compile/ssa: handle nested dead blocks removePredecessor can change which blocks are live. However, it cannot remove dead blocks from the function's slice of blocks because removePredecessor may have been called from within a function doing a walk of the blocks. CL 11879 did not handle this correctly and broke the build. To fix this, mark the block as dead but leave its actual removal for a deadcode pass. Blocks that are dead must have no successors, predecessors, values, or control values, so they will generally be ignored by other passes. To be safe, we add a deadcode pass after the opt pass, which is the only other pass that calls removePredecessor. Two alternatives that I considered and discarded: (1) Make all call sites aware of the fact that removePrecessor might make arbitrary changes to the list of blocks. This will needlessly complicate callers. (2) Handle the things that can go wrong in practice when we encounter a dead-but-not-removed block. CL 11930 takes this approach (and the tests are stolen from that CL). However, this is just patching over the problem. Change-Id: Icf0687b0a8148ce5e96b2988b668804411b05bd8 Reviewed-on: https://go-review.googlesource.com/12004 Reviewed-by: Todd Neal Reviewed-by: Michael Matloob --- src/cmd/compile/internal/ssa/check.go | 13 +++++++++ src/cmd/compile/internal/ssa/compile.go | 1 + src/cmd/compile/internal/ssa/deadcode.go | 8 ++++-- src/cmd/compile/internal/ssa/deadcode_test.go | 39 ++++++++++++++++++++++++++ src/cmd/compile/internal/ssa/gen/genericOps.go | 1 + src/cmd/compile/internal/ssa/opGen.go | 2 ++ src/cmd/compile/internal/ssa/rewrite.go | 3 ++ 7 files changed, 64 insertions(+), 3 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/check.go b/src/cmd/compile/internal/ssa/check.go index a27e1bc653..4fe59e08d1 100644 --- a/src/cmd/compile/internal/ssa/check.go +++ b/src/cmd/compile/internal/ssa/check.go @@ -59,6 +59,19 @@ func checkFunc(f *Func) { if !b.Control.Type.IsMemory() { f.Fatalf("exit block %s has non-memory control value %s", b, b.Control.LongString()) } + 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)) diff --git a/src/cmd/compile/internal/ssa/compile.go b/src/cmd/compile/internal/ssa/compile.go index b02c10a745..4a6c2a9404 100644 --- a/src/cmd/compile/internal/ssa/compile.go +++ b/src/cmd/compile/internal/ssa/compile.go @@ -51,6 +51,7 @@ var passes = [...]pass{ {"phielim", phielim}, {"copyelim", copyelim}, {"opt", opt}, + {"opt deadcode", deadcode}, // remove any blocks orphaned during opt {"generic cse", cse}, {"nilcheckelim", nilcheckelim}, {"generic deadcode", deadcode}, diff --git a/src/cmd/compile/internal/ssa/deadcode.go b/src/cmd/compile/internal/ssa/deadcode.go index a5d0fe0f34..2be7b8ebaf 100644 --- a/src/cmd/compile/internal/ssa/deadcode.go +++ b/src/cmd/compile/internal/ssa/deadcode.go @@ -96,7 +96,7 @@ func deadcode(f *Func) { // TODO: save dead Values and Blocks for reuse? Or should we just let GC handle it? } -// There was an edge b->c. It has been removed from b's successors. +// There was an edge b->c. c has been removed from b's successors. // Fix up c to handle that fact. func (f *Func) removePredecessor(b, c *Block) { work := [][2]*Block{{b, c}} @@ -105,8 +105,6 @@ func (f *Func) removePredecessor(b, c *Block) { b, c := work[0][0], work[0][1] work = work[1:] - n := len(c.Preds) - 1 - // find index of b in c's predecessor list var i int for j, p := range c.Preds { @@ -116,6 +114,7 @@ func (f *Func) removePredecessor(b, c *Block) { } } + n := len(c.Preds) - 1 c.Preds[i] = c.Preds[n] c.Preds[n] = nil // aid GC c.Preds = c.Preds[:n] @@ -143,6 +142,9 @@ func (f *Func) removePredecessor(b, c *Block) { for _, succ := range c.Succs { work = append(work, [2]*Block{c, succ}) } + c.Succs = nil + c.Kind = BlockDead + c.Control = nil } } } diff --git a/src/cmd/compile/internal/ssa/deadcode_test.go b/src/cmd/compile/internal/ssa/deadcode_test.go index ff9e6800da..c63b8e4106 100644 --- a/src/cmd/compile/internal/ssa/deadcode_test.go +++ b/src/cmd/compile/internal/ssa/deadcode_test.go @@ -93,3 +93,42 @@ func TestNeverTaken(t *testing.T) { } } + +func TestNestedDeadBlocks(t *testing.T) { + c := NewConfig("amd64", DummyFrontend{t}) + fun := Fun(c, "entry", + Bloc("entry", + Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("cond", OpConst, TypeBool, 0, false), + 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/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index a6e6c93fc5..c410cc4f02 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -105,6 +105,7 @@ var genericOps = []opData{ var genericBlocks = []blockData{ {name: "Exit"}, // no successors. There should only be 1 of these. + {name: "Dead"}, // no successors; determined to be dead but not yet removed {name: "Plain"}, // a single successor {name: "If"}, // 2 successors, if control goto Succs[0] else goto Succs[1] {name: "Call"}, // 2 successors, normal return and panic diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index a6fb0b06e2..3769cfeb86 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -19,6 +19,7 @@ const ( BlockAMD64UGE BlockExit + BlockDead BlockPlain BlockIf BlockCall @@ -39,6 +40,7 @@ var blockString = [...]string{ BlockAMD64UGE: "UGE", BlockExit: "Exit", + BlockDead: "Dead", BlockPlain: "Plain", BlockIf: "If", BlockCall: "Call", diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go index b2c45969e4..306fe1274e 100644 --- a/src/cmd/compile/internal/ssa/rewrite.go +++ b/src/cmd/compile/internal/ssa/rewrite.go @@ -23,6 +23,9 @@ func applyRewrite(f *Func, rb func(*Block) bool, rv func(*Value, *Config) bool) 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] -- cgit v1.3 From 06f329220f63dab5f09cdef8bfd42bd6dc6c3a68 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Sat, 11 Jul 2015 11:39:12 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: Use Ninit from expressions If an expression has an Ninit list, generate code for it. Required for (at least) OANDAND. Change-Id: I94c9e22e2a76955736f4a8e574d92711419c5e5c Reviewed-on: https://go-review.googlesource.com/12072 Reviewed-by: Brad Fitzpatrick --- src/cmd/compile/internal/gc/ssa.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 96ae49a179..ab16a33510 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -393,7 +393,6 @@ func (s *state) stmt(n *Node) { s.startBlock(bCond) var cond *ssa.Value if n.Left != nil { - s.stmtList(n.Left.Ninit) cond = s.expr(n.Left) } else { cond = s.entryNewValue0A(ssa.OpConst, Types[TBOOL], true) @@ -453,6 +452,7 @@ func (s *state) expr(n *Node) *ssa.Value { s.pushLine(n.Lineno) defer s.popLine() + s.stmtList(n.Ninit) switch n.Op { case ONAME: if n.Class == PFUNC { -- cgit v1.3 From 7a982e3c49c4fc16c2d51bf6e892cb2dd19405be Mon Sep 17 00:00:00 2001 From: ALTree Date: Sat, 11 Jul 2015 16:30:24 +0200 Subject: [dev.ssa] cmd/compile/ssa: Replace less-or-equal with equal in len comparison with zero Since the spec guarantees than 0 <= len always: https://golang.org/ref/spec#Length_and_capacity replace len(...) <= 0 check with len(...) == 0 check Change-Id: I5517a9cb6b190f0b1ee314a67487477435f3b409 Reviewed-on: https://go-review.googlesource.com/12034 Reviewed-by: Brad Fitzpatrick --- src/cmd/compile/internal/ssa/func.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/func.go b/src/cmd/compile/internal/ssa/func.go index bd2b74c151..34d2780104 100644 --- a/src/cmd/compile/internal/ssa/func.go +++ b/src/cmd/compile/internal/ssa/func.go @@ -48,7 +48,7 @@ func (bp *blockPool) newBlock() *Block { bp.mu.Lock() defer bp.mu.Unlock() - if len(bp.blocks) <= 0 { + if len(bp.blocks) == 0 { bp.blocks = make([]Block, blockSize, blockSize) } -- cgit v1.3 From 050ce4390aa16b03e7272e22e79de165589319b5 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Sat, 11 Jul 2015 14:41:22 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: Phi inputs from dead blocks are not live Fixes #11676 Change-Id: I941f951633c89bb1454ce6d1d1b4124d46a7d9dd Reviewed-on: https://go-review.googlesource.com/12091 Reviewed-by: Brad Fitzpatrick --- src/cmd/compile/internal/ssa/deadcode.go | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/deadcode.go b/src/cmd/compile/internal/ssa/deadcode.go index 2be7b8ebaf..1b1ae27e58 100644 --- a/src/cmd/compile/internal/ssa/deadcode.go +++ b/src/cmd/compile/internal/ssa/deadcode.go @@ -44,7 +44,10 @@ func deadcode(f *Func) { // pop a reachable value v := q[len(q)-1] q = q[:len(q)-1] - for _, x := range v.Args { + 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 -- cgit v1.3 From 7af53d98cf720b97f9f941b6747405c5a924eb55 Mon Sep 17 00:00:00 2001 From: Brad Fitzpatrick Date: Fri, 10 Jul 2015 10:47:28 -0600 Subject: [dev.ssa] cmd/compile: implement OCAP And dependent fixes and misc cleanup. Co-hacking with josharian at Gophercon. Change-Id: Ib85dc13b303929017eb0a4d2fc2f603485f7479b Reviewed-on: https://go-review.googlesource.com/12027 Reviewed-by: Keith Randall Run-TryBot: Brad Fitzpatrick --- src/cmd/compile/internal/gc/go.go | 2 +- src/cmd/compile/internal/gc/ssa.go | 35 ++++++++++++++++++++-------------- src/cmd/compile/internal/gc/type.go | 4 ++++ src/cmd/compile/internal/ssa/config.go | 11 +++++++---- 4 files changed, 33 insertions(+), 19 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/go.go b/src/cmd/compile/internal/gc/go.go index 0aa0e289ec..fabe325c38 100644 --- a/src/cmd/compile/internal/gc/go.go +++ b/src/cmd/compile/internal/gc/go.go @@ -199,7 +199,7 @@ type Type struct { 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 diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index ab16a33510..90c1e0a25e 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -6,6 +6,7 @@ package gc import ( "fmt" + "strings" "cmd/compile/internal/ssa" "cmd/internal/obj" @@ -18,7 +19,7 @@ import ( // it will never return nil, and the bool can be removed. func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { name := fn.Func.Nname.Sym.Name - usessa = len(name) > 4 && name[len(name)-4:] == "_ssa" + usessa = strings.HasSuffix(name, "_ssa") if usessa { dumplist("buildssa-enter", fn.Func.Enter) @@ -293,6 +294,8 @@ func (s *state) stmt(n *Node) { case OBLOCK: s.stmtList(n.List) + case OEMPTY: + case ODCL: if n.Left.Class&PHEAP == 0 { return @@ -527,14 +530,18 @@ func (s *state) expr(n *Node) *ssa.Value { return s.newValue2(ssa.OpLoad, n.Left.Type.Type, p, s.mem()) } - case OLEN: + case OLEN, OCAP: switch { - case n.Left.Type.Bound < 0: // slice - return s.newValue1(ssa.OpSliceLen, s.config.Uintptr, s.expr(n.Left)) - case n.Left.Type.IsString(): // string - return s.newValue1(ssa.OpStringLen, s.config.Uintptr, s.expr(n.Left)) + case n.Left.Type.IsSlice(): + op := ssa.OpSliceLen + if n.Op == OCAP { + op = ssa.OpSliceCap + } + return s.newValue1(op, s.config.Int, s.expr(n.Left)) + case n.Left.Type.IsString(): // string; not reachable for OCAP + return s.newValue1(ssa.OpStringLen, s.config.Int, s.expr(n.Left)) default: // array - return s.constInt(s.config.Uintptr, n.Left.Type.Bound) + return s.constInt(s.config.Int, n.Left.Type.Bound) } case OCALLFUNC: @@ -645,19 +652,19 @@ func (s *state) addr(n *Node) *ssa.Value { // used for storing/loading arguments/returns to/from callees return s.entryNewValue1I(ssa.OpOffPtr, Ptrto(n.Type), n.Xoffset, s.sp) case OINDEX: - if n.Left.Type.Bound >= 0 { // array - a := s.addr(n.Left) - i := s.expr(n.Right) - len := s.constInt(s.config.Uintptr, n.Left.Type.Bound) - s.boundsCheck(i, len) - return s.newValue2(ssa.OpPtrIndex, Ptrto(n.Left.Type.Type), a, i) - } else { // slice + if n.Left.Type.IsSlice() { a := s.expr(n.Left) i := s.expr(n.Right) len := s.newValue1(ssa.OpSliceLen, s.config.Uintptr, a) s.boundsCheck(i, len) p := s.newValue1(ssa.OpSlicePtr, Ptrto(n.Left.Type.Type), a) return s.newValue2(ssa.OpPtrIndex, Ptrto(n.Left.Type.Type), p, i) + } else { // array + a := s.addr(n.Left) + i := s.expr(n.Right) + len := s.constInt(s.config.Uintptr, n.Left.Type.Bound) + s.boundsCheck(i, len) + return s.newValue2(ssa.OpPtrIndex, Ptrto(n.Left.Type.Type), a, i) } default: s.Unimplementedf("addr: bad op %v", Oconv(int(n.Op), 0)) diff --git a/src/cmd/compile/internal/gc/type.go b/src/cmd/compile/internal/gc/type.go index 11635d8929..7f7b6635e0 100644 --- a/src/cmd/compile/internal/gc/type.go +++ b/src/cmd/compile/internal/gc/type.go @@ -64,6 +64,10 @@ func (t *Type) IsString() bool { return t.Etype == TSTRING } +func (t *Type) IsSlice() bool { + return t.Etype == TARRAY && t.Bound < 0 +} + func (t *Type) Elem() ssa.Type { return t.Type } diff --git a/src/cmd/compile/internal/ssa/config.go b/src/cmd/compile/internal/ssa/config.go index 53eb5e8eb5..c6c7bf36e9 100644 --- a/src/cmd/compile/internal/ssa/config.go +++ b/src/cmd/compile/internal/ssa/config.go @@ -5,9 +5,10 @@ package ssa type Config struct { - arch string // "amd64", etc. - ptrSize int64 // 4 or 8 - Uintptr Type // pointer arithmetic type + arch string // "amd64", etc. + ptrSize int64 // 4 or 8 + Uintptr Type // pointer arithmetic type + Int Type lowerBlock func(*Block) bool // lowering function lowerValue func(*Value, *Config) bool // lowering function fe Frontend // callbacks into compiler frontend @@ -48,10 +49,12 @@ func NewConfig(arch string, fe Frontend) *Config { fe.Unimplementedf("arch %s not implemented", arch) } - // cache the intptr type in the config + // cache the frequently-used types in the config c.Uintptr = TypeUInt32 + c.Int = TypeInt32 if c.ptrSize == 8 { c.Uintptr = TypeUInt64 + c.Int = TypeInt64 } return c -- cgit v1.3 From d9c72d739c87538b0854e26e6d73470784f6ea3e Mon Sep 17 00:00:00 2001 From: Brad Fitzpatrick Date: Fri, 10 Jul 2015 11:25:48 -0600 Subject: [dev.ssa] cmd/compile: implement ONOT Co-hacking with josharian at Gophercon. Change-Id: Ia59dfab676c6ed598c2c25483439cd1395a4ea87 Reviewed-on: https://go-review.googlesource.com/12029 Reviewed-by: Keith Randall Run-TryBot: Brad Fitzpatrick --- src/cmd/compile/internal/gc/ssa.go | 11 ++++++++ src/cmd/compile/internal/ssa/gen/AMD64.rules | 3 ++ src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 3 +- src/cmd/compile/internal/ssa/gen/genericOps.go | 3 ++ src/cmd/compile/internal/ssa/opGen.go | 24 ++++++++++++++++ src/cmd/compile/internal/ssa/rewriteAMD64.go | 39 ++++++++++++++++++++++++++ 6 files changed, 82 insertions(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 90c1e0a25e..cff1ea71dc 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -496,6 +496,11 @@ func (s *state) expr(n *Node) *ssa.Value { b := s.expr(n.Right) return s.newValue2(binOpToSSA[n.Op], a.Type, a, b) + // unary ops + case ONOT: + a := s.expr(n.Left) + return s.newValue1(ssa.OpNot, a.Type, a) + case OADDR: return s.addr(n.Left) @@ -1185,6 +1190,12 @@ func genValue(v *ssa.Value) { p := Prog(obj.ACALL) p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v.Args[0]) + case ssa.OpAMD64XORQconst: + p := Prog(x86.AXORQ) + p.From.Type = obj.TYPE_CONST + p.From.Offset = v.AuxInt + p.To.Type = obj.TYPE_REG + p.To.Reg = regnum(v.Args[0]) case ssa.OpSP, ssa.OpSB: // nothing to do default: diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index d03da723b7..02b68b2e3c 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -62,6 +62,7 @@ (Store ptr val mem) && is32BitInt(val.Type) -> (MOVLstore ptr val mem) (Store ptr val mem) && is16BitInt(val.Type) -> (MOVWstore ptr val mem) (Store ptr val mem) && is8BitInt(val.Type) -> (MOVBstore ptr val mem) +(Store ptr val mem) && val.Type.IsBoolean() -> (MOVBstore ptr val mem) // checks (IsNonNil p) -> (SETNE (TESTQ p p)) @@ -69,6 +70,8 @@ (Move [size] dst src mem) -> (REPMOVSB dst src (Const [size]) mem) +(Not x) -> (XORQconst [1] x) + (OffPtr [off] ptr) -> (ADDQconst [off] ptr) (Const [val]) && t.IsInteger() -> (MOVQconst [val]) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 5706b9fcef..31beb005f8 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -111,7 +111,8 @@ func init() { {name: "SARQ", reg: gp21shift, asm: "SARQ"}, // signed arg0 >> arg1, shift amount is mod 64 {name: "SARQconst", reg: gp11, asm: "SARQ"}, // signed arg0 >> auxint, shift amount 0-63 - {name: "NEGQ", reg: gp11}, // -arg0 + {name: "NEGQ", reg: gp11}, // -arg0 + {name: "XORQconst", reg: gp11, asm: "XORQ"}, // arg0^auxint {name: "CMPQ", reg: gp2flags, asm: "CMPQ"}, // arg0 compare to arg1 {name: "CMPQconst", reg: gp1flags, asm: "CMPQ"}, // arg0 compare to auxint diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index c410cc4f02..9155e00859 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -22,6 +22,9 @@ var genericOps = []opData{ {name: "Greater"}, // arg0 > arg1 {name: "Geq"}, // arg0 <= arg1 + // 1-input ops + {name: "Not"}, // !arg0 + // Data movement {name: "Phi"}, // select an argument based on which predecessor block we came from {name: "Copy"}, // output = arg0 diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 3769cfeb86..494f4ecf40 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -66,6 +66,7 @@ const ( OpAMD64SARQ OpAMD64SARQconst OpAMD64NEGQ + OpAMD64XORQconst OpAMD64CMPQ OpAMD64CMPQconst OpAMD64TESTQ @@ -123,6 +124,7 @@ const ( OpLeq OpGreater OpGeq + OpNot OpPhi OpCopy OpConst @@ -358,6 +360,19 @@ var opcodeTable = [...]opInfo{ }, }, }, + { + name: "XORQconst", + asm: x86.AXORQ, + reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + clobbers: 0, + outputs: []regMask{ + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + }, + }, { name: "CMPQ", asm: x86.ACMPQ, @@ -1019,6 +1034,15 @@ var opcodeTable = [...]opInfo{ }, generic: true, }, + { + name: "Not", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, { name: "Phi", reg: regInfo{ diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index a781740b9b..95964d10bb 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -1237,6 +1237,23 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto enddccbd4e7581ae8d9916b933d3501987b enddccbd4e7581ae8d9916b933d3501987b: ; + case OpNot: + // match: (Not x) + // cond: + // result: (XORQconst [1] x) + { + x := v.Args[0] + v.Op = OpAMD64XORQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 1 + v.AddArg(x) + return true + } + goto endaabd7f5e27417cf3182cd5e4f4360410 + endaabd7f5e27417cf3182cd5e4f4360410: + ; case OpOffPtr: // match: (OffPtr [off] ptr) // cond: @@ -1626,6 +1643,28 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto ende2dee0bc82f631e3c6b0031bf8d224c1 ende2dee0bc82f631e3c6b0031bf8d224c1: ; + // match: (Store ptr val mem) + // cond: val.Type.IsBoolean() + // result: (MOVBstore ptr val mem) + { + ptr := v.Args[0] + val := v.Args[1] + mem := v.Args[2] + if !(val.Type.IsBoolean()) { + goto end6f343b676bf49740054e459f972b24f5 + } + v.Op = OpAMD64MOVBstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto end6f343b676bf49740054e459f972b24f5 + end6f343b676bf49740054e459f972b24f5: + ; case OpSub: // match: (Sub x y) // cond: is64BitInt(t) -- cgit v1.3 From accf9b5951f14a7a62cfe9ec5c59d6dc880c1bba Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Sat, 11 Jul 2015 15:43:35 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: comment why replacing phi with copy is ok Change-Id: I3e2e8862f2fde4349923016b97e8330b0d494e0e Reviewed-on: https://go-review.googlesource.com/12092 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/ssa/deadcode.go | 33 +++++++++++++++++++++++++++++++- 1 file changed, 32 insertions(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/deadcode.go b/src/cmd/compile/internal/ssa/deadcode.go index 1b1ae27e58..04e5b71ceb 100644 --- a/src/cmd/compile/internal/ssa/deadcode.go +++ b/src/cmd/compile/internal/ssa/deadcode.go @@ -132,9 +132,40 @@ func (f *Func) removePredecessor(b, c *Block) { v.Args = v.Args[:n] if n == 1 { v.Op = OpCopy + // 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. So although the value graph is transiently + // bad, we'll throw away the bad part by the end of + // the next deadcode phase. + // 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. } } - if n == 0 { // c is now dead--recycle its values for _, v := range c.Values { -- cgit v1.3 From 4c521ac8f23e98898a2e1603a6e7a23648be27eb Mon Sep 17 00:00:00 2001 From: Daniel Morsing Date: Sun, 12 Jul 2015 14:37:01 +0100 Subject: [dev.ssa] cmd/compile/internal/gc: implement more no-op statements Change-Id: I26c268f46dcffe39912b8c92ce9abb875310934f Reviewed-on: https://go-review.googlesource.com/12100 Reviewed-by: Brad Fitzpatrick --- src/cmd/compile/internal/gc/ssa.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index cff1ea71dc..2eb0402f69 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -294,7 +294,7 @@ func (s *state) stmt(n *Node) { case OBLOCK: s.stmtList(n.List) - case OEMPTY: + case OEMPTY, ODCLCONST, ODCLTYPE: case ODCL: if n.Left.Class&PHEAP == 0 { -- cgit v1.3 From 7e4c06dad065d1440fe8fcfa8e97702c88e1374e Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Sun, 12 Jul 2015 11:52:09 -0700 Subject: [dev.ssa] cmd/compile/internal/gc: handle _ label correctly An empty label statement can just be ignored, as it cannot be the target of any gotos. Tests are already in test/fixedbugs/issue7538*.go Fixes #11589 Fixes #11593 Change-Id: Iadcd639e7200ce16aa40fd7fa3eaf82522513e82 Reviewed-on: https://go-review.googlesource.com/12093 Reviewed-by: Daniel Morsing Reviewed-by: Brad Fitzpatrick --- src/cmd/compile/internal/gc/ssa.go | 5 +++++ 1 file changed, 5 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 2eb0402f69..d47680bf8a 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -316,6 +316,11 @@ func (s *state) stmt(n *Node) { s.assign(OAS, n.Left.Name.Heapaddr, palloc) case OLABEL, OGOTO: + if n.Op == OLABEL && isblanksym(n.Left.Sym) { + // Empty identifier is valid but useless. + // See issues 11589, 11593. + return + } // get block at label, or make one t := s.labels[n.Left.Sym.Name] if t == nil { -- cgit v1.3 From e81671115c0857d3286e9331870ec9993e81a1a7 Mon Sep 17 00:00:00 2001 From: Brad Fitzpatrick Date: Fri, 10 Jul 2015 12:58:53 -0600 Subject: [dev.ssa] cmd/compile: OANDAND, OOROR Joint hacking with josharian. Hints from matloob and Todd Neal. Now with tests, and OROR. Change-Id: Iff8826fde475691fb72a3eea7396a640b6274af9 Reviewed-on: https://go-review.googlesource.com/12041 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 40 +++++++++++++++ src/cmd/compile/internal/gc/ssa_test.go | 30 ++++++++++++ src/cmd/compile/internal/gc/testdata/short_ssa.go | 60 +++++++++++++++++++++++ src/cmd/compile/internal/ssa/gen/AMD64.rules | 1 + src/cmd/compile/internal/ssa/print.go | 9 +++- src/cmd/compile/internal/ssa/rewriteAMD64.go | 20 ++++++++ 6 files changed, 159 insertions(+), 1 deletion(-) create mode 100644 src/cmd/compile/internal/gc/ssa_test.go create mode 100644 src/cmd/compile/internal/gc/testdata/short_ssa.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index d47680bf8a..c4bfb2e731 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -500,6 +500,46 @@ func (s *state) expr(n *Node) *ssa.Value { a := s.expr(n.Left) b := s.expr(n.Right) return s.newValue2(binOpToSSA[n.Op], a.Type, a, b) + 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 + + bRight := s.f.NewBlock(ssa.BlockPlain) + bResult := s.f.NewBlock(ssa.BlockPlain) + if n.Op == OANDAND { + addEdge(b, bRight) + addEdge(b, bResult) + } else if n.Op == OOROR { + addEdge(b, bResult) + addEdge(b, bRight) + } + + s.startBlock(bRight) + er := s.expr(n.Right) + s.vars[n] = er + + b = s.endBlock() + addEdge(b, bResult) + + s.startBlock(bResult) + return s.variable(n, n.Type) // unary ops case ONOT: 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 0000000000..bcc77255dc --- /dev/null +++ b/src/cmd/compile/internal/gc/ssa_test.go @@ -0,0 +1,30 @@ +// 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" + "strings" + "testing" +) + +func TestShortCircuit(t *testing.T) { + testenv.MustHaveGoBuild(t) + var stdout, stderr bytes.Buffer + cmd := exec.Command("go", "run", "testdata/short_ssa.go") + 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) + } +} 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 0000000000..9427423ff3 --- /dev/null +++ b/src/cmd/compile/internal/gc/testdata/short_ssa.go @@ -0,0 +1,60 @@ +// 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. + +// 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 + +func rightCall(v bool) bool { + rightCalled = true + return v + select {} // hack to prevent inlining + 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/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 02b68b2e3c..aa0f6a7943 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -28,6 +28,7 @@ (MOVBstore ptr (MOVBQSX x) mem) -> (MOVBstore ptr x mem) (Convert x) && t.IsInteger() && x.Type.IsInteger() -> (Copy x) +(ConvNop x) && t == x.Type -> (Copy x) // Lowering shifts // Note: unsigned shifts need to return 0 if shift amount is >= 64. diff --git a/src/cmd/compile/internal/ssa/print.go b/src/cmd/compile/internal/ssa/print.go index 14d88dccd5..c8b90c6f93 100644 --- a/src/cmd/compile/internal/ssa/print.go +++ b/src/cmd/compile/internal/ssa/print.go @@ -26,7 +26,14 @@ func fprintFunc(w io.Writer, f *Func) { fmt.Fprintln(w, f.Type) printed := make([]bool, f.NumValues()) for _, b := range f.Blocks { - fmt.Fprintf(w, " b%d:\n", b.ID) + fmt.Fprintf(w, " b%d:", b.ID) + if len(b.Preds) > 0 { + io.WriteString(w, " <-") + for _, pred := range b.Preds { + fmt.Fprintf(w, " b%d", pred.ID) + } + } + io.WriteString(w, "\n") n := 0 // print phis first since all value cycles contain a phi diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 95964d10bb..d4447ea49a 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -499,6 +499,26 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end4c8bfe9df26fc5aa2bd76b211792732a end4c8bfe9df26fc5aa2bd76b211792732a: ; + case OpConvNop: + // match: (ConvNop x) + // cond: t == x.Type + // result: (Copy x) + { + t := v.Type + x := v.Args[0] + if !(t == x.Type) { + goto end6c588ed8aedc7dca8c06b4ada77e3ddd + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end6c588ed8aedc7dca8c06b4ada77e3ddd + end6c588ed8aedc7dca8c06b4ada77e3ddd: + ; case OpConvert: // match: (Convert x) // cond: t.IsInteger() && x.Type.IsInteger() -- cgit v1.3 From 50e59bb9c8c8cdb0febc224e2c2c6716ea11bd9b Mon Sep 17 00:00:00 2001 From: Brad Fitzpatrick Date: Mon, 13 Jul 2015 14:57:16 -0600 Subject: [dev.ssa] cmd/compile/internal/gc: fix tests on non-amd64 Change-Id: Ibd6a59db2d5feea41a21fbea5c1a7fdd49238aa8 Reviewed-on: https://go-review.googlesource.com/12131 Reviewed-by: Josh Bleecher Snyder Run-TryBot: Brad Fitzpatrick --- src/cmd/compile/internal/gc/ssa_test.go | 7 +++++++ 1 file changed, 7 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa_test.go b/src/cmd/compile/internal/gc/ssa_test.go index bcc77255dc..fbbba6d9cb 100644 --- a/src/cmd/compile/internal/gc/ssa_test.go +++ b/src/cmd/compile/internal/gc/ssa_test.go @@ -8,11 +8,18 @@ import ( "bytes" "internal/testenv" "os/exec" + "runtime" "strings" "testing" ) +// Tests OANDAND and OOROR expressions and short circuiting. +// TODO: move these tests elsewhere? perhaps teach test/run.go how to run them +// with a new action verb. func TestShortCircuit(t *testing.T) { + 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", "run", "testdata/short_ssa.go") -- cgit v1.3 From a92bd662829384203ec70df8c93bb542b0921553 Mon Sep 17 00:00:00 2001 From: Brad Fitzpatrick Date: Mon, 13 Jul 2015 14:01:08 -0600 Subject: [dev.ssa] cmd/compile: support zero type for *T Change-Id: I4c9bcea01e2c4333c2a3592b66f1da9f424747a4 Reviewed-on: https://go-review.googlesource.com/12130 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 2 +- src/cmd/compile/internal/ssa/gen/AMD64.rules | 1 + src/cmd/compile/internal/ssa/rewriteAMD64.go | 18 ++++++++++++++++++ 3 files changed, 20 insertions(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index c4bfb2e731..c75dd16264 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -652,7 +652,7 @@ func (s *state) assign(op uint8, left *Node, right *Node) { switch { case t.IsString(): val = s.entryNewValue0A(ssa.OpConst, left.Type, "") - case t.IsInteger(): + case t.IsInteger() || t.IsPtr(): val = s.entryNewValue0(ssa.OpConst, left.Type) case t.IsBoolean(): val = s.entryNewValue0A(ssa.OpConst, left.Type, false) // TODO: store bools as 0/1 in AuxInt? diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index aa0f6a7943..1eb29105d2 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -76,6 +76,7 @@ (OffPtr [off] ptr) -> (ADDQconst [off] ptr) (Const [val]) && t.IsInteger() -> (MOVQconst [val]) +(Const ) && t.IsPtr() -> (MOVQconst [0]) // nil is the only const pointer (Addr {sym} base) -> (LEAQ {sym} base) diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index d4447ea49a..728c45cc49 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -499,6 +499,24 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end4c8bfe9df26fc5aa2bd76b211792732a end4c8bfe9df26fc5aa2bd76b211792732a: ; + // match: (Const ) + // cond: t.IsPtr() + // result: (MOVQconst [0]) + { + t := v.Type + if !(t.IsPtr()) { + goto endd23abe8d7061f11c260b162e24eec060 + } + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto endd23abe8d7061f11c260b162e24eec060 + endd23abe8d7061f11c260b162e24eec060: + ; case OpConvNop: // match: (ConvNop x) // cond: t == x.Type -- cgit v1.3 From b06961b4f0f4786fb6b92e472d4a056bed650c66 Mon Sep 17 00:00:00 2001 From: Brad Fitzpatrick Date: Mon, 13 Jul 2015 15:46:53 -0600 Subject: [dev.ssa] cmd/compile: treat unsafe.Pointer as a pointer Change-Id: I3f3ac3055c93858894b8852603d79592bbc1696b Reviewed-on: https://go-review.googlesource.com/12140 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/type.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/type.go b/src/cmd/compile/internal/gc/type.go index 7f7b6635e0..f60d01b3bb 100644 --- a/src/cmd/compile/internal/gc/type.go +++ b/src/cmd/compile/internal/gc/type.go @@ -56,7 +56,7 @@ func (t *Type) IsFloat() bool { } func (t *Type) IsPtr() bool { - return t.Etype == TPTR32 || t.Etype == TPTR64 || + return t.Etype == TPTR32 || t.Etype == TPTR64 || t.Etype == TUNSAFEPTR || t.Etype == TMAP || t.Etype == TCHAN || t.Etype == TFUNC } -- cgit v1.3 From c3c84a254483523e686d4b9a3bc30521a9937238 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Mon, 13 Jul 2015 15:55:37 -0700 Subject: [dev.ssa] cmd/compile/internal/gc: Implement ODOT and ODOTPTR in addr. Change-Id: If8a9d5901fa2141d16b1c8d001761ea62bc23207 Reviewed-on: https://go-review.googlesource.com/12141 Reviewed-by: Brad Fitzpatrick --- src/cmd/compile/internal/gc/ssa.go | 8 ++++++++ 1 file changed, 8 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index c75dd16264..589257bc23 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -673,6 +673,7 @@ func (s *state) assign(op uint8, left *Node, right *Node) { } // 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. func (s *state) addr(n *Node) *ssa.Value { switch n.Op { case ONAME: @@ -716,6 +717,13 @@ func (s *state) addr(n *Node) *ssa.Value { s.boundsCheck(i, len) return s.newValue2(ssa.OpPtrIndex, Ptrto(n.Left.Type.Type), a, i) } + case ODOT: + p := s.addr(n.Left) + return s.newValue2(ssa.OpAdd, p.Type, p, s.constInt(s.config.Uintptr, n.Xoffset)) + case ODOTPTR: + p := s.expr(n.Left) + s.nilCheck(p) + return s.newValue2(ssa.OpAdd, p.Type, p, s.constInt(s.config.Uintptr, n.Xoffset)) default: s.Unimplementedf("addr: bad op %v", Oconv(int(n.Op), 0)) return nil -- cgit v1.3 From 337b7e7e3bb3a6a141d4aa10f8ed79ee33b6f7e9 Mon Sep 17 00:00:00 2001 From: Brad Fitzpatrick Date: Mon, 13 Jul 2015 17:30:42 -0600 Subject: [dev.ssa] cmd/compile: handle OLITERAL nil expressions Change-Id: I02b8fb277b486eaf0916ddcd8f28c062d4022d4b Reviewed-on: https://go-review.googlesource.com/12150 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 2 ++ 1 file changed, 2 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 589257bc23..b016bb1838 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -480,6 +480,8 @@ func (s *state) expr(n *Node) *ssa.Value { return s.constInt(n.Type, Mpgetfix(n.Val().U.(*Mpint))) case CTSTR, CTBOOL: return s.entryNewValue0A(ssa.OpConst, n.Type, n.Val().U) + case CTNIL: + return s.entryNewValue0(ssa.OpConst, n.Type) default: s.Unimplementedf("unhandled OLITERAL %v", n.Val().Ctype()) return nil -- cgit v1.3 From 4e204b42f5b66ea36f0421098a42addc7c2ba6c7 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Mon, 13 Jul 2015 23:52:59 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: ensure Phi ops are scheduled first Phi ops should always be scheduled first. They have the semantics of all happening simultaneously at the start of the block. The regalloc phase assumes all the phis will appear first. Change-Id: I30291e1fa384a0819205218f1d1ec3aef6d538dd Reviewed-on: https://go-review.googlesource.com/12154 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/ssa/schedule.go | 24 ++++++++++++++++++------ 1 file changed, 18 insertions(+), 6 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/schedule.go b/src/cmd/compile/internal/ssa/schedule.go index 60d2cd5460..15e8ace391 100644 --- a/src/cmd/compile/internal/ssa/schedule.go +++ b/src/cmd/compile/internal/ssa/schedule.go @@ -54,16 +54,28 @@ func schedule(f *Func) { } } - // Topologically sort the values in b. order = order[:0] + + // Schedule phis first for _, v := range b.Values { - if v == b.Control { - continue - } if v.Op == OpPhi { - // Phis all go first. We handle phis specially - // because they may have self edges "a = phi(a, b, c)" + // TODO: what if a phi is also a control op? It happens for + // mem ops all the time, which shouldn't matter. But for + // regular ops we might be violating invariants about where + // control ops live. + if v == b.Control && !v.Type.IsMemory() { + f.Unimplementedf("phi is a control op %s %s", v, b) + } order = append(order, v) + } + } + + // Topologically sort the non-phi values in b. + for _, v := range b.Values { + if v.Op == OpPhi { + continue + } + if v == b.Control { continue } if state[v.ID] != unmarked { -- cgit v1.3 From b383de2ef9d08882c331b4877ce9d5a69f8f97b2 Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Mon, 13 Jul 2015 21:22:16 -0500 Subject: [dev.ssa] cmd/compile: implement OIND Change-Id: I15aee8095e6388822e2222f1995fe2278ac956ca Reviewed-on: https://go-review.googlesource.com/12129 Reviewed-by: Keith Randall Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/gc/ssa.go | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index b016bb1838..3ad21a6193 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -719,6 +719,10 @@ func (s *state) addr(n *Node) *ssa.Value { s.boundsCheck(i, len) return s.newValue2(ssa.OpPtrIndex, Ptrto(n.Left.Type.Type), a, i) } + case OIND: + p := s.expr(n.Left) + s.nilCheck(p) + return p case ODOT: p := s.addr(n.Left) return s.newValue2(ssa.OpAdd, p.Type, p, s.constInt(s.config.Uintptr, n.Xoffset)) -- cgit v1.3 From 078ba138d370d1752e78c558e795ea9d01d6d1db Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Sun, 5 Jul 2015 18:23:25 -0500 Subject: [dev.ssa] cmd/compile/internal : Implement Lengauer-Tarjan for dominators Implements the simple Lengauer-Tarjan algorithm for dominator and post-dominator calculation. benchmark old ns/op new ns/op delta BenchmarkDominatorsLinear-8 1403862 1292741 -7.92% BenchmarkDominatorsFwdBack-8 1270633 1428285 +12.41% BenchmarkDominatorsManyPred-8 225932354 1530886 -99.32% BenchmarkDominatorsMaxPred-8 445994225 1393612 -99.69% BenchmarkDominatorsMaxPredVal-8 447235248 1246899 -99.72% BenchmarkNilCheckDeep1-8 829 1259 +51.87% BenchmarkNilCheckDeep10-8 2199 2397 +9.00% BenchmarkNilCheckDeep100-8 57325 29405 -48.70% BenchmarkNilCheckDeep1000-8 6625837 2933151 -55.73% BenchmarkNilCheckDeep10000-8 763559787 319105541 -58.21% benchmark old MB/s new MB/s speedup BenchmarkDominatorsLinear-8 7.12 7.74 1.09x BenchmarkDominatorsFwdBack-8 7.87 7.00 0.89x BenchmarkDominatorsManyPred-8 0.04 6.53 163.25x BenchmarkDominatorsMaxPred-8 0.02 7.18 359.00x BenchmarkDominatorsMaxPredVal-8 0.02 8.02 401.00x BenchmarkNilCheckDeep1-8 1.21 0.79 0.65x BenchmarkNilCheckDeep10-8 4.55 4.17 0.92x BenchmarkNilCheckDeep100-8 1.74 3.40 1.95x BenchmarkNilCheckDeep1000-8 0.15 0.34 2.27x BenchmarkNilCheckDeep10000-8 0.01 0.03 3.00x Change-Id: Icec3d774422a9bc64914779804c8c0ab73aa72bf Reviewed-on: https://go-review.googlesource.com/11971 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/dom.go | 200 +++++++++++++++++++++++++++++-- src/cmd/compile/internal/ssa/dom_test.go | 124 +++++++++++++++++-- 2 files changed, 304 insertions(+), 20 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/dom.go b/src/cmd/compile/internal/ssa/dom.go index b4d47c1350..b6fda0c953 100644 --- a/src/cmd/compile/internal/ssa/dom.go +++ b/src/cmd/compile/internal/ssa/dom.go @@ -4,6 +4,14 @@ 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. @@ -11,13 +19,6 @@ package ssa // basic blocks in f. Unreachable blocks will not appear. func postorder(f *Func) []*Block { mark := make([]byte, f.NumBlocks()) - // 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 - ) // result ordering var order []*Block @@ -51,11 +52,196 @@ func postorder(f *Func) []*Block { return order } +type linkedBlocks func(*Block) []*Block + +// dfs performs a depth first search over the blocks. 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 dfs(entry *Block, succFn linkedBlocks) (dfnum []int, order []*Block, parent []*Block) { + maxBlockID := entry.Func.NumBlocks() + + dfnum = make([]int, maxBlockID) + order = make([]*Block, maxBlockID) + parent = make([]*Block, maxBlockID) + + n := 0 + s := make([]*Block, 0, 256) + s = append(s, entry) + parent[entry.ID] = entry + 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 + dfnum[w.ID] = notExplored + } + } + dfnum[node.ID] = n + order[n] = node + } + + 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 dominatorsLT(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 block, maybe store it as f.Exit instead? + var exit *Block + for i := len(f.Blocks) - 1; i >= 0; i-- { + if f.Blocks[i].Kind == BlockExit { + exit = f.Blocks[i] + break + } + } + + // infite loop with no exit + if exit == nil { + return make([]*Block, f.NumBlocks()) + } + return dominatorsLT(exit, 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 dominatorsLT(entry *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 + + // 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. + dfnum, vertex, parent := dfs(entry, succFn) + + maxBlockID := entry.Func.NumBlocks() + semi := make([]*Block, maxBlockID) + samedom := make([]*Block, maxBlockID) + idom := make([]*Block, maxBlockID) + ancestor := make([]*Block, maxBlockID) + best := make([]*Block, maxBlockID) + bucket := 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 == nil { + continue + } + + if dfnum[w.ID] == notFound { + // skip unreachable node + continue + } + // Step 3. Implicitly define the immediate dominator of each + // vertex by applying Corollary 1. (reordered) + for v := bucket[w.ID]; v != nil; v = bucket[v.ID] { + u := eval(v, ancestor, semi, dfnum, best) + if semi[u.ID] == semi[v.ID] { + idom[v.ID] = w // true dominator + } else { + samedom[v.ID] = u // v has same dominator as u + } + } + + p := parent[w.ID] + s := p // semidominator + + var sp *Block + // calculate the semidominator of w + for _, v := range w.Preds { + if dfnum[v.ID] == notFound { + // skip unreachable predecessor + continue + } + + if dfnum[v.ID] <= dfnum[w.ID] { + sp = v + } else { + sp = semi[eval(v, ancestor, semi, dfnum, best).ID] + } + + if dfnum[sp.ID] < dfnum[s.ID] { + s = sp + } + } + + // link + ancestor[w.ID] = p + best[w.ID] = w + + semi[w.ID] = s + if semi[s.ID] != parent[s.ID] { + bucket[w.ID] = bucket[s.ID] + bucket[s.ID] = w + } + } + + // Final pass of step 3 + for v := bucket[0]; v != nil; v = bucket[v.ID] { + idom[v.ID] = 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 == nil { + continue + } + // w has the same dominator as samedom[w.ID] + if samedom[w.ID] != nil { + idom[w.ID] = idom[samedom[w.ID].ID] + } + } + return idom +} + +// eval function from LT paper with path compression +func eval(v *Block, ancestor []*Block, semi []*Block, dfnum []int, best []*Block) *Block { + a := ancestor[v.ID] + if ancestor[a.ID] != nil { + b := eval(a, ancestor, semi, dfnum, best) + ancestor[v.ID] = ancestor[a.ID] + if dfnum[semi[b.ID].ID] < dfnum[semi[best[v.ID].ID].ID] { + best[v.ID] = b + } + } + return best[v.ID] +} + +// 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()) diff --git a/src/cmd/compile/internal/ssa/dom_test.go b/src/cmd/compile/internal/ssa/dom_test.go index 3197a5cc0e..5209e307b7 100644 --- a/src/cmd/compile/internal/ssa/dom_test.go +++ b/src/cmd/compile/internal/ssa/dom_test.go @@ -4,9 +4,7 @@ package ssa -import ( - "testing" -) +import "testing" func BenchmarkDominatorsLinear(b *testing.B) { benchmarkDominators(b, 10000, genLinear) } func BenchmarkDominatorsFwdBack(b *testing.B) { benchmarkDominators(b, 10000, genFwdBack) } @@ -173,20 +171,24 @@ func benchmarkDominators(b *testing.B, size int, bg blockGen) { } } -func verifyDominators(t *testing.T, f fun, doms map[string]string) { +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 f.blocks { + for n, b := range fut.blocks { blockNames[b] = n } - calcDom := dominators(f.f) + calcDom := domFn(fut.f) for n, d := range doms { - nblk, ok := f.blocks[n] + nblk, ok := fut.blocks[n] if !ok { t.Errorf("invalid block name %s", n) } - dblk, ok := f.blocks[d] + dblk, ok := fut.blocks[d] if !ok { t.Errorf("invalid block name %s", d) } @@ -208,7 +210,7 @@ func verifyDominators(t *testing.T, f fun, doms map[string]string) { if d == nil { continue } - for _, b := range f.blocks { + for _, b := range fut.blocks { if int(b.ID) == id { t.Errorf("unexpected dominator of %s for %s", blockNames[d], blockNames[b]) } @@ -217,6 +219,21 @@ func verifyDominators(t *testing.T, f fun, doms map[string]string) { } +func TestDominatorsSingleBlock(t *testing.T) { + c := NewConfig("amd64", DummyFrontend{t}) + fun := Fun(c, "entry", + Bloc("entry", + Valu("mem", OpArg, TypeMem, 0, ".mem"), + 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 := NewConfig("amd64", DummyFrontend{t}) fun := Fun(c, "entry", @@ -239,7 +256,9 @@ func TestDominatorsSimple(t *testing.T) { "exit": "c", } - verifyDominators(t, fun, doms) + CheckFunc(fun.f) + verifyDominators(t, fun, dominators, doms) + verifyDominators(t, fun, dominatorsSimple, doms) } @@ -266,8 +285,32 @@ func TestDominatorsMultPredFwd(t *testing.T) { "exit": "c", } - verifyDominators(t, fun, doms) + CheckFunc(fun.f) + verifyDominators(t, fun, dominators, doms) + verifyDominators(t, fun, dominatorsSimple, doms) +} +func TestDominatorsDeadCode(t *testing.T) { + c := NewConfig("amd64", DummyFrontend{t}) + fun := Fun(c, "entry", + Bloc("entry", + Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("p", OpConst, TypeBool, 0, false), + 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) { @@ -292,7 +335,10 @@ func TestDominatorsMultPredRev(t *testing.T) { "c": "b", "exit": "c", } - verifyDominators(t, fun, doms) + + CheckFunc(fun.f) + verifyDominators(t, fun, dominators, doms) + verifyDominators(t, fun, dominatorsSimple, doms) } func TestDominatorsMultPred(t *testing.T) { @@ -317,5 +363,57 @@ func TestDominatorsMultPred(t *testing.T) { "c": "entry", "exit": "c", } - verifyDominators(t, fun, doms) + + CheckFunc(fun.f) + verifyDominators(t, fun, dominators, doms) + verifyDominators(t, fun, dominatorsSimple, doms) +} + +func TestPostDominators(t *testing.T) { + c := NewConfig("amd64", DummyFrontend{t}) + fun := Fun(c, "entry", + Bloc("entry", + Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("p", OpConst, TypeBool, 0, true), + 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 := NewConfig("amd64", DummyFrontend{t}) + // note lack of an exit block + fun := Fun(c, "entry", + Bloc("entry", + Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("p", OpConst, TypeBool, 0, true), + 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) } -- cgit v1.3 From cd7e0594963fdd77c9baba60677c68c6e218dad6 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Wed, 15 Jul 2015 21:33:49 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: implement ODOT Implement ODOT. Similar to ArrayIndex, StructSelect selects a field out of a larger Value. We may need more ways to rewrite StructSelect, but StructSelect/Load is the typical way it is used. Change-Id: Ida7b8aab3298f4754eaf9fee733974cf8736e45d Reviewed-on: https://go-review.googlesource.com/12265 Reviewed-by: Brad Fitzpatrick --- src/cmd/compile/internal/gc/ssa.go | 9 +++++++++ src/cmd/compile/internal/ssa/gen/generic.rules | 1 + src/cmd/compile/internal/ssa/gen/genericOps.go | 7 ++++--- src/cmd/compile/internal/ssa/opGen.go | 10 ++++++++++ src/cmd/compile/internal/ssa/rewritegeneric.go | 26 ++++++++++++++++++++++++++ 5 files changed, 50 insertions(+), 3 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 3ad21a6193..2ba1ddbb44 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -226,6 +226,11 @@ func (s *state) newValue1A(op ssa.Op, t ssa.Type, aux interface{}, arg *ssa.Valu 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) @@ -556,6 +561,10 @@ func (s *state) expr(n *Node) *ssa.Value { s.nilCheck(p) return s.newValue2(ssa.OpLoad, n.Type, p, s.mem()) + case ODOT: + v := s.expr(n.Left) + return s.newValue1I(ssa.OpStructSelect, n.Type, n.Xoffset, v) + case ODOTPTR: p := s.expr(n.Left) s.nilCheck(p) diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index 9f11a60a6b..a906ec6a5c 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -34,6 +34,7 @@ // Note: bounds check has already been done (ArrayIndex (Load ptr mem) idx) -> (Load (PtrIndex ptr idx) mem) (PtrIndex ptr idx) -> (Add ptr (Mul idx (Const [t.Elem().Size()]))) +(StructSelect [idx] (Load ptr mem)) -> (Load (OffPtr [idx] ptr) mem) // big-object moves // TODO: fix size diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 9155e00859..0af7df1775 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -71,9 +71,10 @@ var genericOps = []opData{ {name: "IsInBounds"}, // 0 <= arg0 < arg1 // Indexing operations - {name: "ArrayIndex"}, // arg0=array, arg1=index. Returns a[i] - {name: "PtrIndex"}, // arg0=ptr, arg1=index. Computes ptr+sizeof(*v.type)*index, where index is extended to ptrwidth type - {name: "OffPtr"}, // arg0 + auxint (arg0 and result are pointers) + {name: "ArrayIndex"}, // arg0=array, arg1=index. Returns a[i] + {name: "PtrIndex"}, // arg0=ptr, arg1=index. Computes ptr+sizeof(*v.type)*index, where index is extended to ptrwidth type + {name: "OffPtr"}, // arg0 + auxint (arg0 and result are pointers) + {name: "StructSelect"}, // arg0=struct, auxint=field offset. Returns field at that offset (size=size of result type) // Slices {name: "SliceMake"}, // arg0=ptr, arg1=len, arg2=cap diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 494f4ecf40..74d30e1df5 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -146,6 +146,7 @@ const ( OpArrayIndex OpPtrIndex OpOffPtr + OpStructSelect OpSliceMake OpSlicePtr OpSliceLen @@ -1232,6 +1233,15 @@ var opcodeTable = [...]opInfo{ }, generic: true, }, + { + name: "StructSelect", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, { name: "SliceMake", reg: regInfo{ diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index 78cb2c8ebb..ca523ee19b 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -383,6 +383,32 @@ func rewriteValuegeneric(v *Value, config *Config) bool { } goto end061edc5d85c73ad909089af2556d9380 end061edc5d85c73ad909089af2556d9380: + ; + case OpStructSelect: + // match: (StructSelect [idx] (Load ptr mem)) + // cond: + // result: (Load (OffPtr [idx] ptr) mem) + { + idx := v.AuxInt + if v.Args[0].Op != OpLoad { + goto end16fdb45e1dd08feb36e3cc3fb5ed8935 + } + ptr := v.Args[0].Args[0] + mem := v.Args[0].Args[1] + v.Op = OpLoad + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpOffPtr, TypeInvalid) + v0.Type = v.Type.PtrTo() + v0.AuxInt = idx + v0.AddArg(ptr) + v.AddArg(v0) + v.AddArg(mem) + return true + } + goto end16fdb45e1dd08feb36e3cc3fb5ed8935 + end16fdb45e1dd08feb36e3cc3fb5ed8935: } return false } -- cgit v1.3 From 766bcc92a5b693f336deffc347be52fe68af884a Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Thu, 16 Jul 2015 12:45:22 -0600 Subject: [dev.ssa] cmd/compile: don't Compile if Unimplemented If we've already hit an Unimplemented, there may be important SSA invariants that do not hold and which could cause ssa.Compile to hang or spin. While we're here, make detected dependency cycles stop execution. Change-Id: Ic7d4eea659e1fe3f2c9b3e8a4eee5567494f46ad Reviewed-on: https://go-review.googlesource.com/12310 Reviewed-by: Brad Fitzpatrick --- src/cmd/compile/internal/gc/ssa.go | 9 +++++---- src/cmd/compile/internal/ssa/print.go | 13 ++++++++++--- 2 files changed, 15 insertions(+), 7 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 2ba1ddbb44..96351def6e 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -108,17 +108,18 @@ func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { // Link up variable uses to variable definitions s.linkForwardReferences() - // Main call to ssa package to compile function - ssa.Compile(s.f) - // Calculate stats about what percentage of functions SSA handles. if false { - fmt.Printf("SSA implemented: %t\n", !e.unimplemented) + defer func() { fmt.Printf("SSA implemented: %t\n", !e.unimplemented) }() } if e.unimplemented { return nil, false } + + // Main call to ssa package to compile function. + ssa.Compile(s.f) + return s.f, usessa // TODO: return s.f, true once runtime support is in (gc maps, write barriers, etc.) } diff --git a/src/cmd/compile/internal/ssa/print.go b/src/cmd/compile/internal/ssa/print.go index c8b90c6f93..e46590224d 100644 --- a/src/cmd/compile/internal/ssa/print.go +++ b/src/cmd/compile/internal/ssa/print.go @@ -8,6 +8,7 @@ import ( "bytes" "fmt" "io" + "os" ) func printFunc(f *Func) { @@ -68,16 +69,22 @@ func fprintFunc(w io.Writer, f *Func) { n++ } if m == n { - fmt.Fprintln(w, "dependency cycle!") + fmt.Fprintln(os.Stderr, "dependency cycle in block", b) for _, v := range b.Values { if printed[v.ID] { continue } - fmt.Fprint(w, " ") - fmt.Fprintln(w, v.LongString()) + fmt.Fprintf(os.Stderr, " %v\n", v.LongString()) printed[v.ID] = true n++ } + // Things are going to go very badly from here; + // one of the optimization passes is likely to hang. + // Frustratingly, panics here get swallowed by fmt, + // and just we end up here again if we call Fatalf. + // Use our last resort. + os.Exit(1) + return } } -- cgit v1.3 From 8adc905a10ffe26204547c95b6d3abe5bf6f9053 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Thu, 16 Jul 2015 13:12:57 -0600 Subject: [dev.ssa] cmd/compile: implement lowering of constant bools Change-Id: Ia56ee9798eefe123d4da04138a6a559d2c25ddf3 Reviewed-on: https://go-review.googlesource.com/12312 Reviewed-by: Brad Fitzpatrick --- src/cmd/compile/internal/ssa/gen/AMD64.rules | 2 ++ src/cmd/compile/internal/ssa/rewriteAMD64.go | 36 ++++++++++++++++++++++++++++ 2 files changed, 38 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 1eb29105d2..6882621f71 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -77,6 +77,8 @@ (Const [val]) && t.IsInteger() -> (MOVQconst [val]) (Const ) && t.IsPtr() -> (MOVQconst [0]) // nil is the only const pointer +(Const ) && t.IsBoolean() && !v.Aux.(bool) -> (MOVQconst [0]) +(Const ) && t.IsBoolean() && v.Aux.(bool) -> (MOVQconst [1]) (Addr {sym} base) -> (LEAQ {sym} base) diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 728c45cc49..7393cd9a89 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -517,6 +517,42 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endd23abe8d7061f11c260b162e24eec060 endd23abe8d7061f11c260b162e24eec060: ; + // match: (Const ) + // cond: t.IsBoolean() && !v.Aux.(bool) + // result: (MOVQconst [0]) + { + t := v.Type + if !(t.IsBoolean() && !v.Aux.(bool)) { + goto end7b1347fd0902b990ee1e49145c7e8c31 + } + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end7b1347fd0902b990ee1e49145c7e8c31 + end7b1347fd0902b990ee1e49145c7e8c31: + ; + // match: (Const ) + // cond: t.IsBoolean() && v.Aux.(bool) + // result: (MOVQconst [1]) + { + t := v.Type + if !(t.IsBoolean() && v.Aux.(bool)) { + goto ende0d1c954b5ab5af7227bff9635774f1c + } + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 1 + return true + } + goto ende0d1c954b5ab5af7227bff9635774f1c + ende0d1c954b5ab5af7227bff9635774f1c: + ; case OpConvNop: // match: (ConvNop x) // cond: t == x.Type -- cgit v1.3 From 3dcc424be70b9d1824f756ab81f97508ae1a7738 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Tue, 14 Jul 2015 13:20:08 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: compute outarg size correctly Keep track of the outargs size needed at each call. Compute the size of the outargs section of the stack frame. It's just the max of the outargs size at all the callsites in the function. Change-Id: I3d0640f654f01307633b1a5f75bab16e211ea6c0 Reviewed-on: https://go-review.googlesource.com/12178 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/gc/ssa.go | 2 ++ src/cmd/compile/internal/ssa/TODO | 1 - src/cmd/compile/internal/ssa/gen/AMD64.rules | 4 ++-- src/cmd/compile/internal/ssa/rewriteAMD64.go | 20 ++++++++++++-------- src/cmd/compile/internal/ssa/stackalloc.go | 16 ++++++++++------ 5 files changed, 26 insertions(+), 17 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 96351def6e..2dad3e1a10 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -626,6 +626,8 @@ func (s *state) expr(n *Node) *ssa.Value { entry := s.newValue2(ssa.OpLoad, s.config.Uintptr, closure, s.mem()) call = s.newValue3(ssa.OpClosureCall, ssa.TypeMem, entry, closure, s.mem()) } + dowidth(n.Left.Type) + call.AuxInt = n.Left.Type.Argwid // call operations carry the argsize of the callee along with them b := s.endBlock() b.Kind = ssa.BlockCall b.Control = call diff --git a/src/cmd/compile/internal/ssa/TODO b/src/cmd/compile/internal/ssa/TODO index 340c905654..cfaf520510 100644 --- a/src/cmd/compile/internal/ssa/TODO +++ b/src/cmd/compile/internal/ssa/TODO @@ -29,7 +29,6 @@ Regalloc - Make calls clobber all registers StackAlloc: - - Compute size of outargs section correctly - Sort variables so all ptr-containing ones are first (so stack maps are smaller) - Reuse stack slots for noninterfering and type-compatible variables diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 6882621f71..47e1fb9c6a 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -88,8 +88,8 @@ (If (SETB cmp) yes no) -> (ULT cmp yes no) (If cond yes no) && cond.Op == OpAMD64MOVBload -> (NE (TESTB cond cond) yes no) -(StaticCall {target} mem) -> (CALLstatic {target} mem) -(ClosureCall entry closure mem) -> (CALLclosure entry closure mem) +(StaticCall [argwid] {target} mem) -> (CALLstatic [argwid] {target} mem) +(ClosureCall [argwid] entry closure mem) -> (CALLclosure [argwid] entry closure mem) // Rules below here apply some simple optimizations after lowering. // TODO: Should this be a separate pass? diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 7393cd9a89..7e892c3844 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -460,10 +460,11 @@ func rewriteValueAMD64(v *Value, config *Config) bool { endf8ca12fe79290bc82b11cfa463bc9413: ; case OpClosureCall: - // match: (ClosureCall entry closure mem) + // match: (ClosureCall [argwid] entry closure mem) // cond: - // result: (CALLclosure entry closure mem) + // result: (CALLclosure [argwid] entry closure mem) { + argwid := v.AuxInt entry := v.Args[0] closure := v.Args[1] mem := v.Args[2] @@ -471,13 +472,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.AuxInt = argwid v.AddArg(entry) v.AddArg(closure) v.AddArg(mem) return true } - goto endee26da781e813a3c602ccb4f7ade98c7 - endee26da781e813a3c602ccb4f7ade98c7: + goto endfd75d26316012d86cb71d0dd1214259b + endfd75d26316012d86cb71d0dd1214259b: ; case OpConst: // match: (Const [val]) @@ -1611,22 +1613,24 @@ func rewriteValueAMD64(v *Value, config *Config) bool { end78e66b6fc298684ff4ac8aec5ce873c9: ; case OpStaticCall: - // match: (StaticCall {target} mem) + // match: (StaticCall [argwid] {target} mem) // cond: - // result: (CALLstatic {target} mem) + // result: (CALLstatic [argwid] {target} mem) { + argwid := v.AuxInt target := v.Aux mem := v.Args[0] v.Op = OpAMD64CALLstatic v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.AuxInt = argwid v.Aux = target v.AddArg(mem) return true } - goto end1948857a7cfc2a4f905045e58d3b9ec1 - end1948857a7cfc2a4f905045e58d3b9ec1: + goto end32c5cbec813d1c2ae94fc9b1090e4b2a + end32c5cbec813d1c2ae94fc9b1090e4b2a: ; case OpStore: // match: (Store ptr val mem) diff --git a/src/cmd/compile/internal/ssa/stackalloc.go b/src/cmd/compile/internal/ssa/stackalloc.go index 85a55ece7c..0bd64a1a14 100644 --- a/src/cmd/compile/internal/ssa/stackalloc.go +++ b/src/cmd/compile/internal/ssa/stackalloc.go @@ -9,12 +9,16 @@ package ssa func stackalloc(f *Func) { home := f.RegAlloc - // First compute the size of the outargs section. - n := int64(16) //TODO: compute max of all callsites - - // Include one slot for deferreturn. - if false && n < f.Config.ptrSize { //TODO: check for deferreturn - n = f.Config.ptrSize + // Start with space for callee arguments/returns. + var n int64 + for _, b := range f.Blocks { + if b.Kind != BlockCall { + continue + } + v := b.Control + if n < v.AuxInt { + n = v.AuxInt + } } // TODO: group variables by ptr/nonptr, size, etc. Emit ptr vars last -- cgit v1.3 From c1593da817c3a557b5ce8ef41def903a619f6daa Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Thu, 16 Jul 2015 14:20:40 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa/gen: Fix *64 strength reduction *64 is <<6, not <<5. Change-Id: I2eb7e113d5003b2c77fbd3abc3defc4d98976a5e Reviewed-on: https://go-review.googlesource.com/12323 Reviewed-by: Brad Fitzpatrick --- src/cmd/compile/internal/ssa/gen/AMD64.rules | 2 +- src/cmd/compile/internal/ssa/rewriteAMD64.go | 10 +++++----- 2 files changed, 6 insertions(+), 6 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 47e1fb9c6a..3e25929af5 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -112,7 +112,7 @@ // strength reduction // TODO: do this a lot more generically (MULQconst [8] x) -> (SHLQconst [3] x) -(MULQconst [64] x) -> (SHLQconst [5] x) +(MULQconst [64] x) -> (SHLQconst [6] x) // fold add/shift into leaq (ADDQ x (SHLQconst [3] y)) -> (LEAQ8 x y) diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 7e892c3844..3e24f9f618 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -1225,22 +1225,22 @@ func rewriteValueAMD64(v *Value, config *Config) bool { ; // match: (MULQconst [64] x) // cond: - // result: (SHLQconst [5] x) + // result: (SHLQconst [6] x) { if v.AuxInt != 64 { - goto end75c0c250c703f89e6c43d718dd5ea3c0 + goto end3e36a587d1e7c193048d489a0429692c } x := v.Args[0] v.Op = OpAMD64SHLQconst v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = 5 + v.AuxInt = 6 v.AddArg(x) return true } - goto end75c0c250c703f89e6c43d718dd5ea3c0 - end75c0c250c703f89e6c43d718dd5ea3c0: + goto end3e36a587d1e7c193048d489a0429692c + end3e36a587d1e7c193048d489a0429692c: ; case OpMove: // match: (Move [size] dst src mem) -- cgit v1.3 From f421735bb4a139ecd59afc78b2b98df6327464cf Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Fri, 17 Jul 2015 10:45:48 -0600 Subject: [dev.ssa] cmd/compile: handle OpCopy loops in rewrite Change-Id: Icbaad6e5cbfc5430a651538fe90c0a9ee664faf4 Reviewed-on: https://go-review.googlesource.com/12360 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/rewrite.go | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go index 306fe1274e..60368784e8 100644 --- a/src/cmd/compile/internal/ssa/rewrite.go +++ b/src/cmd/compile/internal/ssa/rewrite.go @@ -42,7 +42,10 @@ func applyRewrite(f *Func, rb func(*Block) bool, rv func(*Value, *Config) bool) if a.Op != OpCopy { continue } - for a.Op == OpCopy { + // Rewriting can generate OpCopy loops. + // They are harmless (see removePredecessor), + // but take care not to loop forever. + for a.Op == OpCopy && a != a.Args[0] { a = a.Args[0] } v.Args[i] = a -- cgit v1.3 From 21bd483c4ad244b53d4c2d9585787c81f2ce3107 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Mon, 20 Jul 2015 15:30:52 -0700 Subject: [dev.ssa] cmd/compile: refactor out zero value creation This will be used in a subsequent commit. Change-Id: I43eca21f4692d99e164c9f6be0760597c46e6a26 Reviewed-on: https://go-review.googlesource.com/12440 Reviewed-by: Brad Fitzpatrick --- src/cmd/compile/internal/gc/ssa.go | 25 +++++++++++++++---------- 1 file changed, 15 insertions(+), 10 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 2dad3e1a10..d4e4298b39 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -663,16 +663,7 @@ func (s *state) assign(op uint8, left *Node, right *Node) { s.vars[&memvar] = s.newValue2I(ssa.OpZero, ssa.TypeMem, t.Size(), addr, s.mem()) return } - switch { - case t.IsString(): - val = s.entryNewValue0A(ssa.OpConst, left.Type, "") - case t.IsInteger() || t.IsPtr(): - val = s.entryNewValue0(ssa.OpConst, left.Type) - case t.IsBoolean(): - val = s.entryNewValue0A(ssa.OpConst, left.Type, false) // TODO: store bools as 0/1 in AuxInt? - default: - s.Unimplementedf("zero for type %v not implemented", t) - } + val = s.zeroVal(t) } else { val = s.expr(right) } @@ -686,6 +677,20 @@ func (s *state) assign(op uint8, left *Node, right *Node) { s.vars[&memvar] = s.newValue3(ssa.OpStore, ssa.TypeMem, addr, val, s.mem()) } +// zeroVal returns the zero value for type t. +func (s *state) zeroVal(t *Type) *ssa.Value { + switch { + case t.IsString(): + return s.entryNewValue0A(ssa.OpConst, t, "") + case t.IsInteger() || t.IsPtr(): + return s.entryNewValue0(ssa.OpConst, t) + case t.IsBoolean(): + return s.entryNewValue0A(ssa.OpConst, t, false) // TODO: store bools as 0/1 in AuxInt? + } + s.Unimplementedf("zero for type %v not implemented", t) + return nil +} + // 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. func (s *state) addr(n *Node) *ssa.Value { -- cgit v1.3 From 8043f450c170a90de9a04bd801b4f3189ea613ea Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Mon, 20 Jul 2015 15:24:03 -0700 Subject: [dev.ssa] cmd/compile: fix test verb The verb doesn't do anything, but if/when we move these to the test directory, having it be right will be one fewer thing to remember. Change-Id: Ibf0280d7cc14bf48927e25215de6b91c111983d9 Reviewed-on: https://go-review.googlesource.com/12438 Reviewed-by: Brad Fitzpatrick --- src/cmd/compile/internal/gc/testdata/short_ssa.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/testdata/short_ssa.go b/src/cmd/compile/internal/gc/testdata/short_ssa.go index 9427423ff3..1aa7d3e677 100644 --- a/src/cmd/compile/internal/gc/testdata/short_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/short_ssa.go @@ -1,4 +1,4 @@ -// compile +// run // Copyright 2015 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style -- cgit v1.3 From 67fdb0de8656f7c7b76afe8eff614da7bc13b221 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Sun, 19 Jul 2015 15:48:20 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: use width and sign specific opcodes Bake the bit width and signedness into opcodes. Pro: Rewrite rules become easier. Less chance for confusion. Con: Lots more opcodes. Let me know what you think. I'm leaning towards this, but I could be convinced otherwise if people think this is too ugly. Update #11467 Change-Id: Icf1b894268cdf73515877bb123839800d97b9df9 Reviewed-on: https://go-review.googlesource.com/12362 Reviewed-by: Alan Donovan Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/gc/ssa.go | 139 ++++- src/cmd/compile/internal/ssa/config.go | 8 +- src/cmd/compile/internal/ssa/func_test.go | 14 +- src/cmd/compile/internal/ssa/gen/AMD64.rules | 45 +- src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 4 + src/cmd/compile/internal/ssa/gen/generic.rules | 15 +- src/cmd/compile/internal/ssa/gen/genericOps.go | 90 +++- src/cmd/compile/internal/ssa/opGen.go | 675 ++++++++++++++++++++++++- src/cmd/compile/internal/ssa/rewriteAMD64.go | 485 +++++++++++------- src/cmd/compile/internal/ssa/rewritegeneric.go | 101 ++-- src/cmd/compile/internal/ssa/schedule_test.go | 2 +- src/cmd/compile/internal/ssa/shift_test.go | 12 +- src/cmd/compile/internal/ssa/stackalloc.go | 4 +- 13 files changed, 1278 insertions(+), 316 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index d4e4298b39..889b9d8cf8 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -446,19 +446,122 @@ func (s *state) stmt(n *Node) { } } -var binOpToSSA = [...]ssa.Op{ - // Comparisons - OEQ: ssa.OpEq, - ONE: ssa.OpNeq, - OLT: ssa.OpLess, - OLE: ssa.OpLeq, - OGT: ssa.OpGreater, - OGE: ssa.OpGeq, - // Arithmetic - OADD: ssa.OpAdd, - OSUB: ssa.OpSub, - OLSH: ssa.OpLsh, - ORSH: ssa.OpRsh, +type opAndType struct { + op uint8 + etype uint8 +} + +var opToSSA = map[opAndType]ssa.Op{ + opAndType{OADD, TINT8}: ssa.OpAdd8, + opAndType{OADD, TUINT8}: ssa.OpAdd8U, + opAndType{OADD, TINT16}: ssa.OpAdd16, + opAndType{OADD, TUINT16}: ssa.OpAdd16U, + opAndType{OADD, TINT32}: ssa.OpAdd32, + opAndType{OADD, TUINT32}: ssa.OpAdd32U, + opAndType{OADD, TINT64}: ssa.OpAdd64, + opAndType{OADD, TUINT64}: ssa.OpAdd64U, + + opAndType{OSUB, TINT8}: ssa.OpSub8, + opAndType{OSUB, TUINT8}: ssa.OpSub8U, + opAndType{OSUB, TINT16}: ssa.OpSub16, + opAndType{OSUB, TUINT16}: ssa.OpSub16U, + opAndType{OSUB, TINT32}: ssa.OpSub32, + opAndType{OSUB, TUINT32}: ssa.OpSub32U, + opAndType{OSUB, TINT64}: ssa.OpSub64, + opAndType{OSUB, TUINT64}: ssa.OpSub64U, + + opAndType{OLSH, TINT8}: ssa.OpLsh8, + opAndType{OLSH, TUINT8}: ssa.OpLsh8, + opAndType{OLSH, TINT16}: ssa.OpLsh16, + opAndType{OLSH, TUINT16}: ssa.OpLsh16, + opAndType{OLSH, TINT32}: ssa.OpLsh32, + opAndType{OLSH, TUINT32}: ssa.OpLsh32, + opAndType{OLSH, TINT64}: ssa.OpLsh64, + opAndType{OLSH, TUINT64}: ssa.OpLsh64, + + opAndType{ORSH, TINT8}: ssa.OpRsh8, + opAndType{ORSH, TUINT8}: ssa.OpRsh8U, + opAndType{ORSH, TINT16}: ssa.OpRsh16, + opAndType{ORSH, TUINT16}: ssa.OpRsh16U, + opAndType{ORSH, TINT32}: ssa.OpRsh32, + opAndType{ORSH, TUINT32}: ssa.OpRsh32U, + opAndType{ORSH, TINT64}: ssa.OpRsh64, + opAndType{ORSH, TUINT64}: ssa.OpRsh64U, + + 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{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{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{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{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{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, +} + +func (s *state) ssaOp(op uint8, t *Type) ssa.Op { + etype := t.Etype + switch etype { + case TINT: + etype = TINT32 + if s.config.PtrSize == 8 { + etype = TINT64 + } + case TUINT: + etype = TUINT32 + if s.config.PtrSize == 8 { + etype = TUINT64 + } + } + x, ok := opToSSA[opAndType{op, etype}] + if !ok { + s.Unimplementedf("unhandled binary op %s etype=%d", opnames[op], etype) + } + return x } // expr converts the expression n to ssa, adds it to s and returns the ssa result. @@ -503,11 +606,11 @@ func (s *state) expr(n *Node) *ssa.Value { case OLT, OEQ, ONE, OLE, OGE, OGT: a := s.expr(n.Left) b := s.expr(n.Right) - return s.newValue2(binOpToSSA[n.Op], ssa.TypeBool, a, b) + return s.newValue2(s.ssaOp(n.Op, n.Left.Type), ssa.TypeBool, a, b) case OADD, OSUB, OLSH, ORSH: a := s.expr(n.Left) b := s.expr(n.Right) - return s.newValue2(binOpToSSA[n.Op], a.Type, a, b) + return s.newValue2(s.ssaOp(n.Op, n.Type), a.Type, a, b) case OANDAND, OOROR: // To implement OANDAND (and OOROR), we introduce a // new temporary variable to hold the result. The @@ -569,7 +672,7 @@ func (s *state) expr(n *Node) *ssa.Value { case ODOTPTR: p := s.expr(n.Left) s.nilCheck(p) - p = s.newValue2(ssa.OpAdd, p.Type, p, s.constInt(s.config.Uintptr, n.Xoffset)) + p = s.newValue2(ssa.OpAddPtr, p.Type, p, s.constInt(s.config.Uintptr, n.Xoffset)) return s.newValue2(ssa.OpLoad, n.Type, p, s.mem()) case OINDEX: @@ -742,11 +845,11 @@ func (s *state) addr(n *Node) *ssa.Value { return p case ODOT: p := s.addr(n.Left) - return s.newValue2(ssa.OpAdd, p.Type, p, s.constInt(s.config.Uintptr, n.Xoffset)) + return s.newValue2(ssa.OpAddPtr, p.Type, p, s.constInt(s.config.Uintptr, n.Xoffset)) case ODOTPTR: p := s.expr(n.Left) s.nilCheck(p) - return s.newValue2(ssa.OpAdd, p.Type, p, s.constInt(s.config.Uintptr, n.Xoffset)) + return s.newValue2(ssa.OpAddPtr, p.Type, p, s.constInt(s.config.Uintptr, n.Xoffset)) default: s.Unimplementedf("addr: bad op %v", Oconv(int(n.Op), 0)) return nil diff --git a/src/cmd/compile/internal/ssa/config.go b/src/cmd/compile/internal/ssa/config.go index c6c7bf36e9..c9e543ba37 100644 --- a/src/cmd/compile/internal/ssa/config.go +++ b/src/cmd/compile/internal/ssa/config.go @@ -6,7 +6,7 @@ package ssa type Config struct { arch string // "amd64", etc. - ptrSize int64 // 4 or 8 + PtrSize int64 // 4 or 8 Uintptr Type // pointer arithmetic type Int Type lowerBlock func(*Block) bool // lowering function @@ -38,11 +38,11 @@ func NewConfig(arch string, fe Frontend) *Config { c := &Config{arch: arch, fe: fe} switch arch { case "amd64": - c.ptrSize = 8 + c.PtrSize = 8 c.lowerBlock = rewriteBlockAMD64 c.lowerValue = rewriteValueAMD64 case "386": - c.ptrSize = 4 + c.PtrSize = 4 c.lowerBlock = rewriteBlockAMD64 c.lowerValue = rewriteValueAMD64 // TODO(khr): full 32-bit support default: @@ -52,7 +52,7 @@ func NewConfig(arch string, fe Frontend) *Config { // cache the frequently-used types in the config c.Uintptr = TypeUInt32 c.Int = TypeInt32 - if c.ptrSize == 8 { + if c.PtrSize == 8 { c.Uintptr = TypeUInt64 c.Int = TypeInt64 } diff --git a/src/cmd/compile/internal/ssa/func_test.go b/src/cmd/compile/internal/ssa/func_test.go index a620e8f602..edea8f78d1 100644 --- a/src/cmd/compile/internal/ssa/func_test.go +++ b/src/cmd/compile/internal/ssa/func_test.go @@ -267,7 +267,7 @@ func TestArgs(t *testing.T) { Bloc("entry", Valu("a", OpConst, TypeInt64, 14, nil), Valu("b", OpConst, TypeInt64, 26, nil), - Valu("sum", OpAdd, TypeInt64, 0, nil, "a", "b"), + Valu("sum", OpAdd64, TypeInt64, 0, nil, "a", "b"), Valu("mem", OpArg, TypeMem, 0, ".mem"), Goto("exit")), Bloc("exit", @@ -290,7 +290,7 @@ func TestEquiv(t *testing.T) { Bloc("entry", Valu("a", OpConst, TypeInt64, 14, nil), Valu("b", OpConst, TypeInt64, 26, nil), - Valu("sum", OpAdd, TypeInt64, 0, nil, "a", "b"), + Valu("sum", OpAdd64, TypeInt64, 0, nil, "a", "b"), Valu("mem", OpArg, TypeMem, 0, ".mem"), Goto("exit")), Bloc("exit", @@ -299,7 +299,7 @@ func TestEquiv(t *testing.T) { Bloc("entry", Valu("a", OpConst, TypeInt64, 14, nil), Valu("b", OpConst, TypeInt64, 26, nil), - Valu("sum", OpAdd, TypeInt64, 0, nil, "a", "b"), + Valu("sum", OpAdd64, TypeInt64, 0, nil, "a", "b"), Valu("mem", OpArg, TypeMem, 0, ".mem"), Goto("exit")), Bloc("exit", @@ -311,7 +311,7 @@ func TestEquiv(t *testing.T) { Bloc("entry", Valu("a", OpConst, TypeInt64, 14, nil), Valu("b", OpConst, TypeInt64, 26, nil), - Valu("sum", OpAdd, TypeInt64, 0, nil, "a", "b"), + Valu("sum", OpAdd64, TypeInt64, 0, nil, "a", "b"), Valu("mem", OpArg, TypeMem, 0, ".mem"), Goto("exit")), Bloc("exit", @@ -322,7 +322,7 @@ func TestEquiv(t *testing.T) { Bloc("entry", Valu("a", OpConst, TypeInt64, 14, nil), Valu("b", OpConst, TypeInt64, 26, nil), - Valu("sum", OpAdd, TypeInt64, 0, nil, "a", "b"), + Valu("sum", OpAdd64, TypeInt64, 0, nil, "a", "b"), Valu("mem", OpArg, TypeMem, 0, ".mem"), Goto("exit"))), }, @@ -397,14 +397,14 @@ func TestEquiv(t *testing.T) { Valu("mem", OpArg, TypeMem, 0, ".mem"), Valu("a", OpConst, TypeInt64, 14, nil), Valu("b", OpConst, TypeInt64, 26, nil), - Valu("sum", OpAdd, TypeInt64, 0, nil, "a", "b"), + Valu("sum", OpAdd64, TypeInt64, 0, nil, "a", "b"), Exit("mem"))), Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), Valu("a", OpConst, TypeInt64, 0, nil), Valu("b", OpConst, TypeInt64, 14, nil), - Valu("sum", OpAdd, TypeInt64, 0, nil, "b", "a"), + Valu("sum", OpAdd64, TypeInt64, 0, nil, "b", "a"), Exit("mem"))), }, } diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 3e25929af5..eba3710460 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -13,14 +13,25 @@ // Unused portions are junk. // Lowering arithmetic -(Add x y) && (is64BitInt(t) || isPtr(t)) -> (ADDQ x y) -(Add x y) && is32BitInt(t) && !isSigned(t) -> (ADDL x y) -(Add x y) && is32BitInt(t) && isSigned(t) -> (MOVLQSX (ADDL x y)) -(Add x y) && is16BitInt(t) && !isSigned(t) -> (ADDW x y) -(Add x y) && is16BitInt(t) && isSigned(t) -> (MOVWQSX (ADDW x y)) -(Add x y) && is8BitInt(t) && !isSigned(t) -> (ADDB x y) -(Add x y) && is8BitInt(t) && isSigned(t) -> (MOVBQSX (ADDB x y)) -(Sub x y) && is64BitInt(t) -> (SUBQ x y) +(Add64 x y) -> (ADDQ x y) +(Add64U x y) -> (ADDQ x y) +(AddPtr x y) -> (ADDQ x y) +(Add32U x y) -> (ADDL x y) +(Add32 x y) -> (MOVLQSX (ADDL x y)) +(Add16U x y) -> (ADDW x y) +(Add16 x y) -> (MOVWQSX (ADDW x y)) +(Add8U x y) -> (ADDB x y) +(Add8 x y) -> (MOVBQSX (ADDB x y)) + +(Sub64 x y) -> (SUBQ x y) +(Sub64U x y) -> (SUBQ x y) +(Sub32U x y) -> (SUBL x y) +(Sub32 x y) -> (MOVLQSX (SUBL x y)) +(Sub16U x y) -> (SUBW x y) +(Sub16 x y) -> (MOVWQSX (SUBW x y)) +(Sub8U x y) -> (SUBB x y) +(Sub8 x y) -> (MOVBQSX (SUBB x y)) + (Mul x y) && is64BitInt(t) -> (MULQ x y) (MOVLstore ptr (MOVLQSX x) mem) -> (MOVLstore ptr x mem) @@ -34,26 +45,26 @@ // Note: unsigned shifts need to return 0 if shift amount is >= 64. // mask = shift >= 64 ? 0 : 0xffffffffffffffff // result = mask & arg << shift -(Lsh x y) && is64BitInt(t) -> +(Lsh64 x y) -> (ANDQ (SHLQ x y) (SBBQcarrymask (CMPQconst [64] y))) -(Rsh x y) && is64BitInt(t) && !t.IsSigned() -> +(Rsh64U x y) -> (ANDQ (SHRQ x y) (SBBQcarrymask (CMPQconst [64] y))) // Note: signed right shift needs to return 0/-1 if shift amount is >= 64. // if shift > 63 { shift = 63 } // result = arg >> shift -(Rsh x y) && is64BitInt(t) && t.IsSigned() -> +(Rsh64 x y) -> (SARQ x (CMOVQCC (CMPQconst [64] y) (Const [63]) y)) -(Less x y) && is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type) -> (SETL (CMPQ x y)) -(Leq x y) && is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type) -> (SETLE (CMPQ x y)) -(Greater x y) && is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type) -> (SETG (CMPQ x y)) -(Geq x y) && is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type) -> (SETGE (CMPQ x y)) -(Eq x y) && is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type) -> (SETEQ (CMPQ x y)) -(Neq x y) && is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type) -> (SETNE (CMPQ x y)) +(Less64 x y) -> (SETL (CMPQ x y)) +(Leq64 x y) -> (SETLE (CMPQ x y)) +(Greater64 x y) -> (SETG (CMPQ x y)) +(Geq64 x y) -> (SETGE (CMPQ x y)) +(Eq64 x y) -> (SETEQ (CMPQ x y)) +(Neq64 x y) -> (SETNE (CMPQ x y)) (Load ptr mem) && (is64BitInt(t) || isPtr(t)) -> (MOVQload ptr mem) (Load ptr mem) && is32BitInt(t) -> (MOVLload ptr mem) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 31beb005f8..602949eac9 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -174,6 +174,10 @@ func init() { {name: "ADDW", reg: gp21, asm: "ADDW"}, // arg0+arg1 {name: "ADDB", reg: gp21, asm: "ADDB"}, // arg0+arg1 + {name: "SUBL", reg: gp21, asm: "SUBL"}, // arg0-arg1 + {name: "SUBW", reg: gp21, asm: "SUBW"}, // arg0-arg1 + {name: "SUBB", reg: gp21, asm: "SUBB"}, // arg0-arg1 + // (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. diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index a906ec6a5c..e505c43d26 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -20,20 +20,21 @@ // For now, the generated successors must be a permutation of the matched successors. // constant folding -(Add (Const [c]) (Const [d])) && is64BitInt(t) -> (Const [c+d]) +(Add64 (Const [c]) (Const [d])) -> (Const [c+d]) +(Add64U (Const [c]) (Const [d])) -> (Const [c+d]) (Mul (Const [c]) (Const [d])) && is64BitInt(t) -> (Const [c*d]) (IsInBounds (Const [c]) (Const [d])) -> (Const {inBounds(c,d)}) // tear apart slices // TODO: anything that generates a slice needs to go in here. (SlicePtr (Load ptr mem)) -> (Load ptr mem) -(SliceLen (Load ptr mem)) -> (Load (Add ptr (Const [config.ptrSize])) mem) -(SliceCap (Load ptr mem)) -> (Load (Add ptr (Const [config.ptrSize*2])) mem) +(SliceLen (Load ptr mem)) -> (Load (AddPtr ptr (Const [config.PtrSize])) mem) +(SliceCap (Load ptr mem)) -> (Load (AddPtr ptr (Const [config.PtrSize*2])) mem) // indexing operations // Note: bounds check has already been done (ArrayIndex (Load ptr mem) idx) -> (Load (PtrIndex ptr idx) mem) -(PtrIndex ptr idx) -> (Add ptr (Mul idx (Const [t.Elem().Size()]))) +(PtrIndex ptr idx) -> (AddPtr ptr (Mul idx (Const [t.Elem().Size()]))) (StructSelect [idx] (Load ptr mem)) -> (Load (OffPtr [idx] ptr) mem) // big-object moves @@ -41,11 +42,11 @@ (Store dst (Load src mem) mem) && t.Size() > 8 -> (Move [t.Size()] dst src mem) // string ops -(Const {s}) && t.IsString() -> (StringMake (OffPtr [2*config.ptrSize] (Addr {config.fe.StringSym(s.(string))} (SB ))) (Const [int64(len(s.(string)))])) // TODO: ptr -(Load ptr mem) && t.IsString() -> (StringMake (Load ptr mem) (Load (OffPtr [config.ptrSize] ptr) mem)) +(Const {s}) && t.IsString() -> (StringMake (OffPtr [2*config.PtrSize] (Addr {config.fe.StringSym(s.(string))} (SB ))) (Const [int64(len(s.(string)))])) // TODO: ptr +(Load ptr mem) && t.IsString() -> (StringMake (Load ptr mem) (Load (OffPtr [config.PtrSize] ptr) mem)) (StringPtr (StringMake ptr _)) -> ptr (StringLen (StringMake _ len)) -> len -(Store dst str mem) && str.Type.IsString() -> (Store (OffPtr [config.ptrSize] dst) (StringLen str) (Store dst (StringPtr str) mem)) +(Store dst str mem) && str.Type.IsString() -> (Store (OffPtr [config.PtrSize] dst) (StringLen str) (Store dst (StringPtr str) mem)) (If (Const {c}) yes no) && c.(bool) -> (Plain nil yes) (If (Const {c}) yes no) && !c.(bool) -> (Plain nil no) diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 0af7df1775..12c2901076 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -8,19 +8,89 @@ 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: "Add"}, // arg0 + arg1 - {name: "Sub"}, // arg0 - arg1 + {name: "Add8"}, // arg0 + arg1 + {name: "Add16"}, + {name: "Add32"}, + {name: "Add64"}, + {name: "Add8U"}, + {name: "Add16U"}, + {name: "Add32U"}, + {name: "Add64U"}, + {name: "AddPtr"}, + // TODO: Add32F, Add64F, Add64C, Add128C + + {name: "Sub8"}, // arg0 - arg1 + {name: "Sub16"}, + {name: "Sub32"}, + {name: "Sub64"}, + {name: "Sub8U"}, + {name: "Sub16U"}, + {name: "Sub32U"}, + {name: "Sub64U"}, + // TODO: Sub32F, Sub64F, Sub64C, Sub128C + {name: "Mul"}, // arg0 * arg1 - {name: "Lsh"}, // arg0 << arg1 - {name: "Rsh"}, // arg0 >> arg1 (signed/unsigned depending on signedness of type) + + {name: "Lsh8"}, // arg0 << arg1 + {name: "Lsh16"}, + {name: "Lsh32"}, + {name: "Lsh64"}, + + {name: "Rsh8"}, // arg0 >> arg1 + {name: "Rsh8U"}, + {name: "Rsh16"}, + {name: "Rsh16U"}, + {name: "Rsh32"}, + {name: "Rsh32U"}, + {name: "Rsh64"}, + {name: "Rsh64U"}, // 2-input comparisons - {name: "Eq"}, // arg0 == arg1 - {name: "Neq"}, // arg0 != arg1 - {name: "Less"}, // arg0 < arg1 - {name: "Leq"}, // arg0 <= arg1 - {name: "Greater"}, // arg0 > arg1 - {name: "Geq"}, // arg0 <= arg1 + {name: "Eq8"}, // arg0 == arg1 + {name: "Eq16"}, + {name: "Eq32"}, + {name: "Eq64"}, + + {name: "Neq8"}, // arg0 != arg1 + {name: "Neq16"}, + {name: "Neq32"}, + {name: "Neq64"}, + + {name: "Less8"}, // arg0 < arg1 + {name: "Less8U"}, + {name: "Less16"}, + {name: "Less16U"}, + {name: "Less32"}, + {name: "Less32U"}, + {name: "Less64"}, + {name: "Less64U"}, + + {name: "Leq8"}, // arg0 <= arg1 + {name: "Leq8U"}, + {name: "Leq16"}, + {name: "Leq16U"}, + {name: "Leq32"}, + {name: "Leq32U"}, + {name: "Leq64"}, + {name: "Leq64U"}, + + {name: "Greater8"}, // arg0 > arg1 + {name: "Greater8U"}, + {name: "Greater16"}, + {name: "Greater16U"}, + {name: "Greater32"}, + {name: "Greater32U"}, + {name: "Greater64"}, + {name: "Greater64U"}, + + {name: "Geq8"}, // arg0 <= arg1 + {name: "Geq8U"}, + {name: "Geq16"}, + {name: "Geq16U"}, + {name: "Geq32"}, + {name: "Geq32U"}, + {name: "Geq64"}, + {name: "Geq64U"}, // 1-input ops {name: "Not"}, // !arg0 diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 74d30e1df5..95e2ef798a 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -111,19 +111,81 @@ const ( OpAMD64ADDL OpAMD64ADDW OpAMD64ADDB + OpAMD64SUBL + OpAMD64SUBW + OpAMD64SUBB OpAMD64InvertFlags - OpAdd - OpSub + OpAdd8 + OpAdd16 + OpAdd32 + OpAdd64 + OpAdd8U + OpAdd16U + OpAdd32U + OpAdd64U + OpAddPtr + OpSub8 + OpSub16 + OpSub32 + OpSub64 + OpSub8U + OpSub16U + OpSub32U + OpSub64U OpMul - OpLsh - OpRsh - OpEq - OpNeq - OpLess - OpLeq - OpGreater - OpGeq + OpLsh8 + OpLsh16 + OpLsh32 + OpLsh64 + OpRsh8 + OpRsh8U + OpRsh16 + OpRsh16U + OpRsh32 + OpRsh32U + OpRsh64 + OpRsh64U + OpEq8 + OpEq16 + OpEq32 + OpEq64 + OpNeq8 + OpNeq16 + OpNeq32 + OpNeq64 + OpLess8 + OpLess8U + OpLess16 + OpLess16U + OpLess32 + OpLess32U + OpLess64 + OpLess64U + OpLeq8 + OpLeq8U + OpLeq16 + OpLeq16U + OpLeq32 + OpLeq32U + OpLeq64 + OpLeq64U + OpGreater8 + OpGreater8U + OpGreater16 + OpGreater16U + OpGreater32 + OpGreater32U + OpGreater64 + OpGreater64U + OpGeq8 + OpGeq8U + OpGeq16 + OpGeq16U + OpGeq32 + OpGeq32U + OpGeq64 + OpGeq64U OpNot OpPhi OpCopy @@ -927,6 +989,48 @@ var opcodeTable = [...]opInfo{ }, }, }, + { + name: "SUBL", + asm: x86.ASUBL, + reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + clobbers: 0, + outputs: []regMask{ + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + }, + }, + { + name: "SUBW", + asm: x86.ASUBW, + reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + clobbers: 0, + outputs: []regMask{ + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + }, + }, + { + name: "SUBB", + asm: x86.ASUBB, + reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + clobbers: 0, + outputs: []regMask{ + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + }, + }, { name: "InvertFlags", reg: regInfo{ @@ -937,7 +1041,142 @@ var opcodeTable = [...]opInfo{ }, { - name: "Add", + name: "Add8", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Add16", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Add32", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Add64", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Add8U", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Add16U", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Add32U", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Add64U", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "AddPtr", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Sub8", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Sub16", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Sub32", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Sub64", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Sub8U", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Sub16U", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Sub32U", reg: regInfo{ inputs: []regMask{}, clobbers: 0, @@ -946,7 +1185,7 @@ var opcodeTable = [...]opInfo{ generic: true, }, { - name: "Sub", + name: "Sub64U", reg: regInfo{ inputs: []regMask{}, clobbers: 0, @@ -964,7 +1203,403 @@ var opcodeTable = [...]opInfo{ generic: true, }, { - name: "Lsh", + name: "Lsh8", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Lsh16", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Lsh32", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Lsh64", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Rsh8", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Rsh8U", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Rsh16", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Rsh16U", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Rsh32", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Rsh32U", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Rsh64", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Rsh64U", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Eq8", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Eq16", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Eq32", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Eq64", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Neq8", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Neq16", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Neq32", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Neq64", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Less8", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Less8U", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Less16", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Less16U", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Less32", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Less32U", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Less64", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Less64U", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Leq8", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Leq8U", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Leq16", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Leq16U", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Leq32", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Leq32U", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Leq64", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Leq64U", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Greater8", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Greater8U", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Greater16", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Greater16U", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Greater32", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Greater32U", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Greater64", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Greater64U", + reg: regInfo{ + inputs: []regMask{}, + clobbers: 0, + outputs: []regMask{}, + }, + generic: true, + }, + { + name: "Geq8", reg: regInfo{ inputs: []regMask{}, clobbers: 0, @@ -973,7 +1608,7 @@ var opcodeTable = [...]opInfo{ generic: true, }, { - name: "Rsh", + name: "Geq8U", reg: regInfo{ inputs: []regMask{}, clobbers: 0, @@ -982,7 +1617,7 @@ var opcodeTable = [...]opInfo{ generic: true, }, { - name: "Eq", + name: "Geq16", reg: regInfo{ inputs: []regMask{}, clobbers: 0, @@ -991,7 +1626,7 @@ var opcodeTable = [...]opInfo{ generic: true, }, { - name: "Neq", + name: "Geq16U", reg: regInfo{ inputs: []regMask{}, clobbers: 0, @@ -1000,7 +1635,7 @@ var opcodeTable = [...]opInfo{ generic: true, }, { - name: "Less", + name: "Geq32", reg: regInfo{ inputs: []regMask{}, clobbers: 0, @@ -1009,7 +1644,7 @@ var opcodeTable = [...]opInfo{ generic: true, }, { - name: "Leq", + name: "Geq32U", reg: regInfo{ inputs: []regMask{}, clobbers: 0, @@ -1018,7 +1653,7 @@ var opcodeTable = [...]opInfo{ generic: true, }, { - name: "Greater", + name: "Geq64", reg: regInfo{ inputs: []regMask{}, clobbers: 0, @@ -1027,7 +1662,7 @@ var opcodeTable = [...]opInfo{ generic: true, }, { - name: "Geq", + name: "Geq64U", reg: regInfo{ inputs: []regMask{}, clobbers: 0, diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 3e24f9f618..9a879a39bb 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -187,39 +187,35 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end646afc7b328db89ad16ebfa156ae26e5 end646afc7b328db89ad16ebfa156ae26e5: ; - case OpAdd: - // match: (Add x y) - // cond: (is64BitInt(t) || isPtr(t)) - // result: (ADDQ x y) + case OpAdd16: + // match: (Add16 x y) + // cond: + // result: (MOVWQSX (ADDW x y)) { - t := v.Type x := v.Args[0] y := v.Args[1] - if !(is64BitInt(t) || isPtr(t)) { - goto endf031c523d7dd08e4b8e7010a94cd94c9 - } - v.Op = OpAMD64ADDQ + v.Op = OpAMD64MOVWQSX v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AddArg(x) - v.AddArg(y) + v0 := v.Block.NewValue0(v.Line, OpAMD64ADDW, TypeInvalid) + v0.Type = v.Type + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) return true } - goto endf031c523d7dd08e4b8e7010a94cd94c9 - endf031c523d7dd08e4b8e7010a94cd94c9: + goto end2aef2dab49f6b2ca337f58ad0a8209ae + end2aef2dab49f6b2ca337f58ad0a8209ae: ; - // match: (Add x y) - // cond: is32BitInt(t) && !isSigned(t) - // result: (ADDL x y) + case OpAdd16U: + // match: (Add16U x y) + // cond: + // result: (ADDW x y) { - t := v.Type x := v.Args[0] y := v.Args[1] - if !(is32BitInt(t) && !isSigned(t)) { - goto endce1730b0a04d773ed8029e7eac4f3a50 - } - v.Op = OpAMD64ADDL + v.Op = OpAMD64ADDW v.AuxInt = 0 v.Aux = nil v.resetArgs() @@ -227,44 +223,38 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(y) return true } - goto endce1730b0a04d773ed8029e7eac4f3a50 - endce1730b0a04d773ed8029e7eac4f3a50: + goto end8ca34beeb0897b0c70352ba90cca4a1d + end8ca34beeb0897b0c70352ba90cca4a1d: ; - // match: (Add x y) - // cond: is32BitInt(t) && isSigned(t) - // result: (MOVLQSX (ADDL x y)) + case OpAdd32: + // match: (Add32 x y) + // cond: + // result: (MOVLQSX (ADDL x y)) { - t := v.Type x := v.Args[0] y := v.Args[1] - if !(is32BitInt(t) && isSigned(t)) { - goto end86e07674e2e9d2e1fc5a8f5f74375513 - } v.Op = OpAMD64MOVLQSX v.AuxInt = 0 v.Aux = nil v.resetArgs() v0 := v.Block.NewValue0(v.Line, OpAMD64ADDL, TypeInvalid) - v0.Type = t + v0.Type = v.Type v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) return true } - goto end86e07674e2e9d2e1fc5a8f5f74375513 - end86e07674e2e9d2e1fc5a8f5f74375513: + goto end7f18bca004d8c158f50b04e7511af49f + end7f18bca004d8c158f50b04e7511af49f: ; - // match: (Add x y) - // cond: is16BitInt(t) && !isSigned(t) - // result: (ADDW x y) + case OpAdd32U: + // match: (Add32U x y) + // cond: + // result: (ADDL x y) { - t := v.Type x := v.Args[0] y := v.Args[1] - if !(is16BitInt(t) && !isSigned(t)) { - goto end99632c2482f1963513f12a317c588800 - } - v.Op = OpAMD64ADDW + v.Op = OpAMD64ADDL v.AuxInt = 0 v.Aux = nil v.resetArgs() @@ -272,44 +262,35 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(y) return true } - goto end99632c2482f1963513f12a317c588800 - end99632c2482f1963513f12a317c588800: + goto end72ff71aa883fa569307ae06289ac1e30 + end72ff71aa883fa569307ae06289ac1e30: ; - // match: (Add x y) - // cond: is16BitInt(t) && isSigned(t) - // result: (MOVWQSX (ADDW x y)) + case OpAdd64: + // match: (Add64 x y) + // cond: + // result: (ADDQ x y) { - t := v.Type x := v.Args[0] y := v.Args[1] - if !(is16BitInt(t) && isSigned(t)) { - goto endd215b5658d14e7d1cb469a516aa554e9 - } - v.Op = OpAMD64MOVWQSX + v.Op = OpAMD64ADDQ v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64ADDW, TypeInvalid) - v0.Type = t - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) + v.AddArg(x) + v.AddArg(y) return true } - goto endd215b5658d14e7d1cb469a516aa554e9 - endd215b5658d14e7d1cb469a516aa554e9: + goto endd88f18b3f39e3ccc201477a616f0abc0 + endd88f18b3f39e3ccc201477a616f0abc0: ; - // match: (Add x y) - // cond: is8BitInt(t) && !isSigned(t) - // result: (ADDB x y) + case OpAdd64U: + // match: (Add64U x y) + // cond: + // result: (ADDQ x y) { - t := v.Type x := v.Args[0] y := v.Args[1] - if !(is8BitInt(t) && !isSigned(t)) { - goto end41d7f409a1e1076e9645e2e90b7220ce - } - v.Op = OpAMD64ADDB + v.Op = OpAMD64ADDQ v.AuxInt = 0 v.Aux = nil v.resetArgs() @@ -317,32 +298,65 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(y) return true } - goto end41d7f409a1e1076e9645e2e90b7220ce - end41d7f409a1e1076e9645e2e90b7220ce: + goto endee28cc0dbdf2664cb3f6a5ddb3960b1b + endee28cc0dbdf2664cb3f6a5ddb3960b1b: ; - // match: (Add x y) - // cond: is8BitInt(t) && isSigned(t) - // result: (MOVBQSX (ADDB x y)) + case OpAdd8: + // match: (Add8 x y) + // cond: + // result: (MOVBQSX (ADDB x y)) { - t := v.Type x := v.Args[0] y := v.Args[1] - if !(is8BitInt(t) && isSigned(t)) { - goto end858e823866524b81b4636f7dd7e8eefe - } v.Op = OpAMD64MOVBQSX v.AuxInt = 0 v.Aux = nil v.resetArgs() v0 := v.Block.NewValue0(v.Line, OpAMD64ADDB, TypeInvalid) - v0.Type = t + v0.Type = v.Type v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) return true } - goto end858e823866524b81b4636f7dd7e8eefe - end858e823866524b81b4636f7dd7e8eefe: + goto end7078e2b21b2da3acc80e79ba1386d098 + end7078e2b21b2da3acc80e79ba1386d098: + ; + case OpAdd8U: + // match: (Add8U x y) + // cond: + // result: (ADDB x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ADDB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto endb5cb0e4b3566464c17acf1df5e4b0543 + endb5cb0e4b3566464c17acf1df5e4b0543: + ; + case OpAddPtr: + // match: (AddPtr x y) + // cond: + // result: (ADDQ x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ADDQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto enda1d5640788c7157996f9d4af602dec1c + enda1d5640788c7157996f9d4af602dec1c: ; case OpAddr: // match: (Addr {sym} base) @@ -595,16 +609,13 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endcc7894224d4f6b0bcabcece5d0185912 endcc7894224d4f6b0bcabcece5d0185912: ; - case OpEq: - // match: (Eq x y) - // cond: is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type) + case OpEq64: + // match: (Eq64 x y) + // cond: // result: (SETEQ (CMPQ x y)) { x := v.Args[0] y := v.Args[1] - if !(is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type)) { - goto endad64a62086703de09f52315e190bdf0e - } v.Op = OpAMD64SETEQ v.AuxInt = 0 v.Aux = nil @@ -616,19 +627,16 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto endad64a62086703de09f52315e190bdf0e - endad64a62086703de09f52315e190bdf0e: + goto endae6c62e4e20b4f62694b6ee40dbd9211 + endae6c62e4e20b4f62694b6ee40dbd9211: ; - case OpGeq: - // match: (Geq x y) - // cond: is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type) + case OpGeq64: + // match: (Geq64 x y) + // cond: // result: (SETGE (CMPQ x y)) { x := v.Args[0] y := v.Args[1] - if !(is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type)) { - goto end31ba1968829a3b451a35431111140fec - } v.Op = OpAMD64SETGE v.AuxInt = 0 v.Aux = nil @@ -640,19 +648,16 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end31ba1968829a3b451a35431111140fec - end31ba1968829a3b451a35431111140fec: + goto end63f44e3fec8d92723b5bde42d6d7eea0 + end63f44e3fec8d92723b5bde42d6d7eea0: ; - case OpGreater: - // match: (Greater x y) - // cond: is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type) + case OpGreater64: + // match: (Greater64 x y) + // cond: // result: (SETG (CMPQ x y)) { x := v.Args[0] y := v.Args[1] - if !(is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type)) { - goto end1cff30b1bf40104e5e30ab73d6568f7f - } v.Op = OpAMD64SETG v.AuxInt = 0 v.Aux = nil @@ -664,8 +669,8 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end1cff30b1bf40104e5e30ab73d6568f7f - end1cff30b1bf40104e5e30ab73d6568f7f: + goto endaef0cfa5e27e23cf5e527061cf251069 + endaef0cfa5e27e23cf5e527061cf251069: ; case OpIsInBounds: // match: (IsInBounds idx len) @@ -708,16 +713,13 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endff508c3726edfb573abc6128c177e76c endff508c3726edfb573abc6128c177e76c: ; - case OpLeq: - // match: (Leq x y) - // cond: is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type) + case OpLeq64: + // match: (Leq64 x y) + // cond: // result: (SETLE (CMPQ x y)) { x := v.Args[0] y := v.Args[1] - if !(is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type)) { - goto enddb4f100c01cdd95d69d399ffc37e33e7 - } v.Op = OpAMD64SETLE v.AuxInt = 0 v.Aux = nil @@ -729,19 +731,16 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto enddb4f100c01cdd95d69d399ffc37e33e7 - enddb4f100c01cdd95d69d399ffc37e33e7: + goto endf03da5e28dccdb4797671f39e824fb10 + endf03da5e28dccdb4797671f39e824fb10: ; - case OpLess: - // match: (Less x y) - // cond: is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type) + case OpLess64: + // match: (Less64 x y) + // cond: // result: (SETL (CMPQ x y)) { x := v.Args[0] y := v.Args[1] - if !(is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type)) { - goto endcecf13a952d4c6c2383561c7d68a3cf9 - } v.Op = OpAMD64SETL v.AuxInt = 0 v.Aux = nil @@ -753,8 +752,8 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto endcecf13a952d4c6c2383561c7d68a3cf9 - endcecf13a952d4c6c2383561c7d68a3cf9: + goto endf8e7a24c25692045bbcfd2c9356d1a8c + endf8e7a24c25692045bbcfd2c9356d1a8c: ; case OpLoad: // match: (Load ptr mem) @@ -841,17 +840,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end8f83bf72293670e75b22d6627bd13f0b end8f83bf72293670e75b22d6627bd13f0b: ; - case OpLsh: - // match: (Lsh x y) - // cond: is64BitInt(t) + case OpLsh64: + // match: (Lsh64 x y) + // cond: // result: (ANDQ (SHLQ x y) (SBBQcarrymask (CMPQconst [64] y))) { t := v.Type x := v.Args[0] y := v.Args[1] - if !(is64BitInt(t)) { - goto end5d9e2211940fbc82536685578cf37d08 - } v.Op = OpAMD64ANDQ v.AuxInt = 0 v.Aux = nil @@ -871,8 +867,8 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto end5d9e2211940fbc82536685578cf37d08 - end5d9e2211940fbc82536685578cf37d08: + goto end02b17b9d1aca859d392e527fe6fc58da + end02b17b9d1aca859d392e527fe6fc58da: ; case OpAMD64MOVBstore: // match: (MOVBstore ptr (MOVBQSX x) mem) @@ -1289,16 +1285,13 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endfab0d598f376ecba45a22587d50f7aff endfab0d598f376ecba45a22587d50f7aff: ; - case OpNeq: - // match: (Neq x y) - // cond: is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type) + case OpNeq64: + // match: (Neq64 x y) + // cond: // result: (SETNE (CMPQ x y)) { x := v.Args[0] y := v.Args[1] - if !(is64BitInt(v.Args[0].Type) && isSigned(v.Args[0].Type)) { - goto enddccbd4e7581ae8d9916b933d3501987b - } v.Op = OpAMD64SETNE v.AuxInt = 0 v.Aux = nil @@ -1310,8 +1303,8 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto enddccbd4e7581ae8d9916b933d3501987b - enddccbd4e7581ae8d9916b933d3501987b: + goto end8ab0bcb910c0d3213dd8726fbcc4848e + end8ab0bcb910c0d3213dd8726fbcc4848e: ; case OpNot: // match: (Not x) @@ -1348,49 +1341,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end0429f947ee7ac49ff45a243e461a5290 end0429f947ee7ac49ff45a243e461a5290: ; - case OpRsh: - // match: (Rsh x y) - // cond: is64BitInt(t) && !t.IsSigned() - // result: (ANDQ (SHRQ x y) (SBBQcarrymask (CMPQconst [64] y))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - if !(is64BitInt(t) && !t.IsSigned()) { - goto ende3e068773b8e6def1eaedb4f404ca6e5 - } - v.Op = OpAMD64ANDQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64SHRQ, TypeInvalid) - v0.Type = t - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) - v1.Type = t - v2 := v.Block.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) - v2.Type = TypeFlags - v2.AuxInt = 64 - v2.AddArg(y) - v1.AddArg(v2) - v.AddArg(v1) - return true - } - goto ende3e068773b8e6def1eaedb4f404ca6e5 - ende3e068773b8e6def1eaedb4f404ca6e5: - ; - // match: (Rsh x y) - // cond: is64BitInt(t) && t.IsSigned() + case OpRsh64: + // match: (Rsh64 x y) + // cond: // result: (SARQ x (CMOVQCC (CMPQconst [64] y) (Const [63]) y)) { t := v.Type x := v.Args[0] y := v.Args[1] - if !(is64BitInt(t) && t.IsSigned()) { - goto end901ea4851cd5d2277a1ca1bee8f69d59 - } v.Op = OpAMD64SARQ v.AuxInt = 0 v.Aux = nil @@ -1412,8 +1370,38 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end901ea4851cd5d2277a1ca1bee8f69d59 - end901ea4851cd5d2277a1ca1bee8f69d59: + goto end831ac9db492245c5e6c83d0b2a96b2d3 + end831ac9db492245c5e6c83d0b2a96b2d3: + ; + case OpRsh64U: + // match: (Rsh64U x y) + // cond: + // result: (ANDQ (SHRQ x y) (SBBQcarrymask (CMPQconst [64] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64SHRQ, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1.Type = t + v2 := v.Block.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v2.Type = TypeFlags + v2.AuxInt = 64 + v2.AddArg(y) + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto end90c34fa7de598170ea23d23d9a03ebfc + end90c34fa7de598170ea23d23d9a03ebfc: ; case OpAMD64SARQ: // match: (SARQ x (MOVQconst [c])) @@ -1743,17 +1731,109 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end6f343b676bf49740054e459f972b24f5 end6f343b676bf49740054e459f972b24f5: ; - case OpSub: - // match: (Sub x y) - // cond: is64BitInt(t) + case OpSub16: + // match: (Sub16 x y) + // cond: + // result: (MOVWQSX (SUBW x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64MOVWQSX + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64SUBW, TypeInvalid) + v0.Type = v.Type + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto endf9d14f07ce4212200662acd073b77a79 + endf9d14f07ce4212200662acd073b77a79: + ; + case OpSub16U: + // match: (Sub16U x y) + // cond: + // result: (SUBW x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SUBW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end1d72e18fad1c22bb770963f167b98c96 + end1d72e18fad1c22bb770963f167b98c96: + ; + case OpSub32: + // match: (Sub32 x y) + // cond: + // result: (MOVLQSX (SUBL x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64MOVLQSX + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64SUBL, TypeInvalid) + v0.Type = v.Type + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto end4c091fbf93fb9599a70c001845424614 + end4c091fbf93fb9599a70c001845424614: + ; + case OpSub32U: + // match: (Sub32U x y) + // cond: + // result: (SUBL x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SUBL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end281d1020f0e75fce9df321580f07c4d5 + end281d1020f0e75fce9df321580f07c4d5: + ; + case OpSub64: + // match: (Sub64 x y) + // cond: + // result: (SUBQ x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SUBQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto endd88d5646309fd9174584888ecc8aca2c + endd88d5646309fd9174584888ecc8aca2c: + ; + case OpSub64U: + // match: (Sub64U x y) + // cond: // result: (SUBQ x y) { - t := v.Type x := v.Args[0] y := v.Args[1] - if !(is64BitInt(t)) { - goto ende6ef29f885a8ecf3058212bb95917323 - } v.Op = OpAMD64SUBQ v.AuxInt = 0 v.Aux = nil @@ -1762,8 +1842,47 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(y) return true } - goto ende6ef29f885a8ecf3058212bb95917323 - ende6ef29f885a8ecf3058212bb95917323: + goto end288f94a53865cdb00a0290d8358bb7da + end288f94a53865cdb00a0290d8358bb7da: + ; + case OpSub8: + // match: (Sub8 x y) + // cond: + // result: (MOVBQSX (SUBB x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64MOVBQSX + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64SUBB, TypeInvalid) + v0.Type = v.Type + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto endfa3ef95107dcb01ae343f2243e485e80 + endfa3ef95107dcb01ae343f2243e485e80: + ; + case OpSub8U: + // match: (Sub8U x y) + // cond: + // result: (SUBB x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SUBB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end8f5160f898dfa43da7d7d9f8cbaf9615 + end8f5160f898dfa43da7d7d9f8cbaf9615: ; case OpZero: // match: (Zero [0] _ mem) diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index ca523ee19b..7a4b6bf6ef 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -4,23 +4,42 @@ package ssa func rewriteValuegeneric(v *Value, config *Config) bool { switch v.Op { - case OpAdd: - // match: (Add (Const [c]) (Const [d])) - // cond: is64BitInt(t) + case OpAdd64: + // match: (Add64 (Const [c]) (Const [d])) + // cond: // result: (Const [c+d]) { - t := v.Type if v.Args[0].Op != OpConst { - goto end279f4ea85ed10e5ffc5b53f9e060529b + goto endd2f4bfaaf6c937171a287b73e5c2f73e } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst { - goto end279f4ea85ed10e5ffc5b53f9e060529b + goto endd2f4bfaaf6c937171a287b73e5c2f73e } d := v.Args[1].AuxInt - if !(is64BitInt(t)) { - goto end279f4ea85ed10e5ffc5b53f9e060529b + v.Op = OpConst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + d + return true + } + goto endd2f4bfaaf6c937171a287b73e5c2f73e + endd2f4bfaaf6c937171a287b73e5c2f73e: + ; + case OpAdd64U: + // match: (Add64U (Const [c]) (Const [d])) + // cond: + // result: (Const [c+d]) + { + if v.Args[0].Op != OpConst { + goto endfedc373d8be0243cb5dbbc948996fe3a } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst { + goto endfedc373d8be0243cb5dbbc948996fe3a + } + d := v.Args[1].AuxInt v.Op = OpConst v.AuxInt = 0 v.Aux = nil @@ -28,8 +47,8 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.AuxInt = c + d return true } - goto end279f4ea85ed10e5ffc5b53f9e060529b - end279f4ea85ed10e5ffc5b53f9e060529b: + goto endfedc373d8be0243cb5dbbc948996fe3a + endfedc373d8be0243cb5dbbc948996fe3a: ; case OpArrayIndex: // match: (ArrayIndex (Load ptr mem) idx) @@ -60,12 +79,12 @@ func rewriteValuegeneric(v *Value, config *Config) bool { case OpConst: // match: (Const {s}) // cond: t.IsString() - // result: (StringMake (OffPtr [2*config.ptrSize] (Addr {config.fe.StringSym(s.(string))} (SB ))) (Const [int64(len(s.(string)))])) + // result: (StringMake (OffPtr [2*config.PtrSize] (Addr {config.fe.StringSym(s.(string))} (SB ))) (Const [int64(len(s.(string)))])) { t := v.Type s := v.Aux if !(t.IsString()) { - goto end55cd8fd3b98a2459d0ee9d6cbb456b01 + goto endedcb8bd24122d6a47bdc9b752460c344 } v.Op = OpStringMake v.AuxInt = 0 @@ -73,7 +92,7 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.resetArgs() v0 := v.Block.NewValue0(v.Line, OpOffPtr, TypeInvalid) v0.Type = TypeBytePtr - v0.AuxInt = 2 * config.ptrSize + v0.AuxInt = 2 * config.PtrSize v1 := v.Block.NewValue0(v.Line, OpAddr, TypeInvalid) v1.Type = TypeBytePtr v1.Aux = config.fe.StringSym(s.(string)) @@ -88,8 +107,8 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.AddArg(v3) return true } - goto end55cd8fd3b98a2459d0ee9d6cbb456b01 - end55cd8fd3b98a2459d0ee9d6cbb456b01: + goto endedcb8bd24122d6a47bdc9b752460c344 + endedcb8bd24122d6a47bdc9b752460c344: ; case OpIsInBounds: // match: (IsInBounds (Const [c]) (Const [d])) @@ -117,13 +136,13 @@ func rewriteValuegeneric(v *Value, config *Config) bool { case OpLoad: // match: (Load ptr mem) // cond: t.IsString() - // result: (StringMake (Load ptr mem) (Load (OffPtr [config.ptrSize] ptr) mem)) + // result: (StringMake (Load ptr mem) (Load (OffPtr [config.PtrSize] ptr) mem)) { t := v.Type ptr := v.Args[0] mem := v.Args[1] if !(t.IsString()) { - goto endd0afd003b70d726a1c5bbaf51fe06182 + goto endce3ba169a57b8a9f6b12751d49b4e23a } v.Op = OpStringMake v.AuxInt = 0 @@ -138,15 +157,15 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v1.Type = config.Uintptr v2 := v.Block.NewValue0(v.Line, OpOffPtr, TypeInvalid) v2.Type = TypeBytePtr - v2.AuxInt = config.ptrSize + v2.AuxInt = config.PtrSize v2.AddArg(ptr) v1.AddArg(v2) v1.AddArg(mem) v.AddArg(v1) return true } - goto endd0afd003b70d726a1c5bbaf51fe06182 - endd0afd003b70d726a1c5bbaf51fe06182: + goto endce3ba169a57b8a9f6b12751d49b4e23a + endce3ba169a57b8a9f6b12751d49b4e23a: ; case OpMul: // match: (Mul (Const [c]) (Const [d])) @@ -178,12 +197,12 @@ func rewriteValuegeneric(v *Value, config *Config) bool { case OpPtrIndex: // match: (PtrIndex ptr idx) // cond: - // result: (Add ptr (Mul idx (Const [t.Elem().Size()]))) + // result: (AddPtr ptr (Mul idx (Const [t.Elem().Size()]))) { t := v.Type ptr := v.Args[0] idx := v.Args[1] - v.Op = OpAdd + v.Op = OpAddPtr v.AuxInt = 0 v.Aux = nil v.resetArgs() @@ -198,16 +217,16 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end88c7c383675420d1581daeb899039fa8 - end88c7c383675420d1581daeb899039fa8: + goto endc181347cd3c740e2a1da431a981fdd7e + endc181347cd3c740e2a1da431a981fdd7e: ; case OpSliceCap: // match: (SliceCap (Load ptr mem)) // cond: - // result: (Load (Add ptr (Const [config.ptrSize*2])) mem) + // result: (Load (AddPtr ptr (Const [config.PtrSize*2])) mem) { if v.Args[0].Op != OpLoad { - goto end919cfa3d3539eb2e06a435d5f89654b9 + goto end83c0ff7760465a4184bad9e4b47f7be8 } ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] @@ -215,27 +234,27 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAdd, TypeInvalid) + v0 := v.Block.NewValue0(v.Line, OpAddPtr, TypeInvalid) v0.Type = ptr.Type v0.AddArg(ptr) v1 := v.Block.NewValue0(v.Line, OpConst, TypeInvalid) v1.Type = config.Uintptr - v1.AuxInt = config.ptrSize * 2 + v1.AuxInt = config.PtrSize * 2 v0.AddArg(v1) v.AddArg(v0) v.AddArg(mem) return true } - goto end919cfa3d3539eb2e06a435d5f89654b9 - end919cfa3d3539eb2e06a435d5f89654b9: + goto end83c0ff7760465a4184bad9e4b47f7be8 + end83c0ff7760465a4184bad9e4b47f7be8: ; case OpSliceLen: // match: (SliceLen (Load ptr mem)) // cond: - // result: (Load (Add ptr (Const [config.ptrSize])) mem) + // result: (Load (AddPtr ptr (Const [config.PtrSize])) mem) { if v.Args[0].Op != OpLoad { - goto end3d74a5ef07180a709a91052da88bcd01 + goto end20579b262d017d875d579683996f0ef9 } ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] @@ -243,19 +262,19 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAdd, TypeInvalid) + v0 := v.Block.NewValue0(v.Line, OpAddPtr, TypeInvalid) v0.Type = ptr.Type v0.AddArg(ptr) v1 := v.Block.NewValue0(v.Line, OpConst, TypeInvalid) v1.Type = config.Uintptr - v1.AuxInt = config.ptrSize + v1.AuxInt = config.PtrSize v0.AddArg(v1) v.AddArg(v0) v.AddArg(mem) return true } - goto end3d74a5ef07180a709a91052da88bcd01 - end3d74a5ef07180a709a91052da88bcd01: + goto end20579b262d017d875d579683996f0ef9 + end20579b262d017d875d579683996f0ef9: ; case OpSlicePtr: // match: (SlicePtr (Load ptr mem)) @@ -311,13 +330,13 @@ func rewriteValuegeneric(v *Value, config *Config) bool { ; // match: (Store dst str mem) // cond: str.Type.IsString() - // result: (Store (OffPtr [config.ptrSize] dst) (StringLen str) (Store dst (StringPtr str) mem)) + // result: (Store (OffPtr [config.PtrSize] dst) (StringLen str) (Store dst (StringPtr str) mem)) { dst := v.Args[0] str := v.Args[1] mem := v.Args[2] if !(str.Type.IsString()) { - goto end410559d97aed8018f820cd88723de442 + goto endb47e037c1e5ac54c3a41d53163d8aef6 } v.Op = OpStore v.AuxInt = 0 @@ -325,7 +344,7 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.resetArgs() v0 := v.Block.NewValue0(v.Line, OpOffPtr, TypeInvalid) v0.Type = TypeBytePtr - v0.AuxInt = config.ptrSize + v0.AuxInt = config.PtrSize v0.AddArg(dst) v.AddArg(v0) v1 := v.Block.NewValue0(v.Line, OpStringLen, TypeInvalid) @@ -343,8 +362,8 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.AddArg(v2) return true } - goto end410559d97aed8018f820cd88723de442 - end410559d97aed8018f820cd88723de442: + goto endb47e037c1e5ac54c3a41d53163d8aef6 + endb47e037c1e5ac54c3a41d53163d8aef6: ; case OpStringLen: // match: (StringLen (StringMake _ len)) diff --git a/src/cmd/compile/internal/ssa/schedule_test.go b/src/cmd/compile/internal/ssa/schedule_test.go index a9432579f7..3a89483a9a 100644 --- a/src/cmd/compile/internal/ssa/schedule_test.go +++ b/src/cmd/compile/internal/ssa/schedule_test.go @@ -19,7 +19,7 @@ func TestSchedule(t *testing.T) { Valu("mem3", OpStore, TypeInt64, 0, nil, "ptr", "sum", "mem2"), Valu("l1", OpLoad, TypeInt64, 0, nil, "ptr", "mem1"), Valu("l2", OpLoad, TypeInt64, 0, nil, "ptr", "mem2"), - Valu("sum", OpAdd, TypeInt64, 0, nil, "l1", "l2"), + Valu("sum", OpAdd64, TypeInt64, 0, nil, "l1", "l2"), Goto("exit")), Bloc("exit", Exit("mem3"))), diff --git a/src/cmd/compile/internal/ssa/shift_test.go b/src/cmd/compile/internal/ssa/shift_test.go index 29b47c125e..cde48d355a 100644 --- a/src/cmd/compile/internal/ssa/shift_test.go +++ b/src/cmd/compile/internal/ssa/shift_test.go @@ -10,17 +10,17 @@ import ( func TestShiftConstAMD64(t *testing.T) { c := NewConfig("amd64", DummyFrontend{t}) - fun := makeConstShiftFunc(c, 18, OpLsh, TypeUInt64) + fun := makeConstShiftFunc(c, 18, OpLsh64, TypeUInt64) checkOpcodeCounts(t, fun.f, map[Op]int{OpAMD64SHLQconst: 1, OpAMD64CMPQconst: 0, OpAMD64ANDQconst: 0}) - fun = makeConstShiftFunc(c, 66, OpLsh, TypeUInt64) + fun = makeConstShiftFunc(c, 66, OpLsh64, TypeUInt64) checkOpcodeCounts(t, fun.f, map[Op]int{OpAMD64SHLQconst: 0, OpAMD64CMPQconst: 0, OpAMD64ANDQconst: 0}) - fun = makeConstShiftFunc(c, 18, OpRsh, TypeUInt64) + fun = makeConstShiftFunc(c, 18, OpRsh64U, TypeUInt64) checkOpcodeCounts(t, fun.f, map[Op]int{OpAMD64SHRQconst: 1, OpAMD64CMPQconst: 0, OpAMD64ANDQconst: 0}) - fun = makeConstShiftFunc(c, 66, OpRsh, TypeUInt64) + fun = makeConstShiftFunc(c, 66, OpRsh64U, TypeUInt64) checkOpcodeCounts(t, fun.f, map[Op]int{OpAMD64SHRQconst: 0, OpAMD64CMPQconst: 0, OpAMD64ANDQconst: 0}) - fun = makeConstShiftFunc(c, 18, OpRsh, TypeInt64) + fun = makeConstShiftFunc(c, 18, OpRsh64, TypeInt64) checkOpcodeCounts(t, fun.f, map[Op]int{OpAMD64SARQconst: 1, OpAMD64CMPQconst: 0}) - fun = makeConstShiftFunc(c, 66, OpRsh, TypeInt64) + fun = makeConstShiftFunc(c, 66, OpRsh64, TypeInt64) checkOpcodeCounts(t, fun.f, map[Op]int{OpAMD64SARQconst: 1, OpAMD64CMPQconst: 0}) } diff --git a/src/cmd/compile/internal/ssa/stackalloc.go b/src/cmd/compile/internal/ssa/stackalloc.go index 0bd64a1a14..5f18acabfd 100644 --- a/src/cmd/compile/internal/ssa/stackalloc.go +++ b/src/cmd/compile/internal/ssa/stackalloc.go @@ -82,8 +82,8 @@ func stackalloc(f *Func) { } } - n = align(n, f.Config.ptrSize) - n += f.Config.ptrSize // space for return address. TODO: arch-dependent + n = align(n, f.Config.PtrSize) + n += f.Config.PtrSize // space for return address. TODO: arch-dependent f.RegAlloc = home f.FrameSize = n -- cgit v1.3 From 983bc8d1a2d7be649f921a69b2d8e72a5ec032f4 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Fri, 17 Jul 2015 16:47:43 +0000 Subject: Revert "[dev.ssa] cmd/compile: don't Compile if Unimplemented" This reverts commit 766bcc92a5b693f336deffc347be52fe68af884a. Change-Id: I55413c1aa80d82c856a3ea89b4ffccf80fb58013 Reviewed-on: https://go-review.googlesource.com/12361 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 9 ++++----- src/cmd/compile/internal/ssa/print.go | 13 +++---------- 2 files changed, 7 insertions(+), 15 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 889b9d8cf8..e133076bce 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -108,18 +108,17 @@ func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { // Link up variable uses to variable definitions s.linkForwardReferences() + // Main call to ssa package to compile function + ssa.Compile(s.f) + // Calculate stats about what percentage of functions SSA handles. if false { - defer func() { fmt.Printf("SSA implemented: %t\n", !e.unimplemented) }() + fmt.Printf("SSA implemented: %t\n", !e.unimplemented) } if e.unimplemented { return nil, false } - - // Main call to ssa package to compile function. - ssa.Compile(s.f) - return s.f, usessa // TODO: return s.f, true once runtime support is in (gc maps, write barriers, etc.) } diff --git a/src/cmd/compile/internal/ssa/print.go b/src/cmd/compile/internal/ssa/print.go index e46590224d..c8b90c6f93 100644 --- a/src/cmd/compile/internal/ssa/print.go +++ b/src/cmd/compile/internal/ssa/print.go @@ -8,7 +8,6 @@ import ( "bytes" "fmt" "io" - "os" ) func printFunc(f *Func) { @@ -69,22 +68,16 @@ func fprintFunc(w io.Writer, f *Func) { n++ } if m == n { - fmt.Fprintln(os.Stderr, "dependency cycle in block", b) + fmt.Fprintln(w, "dependency cycle!") for _, v := range b.Values { if printed[v.ID] { continue } - fmt.Fprintf(os.Stderr, " %v\n", v.LongString()) + fmt.Fprint(w, " ") + fmt.Fprintln(w, v.LongString()) printed[v.ID] = true n++ } - // Things are going to go very badly from here; - // one of the optimization passes is likely to hang. - // Frustratingly, panics here get swallowed by fmt, - // and just we end up here again if we call Fatalf. - // Use our last resort. - os.Exit(1) - return } } -- cgit v1.3 From a794074da0800fda3cb204b20b3f73af2175383b Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Mon, 20 Jul 2015 15:21:49 -0700 Subject: [dev.ssa] cmd/compile: implement genValue for AMD64SETxx Change-Id: I591f2c0465263dcdeef46920aabf1bbb8e7ac5c0 Reviewed-on: https://go-review.googlesource.com/12436 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 7 +++++++ src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 14 +++++++------- src/cmd/compile/internal/ssa/opGen.go | 7 +++++++ 3 files changed, 21 insertions(+), 7 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index e133076bce..4700b2939c 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1376,6 +1376,13 @@ func genValue(v *ssa.Value) { p.To.Reg = regnum(v.Args[0]) case ssa.OpSP, ssa.OpSB: // nothing to do + case ssa.OpAMD64SETEQ, ssa.OpAMD64SETNE, + ssa.OpAMD64SETL, ssa.OpAMD64SETLE, + ssa.OpAMD64SETG, ssa.OpAMD64SETGE, + ssa.OpAMD64SETB: + p := Prog(v.Op.Asm()) + p.To.Type = obj.TYPE_REG + p.To.Reg = regnum(v) default: v.Unimplementedf("value %s not implemented", v.LongString()) } diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 602949eac9..1c7b817610 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -121,13 +121,13 @@ func init() { {name: "SBBQcarrymask", reg: flagsgp1, asm: "SBBQ"}, // (int64)(-1) if carry is set, 0 if carry is clear. - {name: "SETEQ", reg: flagsgp}, // extract == condition from arg0 - {name: "SETNE", reg: flagsgp}, // extract != condition from arg0 - {name: "SETL", reg: flagsgp}, // extract signed < condition from arg0 - {name: "SETLE", reg: flagsgp}, // extract signed <= condition from arg0 - {name: "SETG", reg: flagsgp}, // extract signed > condition from arg0 - {name: "SETGE", reg: flagsgp}, // extract signed >= condition from arg0 - {name: "SETB", reg: flagsgp}, // extract unsigned < condition from arg0 + {name: "SETEQ", reg: flagsgp, asm: "SETEQ"}, // extract == condition from arg0 + {name: "SETNE", reg: flagsgp, asm: "SETNE"}, // extract != condition from arg0 + {name: "SETL", reg: flagsgp, asm: "SETLT"}, // extract signed < condition from arg0 + {name: "SETLE", reg: flagsgp, asm: "SETLE"}, // extract signed <= condition from arg0 + {name: "SETG", reg: flagsgp, asm: "SETGT"}, // extract signed > condition from arg0 + {name: "SETGE", reg: flagsgp, asm: "SETGE"}, // extract signed >= condition from arg0 + {name: "SETB", reg: flagsgp, asm: "SETCS"}, // extract unsigned < condition from arg0 {name: "CMOVQCC", reg: cmov}, // carry clear diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 95e2ef798a..a57f2cfe7f 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -506,6 +506,7 @@ var opcodeTable = [...]opInfo{ }, { name: "SETEQ", + asm: x86.ASETEQ, reg: regInfo{ inputs: []regMask{ 8589934592, // .FLAGS @@ -518,6 +519,7 @@ var opcodeTable = [...]opInfo{ }, { name: "SETNE", + asm: x86.ASETNE, reg: regInfo{ inputs: []regMask{ 8589934592, // .FLAGS @@ -530,6 +532,7 @@ var opcodeTable = [...]opInfo{ }, { name: "SETL", + asm: x86.ASETLT, reg: regInfo{ inputs: []regMask{ 8589934592, // .FLAGS @@ -542,6 +545,7 @@ var opcodeTable = [...]opInfo{ }, { name: "SETLE", + asm: x86.ASETLE, reg: regInfo{ inputs: []regMask{ 8589934592, // .FLAGS @@ -554,6 +558,7 @@ var opcodeTable = [...]opInfo{ }, { name: "SETG", + asm: x86.ASETGT, reg: regInfo{ inputs: []regMask{ 8589934592, // .FLAGS @@ -566,6 +571,7 @@ var opcodeTable = [...]opInfo{ }, { name: "SETGE", + asm: x86.ASETGE, reg: regInfo{ inputs: []regMask{ 8589934592, // .FLAGS @@ -578,6 +584,7 @@ var opcodeTable = [...]opInfo{ }, { name: "SETB", + asm: x86.ASETCS, reg: regInfo{ inputs: []regMask{ 8589934592, // .FLAGS -- cgit v1.3 From 26f135d7c1a55cb7acaec1eac20e97b0f3b2cf10 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Mon, 20 Jul 2015 15:22:34 -0700 Subject: [dev.ssa] cmd/compile: mark LoadReg8 and StoreReg8 of flags as unimplemented It is not clear to me what the right implementation is. LoadReg8 and StoreReg8 are introduced during regalloc, so after the amd64 rewrites. But implementing them in genValue seems silly. Change-Id: Ia708209c4604867bddcc0e5d75ecd17cf32f52c3 Reviewed-on: https://go-review.googlesource.com/12437 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 8 ++++++++ 1 file changed, 8 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 4700b2939c..aa44dc0798 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1330,6 +1330,10 @@ func genValue(v *ssa.Value) { p.To.Reg = y } case ssa.OpLoadReg8: + if v.Type.IsFlags() { + v.Unimplementedf("load flags not implemented: %v", v.LongString()) + return + } p := Prog(x86.AMOVQ) p.From.Type = obj.TYPE_MEM p.From.Reg = x86.REG_SP @@ -1337,6 +1341,10 @@ func genValue(v *ssa.Value) { p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v) case ssa.OpStoreReg8: + if v.Type.IsFlags() { + v.Unimplementedf("store flags not implemented: %v", v.LongString()) + return + } p := Prog(x86.AMOVQ) p.From.Type = obj.TYPE_REG p.From.Reg = regnum(v.Args[0]) -- cgit v1.3 From 67bfd6956494173a0e2fa6b20bf61bf7b57589e6 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Mon, 20 Jul 2015 15:24:51 -0700 Subject: [dev.ssa] cmd/compile: fix stackalloc handling of zero-aligned variables Prior to this fix, a zero-aligned variable such as a flags variable would reset n to 0. While we're here, log the stack layout so that debugging and reading the generated assembly is easier. Change-Id: I18ef83ea95b6ea877c83f2e595e14c48c9ad7d84 Reviewed-on: https://go-review.googlesource.com/12439 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/stackalloc.go | 8 ++++++++ 1 file changed, 8 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/stackalloc.go b/src/cmd/compile/internal/ssa/stackalloc.go index 5f18acabfd..2d639bf594 100644 --- a/src/cmd/compile/internal/ssa/stackalloc.go +++ b/src/cmd/compile/internal/ssa/stackalloc.go @@ -20,6 +20,7 @@ func stackalloc(f *Func) { n = v.AuxInt } } + f.Logf("stackalloc: 0-%d for callee arguments/returns\n", n) // TODO: group variables by ptr/nonptr, size, etc. Emit ptr vars last // so stackmap is smaller. @@ -36,6 +37,7 @@ func stackalloc(f *Func) { continue } n = align(n, v.Type.Alignment()) + f.Logf("stackalloc: %d-%d for %v\n", n, n+v.Type.Size(), v) loc := &LocalSlot{n} n += v.Type.Size() home = setloc(home, v, loc) @@ -62,6 +64,7 @@ func stackalloc(f *Func) { continue } n = align(n, v.Type.Alignment()) + f.Logf("stackalloc: %d-%d for %v\n", n, n+v.Type.Size(), v) loc := &LocalSlot{n} n += v.Type.Size() home = setloc(home, v, loc) @@ -77,12 +80,14 @@ func stackalloc(f *Func) { } t := s.Typ n = align(n, t.Alignment()) + f.Logf("stackalloc: %d-%d for auto %v\n", n, n+t.Size(), v) s.Offset = n n += t.Size() } } n = align(n, f.Config.PtrSize) + f.Logf("stackalloc: %d-%d for return address\n", n, n+f.Config.ptrSize) n += f.Config.PtrSize // space for return address. TODO: arch-dependent f.RegAlloc = home f.FrameSize = n @@ -92,5 +97,8 @@ func stackalloc(f *Func) { // align increases n to the next multiple of a. a must be a power of 2. func align(n int64, a int64) int64 { + if a == 0 { + return n + } return (n + a - 1) &^ (a - 1) } -- cgit v1.3 From 2574e4ac1cb4c78023801d355b1204cbc2a71f11 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Thu, 16 Jul 2015 13:25:36 -0600 Subject: [dev.ssa] cmd/compile: call through to expr for expression statements Change-Id: I8625eff33f5a49dbaaec060c3fa067d7531193c4 Reviewed-on: https://go-review.googlesource.com/12313 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index aa44dc0798..1b01894ee3 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -299,8 +299,13 @@ func (s *state) stmt(n *Node) { case OBLOCK: s.stmtList(n.List) + // No-ops case OEMPTY, ODCLCONST, ODCLTYPE: + // Expression statements + case OCALLFUNC, OCALLMETH, OCALLINTER: + s.expr(n) + case ODCL: if n.Left.Class&PHEAP == 0 { return @@ -434,9 +439,6 @@ func (s *state) stmt(n *Node) { } s.startBlock(bEnd) - case OCALLFUNC: - s.expr(n) - case OVARKILL: // TODO(khr): ??? anything to do here? Only for addrtaken variables? // Maybe just link it in the store chain? -- cgit v1.3 From a402b58e51e211bd6abdf2fd2f502ffa8facd1f4 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Mon, 20 Jul 2015 15:53:33 -0700 Subject: [dev.ssa] cmd/compile: implement "if SETEQ" branches Change-Id: I814fd0c2f1a622cca7dfd1b771f81de309a1904c Reviewed-on: https://go-review.googlesource.com/12441 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/gen/AMD64.rules | 1 + src/cmd/compile/internal/ssa/rewriteAMD64.go | 20 ++++++++++++++++++++ 2 files changed, 21 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index eba3710460..6c4608dc6c 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -95,6 +95,7 @@ // block rewrites (If (SETL cmp) yes no) -> (LT 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 cond yes no) && cond.Op == OpAMD64MOVBload -> (NE (TESTB cond cond) yes no) diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 9a879a39bb..3c7e41e0e8 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -2142,6 +2142,26 @@ func rewriteBlockAMD64(b *Block) bool { } goto ende4d36879bb8e1bd8facaa8c91ba99dcc ende4d36879bb8e1bd8facaa8c91ba99dcc: + ; + // match: (If (SETEQ cmp) yes no) + // cond: + // result: (EQ cmp yes no) + { + v := b.Control + if v.Op != OpAMD64SETEQ { + goto endf113deb06abc88613840e6282942921a + } + 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 + } + goto endf113deb06abc88613840e6282942921a + endf113deb06abc88613840e6282942921a: ; // match: (If (SETNE cmp) yes no) // cond: -- cgit v1.3 From ac1935b3a7f1873a389e77586ed6e62e9ed5339e Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Tue, 21 Jul 2015 06:58:32 -0700 Subject: [dev.ssa] cmd/compile: fix build Bad rebase in CL 12439. Change-Id: I7ad359519c6274be37456b655f19bf0ca6ac6692 Reviewed-on: https://go-review.googlesource.com/12449 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/ssa/stackalloc.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/stackalloc.go b/src/cmd/compile/internal/ssa/stackalloc.go index 2d639bf594..064b84a804 100644 --- a/src/cmd/compile/internal/ssa/stackalloc.go +++ b/src/cmd/compile/internal/ssa/stackalloc.go @@ -87,7 +87,7 @@ func stackalloc(f *Func) { } n = align(n, f.Config.PtrSize) - f.Logf("stackalloc: %d-%d for return address\n", n, n+f.Config.ptrSize) + f.Logf("stackalloc: %d-%d for return address\n", n, n+f.Config.PtrSize) n += f.Config.PtrSize // space for return address. TODO: arch-dependent f.RegAlloc = home f.FrameSize = n -- cgit v1.3 From 8fb635815355fe74fa0df1f096e8169504bd4f3e Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Tue, 21 Jul 2015 07:10:56 -0700 Subject: [dev.ssa] cmd/compile: don't generate zero values for ssa ops Shorter code, easier to read, no pointless empty slices. Change-Id: Id410364b4f6924b5665188af3373a5e914117c38 Reviewed-on: https://go-review.googlesource.com/12480 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/gen/main.go | 37 +- src/cmd/compile/internal/ssa/opGen.go | 813 ++++--------------------------- 2 files changed, 131 insertions(+), 719 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/gen/main.go b/src/cmd/compile/internal/ssa/gen/main.go index 097f513347..007d33ec23 100644 --- a/src/cmd/compile/internal/ssa/gen/main.go +++ b/src/cmd/compile/internal/ssa/gen/main.go @@ -112,26 +112,37 @@ func genOp() { for _, v := range a.ops { fmt.Fprintln(w, "{") fmt.Fprintf(w, "name:\"%s\",\n", v.name) + 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{") - fmt.Fprintln(w, "inputs: []regMask{") - for _, r := range v.reg.inputs { - fmt.Fprintf(w, "%d,%s\n", r, a.regMaskComment(r)) + // reg inputs + if len(v.reg.inputs) > 0 { + fmt.Fprintln(w, "inputs: []regMask{") + for _, r := range v.reg.inputs { + fmt.Fprintf(w, "%d,%s\n", r, a.regMaskComment(r)) + } + fmt.Fprintln(w, "},") } - fmt.Fprintln(w, "},") - fmt.Fprintf(w, "clobbers: %d,%s\n", v.reg.clobbers, a.regMaskComment(v.reg.clobbers)) - fmt.Fprintln(w, "outputs: []regMask{") - for _, r := range v.reg.outputs { - fmt.Fprintf(w, "%d,%s\n", r, a.regMaskComment(r)) + if v.reg.clobbers > 0 { + fmt.Fprintf(w, "clobbers: %d,%s\n", v.reg.clobbers, a.regMaskComment(v.reg.clobbers)) } - fmt.Fprintln(w, "},") - fmt.Fprintln(w, "},") - if a.name == "generic" { - fmt.Fprintln(w, "generic:true,") + // 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, "},") + fmt.Fprintln(w, "},") // close reg info + fmt.Fprintln(w, "},") // close op } } fmt.Fprintln(w, "}") diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index a57f2cfe7f..4cb9dc42b8 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -231,7 +231,6 @@ var opcodeTable = [...]opInfo{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -243,7 +242,6 @@ var opcodeTable = [...]opInfo{ inputs: []regMask{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -257,7 +255,6 @@ var opcodeTable = [...]opInfo{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -270,7 +267,6 @@ var opcodeTable = [...]opInfo{ inputs: []regMask{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -284,7 +280,6 @@ var opcodeTable = [...]opInfo{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -297,7 +292,6 @@ var opcodeTable = [...]opInfo{ inputs: []regMask{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -311,7 +305,6 @@ var opcodeTable = [...]opInfo{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -324,7 +317,6 @@ var opcodeTable = [...]opInfo{ inputs: []regMask{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -338,7 +330,6 @@ var opcodeTable = [...]opInfo{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 2, // .CX }, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -351,7 +342,6 @@ var opcodeTable = [...]opInfo{ inputs: []regMask{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -365,7 +355,6 @@ var opcodeTable = [...]opInfo{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 2, // .CX }, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -378,7 +367,6 @@ var opcodeTable = [...]opInfo{ inputs: []regMask{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -392,7 +380,6 @@ var opcodeTable = [...]opInfo{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 2, // .CX }, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -405,7 +392,6 @@ var opcodeTable = [...]opInfo{ inputs: []regMask{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -417,7 +403,6 @@ var opcodeTable = [...]opInfo{ inputs: []regMask{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -430,7 +415,6 @@ var opcodeTable = [...]opInfo{ inputs: []regMask{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -444,7 +428,6 @@ var opcodeTable = [...]opInfo{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, - clobbers: 0, outputs: []regMask{ 8589934592, // .FLAGS }, @@ -457,7 +440,6 @@ var opcodeTable = [...]opInfo{ inputs: []regMask{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, - clobbers: 0, outputs: []regMask{ 8589934592, // .FLAGS }, @@ -471,7 +453,6 @@ var opcodeTable = [...]opInfo{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, - clobbers: 0, outputs: []regMask{ 8589934592, // .FLAGS }, @@ -485,7 +466,6 @@ var opcodeTable = [...]opInfo{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, - clobbers: 0, outputs: []regMask{ 8589934592, // .FLAGS }, @@ -498,7 +478,6 @@ var opcodeTable = [...]opInfo{ inputs: []regMask{ 8589934592, // .FLAGS }, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -511,7 +490,6 @@ var opcodeTable = [...]opInfo{ inputs: []regMask{ 8589934592, // .FLAGS }, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -524,7 +502,6 @@ var opcodeTable = [...]opInfo{ inputs: []regMask{ 8589934592, // .FLAGS }, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -537,7 +514,6 @@ var opcodeTable = [...]opInfo{ inputs: []regMask{ 8589934592, // .FLAGS }, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -550,7 +526,6 @@ var opcodeTable = [...]opInfo{ inputs: []regMask{ 8589934592, // .FLAGS }, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -563,7 +538,6 @@ var opcodeTable = [...]opInfo{ inputs: []regMask{ 8589934592, // .FLAGS }, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -576,7 +550,6 @@ var opcodeTable = [...]opInfo{ inputs: []regMask{ 8589934592, // .FLAGS }, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -589,7 +562,6 @@ var opcodeTable = [...]opInfo{ inputs: []regMask{ 8589934592, // .FLAGS }, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -603,7 +575,6 @@ var opcodeTable = [...]opInfo{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -616,7 +587,6 @@ var opcodeTable = [...]opInfo{ inputs: []regMask{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -629,7 +599,6 @@ var opcodeTable = [...]opInfo{ inputs: []regMask{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -642,7 +611,6 @@ var opcodeTable = [...]opInfo{ inputs: []regMask{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -651,8 +619,6 @@ var opcodeTable = [...]opInfo{ { name: "MOVQconst", reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -664,7 +630,6 @@ var opcodeTable = [...]opInfo{ inputs: []regMask{ 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB }, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -677,7 +642,6 @@ var opcodeTable = [...]opInfo{ 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -690,7 +654,6 @@ var opcodeTable = [...]opInfo{ 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -703,7 +666,6 @@ var opcodeTable = [...]opInfo{ 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -716,7 +678,6 @@ var opcodeTable = [...]opInfo{ 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -730,7 +691,6 @@ var opcodeTable = [...]opInfo{ 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB 0, }, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -743,7 +703,6 @@ var opcodeTable = [...]opInfo{ 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB 0, }, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -756,7 +715,6 @@ var opcodeTable = [...]opInfo{ 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB 0, }, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -770,7 +728,6 @@ var opcodeTable = [...]opInfo{ 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB 0, }, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -784,7 +741,6 @@ var opcodeTable = [...]opInfo{ 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB 0, }, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -798,7 +754,6 @@ var opcodeTable = [...]opInfo{ 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB 0, }, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -813,7 +768,6 @@ var opcodeTable = [...]opInfo{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 0, }, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -828,8 +782,6 @@ var opcodeTable = [...]opInfo{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 0, }, - clobbers: 0, - outputs: []regMask{}, }, }, { @@ -841,8 +793,6 @@ var opcodeTable = [...]opInfo{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 0, }, - clobbers: 0, - outputs: []regMask{}, }, }, { @@ -854,8 +804,6 @@ var opcodeTable = [...]opInfo{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 0, }, - clobbers: 0, - outputs: []regMask{}, }, }, { @@ -867,8 +815,6 @@ var opcodeTable = [...]opInfo{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 0, }, - clobbers: 0, - outputs: []regMask{}, }, }, { @@ -880,8 +826,6 @@ var opcodeTable = [...]opInfo{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 0, }, - clobbers: 0, - outputs: []regMask{}, }, }, { @@ -891,8 +835,6 @@ var opcodeTable = [...]opInfo{ 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB 0, }, - clobbers: 0, - outputs: []regMask{}, }, }, { @@ -903,32 +845,19 @@ var opcodeTable = [...]opInfo{ 2, // .CX }, clobbers: 131, // .AX .CX .DI - outputs: []regMask{}, }, }, { name: "MOVQloadglobal", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + reg: regInfo{}, }, { name: "MOVQstoreglobal", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + reg: regInfo{}, }, { name: "CALLstatic", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + reg: regInfo{}, }, { name: "CALLclosure", @@ -938,8 +867,6 @@ var opcodeTable = [...]opInfo{ 4, // .DX 0, }, - clobbers: 0, - outputs: []regMask{}, }, }, { @@ -951,7 +878,6 @@ var opcodeTable = [...]opInfo{ 2, // .CX }, clobbers: 194, // .CX .SI .DI - outputs: []regMask{}, }, }, { @@ -962,7 +888,6 @@ var opcodeTable = [...]opInfo{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -976,7 +901,6 @@ var opcodeTable = [...]opInfo{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -990,7 +914,6 @@ var opcodeTable = [...]opInfo{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -1004,7 +927,6 @@ var opcodeTable = [...]opInfo{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -1018,7 +940,6 @@ var opcodeTable = [...]opInfo{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -1032,7 +953,6 @@ var opcodeTable = [...]opInfo{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, - clobbers: 0, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -1040,938 +960,419 @@ var opcodeTable = [...]opInfo{ }, { name: "InvertFlags", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + reg: regInfo{}, }, { - name: "Add8", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Add8", generic: true, }, { - name: "Add16", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Add16", generic: true, }, { - name: "Add32", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Add32", generic: true, }, { - name: "Add64", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Add64", generic: true, }, { - name: "Add8U", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Add8U", generic: true, }, { - name: "Add16U", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Add16U", generic: true, }, { - name: "Add32U", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Add32U", generic: true, }, { - name: "Add64U", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Add64U", generic: true, }, { - name: "AddPtr", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "AddPtr", generic: true, }, { - name: "Sub8", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Sub8", generic: true, }, { - name: "Sub16", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Sub16", generic: true, }, { - name: "Sub32", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Sub32", generic: true, }, { - name: "Sub64", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Sub64", generic: true, }, { - name: "Sub8U", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Sub8U", generic: true, }, { - name: "Sub16U", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Sub16U", generic: true, }, { - name: "Sub32U", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Sub32U", generic: true, }, { - name: "Sub64U", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Sub64U", generic: true, }, { - name: "Mul", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Mul", generic: true, }, { - name: "Lsh8", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Lsh8", generic: true, }, { - name: "Lsh16", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Lsh16", generic: true, }, { - name: "Lsh32", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Lsh32", generic: true, }, { - name: "Lsh64", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Lsh64", generic: true, }, { - name: "Rsh8", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Rsh8", generic: true, }, { - name: "Rsh8U", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Rsh8U", generic: true, }, { - name: "Rsh16", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Rsh16", generic: true, }, { - name: "Rsh16U", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Rsh16U", generic: true, }, { - name: "Rsh32", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Rsh32", generic: true, }, { - name: "Rsh32U", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Rsh32U", generic: true, }, { - name: "Rsh64", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Rsh64", generic: true, }, { - name: "Rsh64U", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Rsh64U", generic: true, }, { - name: "Eq8", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Eq8", generic: true, }, { - name: "Eq16", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Eq16", generic: true, }, { - name: "Eq32", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Eq32", generic: true, }, { - name: "Eq64", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Eq64", generic: true, }, { - name: "Neq8", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Neq8", generic: true, }, { - name: "Neq16", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Neq16", generic: true, }, { - name: "Neq32", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Neq32", generic: true, }, { - name: "Neq64", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Neq64", generic: true, }, { - name: "Less8", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Less8", generic: true, }, { - name: "Less8U", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Less8U", generic: true, }, { - name: "Less16", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Less16", generic: true, }, { - name: "Less16U", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Less16U", generic: true, }, { - name: "Less32", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Less32", generic: true, }, { - name: "Less32U", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Less32U", generic: true, }, { - name: "Less64", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Less64", generic: true, }, { - name: "Less64U", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Less64U", generic: true, }, { - name: "Leq8", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Leq8", generic: true, }, { - name: "Leq8U", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Leq8U", generic: true, }, { - name: "Leq16", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Leq16", generic: true, }, { - name: "Leq16U", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Leq16U", generic: true, }, { - name: "Leq32", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Leq32", generic: true, }, { - name: "Leq32U", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Leq32U", generic: true, }, { - name: "Leq64", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Leq64", generic: true, }, { - name: "Leq64U", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Leq64U", generic: true, }, { - name: "Greater8", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Greater8", generic: true, }, { - name: "Greater8U", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Greater8U", generic: true, }, { - name: "Greater16", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Greater16", generic: true, }, { - name: "Greater16U", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Greater16U", generic: true, }, { - name: "Greater32", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Greater32", generic: true, }, { - name: "Greater32U", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Greater32U", generic: true, }, { - name: "Greater64", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Greater64", generic: true, }, { - name: "Greater64U", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Greater64U", generic: true, }, { - name: "Geq8", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Geq8", generic: true, }, { - name: "Geq8U", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Geq8U", generic: true, }, { - name: "Geq16", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Geq16", generic: true, }, { - name: "Geq16U", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Geq16U", generic: true, }, { - name: "Geq32", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Geq32", generic: true, }, { - name: "Geq32U", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Geq32U", generic: true, }, { - name: "Geq64", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Geq64", generic: true, }, { - name: "Geq64U", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Geq64U", generic: true, }, { - name: "Not", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Not", generic: true, }, { - name: "Phi", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Phi", generic: true, }, { - name: "Copy", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Copy", generic: true, }, { - name: "Const", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Const", generic: true, }, { - name: "Arg", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Arg", generic: true, }, { - name: "Addr", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Addr", generic: true, }, { - name: "SP", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "SP", generic: true, }, { - name: "SB", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "SB", generic: true, }, { - name: "Func", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Func", generic: true, }, { - name: "Load", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Load", generic: true, }, { - name: "Store", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Store", generic: true, }, { - name: "Move", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Move", generic: true, }, { - name: "Zero", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Zero", generic: true, }, { - name: "ClosureCall", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "ClosureCall", generic: true, }, { - name: "StaticCall", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "StaticCall", generic: true, }, { - name: "Convert", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "Convert", generic: true, }, { - name: "ConvNop", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "ConvNop", generic: true, }, { - name: "IsNonNil", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "IsNonNil", generic: true, }, { - name: "IsInBounds", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "IsInBounds", generic: true, }, { - name: "ArrayIndex", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "ArrayIndex", generic: true, }, { - name: "PtrIndex", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "PtrIndex", generic: true, }, { - name: "OffPtr", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "OffPtr", generic: true, }, { - name: "StructSelect", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "StructSelect", generic: true, }, { - name: "SliceMake", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "SliceMake", generic: true, }, { - name: "SlicePtr", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "SlicePtr", generic: true, }, { - name: "SliceLen", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "SliceLen", generic: true, }, { - name: "SliceCap", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "SliceCap", generic: true, }, { - name: "StringMake", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "StringMake", generic: true, }, { - name: "StringPtr", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "StringPtr", generic: true, }, { - name: "StringLen", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "StringLen", generic: true, }, { - name: "StoreReg8", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "StoreReg8", generic: true, }, { - name: "LoadReg8", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "LoadReg8", generic: true, }, { - name: "FwdRef", - reg: regInfo{ - inputs: []regMask{}, - clobbers: 0, - outputs: []regMask{}, - }, + name: "FwdRef", generic: true, }, } -- cgit v1.3 From 954d5ada291a969b2933f43d9a8f53c28fcb0982 Mon Sep 17 00:00:00 2001 From: Alexandru Moșoi Date: Tue, 21 Jul 2015 16:58:18 +0200 Subject: [dev.ssa] cmd/compile/internal/ssa/gen: implement OMINUS Change-Id: Ibc645d6cf229ecc18af3549dd3750be9d7451abe Reviewed-on: https://go-review.googlesource.com/12472 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 17 +- src/cmd/compile/internal/ssa/gen/AMD64.rules | 9 ++ src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 28 ++-- src/cmd/compile/internal/ssa/gen/genericOps.go | 9 ++ src/cmd/compile/internal/ssa/opGen.go | 208 +++++++++++++++++-------- src/cmd/compile/internal/ssa/rewriteAMD64.go | 137 ++++++++++++++++ 6 files changed, 330 insertions(+), 78 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 1b01894ee3..a77e788a1c 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -471,6 +471,15 @@ var opToSSA = map[opAndType]ssa.Op{ opAndType{OSUB, TINT64}: ssa.OpSub64, opAndType{OSUB, TUINT64}: ssa.OpSub64U, + opAndType{OMINUS, TINT8}: ssa.OpNeg8, + opAndType{OMINUS, TUINT8}: ssa.OpNeg8U, + opAndType{OMINUS, TINT16}: ssa.OpNeg16, + opAndType{OMINUS, TUINT16}: ssa.OpNeg16U, + opAndType{OMINUS, TINT32}: ssa.OpNeg32, + opAndType{OMINUS, TUINT32}: ssa.OpNeg32U, + opAndType{OMINUS, TINT64}: ssa.OpNeg64, + opAndType{OMINUS, TUINT64}: ssa.OpNeg64U, + opAndType{OLSH, TINT8}: ssa.OpLsh8, opAndType{OLSH, TUINT8}: ssa.OpLsh8, opAndType{OLSH, TINT16}: ssa.OpLsh16, @@ -654,9 +663,9 @@ func (s *state) expr(n *Node) *ssa.Value { return s.variable(n, n.Type) // unary ops - case ONOT: + case ONOT, OMINUS: a := s.expr(n.Left) - return s.newValue1(ssa.OpNot, a.Type, a) + return s.newValue1(s.ssaOp(n.Op, n.Type), a.Type, a) case OADDR: return s.addr(n.Left) @@ -1384,6 +1393,10 @@ func genValue(v *ssa.Value) { p.From.Offset = v.AuxInt p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v.Args[0]) + case ssa.OpAMD64NEGQ, ssa.OpAMD64NEGL, ssa.OpAMD64NEGW, ssa.OpAMD64NEGB: + p := Prog(v.Op.Asm()) + p.To.Type = obj.TYPE_REG + p.To.Reg = regnum(v.Args[0]) case ssa.OpSP, ssa.OpSB: // nothing to do case ssa.OpAMD64SETEQ, ssa.OpAMD64SETNE, diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 6c4608dc6c..eb14b6a55b 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -32,6 +32,15 @@ (Sub8U x y) -> (SUBB x y) (Sub8 x y) -> (MOVBQSX (SUBB x y)) +(Neg64 x) -> (NEGQ x) +(Neg64U x) -> (NEGQ x) +(Neg32U x) -> (NEGL x) +(Neg32 x) -> (MOVLQSX (NEGL x)) +(Neg16U x) -> (NEGW x) +(Neg16 x) -> (MOVWQSX (NEGW x)) +(Neg8U x) -> (NEGB x) +(Neg8 x) -> (MOVBQSX (NEGB x)) + (Mul x y) && is64BitInt(t) -> (MULQ x y) (MOVLstore ptr (MOVLQSX x) mem) -> (MOVLstore ptr x mem) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 1c7b817610..ac527918c3 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -96,10 +96,6 @@ func init() { // TODO: 2-address instructions. Mark ops as needing matching input/output regs. var AMD64ops = []opData{ - {name: "ADDQ", reg: gp21}, // arg0 + arg1 - {name: "ADDQconst", reg: gp11}, // arg0 + auxint - {name: "SUBQ", reg: gp21, asm: "SUBQ"}, // arg0 - arg1 - {name: "SUBQconst", reg: gp11, asm: "SUBQ"}, // arg0 - auxint {name: "MULQ", reg: gp21, asm: "IMULQ"}, // arg0 * arg1 {name: "MULQconst", reg: gp11, asm: "IMULQ"}, // arg0 * auxint {name: "ANDQ", reg: gp21, asm: "ANDQ"}, // arg0 & arg1 @@ -111,7 +107,6 @@ func init() { {name: "SARQ", reg: gp21shift, asm: "SARQ"}, // signed arg0 >> arg1, shift amount is mod 64 {name: "SARQconst", reg: gp11, asm: "SARQ"}, // signed arg0 >> auxint, shift amount 0-63 - {name: "NEGQ", reg: gp11}, // -arg0 {name: "XORQconst", reg: gp11, asm: "XORQ"}, // arg0^auxint {name: "CMPQ", reg: gp2flags, asm: "CMPQ"}, // arg0 compare to arg1 @@ -170,13 +165,22 @@ func init() { {name: "REPMOVSB", reg: regInfo{[]regMask{buildReg("DI"), buildReg("SI"), buildReg("CX")}, buildReg("DI SI CX"), nil}}, // move arg2 bytes from arg1 to arg0. arg3=mem, returns memory - {name: "ADDL", reg: gp21, asm: "ADDL"}, // arg0+arg1 - {name: "ADDW", reg: gp21, asm: "ADDW"}, // arg0+arg1 - {name: "ADDB", reg: gp21, asm: "ADDB"}, // arg0+arg1 - - {name: "SUBL", reg: gp21, asm: "SUBL"}, // arg0-arg1 - {name: "SUBW", reg: gp21, asm: "SUBW"}, // arg0-arg1 - {name: "SUBB", reg: gp21, asm: "SUBB"}, // arg0-arg1 + {name: "ADDQ", reg: gp21}, // arg0 + arg1 + {name: "ADDQconst", reg: gp11}, // arg0 + auxint + {name: "ADDL", reg: gp21, asm: "ADDL"}, // arg0 + arg1 + {name: "ADDW", reg: gp21, asm: "ADDW"}, // arg0 + arg1 + {name: "ADDB", reg: gp21, asm: "ADDB"}, // arg0 + arg1 + + {name: "SUBQ", reg: gp21, asm: "SUBQ"}, // arg0 - arg1 + {name: "SUBQconst", reg: gp11, asm: "SUBQ"}, // arg0 - auxint + {name: "SUBL", reg: gp21, asm: "SUBL"}, // arg0 - arg1 + {name: "SUBW", reg: gp21, asm: "SUBW"}, // arg0 - arg1 + {name: "SUBB", reg: gp21, asm: "SUBB"}, // arg0 - arg1 + + {name: "NEGQ", reg: gp11, asm: "NEGQ"}, // -arg0 + {name: "NEGL", reg: gp11, asm: "NEGL"}, // -arg0 + {name: "NEGW", reg: gp11, asm: "NEGW"}, // -arg0 + {name: "NEGB", reg: gp11, asm: "NEGB"}, // -arg0 // (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, diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 12c2901076..5e1856a2fc 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -95,6 +95,15 @@ var genericOps = []opData{ // 1-input ops {name: "Not"}, // !arg0 + {name: "Neg8"}, // - arg0 + {name: "Neg16"}, + {name: "Neg32"}, + {name: "Neg64"}, + {name: "Neg8U"}, + {name: "Neg16U"}, + {name: "Neg32U"}, + {name: "Neg64U"}, + // Data movement {name: "Phi"}, // select an argument based on which predecessor block we came from {name: "Copy"}, // output = arg0 diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 4cb9dc42b8..009e9d4e6d 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -51,10 +51,6 @@ func (k BlockKind) String() string { return blockString[k] } const ( OpInvalid Op = iota - OpAMD64ADDQ - OpAMD64ADDQconst - OpAMD64SUBQ - OpAMD64SUBQconst OpAMD64MULQ OpAMD64MULQconst OpAMD64ANDQ @@ -65,7 +61,6 @@ const ( OpAMD64SHRQconst OpAMD64SARQ OpAMD64SARQconst - OpAMD64NEGQ OpAMD64XORQconst OpAMD64CMPQ OpAMD64CMPQconst @@ -108,12 +103,20 @@ const ( OpAMD64CALLstatic OpAMD64CALLclosure OpAMD64REPMOVSB + OpAMD64ADDQ + OpAMD64ADDQconst OpAMD64ADDL OpAMD64ADDW OpAMD64ADDB + OpAMD64SUBQ + OpAMD64SUBQconst OpAMD64SUBL OpAMD64SUBW OpAMD64SUBB + OpAMD64NEGQ + OpAMD64NEGL + OpAMD64NEGW + OpAMD64NEGB OpAMD64InvertFlags OpAdd8 @@ -187,6 +190,14 @@ const ( OpGeq64 OpGeq64U OpNot + OpNeg8 + OpNeg16 + OpNeg32 + OpNeg64 + OpNeg8U + OpNeg16U + OpNeg32U + OpNeg64U OpPhi OpCopy OpConst @@ -224,54 +235,6 @@ const ( var opcodeTable = [...]opInfo{ {name: "OpInvalid"}, - { - name: "ADDQ", - reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 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: "ADDQconst", - reg: regInfo{ - inputs: []regMask{ - 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: "SUBQ", - asm: x86.ASUBQ, - reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 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: "SUBQconst", - asm: x86.ASUBQ, - reg: regInfo{ - inputs: []regMask{ - 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: "MULQ", asm: x86.AIMULQ, @@ -397,17 +360,6 @@ var opcodeTable = [...]opInfo{ }, }, }, - { - name: "NEGQ", - reg: regInfo{ - inputs: []regMask{ - 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: "XORQconst", asm: x86.AXORQ, @@ -880,6 +832,29 @@ var opcodeTable = [...]opInfo{ clobbers: 194, // .CX .SI .DI }, }, + { + name: "ADDQ", + reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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: "ADDQconst", + reg: regInfo{ + inputs: []regMask{ + 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: "ADDL", asm: x86.AADDL, @@ -919,6 +894,31 @@ var opcodeTable = [...]opInfo{ }, }, }, + { + name: "SUBQ", + asm: x86.ASUBQ, + reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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: "SUBQconst", + asm: x86.ASUBQ, + reg: regInfo{ + inputs: []regMask{ + 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: "SUBL", asm: x86.ASUBL, @@ -958,6 +958,54 @@ var opcodeTable = [...]opInfo{ }, }, }, + { + name: "NEGQ", + asm: x86.ANEGQ, + reg: regInfo{ + inputs: []regMask{ + 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: "NEGL", + asm: x86.ANEGL, + reg: regInfo{ + inputs: []regMask{ + 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: "NEGW", + asm: x86.ANEGW, + reg: regInfo{ + inputs: []regMask{ + 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: "NEGB", + asm: x86.ANEGB, + reg: regInfo{ + inputs: []regMask{ + 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: "InvertFlags", reg: regInfo{}, @@ -1247,6 +1295,38 @@ var opcodeTable = [...]opInfo{ name: "Not", generic: true, }, + { + name: "Neg8", + generic: true, + }, + { + name: "Neg16", + generic: true, + }, + { + name: "Neg32", + generic: true, + }, + { + name: "Neg64", + generic: true, + }, + { + name: "Neg8U", + generic: true, + }, + { + name: "Neg16U", + generic: true, + }, + { + name: "Neg32U", + generic: true, + }, + { + name: "Neg64U", + generic: true, + }, { name: "Phi", generic: true, diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 3c7e41e0e8..68c7d2eb42 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -1285,6 +1285,143 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endfab0d598f376ecba45a22587d50f7aff endfab0d598f376ecba45a22587d50f7aff: ; + case OpNeg16: + // match: (Neg16 x) + // cond: + // result: (MOVWQSX (NEGW x)) + { + x := v.Args[0] + v.Op = OpAMD64MOVWQSX + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64NEGW, TypeInvalid) + v0.Type = v.Type + v0.AddArg(x) + v.AddArg(v0) + return true + } + goto end089988d857b555c3065177bcad1eface + end089988d857b555c3065177bcad1eface: + ; + case OpNeg16U: + // match: (Neg16U x) + // cond: + // result: (NEGW x) + { + x := v.Args[0] + v.Op = OpAMD64NEGW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end8f43be5b376227e92d70b382bded232b + end8f43be5b376227e92d70b382bded232b: + ; + case OpNeg32: + // match: (Neg32 x) + // cond: + // result: (MOVLQSX (NEGL x)) + { + x := v.Args[0] + v.Op = OpAMD64MOVLQSX + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64NEGL, TypeInvalid) + v0.Type = v.Type + v0.AddArg(x) + v.AddArg(v0) + return true + } + goto end2217d3f168126b2ee157cb33befba76d + end2217d3f168126b2ee157cb33befba76d: + ; + case OpNeg32U: + // match: (Neg32U x) + // cond: + // result: (NEGL x) + { + x := v.Args[0] + v.Op = OpAMD64NEGL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end1fe0112076c436ffceabac066776cd18 + end1fe0112076c436ffceabac066776cd18: + ; + case OpNeg64: + // match: (Neg64 x) + // cond: + // result: (NEGQ x) + { + x := v.Args[0] + v.Op = OpAMD64NEGQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto enda06c5b1718f2b96aba10bf5a5c437c6c + enda06c5b1718f2b96aba10bf5a5c437c6c: + ; + case OpNeg64U: + // match: (Neg64U x) + // cond: + // result: (NEGQ x) + { + x := v.Args[0] + v.Op = OpAMD64NEGQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto endbc6beca972ff7f28273a1cdd146e3959 + endbc6beca972ff7f28273a1cdd146e3959: + ; + case OpNeg8: + // match: (Neg8 x) + // cond: + // result: (MOVBQSX (NEGB x)) + { + x := v.Args[0] + v.Op = OpAMD64MOVBQSX + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64NEGB, TypeInvalid) + v0.Type = v.Type + v0.AddArg(x) + v.AddArg(v0) + return true + } + goto end9cfacf0b7d826b85041092625ed494c1 + end9cfacf0b7d826b85041092625ed494c1: + ; + case OpNeg8U: + // match: (Neg8U x) + // cond: + // result: (NEGB x) + { + x := v.Args[0] + v.Op = OpAMD64NEGB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto enda1ffb93a68702148c5fd18e2b72964d0 + enda1ffb93a68702148c5fd18e2b72964d0: + ; case OpNeq64: // match: (Neq64 x y) // cond: -- cgit v1.3 From 3e7e519c367f4ab5b2d9f863302cd0946fe74800 Mon Sep 17 00:00:00 2001 From: Alexandru Moșoi Date: Fri, 17 Jul 2015 12:26:35 +0200 Subject: [dev.ssa] cmd/compile/internal/ssa/gen: generalize strength reduction. Handle multiplication with -1, 0, 3, 5, 9 and all powers of two. Change-Id: I8e87e7670dae389aebf6f446d7a56950cacb59e0 Reviewed-on: https://go-review.googlesource.com/12350 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/gen/AMD64.rules | 10 ++- src/cmd/compile/internal/ssa/rewrite.go | 15 ++++ src/cmd/compile/internal/ssa/rewriteAMD64.go | 122 +++++++++++++++++++++++---- 3 files changed, 129 insertions(+), 18 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index eb14b6a55b..ee5029ad56 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -131,9 +131,13 @@ (CMPQ (MOVQconst [c]) x) -> (InvertFlags (CMPQconst x [c])) // strength reduction -// TODO: do this a lot more generically -(MULQconst [8] x) -> (SHLQconst [3] x) -(MULQconst [64] x) -> (SHLQconst [6] x) +(MULQconst [-1] x) -> (NEGQ x) +(MULQconst [0] _) -> (MOVQconst [0]) +(MULQconst [1] x) -> (Copy 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) // fold add/shift into leaq (ADDQ x (SHLQconst [3] y)) -> (LEAQ8 x y) diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go index 60368784e8..90ac7d7a68 100644 --- a/src/cmd/compile/internal/ssa/rewrite.go +++ b/src/cmd/compile/internal/ssa/rewrite.go @@ -119,3 +119,18 @@ func mergeSym(x, y interface{}) interface{} { func inBounds(idx, len int64) bool { return idx >= 0 && idx < len } + +// log2 returns logarithm in base of n. +// expects n to be a power of 2. +func log2(n int64) (l int64) { + for n > 1 { + l++ + n >>= 1 + } + return l +} + +// isPowerOfTwo returns true if n is a power of 2. +func isPowerOfTwo(n int64) bool { + return n > 0 && n&(n-1) == 0 +} diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 68c7d2eb42..c118cc4279 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -1200,43 +1200,135 @@ func rewriteValueAMD64(v *Value, config *Config) bool { endc6e18d6968175d6e58eafa6dcf40c1b8: ; case OpAMD64MULQconst: - // match: (MULQconst [8] x) + // match: (MULQconst [-1] x) // cond: - // result: (SHLQconst [3] x) + // result: (NEGQ x) { - if v.AuxInt != 8 { - goto ende8d313a52a134fb2e1c0beb54ea599fd + if v.AuxInt != -1 { + goto end82501cca6b5fb121a7f8b197e55f2fec } x := v.Args[0] - v.Op = OpAMD64SHLQconst + v.Op = OpAMD64NEGQ v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = 3 v.AddArg(x) return true } - goto ende8d313a52a134fb2e1c0beb54ea599fd - ende8d313a52a134fb2e1c0beb54ea599fd: + goto end82501cca6b5fb121a7f8b197e55f2fec + end82501cca6b5fb121a7f8b197e55f2fec: ; - // match: (MULQconst [64] x) + // match: (MULQconst [0] _) // cond: - // result: (SHLQconst [6] x) + // result: (MOVQconst [0]) { - if v.AuxInt != 64 { - goto end3e36a587d1e7c193048d489a0429692c + if v.AuxInt != 0 { + goto endcb9faa068e3558ff44daaf1d47d091b5 + } + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto endcb9faa068e3558ff44daaf1d47d091b5 + endcb9faa068e3558ff44daaf1d47d091b5: + ; + // match: (MULQconst [1] x) + // cond: + // result: (Copy x) + { + if v.AuxInt != 1 { + goto endd7217a7c6311fc7a3e0736a1b0b5be73 } x := v.Args[0] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto endd7217a7c6311fc7a3e0736a1b0b5be73 + endd7217a7c6311fc7a3e0736a1b0b5be73: + ; + // match: (MULQconst [3] x) + // cond: + // result: (LEAQ2 x x) + { + if v.AuxInt != 3 { + goto end34a86f261671b5852bec6c57155fe0da + } + x := v.Args[0] + v.Op = OpAMD64LEAQ2 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(x) + return true + } + goto end34a86f261671b5852bec6c57155fe0da + end34a86f261671b5852bec6c57155fe0da: + ; + // match: (MULQconst [5] x) + // cond: + // result: (LEAQ4 x x) + { + if v.AuxInt != 5 { + goto end534601906c45a9171a9fec3e4b82b189 + } + x := v.Args[0] + v.Op = OpAMD64LEAQ4 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(x) + return true + } + goto end534601906c45a9171a9fec3e4b82b189 + end534601906c45a9171a9fec3e4b82b189: + ; + // match: (MULQconst [9] x) + // cond: + // result: (LEAQ8 x x) + { + if v.AuxInt != 9 { + goto end48a2280b6459821289c56073b8354997 + } + x := v.Args[0] + v.Op = OpAMD64LEAQ8 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(x) + return true + } + goto end48a2280b6459821289c56073b8354997 + end48a2280b6459821289c56073b8354997: + ; + // match: (MULQconst [c] x) + // cond: isPowerOfTwo(c) + // result: (SHLQconst [log2(c)] x) + { + c := v.AuxInt + x := v.Args[0] + if !(isPowerOfTwo(c)) { + goto end75076953dbfe022526a153eda99b39b2 + } v.Op = OpAMD64SHLQconst v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = 6 + v.AuxInt = log2(c) v.AddArg(x) return true } - goto end3e36a587d1e7c193048d489a0429692c - end3e36a587d1e7c193048d489a0429692c: + goto end75076953dbfe022526a153eda99b39b2 + end75076953dbfe022526a153eda99b39b2: ; case OpMove: // match: (Move [size] dst src mem) -- cgit v1.3 From 61aa0953e542eb047f22905f84c7d627a35b8607 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Mon, 20 Jul 2015 15:39:14 -0700 Subject: [dev.ssa] cmd/compile: implement control flow handling Add label and goto checks and improve test coverage. Implement OSWITCH and OSELECT. Implement OBREAK and OCONTINUE. Allow generation of code in dead blocks. Change-Id: Ibebb7c98b4b2344f46d38db7c9dce058c56beaac Reviewed-on: https://go-review.googlesource.com/12445 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/gen.go | 2 + src/cmd/compile/internal/gc/ssa.go | 316 ++++++++++++++++++++-- src/cmd/compile/internal/gc/ssa_test.go | 17 +- src/cmd/compile/internal/gc/testdata/break_ssa.go | 255 +++++++++++++++++ src/cmd/compile/internal/ssa/compile.go | 1 + test/label.go | 4 + test/label1.go | 31 ++- 7 files changed, 590 insertions(+), 36 deletions(-) create mode 100644 src/cmd/compile/internal/gc/testdata/break_ssa.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/gen.go b/src/cmd/compile/internal/gc/gen.go index 764895f15d..6390818e16 100644 --- a/src/cmd/compile/internal/gc/gen.go +++ b/src/cmd/compile/internal/gc/gen.go @@ -141,6 +141,8 @@ func newlab(n *Node) *Label { 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 diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index a77e788a1c..96756b11d0 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -62,7 +62,8 @@ func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { // Allocate starting values s.vars = map[*Node]*ssa.Value{} - s.labels = map[string]*ssa.Block{} + s.labels = map[string]*ssaLabel{} + s.labeledNodes = map[*Node]*ssaLabel{} s.startmem = s.entryNewValue0(ssa.OpArg, ssa.TypeMem) s.sp = s.entryNewValue0(ssa.OpSP, s.config.Uintptr) // TODO: use generic pointer type (unsafe.Pointer?) instead s.sb = s.entryNewValue0(ssa.OpSB, s.config.Uintptr) @@ -105,6 +106,31 @@ func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { s.exit.Control = s.mem() s.endBlock() + // 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 { + return nil, false + } + // Link up variable uses to variable definitions s.linkForwardReferences() @@ -132,8 +158,16 @@ type state struct { // exit block that "return" jumps to (and panics jump to) exit *ssa.Block - // the target block for each label in f - labels map[string]*ssa.Block + // 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 + + // 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 @@ -157,6 +191,34 @@ type state struct { 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) Fatalf(msg string, args ...interface{}) { s.config.Fatalf(msg, args...) } func (s *state) Unimplementedf(msg string, args ...interface{}) { s.config.Unimplementedf(msg, args...) } @@ -206,6 +268,10 @@ 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) @@ -293,6 +359,16 @@ 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 { @@ -325,32 +401,61 @@ func (s *state) stmt(n *Node) { } s.assign(OAS, n.Left.Name.Heapaddr, palloc) - case OLABEL, OGOTO: - if n.Op == OLABEL && isblanksym(n.Left.Sym) { + case OLABEL: + sym := n.Left.Sym + + if isblanksym(sym) { // Empty identifier is valid but useless. // See issues 11589, 11593. return } - // get block at label, or make one - t := s.labels[n.Left.Sym.Name] - if t == nil { - t = s.f.NewBlock(ssa.BlockPlain) - s.labels[n.Left.Sym.Name] = t + + 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 + } } - // go to that label (we pretend "label:" is preceded by "goto label") - if b := s.endBlock(); b != nil { - addEdge(b, t) + + 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) } - if n.Op == OLABEL { - // next we work on the label's target block - s.startBlock(t) + // go to that label (we pretend "label:" is preceded by "goto label") + b := s.endBlock() + addEdge(b, 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 n.Op == OGOTO && s.curBlock == nil { - s.Unimplementedf("goto at start of function; see test/goto.go") - panic("stop compiling here, on pain of infinite loops") + + if lab.defined() { + s.checkgoto(n, lab.defNode) + } else { + s.fwdGotos = append(s.fwdGotos, n) } + b := s.endBlock() + addEdge(b, lab.target) + case OAS, OASWB: s.assign(n.Op, n.Left, n.Right) @@ -396,6 +501,58 @@ func (s *state) stmt(n *Node) { b := s.endBlock() addEdge(b, s.exit) + 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() + addEdge(b, to) + case OFOR: // OFOR: for Ninit; Left; Right { Nbody } bCond := s.f.NewBlock(ssa.BlockPlain) @@ -422,9 +579,31 @@ func (s *state) stmt(n *Node) { addEdge(b, bBody) addEdge(b, bEnd) + // 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.stmtList(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 { addEdge(b, bIncr) } @@ -439,6 +618,32 @@ func (s *state) stmt(n *Node) { } 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.stmtList(n.Nbody) + + s.breakTo = prevBreak + if lab != nil { + lab.breakTarget = nil + } + + if b := s.endBlock(); b != nil { + addEdge(b, bEnd) + } + s.startBlock(bEnd) + case OVARKILL: // TODO(khr): ??? anything to do here? Only for addrtaken variables? // Maybe just link it in the store chain? @@ -924,14 +1129,66 @@ func (s *state) boundsCheck(idx, len *ssa.Value) { s.startBlock(bNext) } +// 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 { - if s.curBlock == nil { - // Unimplemented instead of Fatal because fixedbugs/bug303.go - // demonstrates a case in which this appears to happen legitimately. - // TODO: decide on the correct behavior here. - s.Unimplementedf("nil curblock adding variable %v (%v)", name, t) - } v := s.vars[name] if v == nil { // TODO: get type? Take Sym as arg? @@ -989,8 +1246,13 @@ func (s *state) lookupVarIncoming(b *ssa.Block, t ssa.Type, name *Node) *ssa.Val vals = append(vals, s.lookupVarOutgoing(p, t, name)) } if len(vals) == 0 { - s.Unimplementedf("TODO: Handle fixedbugs/bug076.go") - return nil + // 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, + // so use the default/zero value. + if name == &memvar { + return s.startmem + } + return s.zeroVal(name.Type) } v0 := vals[0] for i := 1; i < len(vals); i++ { diff --git a/src/cmd/compile/internal/gc/ssa_test.go b/src/cmd/compile/internal/gc/ssa_test.go index fbbba6d9cb..4354d020f2 100644 --- a/src/cmd/compile/internal/gc/ssa_test.go +++ b/src/cmd/compile/internal/gc/ssa_test.go @@ -8,23 +8,24 @@ import ( "bytes" "internal/testenv" "os/exec" + "path/filepath" "runtime" "strings" "testing" ) -// Tests OANDAND and OOROR expressions and short circuiting. -// TODO: move these tests elsewhere? perhaps teach test/run.go how to run them -// with a new action verb. -func TestShortCircuit(t *testing.T) { +// 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) { 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", "run", "testdata/short_ssa.go") + cmd := exec.Command("go", "run", filepath.Join("testdata", filename)) cmd.Stdout = &stdout cmd.Stderr = &stderr + // TODO: set GOGC=off until we have stackmaps if err := cmd.Run(); err != nil { t.Fatalf("Failed: %v:\nOut: %s\nStderr: %s\n", err, &stdout, &stderr) } @@ -35,3 +36,9 @@ func TestShortCircuit(t *testing.T) { 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") } 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 0000000000..855ef70049 --- /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/ssa/compile.go b/src/cmd/compile/internal/ssa/compile.go index 4a6c2a9404..7a7b9926ed 100644 --- a/src/cmd/compile/internal/ssa/compile.go +++ b/src/cmd/compile/internal/ssa/compile.go @@ -50,6 +50,7 @@ type pass struct { var passes = [...]pass{ {"phielim", phielim}, {"copyelim", copyelim}, + {"early deadcode", deadcode}, // remove generated dead code to avoid doing pointless work during opt {"opt", opt}, {"opt deadcode", deadcode}, // remove any blocks orphaned during opt {"generic cse", cse}, diff --git a/test/label.go b/test/label.go index a1811c2d68..c3c0c27edd 100644 --- a/test/label.go +++ b/test/label.go @@ -58,4 +58,8 @@ L10: default: break L10 } + + goto L10 + + goto go2 // ERROR "label go2 not defined" } diff --git a/test/label1.go b/test/label1.go index bc8fea6f6a..937b5cb900 100644 --- a/test/label1.go +++ b/test/label1.go @@ -31,11 +31,17 @@ L2: 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: @@ -43,7 +49,7 @@ L3: 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 } @@ -54,7 +60,7 @@ L4: 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 @@ -67,7 +73,7 @@ L5: 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 @@ -84,4 +90,21 @@ L5: 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 + } + } } -- cgit v1.3 From e0ac5c53377a0145494a051330ea00e2995f9ed8 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Mon, 20 Jul 2015 18:42:45 -0700 Subject: [dev.ssa] cmd/compile: minor cleanup Change-Id: Ib33f3b1cfa09f410675d275e214d8ddc246c53c3 Reviewed-on: https://go-review.googlesource.com/12548 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 7 +++---- src/cmd/compile/internal/ssa/TODO | 3 +++ 2 files changed, 6 insertions(+), 4 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 96756b11d0..9b5606a32f 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -22,6 +22,7 @@ func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { usessa = strings.HasSuffix(name, "_ssa") if usessa { + fmt.Println("generating SSA for", name) dumplist("buildssa-enter", fn.Func.Enter) dumplist("buildssa-body", fn.Nbody) } @@ -481,16 +482,14 @@ func (s *state) stmt(n *Node) { s.startBlock(bThen) s.stmtList(n.Nbody) - b = s.endBlock() - if b != nil { + if b := s.endBlock(); b != nil { addEdge(b, bEnd) } if n.Rlist != nil { s.startBlock(bElse) s.stmtList(n.Rlist) - b = s.endBlock() - if b != nil { + if b := s.endBlock(); b != nil { addEdge(b, bEnd) } } diff --git a/src/cmd/compile/internal/ssa/TODO b/src/cmd/compile/internal/ssa/TODO index cfaf520510..0074ded5d1 100644 --- a/src/cmd/compile/internal/ssa/TODO +++ b/src/cmd/compile/internal/ssa/TODO @@ -27,6 +27,7 @@ Regalloc - Handle 2-address instructions. - Floating point registers - Make calls clobber all registers + - Make liveness analysis non-quadratic. StackAlloc: - Sort variables so all ptr-containing ones are first (so stack @@ -60,3 +61,5 @@ Other expression subtrees in the output. - Implement memory zeroing with REPSTOSQ and DuffZero - make deadstore work with zeroing. + - Add a value range propagation optimization pass. + Use it for bounds check elimination and bitwidth reduction. -- cgit v1.3 From e61e7c96f7d96b7da60769a0cfb3c86814284c80 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Wed, 22 Jul 2015 19:19:40 -0700 Subject: [dev.ssa] cmd/compile: add some common binary ops Change-Id: I1af486a69960b9b66d5c2c9bbfcf7db6ef075d8c Reviewed-on: https://go-review.googlesource.com/12563 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 9b5606a32f..4e1e582b02 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -675,6 +675,8 @@ var opToSSA = map[opAndType]ssa.Op{ opAndType{OSUB, TINT64}: ssa.OpSub64, opAndType{OSUB, TUINT64}: ssa.OpSub64U, + opAndType{ONOT, TBOOL}: ssa.OpNot, + opAndType{OMINUS, TINT8}: ssa.OpNeg8, opAndType{OMINUS, TUINT8}: ssa.OpNeg8U, opAndType{OMINUS, TINT16}: ssa.OpNeg16, @@ -710,6 +712,7 @@ var opToSSA = map[opAndType]ssa.Op{ opAndType{OEQ, TUINT32}: ssa.OpEq32, opAndType{OEQ, TINT64}: ssa.OpEq64, opAndType{OEQ, TUINT64}: ssa.OpEq64, + opAndType{OEQ, TPTR64}: ssa.OpEq64, opAndType{ONE, TINT8}: ssa.OpNeq8, opAndType{ONE, TUINT8}: ssa.OpNeq8, @@ -719,6 +722,7 @@ var opToSSA = map[opAndType]ssa.Op{ opAndType{ONE, TUINT32}: ssa.OpNeq32, opAndType{ONE, TINT64}: ssa.OpNeq64, opAndType{ONE, TUINT64}: ssa.OpNeq64, + opAndType{ONE, TPTR64}: ssa.OpNeq64, opAndType{OLT, TINT8}: ssa.OpLess8, opAndType{OLT, TUINT8}: ssa.OpLess8U, -- cgit v1.3 From d5297f726199fd6ef27db82d5d663db83d74e2b1 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Wed, 22 Jul 2015 20:40:18 -0700 Subject: [dev.ssa] cmd/compile: speed up liveness analysis This reduces the wall time to run test/slice3.go on my laptop from >10m to ~20s. This could perhaps be further reduced by using a worklist of blocks and/or implementing the suggestion in the comment in this CL, but at this point, it's fast enough that there is no need. Change-Id: I741119e0c8310051d7185459f78be8b89237b85b Reviewed-on: https://go-review.googlesource.com/12564 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/regalloc.go | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index 27e4f754d1..f46fe25be4 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -419,13 +419,24 @@ func live(f *Func) [][]ID { s := newSparseSet(f.NumValues()) t := newSparseSet(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 { - for _, b := range f.Blocks { + for _, b := range po { f.Logf("live %s %v\n", b, live[b.ID]) } changed := false - for _, b := range f.Blocks { + for _, b := range po { // Start with known live values at the end of the block s.clear() s.addAll(live[b.ID]) -- cgit v1.3 From be1eb57a8b4f4728b1bfae18d7847ff111e2f46f Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Wed, 22 Jul 2015 13:46:15 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: implement multiplies Use width-and-signed-specific multiply opcodes. Implement OMUL. A few other cleanups. Fixes #11467 Change-Id: Ib0fe80a1a9b7208dbb8a2b6b652a478847f5d244 Reviewed-on: https://go-review.googlesource.com/12540 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/gc/ssa.go | 36 ++-- src/cmd/compile/internal/ssa/gen/AMD64.rules | 16 +- src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 12 +- src/cmd/compile/internal/ssa/gen/generic.rules | 7 +- src/cmd/compile/internal/ssa/gen/genericOps.go | 10 +- src/cmd/compile/internal/ssa/opGen.go | 123 ++++++++++++- src/cmd/compile/internal/ssa/rewriteAMD64.go | 236 ++++++++++++++++++++++++- src/cmd/compile/internal/ssa/rewritegeneric.go | 93 ++++++++-- 8 files changed, 485 insertions(+), 48 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 4e1e582b02..d6c0bc7c59 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -686,6 +686,15 @@ var opToSSA = map[opAndType]ssa.Op{ opAndType{OMINUS, TINT64}: ssa.OpNeg64, opAndType{OMINUS, TUINT64}: ssa.OpNeg64U, + opAndType{OMUL, TINT8}: ssa.OpMul8, + opAndType{OMUL, TUINT8}: ssa.OpMul8U, + opAndType{OMUL, TINT16}: ssa.OpMul16, + opAndType{OMUL, TUINT16}: ssa.OpMul16U, + opAndType{OMUL, TINT32}: ssa.OpMul32, + opAndType{OMUL, TUINT32}: ssa.OpMul32U, + opAndType{OMUL, TINT64}: ssa.OpMul64, + opAndType{OMUL, TUINT64}: ssa.OpMul64U, + opAndType{OLSH, TINT8}: ssa.OpLsh8, opAndType{OLSH, TUINT8}: ssa.OpLsh8, opAndType{OLSH, TINT16}: ssa.OpLsh16, @@ -825,7 +834,7 @@ func (s *state) expr(n *Node) *ssa.Value { a := s.expr(n.Left) b := s.expr(n.Right) return s.newValue2(s.ssaOp(n.Op, n.Left.Type), ssa.TypeBool, a, b) - case OADD, OSUB, OLSH, ORSH: + case OADD, OSUB, OMUL, OLSH, ORSH: a := s.expr(n.Left) b := s.expr(n.Right) return s.newValue2(s.ssaOp(n.Op, n.Type), a.Type, a, b) @@ -1387,7 +1396,7 @@ func genValue(v *ssa.Value) { p.From.Index = regnum(v.Args[1]) p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v) - case ssa.OpAMD64ADDB, ssa.OpAMD64ANDQ: + case ssa.OpAMD64ADDB, ssa.OpAMD64ANDQ, ssa.OpAMD64MULQ, ssa.OpAMD64MULL, ssa.OpAMD64MULW: r := regnum(v) x := regnum(v.Args[0]) y := regnum(v.Args[1]) @@ -1417,18 +1426,25 @@ func genValue(v *ssa.Value) { p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v) case ssa.OpAMD64MULQconst: - v.Unimplementedf("IMULQ doasm") - return - // TODO: this isn't right. doasm fails on it. I don't think obj - // has ever been taught to compile imul $c, r1, r2. + r := regnum(v) + x := regnum(v.Args[0]) + if r != x { + p := Prog(x86.AMOVQ) + p.From.Type = obj.TYPE_REG + p.From.Reg = x + p.To.Type = obj.TYPE_REG + p.To.Reg = r + } p := Prog(x86.AIMULQ) p.From.Type = obj.TYPE_CONST p.From.Offset = v.AuxInt - p.From3 = new(obj.Addr) - p.From3.Type = obj.TYPE_REG - p.From3.Reg = regnum(v.Args[0]) p.To.Type = obj.TYPE_REG - p.To.Reg = regnum(v) + 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: // This code compensates for the fact that the register allocator // doesn't understand 2-address instructions yet. TODO: fix that. diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index ee5029ad56..59f5564080 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -41,11 +41,25 @@ (Neg8U x) -> (NEGB x) (Neg8 x) -> (MOVBQSX (NEGB x)) -(Mul x y) && is64BitInt(t) -> (MULQ x y) +(Mul64 x y) -> (MULQ x y) +(Mul64U x y) -> (MULQ x y) +(MulPtr x y) -> (MULQ x y) +(Mul32 x y) -> (MOVLQSX (MULL x y)) +(Mul32U x y) -> (MULL x y) +(Mul16 x y) -> (MOVWQSX (MULW x y)) +(Mul16U x y) -> (MULW x y) +// Note: we use 16-bit multiply instructions for 8-bit multiplies because +// the 16-bit multiply instructions are more forgiving (they operate on +// any register instead of just AX/DX). +(Mul8 x y) -> (MOVBQSX (MULW x y)) +(Mul8U x y) -> (MOVBQZX (MULW x y)) (MOVLstore ptr (MOVLQSX x) mem) -> (MOVLstore ptr x mem) (MOVWstore ptr (MOVWQSX x) mem) -> (MOVWstore ptr x mem) (MOVBstore ptr (MOVBQSX x) mem) -> (MOVBstore ptr x mem) +(MOVLstore ptr (MOVLQZX x) mem) -> (MOVLstore ptr x mem) +(MOVWstore ptr (MOVWQZX x) mem) -> (MOVWstore ptr x mem) +(MOVBstore ptr (MOVBQZX x) mem) -> (MOVBstore ptr x mem) (Convert x) && t.IsInteger() && x.Type.IsInteger() -> (Copy x) (ConvNop x) && t == x.Type -> (Copy x) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index ac527918c3..382d666ae6 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -126,9 +126,12 @@ func init() { {name: "CMOVQCC", reg: cmov}, // carry clear - {name: "MOVLQSX", reg: gp11, asm: "MOVLQSX"}, // extend arg0 from int32 to int64 - {name: "MOVWQSX", reg: gp11, asm: "MOVWQSX"}, // extend arg0 from int16 to int64 - {name: "MOVBQSX", reg: gp11, asm: "MOVBQSX"}, // extend arg0 from int8 to int64 + {name: "MOVBQSX", reg: gp11, asm: "MOVBQSX"}, // sign extend arg0 from int8 to int64 + {name: "MOVBQZX", reg: gp11, asm: "MOVBQZX"}, // zero extend arg0 from int8 to int64 + {name: "MOVWQSX", reg: gp11, asm: "MOVWQSX"}, // sign extend arg0 from int16 to int64 + {name: "MOVWQZX", reg: gp11, asm: "MOVWQZX"}, // zero extend arg0 from int16 to int64 + {name: "MOVLQSX", reg: gp11, asm: "MOVLQSX"}, // sign extend arg0 from int32 to int64 + {name: "MOVLQZX", reg: gp11, asm: "MOVLQZX"}, // zero extend arg0 from int32 to int64 {name: "MOVQconst", reg: gp01}, // auxint {name: "LEAQ", reg: gp11sb}, // arg0 + auxint + offset encoded in aux @@ -182,6 +185,9 @@ func init() { {name: "NEGW", reg: gp11, asm: "NEGW"}, // -arg0 {name: "NEGB", reg: gp11, asm: "NEGB"}, // -arg0 + {name: "MULL", reg: gp21, asm: "IMULL"}, // arg0*arg1 + {name: "MULW", reg: gp21, asm: "IMULW"}, // arg0*arg1 + // (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. diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index e505c43d26..0b4d3b7886 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -22,7 +22,10 @@ // constant folding (Add64 (Const [c]) (Const [d])) -> (Const [c+d]) (Add64U (Const [c]) (Const [d])) -> (Const [c+d]) -(Mul (Const [c]) (Const [d])) && is64BitInt(t) -> (Const [c*d]) +(AddPtr (Const [c]) (Const [d])) -> (Const [c+d]) +(Mul64 (Const [c]) (Const [d])) -> (Const [c*d]) +(Mul64U (Const [c]) (Const [d])) -> (Const [c*d]) +(MulPtr (Const [c]) (Const [d])) -> (Const [c*d]) (IsInBounds (Const [c]) (Const [d])) -> (Const {inBounds(c,d)}) // tear apart slices @@ -34,7 +37,7 @@ // indexing operations // Note: bounds check has already been done (ArrayIndex (Load ptr mem) idx) -> (Load (PtrIndex ptr idx) mem) -(PtrIndex ptr idx) -> (AddPtr ptr (Mul idx (Const [t.Elem().Size()]))) +(PtrIndex ptr idx) -> (AddPtr ptr (MulPtr idx (Const [t.Elem().Size()]))) (StructSelect [idx] (Load ptr mem)) -> (Load (OffPtr [idx] ptr) mem) // big-object moves diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 5e1856a2fc..6129849ec6 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -29,7 +29,15 @@ var genericOps = []opData{ {name: "Sub64U"}, // TODO: Sub32F, Sub64F, Sub64C, Sub128C - {name: "Mul"}, // arg0 * arg1 + {name: "Mul8"}, // arg0 * arg1 + {name: "Mul16"}, + {name: "Mul32"}, + {name: "Mul64"}, + {name: "Mul8U"}, + {name: "Mul16U"}, + {name: "Mul32U"}, + {name: "Mul64U"}, + {name: "MulPtr"}, // MulPtr is used for address calculations {name: "Lsh8"}, // arg0 << arg1 {name: "Lsh16"}, diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 009e9d4e6d..0b15801ced 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -75,9 +75,12 @@ const ( OpAMD64SETGE OpAMD64SETB OpAMD64CMOVQCC - OpAMD64MOVLQSX - OpAMD64MOVWQSX OpAMD64MOVBQSX + OpAMD64MOVBQZX + OpAMD64MOVWQSX + OpAMD64MOVWQZX + OpAMD64MOVLQSX + OpAMD64MOVLQZX OpAMD64MOVQconst OpAMD64LEAQ OpAMD64LEAQ1 @@ -117,6 +120,8 @@ const ( OpAMD64NEGL OpAMD64NEGW OpAMD64NEGB + OpAMD64MULL + OpAMD64MULW OpAMD64InvertFlags OpAdd8 @@ -136,7 +141,15 @@ const ( OpSub16U OpSub32U OpSub64U - OpMul + OpMul8 + OpMul16 + OpMul32 + OpMul64 + OpMul8U + OpMul16U + OpMul32U + OpMul64U + OpMulPtr OpLsh8 OpLsh16 OpLsh32 @@ -533,8 +546,20 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVLQSX", - asm: x86.AMOVLQSX, + name: "MOVBQSX", + asm: x86.AMOVBQSX, + reg: regInfo{ + inputs: []regMask{ + 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", + asm: x86.AMOVBQZX, reg: regInfo{ inputs: []regMask{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -557,8 +582,32 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVBQSX", - asm: x86.AMOVBQSX, + name: "MOVWQZX", + asm: x86.AMOVWQZX, + reg: regInfo{ + inputs: []regMask{ + 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", + asm: x86.AMOVLQSX, + reg: regInfo{ + inputs: []regMask{ + 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", + asm: x86.AMOVLQZX, reg: regInfo{ inputs: []regMask{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -1006,6 +1055,32 @@ var opcodeTable = [...]opInfo{ }, }, }, + { + name: "MULL", + asm: x86.AIMULL, + reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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: "MULW", + asm: x86.AIMULW, + reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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: "InvertFlags", reg: regInfo{}, @@ -1080,7 +1155,39 @@ var opcodeTable = [...]opInfo{ generic: true, }, { - name: "Mul", + name: "Mul8", + generic: true, + }, + { + name: "Mul16", + generic: true, + }, + { + name: "Mul32", + generic: true, + }, + { + name: "Mul64", + generic: true, + }, + { + name: "Mul8U", + generic: true, + }, + { + name: "Mul16U", + generic: true, + }, + { + name: "Mul32U", + generic: true, + }, + { + name: "Mul64U", + generic: true, + }, + { + name: "MulPtr", generic: true, }, { diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index c118cc4279..4b63c97ebb 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -893,6 +893,28 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endc356ef104095b9217b36b594f85171c6 endc356ef104095b9217b36b594f85171c6: ; + // match: (MOVBstore ptr (MOVBQZX x) mem) + // cond: + // result: (MOVBstore ptr x mem) + { + ptr := v.Args[0] + if v.Args[1].Op != OpAMD64MOVBQZX { + goto end25841a70cce7ac32c6d5e561b992d3df + } + x := v.Args[1].Args[0] + mem := v.Args[2] + v.Op = OpAMD64MOVBstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v.AddArg(x) + v.AddArg(mem) + return true + } + goto end25841a70cce7ac32c6d5e561b992d3df + end25841a70cce7ac32c6d5e561b992d3df: + ; case OpAMD64MOVLstore: // match: (MOVLstore ptr (MOVLQSX x) mem) // cond: @@ -916,6 +938,28 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endf79c699f70cb356abb52dc28f4abf46b endf79c699f70cb356abb52dc28f4abf46b: ; + // match: (MOVLstore ptr (MOVLQZX x) mem) + // cond: + // result: (MOVLstore ptr x mem) + { + ptr := v.Args[0] + if v.Args[1].Op != OpAMD64MOVLQZX { + goto end67d1549d16d373e4ad6a89298866d1bc + } + x := v.Args[1].Args[0] + mem := v.Args[2] + v.Op = OpAMD64MOVLstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v.AddArg(x) + v.AddArg(mem) + return true + } + goto end67d1549d16d373e4ad6a89298866d1bc + end67d1549d16d373e4ad6a89298866d1bc: + ; case OpAMD64MOVQload: // match: (MOVQload [off1] (ADDQconst [off2] ptr) mem) // cond: @@ -1155,6 +1199,28 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endcc13af07a951a61fcfec3299342f7e1f endcc13af07a951a61fcfec3299342f7e1f: ; + // match: (MOVWstore ptr (MOVWQZX x) mem) + // cond: + // result: (MOVWstore ptr x mem) + { + ptr := v.Args[0] + if v.Args[1].Op != OpAMD64MOVWQZX { + goto end4e7df15ee55bdd73d8ecd61b759134d4 + } + x := v.Args[1].Args[0] + mem := v.Args[2] + v.Op = OpAMD64MOVWstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v.AddArg(x) + v.AddArg(mem) + return true + } + goto end4e7df15ee55bdd73d8ecd61b759134d4 + end4e7df15ee55bdd73d8ecd61b759134d4: + ; case OpAMD64MULQ: // match: (MULQ x (MOVQconst [c])) // cond: c == int64(int32(c)) @@ -1355,17 +1421,169 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end1b2d226705fd31dbbe74e3286af178ea end1b2d226705fd31dbbe74e3286af178ea: ; - case OpMul: - // match: (Mul x y) - // cond: is64BitInt(t) + case OpMul16: + // match: (Mul16 x y) + // cond: + // result: (MOVWQSX (MULW x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64MOVWQSX + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64MULW, TypeInvalid) + v0.Type = v.Type + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto end395fc5128ed3789326d04b4555ecfd16 + end395fc5128ed3789326d04b4555ecfd16: + ; + case OpMul16U: + // match: (Mul16U x y) + // cond: + // result: (MULW x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64MULW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto endec860875a3c61ac3738fa330a3857bb3 + endec860875a3c61ac3738fa330a3857bb3: + ; + case OpMul32: + // match: (Mul32 x y) + // cond: + // result: (MOVLQSX (MULL x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64MOVLQSX + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64MULL, TypeInvalid) + v0.Type = v.Type + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto endb756489a642e438ff6e89e55754334e2 + endb756489a642e438ff6e89e55754334e2: + ; + case OpMul32U: + // match: (Mul32U x y) + // cond: + // result: (MULL x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64MULL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto ende4c566176fb13075292de5ccb016c5fc + ende4c566176fb13075292de5ccb016c5fc: + ; + case OpMul64: + // match: (Mul64 x y) + // cond: + // result: (MULQ x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64MULQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end38da21e77ac329eb643b20e7d97d5853 + end38da21e77ac329eb643b20e7d97d5853: + ; + case OpMul64U: + // match: (Mul64U x y) + // cond: + // result: (MULQ x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64MULQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end3da28ba90850e15f0ed2c37fbce90650 + end3da28ba90850e15f0ed2c37fbce90650: + ; + case OpMul8: + // match: (Mul8 x y) + // cond: + // result: (MOVBQSX (MULW x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64MOVBQSX + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64MULW, TypeInvalid) + v0.Type = TypeInt16 + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto end418ba69107bb1e02d5015c73c9f9a5c9 + end418ba69107bb1e02d5015c73c9f9a5c9: + ; + case OpMul8U: + // match: (Mul8U x y) + // cond: + // result: (MOVBQZX (MULW x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64MOVBQZX + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64MULW, TypeInvalid) + v0.Type = TypeUInt16 + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto end9d0a972d9b8a32b84ed38a32bfeb01b6 + end9d0a972d9b8a32b84ed38a32bfeb01b6: + ; + case OpMulPtr: + // match: (MulPtr x y) + // cond: // result: (MULQ x y) { - t := v.Type x := v.Args[0] y := v.Args[1] - if !(is64BitInt(t)) { - goto endfab0d598f376ecba45a22587d50f7aff - } v.Op = OpAMD64MULQ v.AuxInt = 0 v.Aux = nil @@ -1374,8 +1592,8 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(y) return true } - goto endfab0d598f376ecba45a22587d50f7aff - endfab0d598f376ecba45a22587d50f7aff: + goto endbbedad106c011a93243e2062afdcc75f + endbbedad106c011a93243e2062afdcc75f: ; case OpNeg16: // match: (Neg16 x) diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index 7a4b6bf6ef..1095b85d91 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -50,6 +50,29 @@ func rewriteValuegeneric(v *Value, config *Config) bool { goto endfedc373d8be0243cb5dbbc948996fe3a endfedc373d8be0243cb5dbbc948996fe3a: ; + case OpAddPtr: + // match: (AddPtr (Const [c]) (Const [d])) + // cond: + // result: (Const [c+d]) + { + if v.Args[0].Op != OpConst { + goto end67284cb7ae441d6c763096b49a3569a3 + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst { + goto end67284cb7ae441d6c763096b49a3569a3 + } + d := v.Args[1].AuxInt + v.Op = OpConst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + d + return true + } + goto end67284cb7ae441d6c763096b49a3569a3 + end67284cb7ae441d6c763096b49a3569a3: + ; case OpArrayIndex: // match: (ArrayIndex (Load ptr mem) idx) // cond: @@ -167,23 +190,65 @@ func rewriteValuegeneric(v *Value, config *Config) bool { goto endce3ba169a57b8a9f6b12751d49b4e23a endce3ba169a57b8a9f6b12751d49b4e23a: ; - case OpMul: - // match: (Mul (Const [c]) (Const [d])) - // cond: is64BitInt(t) + case OpMul64: + // match: (Mul64 (Const [c]) (Const [d])) + // cond: + // result: (Const [c*d]) + { + if v.Args[0].Op != OpConst { + goto endf4ba5346dc8a624781afaa68a8096a9a + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst { + goto endf4ba5346dc8a624781afaa68a8096a9a + } + d := v.Args[1].AuxInt + v.Op = OpConst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c * d + return true + } + goto endf4ba5346dc8a624781afaa68a8096a9a + endf4ba5346dc8a624781afaa68a8096a9a: + ; + case OpMul64U: + // match: (Mul64U (Const [c]) (Const [d])) + // cond: // result: (Const [c*d]) { - t := v.Type if v.Args[0].Op != OpConst { - goto endd82095c6a872974522d33aaff1ee07be + goto end88b6638d23b281a90172e80ab26549cb } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst { - goto endd82095c6a872974522d33aaff1ee07be + goto end88b6638d23b281a90172e80ab26549cb } d := v.Args[1].AuxInt - if !(is64BitInt(t)) { - goto endd82095c6a872974522d33aaff1ee07be + v.Op = OpConst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c * d + return true + } + goto end88b6638d23b281a90172e80ab26549cb + end88b6638d23b281a90172e80ab26549cb: + ; + case OpMulPtr: + // match: (MulPtr (Const [c]) (Const [d])) + // cond: + // result: (Const [c*d]) + { + if v.Args[0].Op != OpConst { + goto end10541de7ea2bce703c1e372ac9a271e7 + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst { + goto end10541de7ea2bce703c1e372ac9a271e7 } + d := v.Args[1].AuxInt v.Op = OpConst v.AuxInt = 0 v.Aux = nil @@ -191,13 +256,13 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.AuxInt = c * d return true } - goto endd82095c6a872974522d33aaff1ee07be - endd82095c6a872974522d33aaff1ee07be: + goto end10541de7ea2bce703c1e372ac9a271e7 + end10541de7ea2bce703c1e372ac9a271e7: ; case OpPtrIndex: // match: (PtrIndex ptr idx) // cond: - // result: (AddPtr ptr (Mul idx (Const [t.Elem().Size()]))) + // result: (AddPtr ptr (MulPtr idx (Const [t.Elem().Size()]))) { t := v.Type ptr := v.Args[0] @@ -207,7 +272,7 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(ptr) - v0 := v.Block.NewValue0(v.Line, OpMul, TypeInvalid) + v0 := v.Block.NewValue0(v.Line, OpMulPtr, TypeInvalid) v0.Type = config.Uintptr v0.AddArg(idx) v1 := v.Block.NewValue0(v.Line, OpConst, TypeInvalid) @@ -217,8 +282,8 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto endc181347cd3c740e2a1da431a981fdd7e - endc181347cd3c740e2a1da431a981fdd7e: + goto endb39bbe157d1791123f6083b2cfc59ddc + endb39bbe157d1791123f6083b2cfc59ddc: ; case OpSliceCap: // match: (SliceCap (Load ptr mem)) -- cgit v1.3 From 00437ebe73944854d58ddb6710a185677317ee6e Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Mon, 20 Jul 2015 18:50:17 -0700 Subject: [dev.ssa] cmd/compile: don't combine phi vars from different blocks in CSE Here is a concrete case in which this goes wrong. func f_ssa() int { var n int Next: for j := 0; j < 3; j++ { for i := 0; i < 10; i++ { if i == 6 { continue Next } n = i } n += j + j + j + j + j + j + j + j + j + j // j * 10 } return n } What follows is the function printout before and after CSE. Note blocks b8 and b10 in the before case. b8 is the inner loop's condition: i < 10. b10 is the inner loop's increment: i++. v82 is i. On entry to b8, it is either 0 (v19) the first time, or the result of incrementing v82, by way of v29. The CSE pass considered v82 and v49 to be common subexpressions, and eliminated v82 in favor of v49. In the after case, v82 is now dead and will shortly be eliminated. As a result, v29 is also dead, and we have lost the increment. The loop runs forever. BEFORE CSE f_ssa b1: v1 = Arg v2 = SP v4 = Addr <*int> {~r0} v2 v13 = Zero [8] v4 v1 v14 = Const v15 = Const v17 = Const [3] v19 = Const v21 = Const [10] v24 = Const [6] v28 = Const [1] v43 = Const [1] Plain -> b3 b2: <- b7 Exit v47 b3: <- b1 Plain -> b4 b4: <- b3 b6 v49 = Phi v15 v44 v68 = Phi v14 v67 v81 = Phi v13 v81 v18 = Less v49 v17 If v18 -> b5 b7 b5: <- b4 Plain -> b8 b6: <- b12 b11 v67 = Phi v66 v41 v44 = Add v49 v43 Plain -> b4 b7: <- b4 v47 = Store v4 v68 v81 Plain -> b2 b8: <- b5 b10 v66 = Phi v68 v82 v82 = Phi v19 v29 v22 = Less v82 v21 If v22 -> b9 b11 b9: <- b8 v25 = Eq v82 v24 If v25 -> b12 b13 b10: <- b13 v29 = Add v82 v28 Plain -> b8 b11: <- b8 v32 = Add v49 v49 v33 = Add v32 v49 v34 = Add v33 v49 v35 = Add v34 v49 v36 = Add v35 v49 v37 = Add v36 v49 v38 = Add v37 v49 v39 = Add v38 v49 v40 = Add v39 v49 v41 = Add v66 v40 Plain -> b6 b12: <- b9 Plain -> b6 b13: <- b9 Plain -> b10 AFTER CSE f_ssa b1: v1 = Arg v2 = SP v4 = Addr <*int> {~r0} v2 v13 = Zero [8] v4 v1 v14 = Const v15 = Const v17 = Const [3] v19 = Const v21 = Const [10] v24 = Const [6] v28 = Const [1] v43 = Const [1] Plain -> b3 b2: <- b7 Exit v47 b3: <- b1 Plain -> b4 b4: <- b3 b6 v49 = Phi v19 v44 v68 = Phi v19 v67 v81 = Phi v13 v81 v18 = Less v49 v17 If v18 -> b5 b7 b5: <- b4 Plain -> b8 b6: <- b12 b11 v67 = Phi v66 v41 v44 = Add v49 v43 Plain -> b4 b7: <- b4 v47 = Store v4 v68 v81 Plain -> b2 b8: <- b5 b10 v66 = Phi v68 v49 v82 = Phi v19 v29 v22 = Less v49 v21 If v22 -> b9 b11 b9: <- b8 v25 = Eq v49 v24 If v25 -> b12 b13 b10: <- b13 v29 = Add v49 v43 Plain -> b8 b11: <- b8 v32 = Add v49 v49 v33 = Add v32 v49 v34 = Add v33 v49 v35 = Add v34 v49 v36 = Add v35 v49 v37 = Add v36 v49 v38 = Add v37 v49 v39 = Add v38 v49 v40 = Add v39 v49 v41 = Add v66 v40 Plain -> b6 b12: <- b9 Plain -> b6 b13: <- b9 Plain -> b10 Change-Id: I16fc4ec527ec63f24f7d0d79d1a4a59bf37269de Reviewed-on: https://go-review.googlesource.com/12444 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/cse.go | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/cse.go b/src/cmd/compile/internal/ssa/cse.go index a64e993e2a..9212aaf314 100644 --- a/src/cmd/compile/internal/ssa/cse.go +++ b/src/cmd/compile/internal/ssa/cse.go @@ -17,6 +17,7 @@ func cse(f *Func) { // 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 @@ -24,18 +25,23 @@ func cse(f *Func) { // It starts with a coarse partition and iteratively refines it // until it reaches a fixed point. - // Make initial partition based on opcode/type-name/aux/auxint/nargs + // Make initial partition based on opcode/type-name/aux/auxint/nargs/phi-block type key struct { op Op typ string aux interface{} auxint int64 nargs int + block ID // block id for phi vars, -1 otherwise } m := map[key]eqclass{} for _, b := range f.Blocks { for _, v := range b.Values { - k := key{v.Op, v.Type.String(), v.Aux, v.AuxInt, len(v.Args)} + bid := ID(-1) + if v.Op == OpPhi { + bid = b.ID + } + k := key{v.Op, v.Type.String(), v.Aux, v.AuxInt, len(v.Args), bid} m[k] = append(m[k], v) } } @@ -45,6 +51,9 @@ func cse(f *Func) { for _, v := range m { partition = append(partition, v) } + // TODO: Sort partition here for perfect reproducibility? + // Sort by what? Partition size? + // (Could that improve efficiency by discovering splits earlier?) // map from value id back to eqclass id valueEqClass := make([]int, f.NumValues()) -- cgit v1.3 From 8c954d57801d8ea855003425fbbbf78de8733e6a Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Wed, 15 Jul 2015 14:38:19 -0600 Subject: [dev.ssa] cmd/compile: speed up cse By walking only the current set of partitions at any given point, the cse pass ended up doing lots of extraneous, effectively O(n^2) work. Using a regular for loop allows each cse pass to make as much progress as possible by processing each new class as it is introduced. This can and should be optimized further, but it already reduces by 75% cse time on test/slice3.go. The overall time to compile test/slice3.go is still dominated by the O(n^2) work in the liveness pass. However, Keith is rewriting regalloc anyway. Change-Id: I8be020b2f69352234587eeadeba923481bf43fcc Reviewed-on: https://go-review.googlesource.com/12244 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/cse.go | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/cse.go b/src/cmd/compile/internal/ssa/cse.go index 9212aaf314..ebc25151b2 100644 --- a/src/cmd/compile/internal/ssa/cse.go +++ b/src/cmd/compile/internal/ssa/cse.go @@ -69,7 +69,10 @@ func cse(f *Func) { for { changed := false - for i, e := range partition { + // 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 q. -- cgit v1.3 From d298209b1c22e970adb19761c924f3301ca7e252 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Wed, 22 Jul 2015 13:13:53 -0700 Subject: [dev.ssa] cmd/compile: add GOSSAFUNC and GOSSAPKG These temporary environment variables make it possible to enable using SSA-generated code for a particular function or package without having to rebuild the compiler. This makes it possible to start bulk testing SSA generated code. First, bump up the default stack size (_StackMin in runtime/stack2.go) to something large like 32768, because without stackmaps we can't grow stacks. Then run something like: for pkg in `go list std` do GOGC=off GOSSAPKG=`basename $pkg` go test -a $pkg done When a test fails, you can re-run those tests, selectively enabling one function after another, until you find the one that is causing trouble. Doing this right now yields some interesting results: * There are several packages for which we generate some code and whose tests pass. Yay! * We can generate code for encoding/base64, but tests there fail, so there's a bug to fix. * Attempting to build the runtime yields a panic during codegen: panic: interface conversion: ssa.Location is nil, not *ssa.LocalSlot * The top unimplemented codegen items are (simplified): 59 genValue not implemented: REPMOVSB 18 genValue not implemented: REPSTOSQ 14 genValue not implemented: SUBQ 9 branch not implemented: If v -> b b. Control: XORQconst [1] 8 genValue not implemented: MOVQstoreidx8 4 branch not implemented: If v -> b b. Control: SETG 3 branch not implemented: If v -> b b. Control: SETLE 2 load flags not implemented: LoadReg8 2 genValue not implemented: InvertFlags 1 store flags not implemented: StoreReg8 1 branch not implemented: If v -> b b. Control: SETGE Change-Id: Ib64809ac0c917e25bcae27829ae634c70d290c7f Reviewed-on: https://go-review.googlesource.com/12547 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 20 +++++++++++++++++--- src/cmd/compile/internal/ssa/config.go | 2 ++ 2 files changed, 19 insertions(+), 3 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index d6c0bc7c59..6871fc48cd 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -6,6 +6,7 @@ package gc import ( "fmt" + "os" "strings" "cmd/compile/internal/ssa" @@ -146,7 +147,10 @@ func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { if e.unimplemented { return nil, false } - return s.f, usessa // TODO: return s.f, true once runtime support is in (gc maps, write barriers, etc.) + + // TODO: enable codegen more broadly once the codegen stabilizes + // and runtime support is in (gc maps, write barriers, etc.) + return s.f, usessa || name == os.Getenv("GOSSAFUNC") || localpkg.Name == os.Getenv("GOSSAPKG") } type state struct { @@ -1321,6 +1325,12 @@ func genssa(f *ssa.Func, ptxt *obj.Prog, gcargs, gclocals *Sym) { return } + 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 + ptxt.To.Type = obj.TYPE_TEXTSIZE ptxt.To.Val = int32(Rnd(Curfn.Type.Argwid, int64(Widthptr))) // arg size ptxt.To.Offset = f.FrameSize - 8 // TODO: arch-dependent @@ -1688,7 +1698,7 @@ func genValue(v *ssa.Value) { p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v) default: - v.Unimplementedf("value %s not implemented", v.LongString()) + v.Unimplementedf("genValue not implemented: %s", v.LongString()) } } @@ -1810,7 +1820,7 @@ func genBlock(b, next *ssa.Block, branches []branch) []branch { } default: - b.Unimplementedf("branch %s not implemented", b.LongString()) + b.Unimplementedf("branch not implemented: %s. Control: %s", b.LongString(), b.Control.LongString()) } return branches } @@ -1900,6 +1910,7 @@ func localOffset(v *ssa.Value) int64 { type ssaExport struct { log bool unimplemented bool + mustImplement bool } // StringSym returns a symbol (a *Sym wrapped in an interface) which @@ -1929,6 +1940,9 @@ func (e *ssaExport) Fatalf(msg string, args ...interface{}) { // Unimplemented reports that the function cannot be compiled. // It will be removed once SSA work is complete. func (e *ssaExport) Unimplementedf(msg string, args ...interface{}) { + if e.mustImplement { + Fatal(msg, args...) + } const alwaysLog = false // enable to calculate top unimplemented features if !e.unimplemented && (e.log || alwaysLog) { // first implementation failure, print explanation diff --git a/src/cmd/compile/internal/ssa/config.go b/src/cmd/compile/internal/ssa/config.go index c9e543ba37..78e3295ed8 100644 --- a/src/cmd/compile/internal/ssa/config.go +++ b/src/cmd/compile/internal/ssa/config.go @@ -60,6 +60,8 @@ func NewConfig(arch string, fe Frontend) *Config { return c } +func (c *Config) Frontend() Frontend { return c.fe } + // NewFunc returns a new, empty function object func (c *Config) NewFunc() *Func { // TODO(khr): should this function take name, type, etc. as arguments? -- cgit v1.3 From 5254be3a9c2d6427c081999309e836951210a69e Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Wed, 22 Jul 2015 19:18:35 -0700 Subject: [dev.ssa] cmd/compile: make etypes readable Change-Id: Id89ea3b458597dd93d269b9fe5475e9cccc6d992 Reviewed-on: https://go-review.googlesource.com/12562 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/fmt.go | 1 + src/cmd/compile/internal/gc/ssa.go | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/fmt.go b/src/cmd/compile/internal/gc/fmt.go index b40014be80..c50579924d 100644 --- a/src/cmd/compile/internal/gc/fmt.go +++ b/src/cmd/compile/internal/gc/fmt.go @@ -396,6 +396,7 @@ var etnames = []string{ TFORW: "FORW", TFIELD: "FIELD", TSTRING: "STRING", + TUNSAFEPTR: "TUNSAFEPTR", TANY: "ANY", } diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 6871fc48cd..d29da9d042 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -790,7 +790,7 @@ func (s *state) ssaOp(op uint8, t *Type) ssa.Op { } x, ok := opToSSA[opAndType{op, etype}] if !ok { - s.Unimplementedf("unhandled binary op %s etype=%d", opnames[op], etype) + s.Unimplementedf("unhandled binary op %s etype=%s", opnames[op], Econv(int(etype), 0)) } return x } -- cgit v1.3 From 317226e61c7269b97dafe8fd7524559ed64c64a2 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Wed, 22 Jul 2015 21:04:25 -0700 Subject: [dev.ssa] cmd/compile: use v.Args[x].Op in CSE key Experimentally, the Ops of v.Args do a good job of differentiating values that will end up in different partitions. Most values have at most two args, so use them. This reduces the wall time to run test/slice3.go on my laptop from ~20s to ~12s. Credit to Todd Neal for the idea. Change-Id: I55d08f09eb678bbe8366924ca2fabcd32526bf41 Reviewed-on: https://go-review.googlesource.com/12565 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/cse.go | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/cse.go b/src/cmd/compile/internal/ssa/cse.go index ebc25151b2..c98217339b 100644 --- a/src/cmd/compile/internal/ssa/cse.go +++ b/src/cmd/compile/internal/ssa/cse.go @@ -25,7 +25,7 @@ func cse(f *Func) { // It starts with a coarse partition and iteratively refines it // until it reaches a fixed point. - // Make initial partition based on opcode/type-name/aux/auxint/nargs/phi-block + // Make initial partition based on opcode, type-name, aux, auxint, nargs, phi-block, and the ops of v's first args type key struct { op Op typ string @@ -33,6 +33,8 @@ func cse(f *Func) { auxint int64 nargs int block ID // block id for phi vars, -1 otherwise + arg0op Op // v.Args[0].Op if len(v.Args) > 0, OpInvalid otherwise + arg1op Op // v.Args[1].Op if len(v.Args) > 1, OpInvalid otherwise } m := map[key]eqclass{} for _, b := range f.Blocks { @@ -41,7 +43,15 @@ func cse(f *Func) { if v.Op == OpPhi { bid = b.ID } - k := key{v.Op, v.Type.String(), v.Aux, v.AuxInt, len(v.Args), bid} + arg0op := OpInvalid + if len(v.Args) > 0 { + arg0op = v.Args[0].Op + } + arg1op := OpInvalid + if len(v.Args) > 1 { + arg1op = v.Args[1].Op + } + k := key{v.Op, v.Type.String(), v.Aux, v.AuxInt, len(v.Args), bid, arg0op, arg1op} m[k] = append(m[k], v) } } -- cgit v1.3 From 851ceebcebb2ae9352a2be958c86f63e70d344b1 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Wed, 22 Jul 2015 21:21:50 -0700 Subject: [dev.ssa] cmd/compile: don't alloc new CSE classes This reduces the time to compile test/slice3.go on my laptop from ~12s to ~3.8s. It reduces the max memory use from ~4.8gb to ~450mb. This is still considerably worse than tip, at 1s and 300mb respectively, but it's getting closer. Hopefully this will fix the build at long last. Change-Id: Iac26b52023f408438cba3ea1b81dcd82ca402b90 Reviewed-on: https://go-review.googlesource.com/12566 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/cse.go | 20 ++++++++++++-------- 1 file changed, 12 insertions(+), 8 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/cse.go b/src/cmd/compile/internal/ssa/cse.go index c98217339b..6851ca9f40 100644 --- a/src/cmd/compile/internal/ssa/cse.go +++ b/src/cmd/compile/internal/ssa/cse.go @@ -85,18 +85,22 @@ func cse(f *Func) { e := partition[i] v := e[0] // all values in this equiv class that are not equivalent to v get moved - // into another equiv class q. - var q eqclass + // into another equiv class. + // To avoid allocating while building that equivalence class, + // move the values equivalent to v to the beginning of e, + // other values to the end of e, and track where the split is. + allvals := e + split := len(e) eqloop: for j := 1; j < len(e); { w := e[j] for i := 0; i < len(v.Args); i++ { if valueEqClass[v.Args[i].ID] != valueEqClass[w.Args[i].ID] || !v.Type.Equal(w.Type) { // w is not equivalent to v. - // remove w from e - e, e[j] = e[:len(e)-1], e[len(e)-1] - // add w to q - q = append(q, w) + // move it to the end, shrink e, and move the split. + e[j], e[len(e)-1] = e[len(e)-1], e[j] + e = e[:len(e)-1] + split-- valueEqClass[w.ID] = len(partition) changed = true continue eqloop @@ -106,8 +110,8 @@ func cse(f *Func) { j++ } partition[i] = e - if q != nil { - partition = append(partition, q) + if split < len(allvals) { + partition = append(partition, allvals[split:]) } } -- cgit v1.3 From d90e0481bf0c2f5ba13ed0ae1872b223f0c5ce9c Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Thu, 23 Jul 2015 20:01:40 -0500 Subject: [dev.ssa] cmd/compile: implement LEAQ2/LEAQ4/LEAQ8 opcodes Change-Id: I8da76b9a4c5c80e8515e69e105d6349fe3ad9281 Reviewed-on: https://go-review.googlesource.com/12611 Reviewed-by: Keith Randall Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/gc/ssa.go | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index d29da9d042..0ea5aa41f1 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1538,11 +1538,20 @@ func genValue(v *ssa.Value) { p.From.Type = obj.TYPE_REG p.To.Type = obj.TYPE_REG p.To.Reg = r - case ssa.OpAMD64LEAQ1: + 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]) - p.From.Scale = 1 + 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 -- cgit v1.3 From 8d31df18afd682b8440f3ea82033c01b144c65c8 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Fri, 24 Jul 2015 11:28:12 -0700 Subject: [dev.ssa] cmd/compile: use string contents instead of offset from string header This generates more efficient code. Before: 0x003a 00058 (rr.go:7) LEAQ go.string.hdr."="(SB), BX 0x0041 00065 (rr.go:7) LEAQ 16(BX), BP 0x0045 00069 (rr.go:7) MOVQ BP, 16(SP) After: 0x003a 00058 (rr.go:7) LEAQ go.string."="(SB), BX 0x0041 00065 (rr.go:7) MOVQ BX, 16(SP) It also matches the existing backend and is more robust to other changes, such as CL 11698, which I believe broke the current code. This CL fixes the encoding/base64 tests, as run with: GOGC=off GOSSAPKG=base64 go test -a encoding/base64 Change-Id: I3c475bed1dd3335cc14e13309e11d23f0ed32c17 Reviewed-on: https://go-review.googlesource.com/12654 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 10 ++++----- src/cmd/compile/internal/ssa/config.go | 6 ++---- src/cmd/compile/internal/ssa/export_test.go | 2 +- src/cmd/compile/internal/ssa/gen/generic.rules | 2 +- src/cmd/compile/internal/ssa/rewritegeneric.go | 28 +++++++++++--------------- 5 files changed, 21 insertions(+), 27 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 0ea5aa41f1..e7772a92bb 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1922,12 +1922,12 @@ type ssaExport struct { mustImplement bool } -// StringSym returns a symbol (a *Sym wrapped in an interface) which -// is a global string constant containing s. -func (*ssaExport) StringSym(s string) interface{} { +// 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... - hdr, _ := stringsym(s) - return &ssa.ExternSymbol{Typ: idealstring, Sym: hdr} + _, data := stringsym(s) + return &ssa.ExternSymbol{Typ: idealstring, Sym: data} } // Log logs a message from the compiler. diff --git a/src/cmd/compile/internal/ssa/config.go b/src/cmd/compile/internal/ssa/config.go index 78e3295ed8..d3d2c66b7f 100644 --- a/src/cmd/compile/internal/ssa/config.go +++ b/src/cmd/compile/internal/ssa/config.go @@ -17,10 +17,8 @@ type Config struct { } type Frontend interface { - // StringSym returns a symbol pointing to the given string. - // Strings are laid out in read-only memory with one word of pointer, - // one word of length, then the contents of the string. - StringSym(string) interface{} // returns *gc.Sym + // StringData returns a symbol pointing to the given string's contents. + StringData(string) interface{} // returns *gc.Sym // Log logs a message from the compiler. Logf(string, ...interface{}) diff --git a/src/cmd/compile/internal/ssa/export_test.go b/src/cmd/compile/internal/ssa/export_test.go index cec4abff56..d13729efbf 100644 --- a/src/cmd/compile/internal/ssa/export_test.go +++ b/src/cmd/compile/internal/ssa/export_test.go @@ -15,7 +15,7 @@ type DummyFrontend struct { t testing.TB } -func (DummyFrontend) StringSym(s string) interface{} { +func (DummyFrontend) StringData(s string) interface{} { return nil } diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index 0b4d3b7886..492676d9b7 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -45,7 +45,7 @@ (Store dst (Load src mem) mem) && t.Size() > 8 -> (Move [t.Size()] dst src mem) // string ops -(Const {s}) && t.IsString() -> (StringMake (OffPtr [2*config.PtrSize] (Addr {config.fe.StringSym(s.(string))} (SB ))) (Const [int64(len(s.(string)))])) // TODO: ptr +(Const {s}) && t.IsString() -> (StringMake (Addr {config.fe.StringData(s.(string))} (SB )) (Const [int64(len(s.(string)))])) (Load ptr mem) && t.IsString() -> (StringMake (Load ptr mem) (Load (OffPtr [config.PtrSize] ptr) mem)) (StringPtr (StringMake ptr _)) -> ptr (StringLen (StringMake _ len)) -> len diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index 1095b85d91..66b6c1a7a5 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -102,36 +102,32 @@ func rewriteValuegeneric(v *Value, config *Config) bool { case OpConst: // match: (Const {s}) // cond: t.IsString() - // result: (StringMake (OffPtr [2*config.PtrSize] (Addr {config.fe.StringSym(s.(string))} (SB ))) (Const [int64(len(s.(string)))])) + // result: (StringMake (Addr {config.fe.StringData(s.(string))} (SB )) (Const [int64(len(s.(string)))])) { t := v.Type s := v.Aux if !(t.IsString()) { - goto endedcb8bd24122d6a47bdc9b752460c344 + goto enda6f250a3c775ae5a239ece8074b46cea } v.Op = OpStringMake v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpOffPtr, TypeInvalid) + v0 := v.Block.NewValue0(v.Line, OpAddr, TypeInvalid) v0.Type = TypeBytePtr - v0.AuxInt = 2 * config.PtrSize - v1 := v.Block.NewValue0(v.Line, OpAddr, TypeInvalid) - v1.Type = TypeBytePtr - v1.Aux = config.fe.StringSym(s.(string)) - v2 := v.Block.NewValue0(v.Line, OpSB, TypeInvalid) - v2.Type = config.Uintptr - v1.AddArg(v2) + v0.Aux = config.fe.StringData(s.(string)) + v1 := v.Block.NewValue0(v.Line, OpSB, TypeInvalid) + v1.Type = config.Uintptr v0.AddArg(v1) v.AddArg(v0) - v3 := v.Block.NewValue0(v.Line, OpConst, TypeInvalid) - v3.Type = config.Uintptr - v3.AuxInt = int64(len(s.(string))) - v.AddArg(v3) + v2 := v.Block.NewValue0(v.Line, OpConst, TypeInvalid) + v2.Type = config.Uintptr + v2.AuxInt = int64(len(s.(string))) + v.AddArg(v2) return true } - goto endedcb8bd24122d6a47bdc9b752460c344 - endedcb8bd24122d6a47bdc9b752460c344: + goto enda6f250a3c775ae5a239ece8074b46cea + enda6f250a3c775ae5a239ece8074b46cea: ; case OpIsInBounds: // match: (IsInBounds (Const [c]) (Const [d])) -- cgit v1.3 From 5c5f2a731ccfb9dec12967ed2da8f530b8c23a61 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Fri, 24 Jul 2015 11:43:25 -0700 Subject: [dev.ssa] cmd/compile: convert localOffset panic to unimplemented This prevents panics while attempting to generate code for the runtime package. Now: : internal compiler error: localOffset of non-LocalSlot value: v10 = ADDQconst <*m> [256] v22 Change-Id: I20ed6ec6aae2c91183b8c826b8ebcc98e8ceebff Reviewed-on: https://go-review.googlesource.com/12655 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index e7772a92bb..2b6962a979 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1911,8 +1911,15 @@ func regnum(v *ssa.Value) int16 { // localOffset returns the offset below the frame pointer where // a stack-allocated local has been allocated. Panics if v // is not assigned to a local slot. +// TODO: Make this panic again once it stops happening routinely. func localOffset(v *ssa.Value) int64 { - return v.Block.Func.RegAlloc[v.ID].(*ssa.LocalSlot).Idx + reg := v.Block.Func.RegAlloc[v.ID] + slot, ok := reg.(*ssa.LocalSlot) + if !ok { + v.Unimplementedf("localOffset of non-LocalSlot value: %s", v.LongString()) + return 0 + } + return slot.Idx } // ssaExport exports a bunch of compiler services for the ssa backend. -- cgit v1.3 From 71b570774da4c42139a9e16735a353209f0f8def Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Fri, 24 Jul 2015 12:47:00 -0700 Subject: [dev.ssa] cmd/compile: finish implementing comparisons Change-Id: I4e496c7c7239111133631f76ca25e14be64800c6 Reviewed-on: https://go-review.googlesource.com/12656 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 105 +++++++---------------- src/cmd/compile/internal/ssa/gen/AMD64.rules | 6 ++ src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 3 + src/cmd/compile/internal/ssa/opGen.go | 39 +++++++++ src/cmd/compile/internal/ssa/rewriteAMD64.go | 120 +++++++++++++++++++++++++++ 5 files changed, 197 insertions(+), 76 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 2b6962a979..b8831793fc 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1702,7 +1702,8 @@ func genValue(v *ssa.Value) { case ssa.OpAMD64SETEQ, ssa.OpAMD64SETNE, ssa.OpAMD64SETL, ssa.OpAMD64SETLE, ssa.OpAMD64SETG, ssa.OpAMD64SETGE, - ssa.OpAMD64SETB: + ssa.OpAMD64SETB, ssa.OpAMD64SETBE, + ssa.OpAMD64SETA, ssa.OpAMD64SETAE: p := Prog(v.Op.Asm()) p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v) @@ -1725,6 +1726,19 @@ func movZero(as int, width int64, nbytes int64, offset int64, regnum int16) (nle 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}, +} + func genBlock(b, next *ssa.Block, branches []branch) []branch { lineno = b.Line switch b.Kind { @@ -1742,85 +1756,24 @@ func genBlock(b, next *ssa.Block, branches []branch) []branch { p.To.Type = obj.TYPE_BRANCH branches = append(branches, branch{p, b.Succs[0]}) } - case ssa.BlockAMD64EQ: - if b.Succs[0] == next { - p := Prog(x86.AJNE) - p.To.Type = obj.TYPE_BRANCH - branches = append(branches, branch{p, b.Succs[1]}) - } else if b.Succs[1] == next { - p := Prog(x86.AJEQ) - p.To.Type = obj.TYPE_BRANCH - branches = append(branches, branch{p, b.Succs[0]}) - } else { - p := Prog(x86.AJEQ) - p.To.Type = obj.TYPE_BRANCH - branches = append(branches, branch{p, b.Succs[0]}) - q := Prog(obj.AJMP) - q.To.Type = obj.TYPE_BRANCH - branches = append(branches, branch{q, b.Succs[1]}) - } - case ssa.BlockAMD64NE: - if b.Succs[0] == next { - p := Prog(x86.AJEQ) - p.To.Type = obj.TYPE_BRANCH - branches = append(branches, branch{p, b.Succs[1]}) - } else if b.Succs[1] == next { - p := Prog(x86.AJNE) - p.To.Type = obj.TYPE_BRANCH - branches = append(branches, branch{p, b.Succs[0]}) - } else { - p := Prog(x86.AJNE) - p.To.Type = obj.TYPE_BRANCH - branches = append(branches, branch{p, b.Succs[0]}) - q := Prog(obj.AJMP) - q.To.Type = obj.TYPE_BRANCH - branches = append(branches, branch{q, b.Succs[1]}) - } - case ssa.BlockAMD64LT: - if b.Succs[0] == next { - p := Prog(x86.AJGE) - p.To.Type = obj.TYPE_BRANCH - branches = append(branches, branch{p, b.Succs[1]}) - } else if b.Succs[1] == next { - p := Prog(x86.AJLT) - p.To.Type = obj.TYPE_BRANCH - branches = append(branches, branch{p, b.Succs[0]}) - } else { - p := Prog(x86.AJLT) - p.To.Type = obj.TYPE_BRANCH - branches = append(branches, branch{p, b.Succs[0]}) - q := Prog(obj.AJMP) - q.To.Type = obj.TYPE_BRANCH - branches = append(branches, branch{q, b.Succs[1]}) - } - case ssa.BlockAMD64ULT: - if b.Succs[0] == next { - p := Prog(x86.AJCC) - p.To.Type = obj.TYPE_BRANCH - branches = append(branches, branch{p, b.Succs[1]}) - } else if b.Succs[1] == next { - p := Prog(x86.AJCS) - p.To.Type = obj.TYPE_BRANCH - branches = append(branches, branch{p, b.Succs[0]}) - } else { - p := Prog(x86.AJCS) - p.To.Type = obj.TYPE_BRANCH - branches = append(branches, branch{p, b.Succs[0]}) - q := Prog(obj.AJMP) - q.To.Type = obj.TYPE_BRANCH - branches = append(branches, branch{q, b.Succs[1]}) - } - case ssa.BlockAMD64UGT: - if b.Succs[0] == next { - p := Prog(x86.AJLS) + 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] + switch next { + case b.Succs[0]: + p := Prog(jmp.invasm) p.To.Type = obj.TYPE_BRANCH branches = append(branches, branch{p, b.Succs[1]}) - } else if b.Succs[1] == next { - p := Prog(x86.AJHI) + case b.Succs[1]: + p := Prog(jmp.asm) p.To.Type = obj.TYPE_BRANCH branches = append(branches, branch{p, b.Succs[0]}) - } else { - p := Prog(x86.AJHI) + default: + p := Prog(jmp.asm) p.To.Type = obj.TYPE_BRANCH branches = append(branches, branch{p, b.Succs[0]}) q := Prog(obj.AJMP) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 59f5564080..f1ae4f6a82 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -118,9 +118,15 @@ // 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) (If cond yes no) && cond.Op == OpAMD64MOVBload -> (NE (TESTB cond cond) yes no) (StaticCall [argwid] {target} mem) -> (CALLstatic [argwid] {target} mem) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 382d666ae6..382d64c9de 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -123,6 +123,9 @@ func init() { {name: "SETG", reg: flagsgp, asm: "SETGT"}, // extract signed > condition from arg0 {name: "SETGE", reg: flagsgp, asm: "SETGE"}, // extract signed >= condition from arg0 {name: "SETB", reg: flagsgp, asm: "SETCS"}, // extract unsigned < condition from arg0 + {name: "SETBE", reg: flagsgp, asm: "SETLS"}, // extract unsigned <= condition from arg0 + {name: "SETA", reg: flagsgp, asm: "SETHI"}, // extract unsigned > condition from arg0 + {name: "SETAE", reg: flagsgp, asm: "SETCC"}, // extract unsigned >= condition from arg0 {name: "CMOVQCC", reg: cmov}, // carry clear diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 0b15801ced..8c1ef0b9d9 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -74,6 +74,9 @@ const ( OpAMD64SETG OpAMD64SETGE OpAMD64SETB + OpAMD64SETBE + OpAMD64SETA + OpAMD64SETAE OpAMD64CMOVQCC OpAMD64MOVBQSX OpAMD64MOVBQZX @@ -532,6 +535,42 @@ var opcodeTable = [...]opInfo{ }, }, }, + { + name: "SETBE", + asm: x86.ASETLS, + reg: regInfo{ + inputs: []regMask{ + 8589934592, // .FLAGS + }, + outputs: []regMask{ + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + }, + }, + { + name: "SETA", + asm: x86.ASETHI, + reg: regInfo{ + inputs: []regMask{ + 8589934592, // .FLAGS + }, + outputs: []regMask{ + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + }, + }, + { + name: "SETAE", + asm: x86.ASETCC, + reg: regInfo{ + inputs: []regMask{ + 8589934592, // .FLAGS + }, + outputs: []regMask{ + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + }, + }, { name: "CMOVQCC", reg: regInfo{ diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 4b63c97ebb..f8642a7bb5 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -2589,6 +2589,66 @@ func rewriteBlockAMD64(b *Block) bool { } goto ende4d36879bb8e1bd8facaa8c91ba99dcc ende4d36879bb8e1bd8facaa8c91ba99dcc: + ; + // match: (If (SETLE cmp) yes no) + // cond: + // result: (LE cmp yes no) + { + v := b.Control + if v.Op != OpAMD64SETLE { + goto end40df18679690e8f9005d8642fab44654 + } + 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 + } + goto end40df18679690e8f9005d8642fab44654 + end40df18679690e8f9005d8642fab44654: + ; + // match: (If (SETG cmp) yes no) + // cond: + // result: (GT cmp yes no) + { + v := b.Control + if v.Op != OpAMD64SETG { + goto endb1faff07a84ae08a4b05a4a7e71eb740 + } + 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 + } + goto endb1faff07a84ae08a4b05a4a7e71eb740 + endb1faff07a84ae08a4b05a4a7e71eb740: + ; + // match: (If (SETGE cmp) yes no) + // cond: + // result: (GE cmp yes no) + { + v := b.Control + if v.Op != OpAMD64SETGE { + goto enda9211ccfa5b0ab8eafc0017630c542b6 + } + 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 + } + goto enda9211ccfa5b0ab8eafc0017630c542b6 + enda9211ccfa5b0ab8eafc0017630c542b6: ; // match: (If (SETEQ cmp) yes no) // cond: @@ -2649,6 +2709,66 @@ func rewriteBlockAMD64(b *Block) bool { } goto end04935012db9defeafceef8175f803ea2 end04935012db9defeafceef8175f803ea2: + ; + // match: (If (SETBE cmp) yes no) + // cond: + // result: (ULE cmp yes no) + { + v := b.Control + if v.Op != OpAMD64SETBE { + goto endfe0178f6f4406945ca8966817d04be60 + } + 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 + } + goto endfe0178f6f4406945ca8966817d04be60 + endfe0178f6f4406945ca8966817d04be60: + ; + // match: (If (SETA cmp) yes no) + // cond: + // result: (UGT cmp yes no) + { + v := b.Control + if v.Op != OpAMD64SETA { + goto endbd22a7d56a98d85e4e132ff952dae262 + } + 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 + } + goto endbd22a7d56a98d85e4e132ff952dae262 + endbd22a7d56a98d85e4e132ff952dae262: + ; + // match: (If (SETAE cmp) yes no) + // cond: + // result: (UGE cmp yes no) + { + v := b.Control + if v.Op != OpAMD64SETAE { + goto end9bea9963c3c5dfb97249a5feb8287f94 + } + 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 + } + goto end9bea9963c3c5dfb97249a5feb8287f94 + end9bea9963c3c5dfb97249a5feb8287f94: ; // match: (If cond yes no) // cond: cond.Op == OpAMD64MOVBload -- cgit v1.3 From 7e74e43366d58844cb30f382374e6447b93ac706 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Fri, 24 Jul 2015 11:55:52 -0700 Subject: [dev.ssa] cmd/compile: minor cleanup Cull dead code. Add TODOs. Change-Id: I81d24371de47f5a27d3a3a0ec0ef5baaf6814c06 Reviewed-on: https://go-review.googlesource.com/12659 Reviewed-by: Brad Fitzpatrick --- src/cmd/compile/internal/gc/ssa.go | 5 ++--- src/cmd/compile/internal/ssa/TODO | 4 ++++ src/cmd/compile/internal/ssa/gen/genericOps.go | 2 +- 3 files changed, 7 insertions(+), 4 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index b8831793fc..e9f99b1799 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1114,6 +1114,8 @@ func canSSA(n *Node) bool { // nilCheck generates nil pointer checking code. // Starts a new block on return. +// Used only for automatically inserted nil checks, +// not for user code like 'x != nil'. func (s *state) nilCheck(ptr *ssa.Value) { c := s.newValue1(ssa.OpIsNonNil, ssa.TypeBool, ptr) b := s.endBlock() @@ -1466,7 +1468,6 @@ func genValue(v *ssa.Value) { p.From.Reg = x p.To.Type = obj.TYPE_REG p.To.Reg = r - x = r } p := Prog(x86.ASUBQ) p.From.Type = obj.TYPE_CONST @@ -1485,7 +1486,6 @@ func genValue(v *ssa.Value) { p.From.Reg = x p.To.Type = obj.TYPE_REG p.To.Reg = r - x = r } p := Prog(v.Op.Asm()) p.From.Type = obj.TYPE_REG @@ -1501,7 +1501,6 @@ func genValue(v *ssa.Value) { p.From.Reg = x p.To.Type = obj.TYPE_REG p.To.Reg = r - x = r } p := Prog(v.Op.Asm()) p.From.Type = obj.TYPE_CONST diff --git a/src/cmd/compile/internal/ssa/TODO b/src/cmd/compile/internal/ssa/TODO index 0074ded5d1..225768c73c 100644 --- a/src/cmd/compile/internal/ssa/TODO +++ b/src/cmd/compile/internal/ssa/TODO @@ -52,6 +52,9 @@ Common-Subexpression Elimination - Can we move control values out of their basic block? This would break nilcheckelim as currently implemented, but it could be replaced by a similar CFG simplication pass. + - 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? Other - Write barriers @@ -63,3 +66,4 @@ Other - make deadstore work with zeroing. - Add a value range propagation optimization pass. Use it for bounds check elimination and bitwidth reduction. + - Branch prediction: Respect hints from the frontend, add our own. diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 6129849ec6..4014fd5009 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -153,7 +153,7 @@ var genericOps = []opData{ {name: "Convert"}, // convert arg0 to another type {name: "ConvNop"}, // interpret arg0 as another type - // Safety checks + // Automatically inserted safety checks {name: "IsNonNil"}, // arg0 != nil {name: "IsInBounds"}, // 0 <= arg0 < arg1 -- cgit v1.3 From 52d76f7a6a02cf5834251a4ceadc686a9f83ac81 Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Thu, 23 Jul 2015 18:44:09 -0500 Subject: [dev.ssa] cmd/compile: rewrite if not Rewrite if !cond by swapping the branches and removing the not. Change-Id: If3af1bac02bfc566faba872a8c7f7e5ce38e9f58 Reviewed-on: https://go-review.googlesource.com/12610 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/ssa/gen/generic.rules | 1 + src/cmd/compile/internal/ssa/rewritegeneric.go | 20 ++++++++++++++++++++ 2 files changed, 21 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index 492676d9b7..fc5ffb9610 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -51,5 +51,6 @@ (StringLen (StringMake _ len)) -> len (Store dst str mem) && str.Type.IsString() -> (Store (OffPtr [config.PtrSize] dst) (StringLen str) (Store dst (StringPtr str) mem)) +(If (Not cond) yes no) -> (If cond no yes) (If (Const {c}) yes no) && c.(bool) -> (Plain nil yes) (If (Const {c}) yes no) && !c.(bool) -> (Plain nil no) diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index 66b6c1a7a5..54358129e0 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -495,6 +495,26 @@ func rewriteValuegeneric(v *Value, config *Config) bool { func rewriteBlockgeneric(b *Block) bool { switch b.Kind { case BlockIf: + // match: (If (Not cond) yes no) + // cond: + // result: (If cond no yes) + { + v := b.Control + if v.Op != OpNot { + goto endebe19c1c3c3bec068cdb2dd29ef57f96 + } + 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 + return true + } + goto endebe19c1c3c3bec068cdb2dd29ef57f96 + endebe19c1c3c3bec068cdb2dd29ef57f96: + ; // match: (If (Const {c}) yes no) // cond: c.(bool) // result: (Plain nil yes) -- cgit v1.3 From db5232620a1722ae1bcdf5f0d8cd15ba0bac2077 Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Sat, 25 Jul 2015 12:53:58 -0500 Subject: [dev.ssa] cmd/compile: only fold 32 bit integers for add/multiply Fix an issue where doasm fails if trying to multiply by a larger than 32 bit const (doasm: notfound ft=9 tt=14 00008 IMULQ $34359738369, CX 9 14). Fix truncation of 64 to 32 bit integer when generating LEA causing incorrect values to be computed. Change-Id: I1e65b63cc32ac673a9bb5a297b578b44c2f1ac8f Reviewed-on: https://go-review.googlesource.com/12678 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa_test.go | 3 ++ src/cmd/compile/internal/gc/testdata/arith_ssa.go | 47 +++++++++++++++++++++++ src/cmd/compile/internal/ssa/gen/AMD64.rules | 9 +++-- src/cmd/compile/internal/ssa/rewrite.go | 7 +++- src/cmd/compile/internal/ssa/rewriteAMD64.go | 45 +++++++++++++--------- 5 files changed, 88 insertions(+), 23 deletions(-) create mode 100644 src/cmd/compile/internal/gc/testdata/arith_ssa.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa_test.go b/src/cmd/compile/internal/gc/ssa_test.go index 4354d020f2..f51d6de871 100644 --- a/src/cmd/compile/internal/gc/ssa_test.go +++ b/src/cmd/compile/internal/gc/ssa_test.go @@ -42,3 +42,6 @@ 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") } + +// TestArithmetic tests that both backends have the same result for arithmetic expressions. +func TestArithmetic(t *testing.T) { runTest(t, "arith_ssa.go") } 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 0000000000..a4fdf16f7d --- /dev/null +++ b/src/cmd/compile/internal/gc/testdata/arith_ssa.go @@ -0,0 +1,47 @@ +// 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 + +func test64BitConstMult(a, b int64) { + want := 34359738369*a + b*34359738370 + if got := test64BitConstMult_ssa(a, b); want != got { + println("test64BitConstMult failed, wanted", want, "got", got) + failed = true + } +} +func test64BitConstMult_ssa(a, b int64) int64 { + switch { // prevent inlining + } + return 34359738369*a + b*34359738370 +} + +func test64BitConstAdd(a, b int64) { + want := a + 575815584948629622 + b + 2991856197886747025 + if got := test64BitConstAdd_ssa(a, b); want != got { + println("test64BitConstAdd failed, wanted", want, "got", got) + failed = true + } +} +func test64BitConstAdd_ssa(a, b int64) int64 { + switch { + } + return a + 575815584948629622 + b + 2991856197886747025 +} + +var failed = false + +func main() { + + test64BitConstMult(1, 2) + test64BitConstAdd(1, 2) + + if failed { + panic("failed") + } +} diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index f1ae4f6a82..7f5fd663e3 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -136,12 +136,13 @@ // TODO: Should this be a separate pass? // fold constants into instructions -(ADDQ x (MOVQconst [c])) -> (ADDQconst [c] x) // TODO: restrict c to int32 range? -(ADDQ (MOVQconst [c]) x) -> (ADDQconst [c] x) +// TODO: restrict c to int32 range for all? +(ADDQ x (MOVQconst [c])) && is32Bit(c) -> (ADDQconst [c] x) +(ADDQ (MOVQconst [c]) x) && is32Bit(c) -> (ADDQconst [c] x) (SUBQ x (MOVQconst [c])) -> (SUBQconst x [c]) (SUBQ (MOVQconst [c]) x) -> (NEGQ (SUBQconst x [c])) -(MULQ x (MOVQconst [c])) && c == int64(int32(c)) -> (MULQconst [c] x) -(MULQ (MOVQconst [c]) x) -> (MULQconst [c] x) +(MULQ x (MOVQconst [c])) && is32Bit(c) -> (MULQconst [c] x) +(MULQ (MOVQconst [c]) x) && is32Bit(c) -> (MULQconst [c] x) (ANDQ x (MOVQconst [c])) -> (ANDQconst [c] x) (ANDQ (MOVQconst [c]) x) -> (ANDQconst [c] x) (SHLQ x (MOVQconst [c])) -> (SHLQconst [c] x) diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go index 90ac7d7a68..a02f1d50b2 100644 --- a/src/cmd/compile/internal/ssa/rewrite.go +++ b/src/cmd/compile/internal/ssa/rewrite.go @@ -130,7 +130,12 @@ func log2(n int64) (l int64) { return l } -// isPowerOfTwo returns true if n is a power of 2. +// 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)) +} diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index f8642a7bb5..5019e69529 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -6,14 +6,17 @@ func rewriteValueAMD64(v *Value, config *Config) bool { switch v.Op { case OpAMD64ADDQ: // match: (ADDQ x (MOVQconst [c])) - // cond: + // cond: is32Bit(c) // result: (ADDQconst [c] x) { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVQconst { - goto endacffd55e74ee0ff59ad58a18ddfc9973 + goto end1de8aeb1d043e0dadcffd169a99ce5c0 } c := v.Args[1].AuxInt + if !(is32Bit(c)) { + goto end1de8aeb1d043e0dadcffd169a99ce5c0 + } v.Op = OpAMD64ADDQconst v.AuxInt = 0 v.Aux = nil @@ -22,18 +25,21 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(x) return true } - goto endacffd55e74ee0ff59ad58a18ddfc9973 - endacffd55e74ee0ff59ad58a18ddfc9973: + goto end1de8aeb1d043e0dadcffd169a99ce5c0 + end1de8aeb1d043e0dadcffd169a99ce5c0: ; // match: (ADDQ (MOVQconst [c]) x) - // cond: + // cond: is32Bit(c) // result: (ADDQconst [c] x) { if v.Args[0].Op != OpAMD64MOVQconst { - goto end7166f476d744ab7a51125959d3d3c7e2 + goto endca635e3bdecd9e3aeb892f841021dfaa } c := v.Args[0].AuxInt x := v.Args[1] + if !(is32Bit(c)) { + goto endca635e3bdecd9e3aeb892f841021dfaa + } v.Op = OpAMD64ADDQconst v.AuxInt = 0 v.Aux = nil @@ -42,8 +48,8 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(x) return true } - goto end7166f476d744ab7a51125959d3d3c7e2 - end7166f476d744ab7a51125959d3d3c7e2: + goto endca635e3bdecd9e3aeb892f841021dfaa + endca635e3bdecd9e3aeb892f841021dfaa: ; // match: (ADDQ x (SHLQconst [3] y)) // cond: @@ -1223,16 +1229,16 @@ func rewriteValueAMD64(v *Value, config *Config) bool { ; case OpAMD64MULQ: // match: (MULQ x (MOVQconst [c])) - // cond: c == int64(int32(c)) + // cond: is32Bit(c) // result: (MULQconst [c] x) { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVQconst { - goto end680a32a37babfff4bfa7d23be592a131 + goto endb38c6e3e0ddfa25ba0ef9684ac1528c0 } c := v.Args[1].AuxInt - if !(c == int64(int32(c))) { - goto end680a32a37babfff4bfa7d23be592a131 + if !(is32Bit(c)) { + goto endb38c6e3e0ddfa25ba0ef9684ac1528c0 } v.Op = OpAMD64MULQconst v.AuxInt = 0 @@ -1242,18 +1248,21 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(x) return true } - goto end680a32a37babfff4bfa7d23be592a131 - end680a32a37babfff4bfa7d23be592a131: + goto endb38c6e3e0ddfa25ba0ef9684ac1528c0 + endb38c6e3e0ddfa25ba0ef9684ac1528c0: ; // match: (MULQ (MOVQconst [c]) x) - // cond: + // cond: is32Bit(c) // result: (MULQconst [c] x) { if v.Args[0].Op != OpAMD64MOVQconst { - goto endc6e18d6968175d6e58eafa6dcf40c1b8 + goto end9cb4f29b0bd7141639416735dcbb3b87 } c := v.Args[0].AuxInt x := v.Args[1] + if !(is32Bit(c)) { + goto end9cb4f29b0bd7141639416735dcbb3b87 + } v.Op = OpAMD64MULQconst v.AuxInt = 0 v.Aux = nil @@ -1262,8 +1271,8 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(x) return true } - goto endc6e18d6968175d6e58eafa6dcf40c1b8 - endc6e18d6968175d6e58eafa6dcf40c1b8: + goto end9cb4f29b0bd7141639416735dcbb3b87 + end9cb4f29b0bd7141639416735dcbb3b87: ; case OpAMD64MULQconst: // match: (MULQconst [-1] x) -- cgit v1.3 From 0bb2a50a55b15b7a9ea63cfa55a29e13ef29b542 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Fri, 24 Jul 2015 14:51:51 -0700 Subject: [dev.ssa] cmd/compile: respect stack slot width when storing/loading registers Prior to this, we were smashing our own stack, which caused the crypto/sha256 tests to fail. Change-Id: I7dd94cf466d175b3be0cd65f9c4fe8b1223081fe Reviewed-on: https://go-review.googlesource.com/12660 Reviewed-by: Daniel Morsing Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 25 +++++++++++++++++++++---- src/cmd/compile/internal/ssa/gen/genericOps.go | 6 ++---- src/cmd/compile/internal/ssa/opGen.go | 8 ++++---- src/cmd/compile/internal/ssa/regalloc.go | 8 ++++---- 4 files changed, 31 insertions(+), 16 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index e9f99b1799..7a3396482f 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1639,23 +1639,23 @@ func genValue(v *ssa.Value) { p.To.Type = obj.TYPE_REG p.To.Reg = y } - case ssa.OpLoadReg8: + case ssa.OpLoadReg: if v.Type.IsFlags() { v.Unimplementedf("load flags not implemented: %v", v.LongString()) return } - p := Prog(x86.AMOVQ) + p := Prog(movSize(v.Type.Size())) p.From.Type = obj.TYPE_MEM p.From.Reg = x86.REG_SP p.From.Offset = localOffset(v.Args[0]) p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v) - case ssa.OpStoreReg8: + case ssa.OpStoreReg: if v.Type.IsFlags() { v.Unimplementedf("store flags not implemented: %v", v.LongString()) return } - p := Prog(x86.AMOVQ) + p := Prog(movSize(v.Type.Size())) p.From.Type = obj.TYPE_REG p.From.Reg = regnum(v.Args[0]) p.To.Type = obj.TYPE_MEM @@ -1711,6 +1711,23 @@ func genValue(v *ssa.Value) { } } +// movSize returns the MOV instruction of the given width. +func movSize(width int64) (asm int) { + switch width { + case 1: + asm = x86.AMOVB + case 2: + asm = x86.AMOVW + case 4: + asm = x86.AMOVL + case 8: + asm = x86.AMOVQ + default: + panic(fmt.Errorf("bad movSize %d", width)) + } + return asm +} + // 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) diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 4014fd5009..1b5f098ec4 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -178,10 +178,8 @@ var genericOps = []opData{ // 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. - // TODO: remove these, make them arch-specific ops stored - // in the fields of Config instead. - {name: "StoreReg8"}, - {name: "LoadReg8"}, + {name: "StoreReg"}, + {name: "LoadReg"}, // Used during ssa construction. Like Copy, but the arg has not been specified yet. {name: "FwdRef"}, diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 8c1ef0b9d9..5302c90442 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -243,8 +243,8 @@ const ( OpStringMake OpStringPtr OpStringLen - OpStoreReg8 - OpLoadReg8 + OpStoreReg + OpLoadReg OpFwdRef ) @@ -1590,11 +1590,11 @@ var opcodeTable = [...]opInfo{ generic: true, }, { - name: "StoreReg8", + name: "StoreReg", generic: true, }, { - name: "LoadReg8", + name: "LoadReg", generic: true, }, { diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index f46fe25be4..101eedd93f 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -240,7 +240,7 @@ func regalloc(f *Func) { c := regs[r].c if regs[r].dirty && lastUse[x.ID] > idx { // Write x back to home. Its value is currently held in c. - x.Op = OpStoreReg8 + x.Op = OpStoreReg x.Aux = nil x.resetArgs() x.AddArg(c) @@ -276,7 +276,7 @@ func regalloc(f *Func) { c = b.NewValue1(w.Line, OpCopy, w.Type, regs[s].c) } else { // Load from home location - c = b.NewValue1(w.Line, OpLoadReg8, w.Type, w) + c = b.NewValue1(w.Line, OpLoadReg, w.Type, w) } home = setloc(home, c, ®isters[r]) // Remember what we did @@ -319,7 +319,7 @@ func regalloc(f *Func) { c := regs[r].c if regs[r].dirty && lastUse[x.ID] > idx { // Write x back to home. Its value is currently held in c. - x.Op = OpStoreReg8 + x.Op = OpStoreReg x.Aux = nil x.resetArgs() x.AddArg(c) @@ -373,7 +373,7 @@ func regalloc(f *Func) { } // change v to be a copy of c - v.Op = OpStoreReg8 + v.Op = OpStoreReg v.Aux = nil v.resetArgs() v.AddArg(c) -- cgit v1.3 From b61f8c8df3247945ef723a22df0327264adfa3f9 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Fri, 24 Jul 2015 20:09:39 -0700 Subject: [dev.ssa] cmd/compile: fix registers for in-place instructions Some of these were right; others weren't. Fixes 'GOGC=off GOSSAPKG=mime go test -a mime'. The right long term fix is probably to teach the register allocator about in-place instructions. In the meantime, all the tests that we can run now pass. Change-Id: I8e37b00a5f5e14f241b427d45d5f5cc1064883a2 Reviewed-on: https://go-review.googlesource.com/12664 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 8 +------- src/cmd/compile/internal/ssa/TODO | 2 ++ 2 files changed, 3 insertions(+), 7 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 7a3396482f..32d42d8264 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1492,7 +1492,7 @@ func genValue(v *ssa.Value) { p.From.Reg = regnum(v.Args[1]) // should be CX p.To.Type = obj.TYPE_REG p.To.Reg = r - case ssa.OpAMD64SHLQconst, ssa.OpAMD64SHRQconst, ssa.OpAMD64SARQconst: + case ssa.OpAMD64SHLQconst, ssa.OpAMD64SHRQconst, ssa.OpAMD64SARQconst, ssa.OpAMD64XORQconst: x := regnum(v.Args[0]) r := regnum(v) if x != r { @@ -1686,12 +1686,6 @@ func genValue(v *ssa.Value) { p := Prog(obj.ACALL) p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v.Args[0]) - case ssa.OpAMD64XORQconst: - p := Prog(x86.AXORQ) - p.From.Type = obj.TYPE_CONST - p.From.Offset = v.AuxInt - p.To.Type = obj.TYPE_REG - p.To.Reg = regnum(v.Args[0]) case ssa.OpAMD64NEGQ, ssa.OpAMD64NEGL, ssa.OpAMD64NEGW, ssa.OpAMD64NEGB: p := Prog(v.Op.Asm()) p.To.Type = obj.TYPE_REG diff --git a/src/cmd/compile/internal/ssa/TODO b/src/cmd/compile/internal/ssa/TODO index 225768c73c..f77c5ad8f3 100644 --- a/src/cmd/compile/internal/ssa/TODO +++ b/src/cmd/compile/internal/ssa/TODO @@ -28,6 +28,8 @@ Regalloc - Floating point registers - Make calls clobber all registers - Make liveness analysis non-quadratic. + - Handle in-place instructions (like XORQconst) directly: + Use XORQ AX, 1 rather than MOVQ AX, BX; XORQ BX, 1. StackAlloc: - Sort variables so all ptr-containing ones are first (so stack -- cgit v1.3 From c9a38ce758e3de93e73842bf42a6e84f182d183a Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Sun, 26 Jul 2015 09:48:20 -0500 Subject: [dev.ssa] cmd/compile: don't flush a value derived from the current value If flushing a value from a register that might be used by the current old-schedule value, save it to the home location. This resolves the error that was changed from panic to unimplemented in CL 12655. Change-Id: If864be34abcd6e11d6117a061376e048a3e29b3a Reviewed-on: https://go-review.googlesource.com/12682 Reviewed-by: Keith Randall Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/gc/testdata/arith_ssa.go | 20 ++++++++++++++++++++ src/cmd/compile/internal/ssa/regalloc.go | 4 ++-- 2 files changed, 22 insertions(+), 2 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/testdata/arith_ssa.go b/src/cmd/compile/internal/gc/testdata/arith_ssa.go index a4fdf16f7d..22fc034a1c 100644 --- a/src/cmd/compile/internal/gc/testdata/arith_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/arith_ssa.go @@ -8,6 +8,8 @@ package main +// test64BitConstMulti tests that rewrite rules don't fold 64 bit constants +// into multiply instructions. func test64BitConstMult(a, b int64) { want := 34359738369*a + b*34359738370 if got := test64BitConstMult_ssa(a, b); want != got { @@ -21,6 +23,8 @@ 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(a, b int64) { want := a + 575815584948629622 + b + 2991856197886747025 if got := test64BitConstAdd_ssa(a, b); want != got { @@ -34,12 +38,28 @@ 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(a, b, c, d int8) { + want := a + -32 + b + 63*c*-87*d + if got := testRegallocCVSpill_ssa(a, b, c, d); want != got { + println("testRegallocCVSpill failed, wanted", want, "got", got) + failed = true + } +} +func testRegallocCVSpill_ssa(a, b, c, d int8) int8 { + switch { + } + return a + -32 + b + 63*c*-87*d +} + var failed = false func main() { test64BitConstMult(1, 2) test64BitConstAdd(1, 2) + testRegallocCVSpill(1, 2, 3, 4) if failed { panic("failed") diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index 101eedd93f..a13b8b2a06 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -238,7 +238,7 @@ func regalloc(f *Func) { if regs[r].v != nil { x := regs[r].v c := regs[r].c - if regs[r].dirty && lastUse[x.ID] > idx { + if regs[r].dirty && lastUse[x.ID] >= idx { // Write x back to home. Its value is currently held in c. x.Op = OpStoreReg x.Aux = nil @@ -317,7 +317,7 @@ func regalloc(f *Func) { if regs[r].v != nil { x := regs[r].v c := regs[r].c - if regs[r].dirty && lastUse[x.ID] > idx { + if regs[r].dirty && lastUse[x.ID] >= idx { // Write x back to home. Its value is currently held in c. x.Op = OpStoreReg x.Aux = nil -- cgit v1.3 From 15dcdfba0fd1c0949c094b4c07c7d10be565ccf3 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Tue, 21 Jul 2015 07:37:47 -0700 Subject: [dev.ssa] cmd/compile: implement OCALLMETH This mimics the way the old backend compiles OCALLMETH. Change-Id: I635c8e7a48c8b5619bd837f78fa6eeba83a57b2f Reviewed-on: https://go-review.googlesource.com/12549 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 31 ++++++++++++++++++++++++------- 1 file changed, 24 insertions(+), 7 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 32d42d8264..4de0518e6c 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -940,13 +940,30 @@ func (s *state) expr(n *Node) *ssa.Value { return s.constInt(s.config.Int, n.Left.Type.Bound) } - case OCALLFUNC: - static := n.Left.Op == ONAME && n.Left.Class == PFUNC + case OCALLFUNC, OCALLMETH: + left := n.Left + static := left.Op == ONAME && left.Class == PFUNC + + if n.Op == OCALLMETH { + // Rewrite to an OCALLFUNC: (p.f)(...) becomes (f)(p, ...) + // Take care not to modify the original AST. + if left.Op != ODOTMETH { + Fatal("OCALLMETH: n.Left not an ODOTMETH: %v", left) + } + + newLeft := *left.Right + newLeft.Type = left.Type + if newLeft.Op == ONAME { + newLeft.Class = PFUNC + } + left = &newLeft + static = true + } // evaluate closure var closure *ssa.Value if !static { - closure = s.expr(n.Left) + closure = s.expr(left) } // run all argument assignments @@ -955,13 +972,13 @@ func (s *state) expr(n *Node) *ssa.Value { bNext := s.f.NewBlock(ssa.BlockPlain) var call *ssa.Value if static { - call = s.newValue1A(ssa.OpStaticCall, ssa.TypeMem, n.Left.Sym, s.mem()) + call = s.newValue1A(ssa.OpStaticCall, ssa.TypeMem, left.Sym, s.mem()) } else { entry := s.newValue2(ssa.OpLoad, s.config.Uintptr, closure, s.mem()) call = s.newValue3(ssa.OpClosureCall, ssa.TypeMem, entry, closure, s.mem()) } - dowidth(n.Left.Type) - call.AuxInt = n.Left.Type.Argwid // call operations carry the argsize of the callee along with them + dowidth(left.Type) + call.AuxInt = left.Type.Argwid // call operations carry the argsize of the callee along with them b := s.endBlock() b.Kind = ssa.BlockCall b.Control = call @@ -971,7 +988,7 @@ func (s *state) expr(n *Node) *ssa.Value { // read result from stack at the start of the fallthrough block s.startBlock(bNext) var titer Iter - fp := Structfirst(&titer, Getoutarg(n.Left.Type)) + fp := Structfirst(&titer, Getoutarg(left.Type)) if fp == nil { // CALLFUNC has no return value. Continue with the next statement. return nil -- cgit v1.3 From 1807d54d8594c52cdf79c8a9ad60607d2796fec6 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Mon, 27 Jul 2015 12:45:56 -0700 Subject: [dev.ssa] cmd/compile: detect unbalanced rules Rules may span multiple lines, but if we're still unbalanced at the end of the file, something is wrong. I write unbalanced rules depressingly often. Change-Id: Ibd04aa06539e2a0ffef73bb665febf3542fd11f1 Reviewed-on: https://go-review.googlesource.com/12710 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/gen/rulegen.go | 3 +++ 1 file changed, 3 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/gen/rulegen.go b/src/cmd/compile/internal/ssa/gen/rulegen.go index 46e0e507c4..8dca0bca1f 100644 --- a/src/cmd/compile/internal/ssa/gen/rulegen.go +++ b/src/cmd/compile/internal/ssa/gen/rulegen.go @@ -88,6 +88,9 @@ func genRules(arch arch) { } rule = "" } + if unbalanced(rule) { + log.Fatalf("unbalanced rule: %v\n", rule) + } if err := scanner.Err(); err != nil { log.Fatalf("scanner failed: %v\n", err) } -- cgit v1.3 From c15b0e83d2e5d00d9b19a5ba191aff26831458d8 Mon Sep 17 00:00:00 2001 From: Alexandru Moșoi Date: Tue, 21 Jul 2015 18:06:15 +0200 Subject: [dev.ssa] cmd/compile/internal/ssa/gen: implement all bit sizes for Eq and Neq Change-Id: I2c5c75153493b5dd3f1a743e5edf04403e83b31b Reviewed-on: https://go-review.googlesource.com/12474 Reviewed-by: Keith Randall Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/gc/ssa.go | 2 +- src/cmd/compile/internal/ssa/gen/AMD64.rules | 8 ++ src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 8 +- src/cmd/compile/internal/ssa/opGen.go | 42 +++++++++ src/cmd/compile/internal/ssa/rewriteAMD64.go | 126 +++++++++++++++++++++++++++ 5 files changed, 183 insertions(+), 3 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 4de0518e6c..91ec5a9a8b 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1579,7 +1579,7 @@ func genValue(v *ssa.Value) { addAux(&p.From, v) p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v) - case ssa.OpAMD64CMPQ, ssa.OpAMD64TESTB, ssa.OpAMD64TESTQ: + case ssa.OpAMD64CMPQ, ssa.OpAMD64CMPL, ssa.OpAMD64CMPW, ssa.OpAMD64CMPB, ssa.OpAMD64TESTB, ssa.OpAMD64TESTQ: p := Prog(v.Op.Asm()) p.From.Type = obj.TYPE_REG p.From.Reg = regnum(v.Args[0]) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 7f5fd663e3..49140c87f4 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -86,8 +86,16 @@ (Leq64 x y) -> (SETLE (CMPQ x y)) (Greater64 x y) -> (SETG (CMPQ x y)) (Geq64 x y) -> (SETGE (CMPQ 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)) + (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)) (Load ptr mem) && (is64BitInt(t) || isPtr(t)) -> (MOVQload ptr mem) (Load ptr mem) && is32BitInt(t) -> (MOVLload ptr mem) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 382d64c9de..f67a1e0273 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -111,8 +111,12 @@ func init() { {name: "CMPQ", reg: gp2flags, asm: "CMPQ"}, // arg0 compare to arg1 {name: "CMPQconst", reg: gp1flags, asm: "CMPQ"}, // arg0 compare to auxint - {name: "TESTQ", reg: gp2flags, asm: "TESTQ"}, // (arg0 & arg1) compare to 0 - {name: "TESTB", reg: gp2flags, asm: "TESTB"}, // (arg0 & arg1) compare to 0 + {name: "CMPL", reg: gp2flags, asm: "CMPL"}, // arg0 compare to arg1 + {name: "CMPW", reg: gp2flags, asm: "CMPW"}, // arg0 compare to arg1 + {name: "CMPB", reg: gp2flags, asm: "CMPB"}, // arg0 compare to arg1 + + {name: "TESTQ", reg: gp2flags, asm: "TESTQ"}, // (arg0 & arg1) compare to 0 + {name: "TESTB", reg: gp2flags, asm: "TESTB"}, // (arg0 & arg1) compare to 0 {name: "SBBQcarrymask", reg: flagsgp1, asm: "SBBQ"}, // (int64)(-1) if carry is set, 0 if carry is clear. diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 5302c90442..9f2ad400fa 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -64,6 +64,9 @@ const ( OpAMD64XORQconst OpAMD64CMPQ OpAMD64CMPQconst + OpAMD64CMPL + OpAMD64CMPW + OpAMD64CMPB OpAMD64TESTQ OpAMD64TESTB OpAMD64SBBQcarrymask @@ -413,6 +416,45 @@ var opcodeTable = [...]opInfo{ }, }, }, + { + name: "CMPL", + asm: x86.ACMPL, + reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + outputs: []regMask{ + 8589934592, // .FLAGS + }, + }, + }, + { + name: "CMPW", + asm: x86.ACMPW, + reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + outputs: []regMask{ + 8589934592, // .FLAGS + }, + }, + }, + { + name: "CMPB", + asm: x86.ACMPB, + reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + outputs: []regMask{ + 8589934592, // .FLAGS + }, + }, + }, { name: "TESTQ", asm: x86.ATESTQ, diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 5019e69529..d977f5b9f4 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -615,6 +615,48 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endcc7894224d4f6b0bcabcece5d0185912 endcc7894224d4f6b0bcabcece5d0185912: ; + case OpEq16: + // match: (Eq16 x y) + // cond: + // result: (SETEQ (CMPW x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETEQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto end66a03470b5b3e8457ba205ccfcaccea6 + end66a03470b5b3e8457ba205ccfcaccea6: + ; + case OpEq32: + // match: (Eq32 x y) + // cond: + // result: (SETEQ (CMPL x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETEQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto end4d77d0b016f93817fd6e5f60fa0e7ef2 + end4d77d0b016f93817fd6e5f60fa0e7ef2: + ; case OpEq64: // match: (Eq64 x y) // cond: @@ -636,6 +678,27 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endae6c62e4e20b4f62694b6ee40dbd9211 endae6c62e4e20b4f62694b6ee40dbd9211: ; + case OpEq8: + // match: (Eq8 x y) + // cond: + // result: (SETEQ (CMPB x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETEQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto end84a692e769900e3adbfe00718d2169e0 + end84a692e769900e3adbfe00718d2169e0: + ; case OpGeq64: // match: (Geq64 x y) // cond: @@ -1741,6 +1804,48 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto enda1ffb93a68702148c5fd18e2b72964d0 enda1ffb93a68702148c5fd18e2b72964d0: ; + case OpNeq16: + // match: (Neq16 x y) + // cond: + // result: (SETNE (CMPW x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETNE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto endf177c3b3868606824e43e11da7804572 + endf177c3b3868606824e43e11da7804572: + ; + case OpNeq32: + // match: (Neq32 x y) + // cond: + // result: (SETNE (CMPL x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETNE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto end39c4bf6d063f8a0b6f0064c96ce25173 + end39c4bf6d063f8a0b6f0064c96ce25173: + ; case OpNeq64: // match: (Neq64 x y) // cond: @@ -1762,6 +1867,27 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end8ab0bcb910c0d3213dd8726fbcc4848e end8ab0bcb910c0d3213dd8726fbcc4848e: ; + case OpNeq8: + // match: (Neq8 x y) + // cond: + // result: (SETNE (CMPB x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETNE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto end4aaff28af59a65b3684f4f1897299932 + end4aaff28af59a65b3684f4f1897299932: + ; case OpNot: // match: (Not x) // cond: -- cgit v1.3 From edff881ce5ca9c2ee209bcd7a2cd92b63ffe4179 Mon Sep 17 00:00:00 2001 From: Alexandru Moșoi Date: Tue, 28 Jul 2015 14:58:49 +0200 Subject: [dev.ssa] cmd/compile/internal/ssa/gen: implement OAND. Before this patch there was only partial support for ANDQconst which was not lowered. This patch added support for AND operations for all bit sizes and signs. Change-Id: I3a6b2cddfac5361b27e85fcd97f7f3537ebfbcb6 Reviewed-on: https://go-review.googlesource.com/12761 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 17 ++- src/cmd/compile/internal/ssa/gen/AMD64.rules | 9 ++ src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 8 +- src/cmd/compile/internal/ssa/gen/genericOps.go | 9 ++ src/cmd/compile/internal/ssa/opGen.go | 136 +++++++++++++++++----- src/cmd/compile/internal/ssa/rewriteAMD64.go | 153 +++++++++++++++++++++++++ 6 files changed, 300 insertions(+), 32 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 91ec5a9a8b..970799cf56 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -699,6 +699,15 @@ var opToSSA = map[opAndType]ssa.Op{ opAndType{OMUL, TINT64}: ssa.OpMul64, opAndType{OMUL, TUINT64}: ssa.OpMul64U, + opAndType{OAND, TINT8}: ssa.OpAnd8, + opAndType{OAND, TUINT8}: ssa.OpAnd8U, + opAndType{OAND, TINT16}: ssa.OpAnd16, + opAndType{OAND, TUINT16}: ssa.OpAnd16U, + opAndType{OAND, TINT32}: ssa.OpAnd32, + opAndType{OAND, TUINT32}: ssa.OpAnd32U, + opAndType{OAND, TINT64}: ssa.OpAnd64, + opAndType{OAND, TUINT64}: ssa.OpAnd64U, + opAndType{OLSH, TINT8}: ssa.OpLsh8, opAndType{OLSH, TUINT8}: ssa.OpLsh8, opAndType{OLSH, TINT16}: ssa.OpLsh16, @@ -838,7 +847,7 @@ func (s *state) expr(n *Node) *ssa.Value { a := s.expr(n.Left) b := s.expr(n.Right) return s.newValue2(s.ssaOp(n.Op, n.Left.Type), ssa.TypeBool, a, b) - case OADD, OSUB, OMUL, OLSH, ORSH: + case OADD, OSUB, OMUL, OLSH, ORSH, OAND: a := s.expr(n.Left) b := s.expr(n.Right) return s.newValue2(s.ssaOp(n.Op, n.Type), a.Type, a, b) @@ -1425,7 +1434,9 @@ func genValue(v *ssa.Value) { p.From.Index = regnum(v.Args[1]) p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v) - case ssa.OpAMD64ADDB, ssa.OpAMD64ANDQ, ssa.OpAMD64MULQ, ssa.OpAMD64MULL, ssa.OpAMD64MULW: + case ssa.OpAMD64ADDB, + ssa.OpAMD64ANDQ, ssa.OpAMD64ANDL, ssa.OpAMD64ANDW, ssa.OpAMD64ANDB, + ssa.OpAMD64MULQ, ssa.OpAMD64MULL, ssa.OpAMD64MULW: r := regnum(v) x := regnum(v.Args[0]) y := regnum(v.Args[1]) @@ -1509,7 +1520,7 @@ func genValue(v *ssa.Value) { p.From.Reg = regnum(v.Args[1]) // should be CX p.To.Type = obj.TYPE_REG p.To.Reg = r - case ssa.OpAMD64SHLQconst, ssa.OpAMD64SHRQconst, ssa.OpAMD64SARQconst, ssa.OpAMD64XORQconst: + case ssa.OpAMD64ANDQconst, ssa.OpAMD64SHLQconst, ssa.OpAMD64SHRQconst, ssa.OpAMD64SARQconst, ssa.OpAMD64XORQconst: x := regnum(v.Args[0]) r := regnum(v) if x != r { diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 49140c87f4..5f4a5b5a69 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -23,6 +23,15 @@ (Add8U x y) -> (ADDB x y) (Add8 x y) -> (MOVBQSX (ADDB x y)) +(And64 x y) -> (ANDQ x y) +(And64U x y) -> (ANDQ x y) +(And32U x y) -> (ANDL x y) +(And32 x y) -> (MOVLQSX (ANDL x y)) +(And16U x y) -> (ANDW x y) +(And16 x y) -> (MOVWQSX (ANDW x y)) +(And8U x y) -> (ANDB x y) +(And8 x y) -> (MOVBQSX (ANDB x y)) + (Sub64 x y) -> (SUBQ x y) (Sub64U x y) -> (SUBQ x y) (Sub32U x y) -> (SUBL x y) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index f67a1e0273..1a0a8e28e5 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -98,8 +98,6 @@ func init() { var AMD64ops = []opData{ {name: "MULQ", reg: gp21, asm: "IMULQ"}, // arg0 * arg1 {name: "MULQconst", reg: gp11, asm: "IMULQ"}, // arg0 * auxint - {name: "ANDQ", reg: gp21, asm: "ANDQ"}, // arg0 & arg1 - {name: "ANDQconst", reg: gp11, asm: "ANDQ"}, // arg0 & auxint {name: "SHLQ", reg: gp21shift, asm: "SHLQ"}, // arg0 << arg1, shift amount is mod 64 {name: "SHLQconst", reg: gp11, asm: "SHLQ"}, // arg0 << auxint, shift amount 0-63 {name: "SHRQ", reg: gp21shift, asm: "SHRQ"}, // unsigned arg0 >> arg1, shift amount is mod 64 @@ -195,6 +193,12 @@ func init() { {name: "MULL", reg: gp21, asm: "IMULL"}, // arg0*arg1 {name: "MULW", reg: gp21, asm: "IMULW"}, // arg0*arg1 + {name: "ANDQ", reg: gp21, asm: "ANDQ"}, // arg0 & arg1 + {name: "ANDQconst", reg: gp11, asm: "ANDQ"}, // arg0 & auxint + {name: "ANDL", reg: gp21, asm: "ANDL"}, // arg0 & arg1 + {name: "ANDW", reg: gp21, asm: "ANDW"}, // arg0 & arg1 + {name: "ANDB", reg: gp21, asm: "ANDB"}, // arg0 & arg1 + // (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. diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 1b5f098ec4..0dc3ac42ba 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -39,6 +39,15 @@ var genericOps = []opData{ {name: "Mul64U"}, {name: "MulPtr"}, // MulPtr is used for address calculations + {name: "And8"}, // arg0 & arg1 + {name: "And16"}, + {name: "And32"}, + {name: "And64"}, + {name: "And8U"}, + {name: "And16U"}, + {name: "And32U"}, + {name: "And64U"}, + {name: "Lsh8"}, // arg0 << arg1 {name: "Lsh16"}, {name: "Lsh32"}, diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 9f2ad400fa..d916ad0da2 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -53,8 +53,6 @@ const ( OpAMD64MULQ OpAMD64MULQconst - OpAMD64ANDQ - OpAMD64ANDQconst OpAMD64SHLQ OpAMD64SHLQconst OpAMD64SHRQ @@ -128,6 +126,11 @@ const ( OpAMD64NEGB OpAMD64MULL OpAMD64MULW + OpAMD64ANDQ + OpAMD64ANDQconst + OpAMD64ANDL + OpAMD64ANDW + OpAMD64ANDB OpAMD64InvertFlags OpAdd8 @@ -156,6 +159,14 @@ const ( OpMul32U OpMul64U OpMulPtr + OpAnd8 + OpAnd16 + OpAnd32 + OpAnd64 + OpAnd8U + OpAnd16U + OpAnd32U + OpAnd64U OpLsh8 OpLsh16 OpLsh32 @@ -279,31 +290,6 @@ var opcodeTable = [...]opInfo{ }, }, }, - { - name: "ANDQ", - asm: x86.AANDQ, - reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 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: "ANDQconst", - asm: x86.AANDQ, - reg: regInfo{ - inputs: []regMask{ - 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: "SHLQ", asm: x86.ASHLQ, @@ -1162,6 +1148,70 @@ var opcodeTable = [...]opInfo{ }, }, }, + { + name: "ANDQ", + asm: x86.AANDQ, + reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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: "ANDQconst", + asm: x86.AANDQ, + reg: regInfo{ + inputs: []regMask{ + 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: "ANDL", + asm: x86.AANDL, + reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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: "ANDW", + asm: x86.AANDW, + reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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: "ANDB", + asm: x86.AANDB, + reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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: "InvertFlags", reg: regInfo{}, @@ -1271,6 +1321,38 @@ var opcodeTable = [...]opInfo{ name: "MulPtr", generic: true, }, + { + name: "And8", + generic: true, + }, + { + name: "And16", + generic: true, + }, + { + name: "And32", + generic: true, + }, + { + name: "And64", + generic: true, + }, + { + name: "And8U", + generic: true, + }, + { + name: "And16U", + generic: true, + }, + { + name: "And32U", + generic: true, + }, + { + name: "And64U", + generic: true, + }, { name: "Lsh8", generic: true, diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index d977f5b9f4..1c1638bf18 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -382,6 +382,159 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end53cad0c3c9daa5575680e77c14e05e72 end53cad0c3c9daa5575680e77c14e05e72: ; + case OpAnd16: + // match: (And16 x y) + // cond: + // result: (MOVWQSX (ANDW x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64MOVWQSX + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64ANDW, TypeInvalid) + v0.Type = v.Type + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto end566a8c12ea6f1c18d200aaf3a911e2e5 + end566a8c12ea6f1c18d200aaf3a911e2e5: + ; + case OpAnd16U: + // match: (And16U x y) + // cond: + // result: (ANDW x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end248cfb532a3bb6b244ed5e9124b35c13 + end248cfb532a3bb6b244ed5e9124b35c13: + ; + case OpAnd32: + // match: (And32 x y) + // cond: + // result: (MOVLQSX (ANDL x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64MOVLQSX + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64ANDL, TypeInvalid) + v0.Type = v.Type + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto ende53f2add9b41c8a17440e9c72372c8c4 + ende53f2add9b41c8a17440e9c72372c8c4: + ; + case OpAnd32U: + // match: (And32U x y) + // cond: + // result: (ANDL x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto endaceb9ea4ffc888774cfa38ed13d860d6 + endaceb9ea4ffc888774cfa38ed13d860d6: + ; + case OpAnd64: + // match: (And64 x y) + // cond: + // result: (ANDQ x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto enda0bde5853819d05fa2b7d3b723629552 + enda0bde5853819d05fa2b7d3b723629552: + ; + case OpAnd64U: + // match: (And64U x y) + // cond: + // result: (ANDQ x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end7d0ff84f3ba7cf7880e73176b38d0a4b + end7d0ff84f3ba7cf7880e73176b38d0a4b: + ; + case OpAnd8: + // match: (And8 x y) + // cond: + // result: (MOVBQSX (ANDB x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64MOVBQSX + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64ANDB, TypeInvalid) + v0.Type = v.Type + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto endb570a5dfeea1414989cb9c8ab0b9c329 + endb570a5dfeea1414989cb9c8ab0b9c329: + ; + case OpAnd8U: + // match: (And8U x y) + // cond: + // result: (ANDB x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end6a9db8b74df974171e72ce228b3e2c98 + end6a9db8b74df974171e72ce228b3e2c98: + ; case OpAMD64CMOVQCC: // match: (CMOVQCC (CMPQconst [c] (MOVQconst [d])) _ x) // cond: inBounds(d, c) -- cgit v1.3 From 9ca24fcda88398cc39e9b6e43bc1de51610a3b01 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Mon, 27 Jul 2015 13:17:45 -0700 Subject: [dev.ssa] cmd/compile: implement non-numeric comparisons The only slice/interface comparisons that reach the backend are comparisons to nil. Funcs, maps, and channels are references types, so pointer equality is enough. Change-Id: I60a71da46a36202e9bd62ed370ab7d7f2e2800e7 Reviewed-on: https://go-review.googlesource.com/12715 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 52 ++++++++----- src/cmd/compile/internal/ssa/gen/AMD64.rules | 2 + src/cmd/compile/internal/ssa/gen/generic.rules | 9 +++ src/cmd/compile/internal/ssa/gen/genericOps.go | 4 + src/cmd/compile/internal/ssa/opGen.go | 20 +++++ src/cmd/compile/internal/ssa/rewriteAMD64.go | 42 ++++++++++ src/cmd/compile/internal/ssa/rewritegeneric.go | 104 +++++++++++++++++++++++++ 7 files changed, 214 insertions(+), 19 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 970799cf56..0a45be0078 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -726,25 +726,39 @@ var opToSSA = map[opAndType]ssa.Op{ opAndType{ORSH, TINT64}: ssa.OpRsh64, opAndType{ORSH, TUINT64}: ssa.OpRsh64U, - 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, TPTR64}: ssa.OpEq64, - - 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, TPTR64}: ssa.OpNeq64, + 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, TPTR64}: ssa.OpEq64, + opAndType{OEQ, TINTER}: ssa.OpEqFat, // e == nil only + opAndType{OEQ, TARRAY}: ssa.OpEqFat, // slice only; a == nil only + opAndType{OEQ, TFUNC}: ssa.OpEqPtr, + opAndType{OEQ, TMAP}: ssa.OpEqPtr, + opAndType{OEQ, TCHAN}: ssa.OpEqPtr, + opAndType{OEQ, TUINTPTR}: ssa.OpEqPtr, + + 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, TPTR64}: ssa.OpNeq64, + opAndType{ONE, TINTER}: ssa.OpNeqFat, // e != nil only + opAndType{ONE, TARRAY}: ssa.OpNeqFat, // slice only; a != nil only + opAndType{ONE, TFUNC}: ssa.OpNeqPtr, + opAndType{ONE, TMAP}: ssa.OpNeqPtr, + opAndType{ONE, TCHAN}: ssa.OpNeqPtr, + opAndType{ONE, TUINTPTR}: ssa.OpNeqPtr, opAndType{OLT, TINT8}: ssa.OpLess8, opAndType{OLT, TUINT8}: ssa.OpLess8U, diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 5f4a5b5a69..ea3974935f 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -100,11 +100,13 @@ (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)) (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)) (Load ptr mem) && (is64BitInt(t) || isPtr(t)) -> (MOVQload ptr mem) (Load ptr mem) && is32BitInt(t) -> (MOVLload ptr mem) diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index fc5ffb9610..dd48706e63 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -34,6 +34,15 @@ (SliceLen (Load ptr mem)) -> (Load (AddPtr ptr (Const [config.PtrSize])) mem) (SliceCap (Load ptr mem)) -> (Load (AddPtr ptr (Const [config.PtrSize*2])) mem) +// slice and interface comparisons +// the frontend ensures that we can only compare against nil +// start by putting nil on the right to simplify the other rules +(EqFat x y) && x.Op == OpConst && y.Op != OpConst -> (EqFat y x) +(NeqFat x y) && x.Op == OpConst && y.Op != OpConst -> (NeqFat y x) +// it suffices to check the first word (backing array for slices, dynamic type for interfaces) +(EqFat (Load ptr mem) y) && y.Op == OpConst -> (EqPtr (Load ptr mem) (Const [0])) +(NeqFat (Load ptr mem) y) && y.Op == OpConst -> (NeqPtr (Load ptr mem) (Const [0])) + // indexing operations // Note: bounds check has already been done (ArrayIndex (Load ptr mem) idx) -> (Load (PtrIndex ptr idx) mem) diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 0dc3ac42ba..c67643d94e 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -67,11 +67,15 @@ var genericOps = []opData{ {name: "Eq16"}, {name: "Eq32"}, {name: "Eq64"}, + {name: "EqPtr"}, + {name: "EqFat"}, // slice/interface; arg0 or arg1 is nil; other cases handled by frontend {name: "Neq8"}, // arg0 != arg1 {name: "Neq16"}, {name: "Neq32"}, {name: "Neq64"}, + {name: "NeqPtr"}, + {name: "NeqFat"}, // slice/interface; arg0 or arg1 is nil; other cases handled by frontend {name: "Less8"}, // arg0 < arg1 {name: "Less8U"}, diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index d916ad0da2..d83f87305d 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -183,10 +183,14 @@ const ( OpEq16 OpEq32 OpEq64 + OpEqPtr + OpEqFat OpNeq8 OpNeq16 OpNeq32 OpNeq64 + OpNeqPtr + OpNeqFat OpLess8 OpLess8U OpLess16 @@ -1417,6 +1421,14 @@ var opcodeTable = [...]opInfo{ name: "Eq64", generic: true, }, + { + name: "EqPtr", + generic: true, + }, + { + name: "EqFat", + generic: true, + }, { name: "Neq8", generic: true, @@ -1433,6 +1445,14 @@ var opcodeTable = [...]opInfo{ name: "Neq64", generic: true, }, + { + name: "NeqPtr", + generic: true, + }, + { + name: "NeqFat", + generic: true, + }, { name: "Less8", generic: true, diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 1c1638bf18..41bb6213f1 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -852,6 +852,27 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end84a692e769900e3adbfe00718d2169e0 end84a692e769900e3adbfe00718d2169e0: ; + case OpEqPtr: + // match: (EqPtr x y) + // cond: + // result: (SETEQ (CMPQ x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETEQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto end6de1d39c9d151e5e503d643bd835356e + end6de1d39c9d151e5e503d643bd835356e: + ; case OpGeq64: // match: (Geq64 x y) // cond: @@ -2041,6 +2062,27 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end4aaff28af59a65b3684f4f1897299932 end4aaff28af59a65b3684f4f1897299932: ; + case OpNeqPtr: + // match: (NeqPtr x y) + // cond: + // result: (SETNE (CMPQ x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETNE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto end6e180ffd9583cd55361ed3e465158a4c + end6e180ffd9583cd55361ed3e465158a4c: + ; case OpNot: // match: (Not x) // cond: diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index 54358129e0..976fbc94a0 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -129,6 +129,58 @@ func rewriteValuegeneric(v *Value, config *Config) bool { goto enda6f250a3c775ae5a239ece8074b46cea enda6f250a3c775ae5a239ece8074b46cea: ; + case OpEqFat: + // match: (EqFat x y) + // cond: x.Op == OpConst && y.Op != OpConst + // result: (EqFat y x) + { + x := v.Args[0] + y := v.Args[1] + if !(x.Op == OpConst && y.Op != OpConst) { + goto end4540bddcf0fc8e4b71fac6e9edbb8eec + } + v.Op = OpEqFat + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(y) + v.AddArg(x) + return true + } + goto end4540bddcf0fc8e4b71fac6e9edbb8eec + end4540bddcf0fc8e4b71fac6e9edbb8eec: + ; + // match: (EqFat (Load ptr mem) y) + // cond: y.Op == OpConst + // result: (EqPtr (Load ptr mem) (Const [0])) + { + if v.Args[0].Op != OpLoad { + goto end779b0e24e33d8eff668c368b90387caa + } + ptr := v.Args[0].Args[0] + mem := v.Args[0].Args[1] + y := v.Args[1] + if !(y.Op == OpConst) { + goto end779b0e24e33d8eff668c368b90387caa + } + v.Op = OpEqPtr + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpLoad, TypeInvalid) + v0.Type = config.Uintptr + v0.AddArg(ptr) + v0.AddArg(mem) + v.AddArg(v0) + v1 := v.Block.NewValue0(v.Line, OpConst, TypeInvalid) + v1.Type = config.Uintptr + v1.AuxInt = 0 + v.AddArg(v1) + return true + } + goto end779b0e24e33d8eff668c368b90387caa + end779b0e24e33d8eff668c368b90387caa: + ; case OpIsInBounds: // match: (IsInBounds (Const [c]) (Const [d])) // cond: @@ -255,6 +307,58 @@ func rewriteValuegeneric(v *Value, config *Config) bool { goto end10541de7ea2bce703c1e372ac9a271e7 end10541de7ea2bce703c1e372ac9a271e7: ; + case OpNeqFat: + // match: (NeqFat x y) + // cond: x.Op == OpConst && y.Op != OpConst + // result: (NeqFat y x) + { + x := v.Args[0] + y := v.Args[1] + if !(x.Op == OpConst && y.Op != OpConst) { + goto end5d2a9d3aa52fb6866825f35ac65c7cfd + } + v.Op = OpNeqFat + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(y) + v.AddArg(x) + return true + } + goto end5d2a9d3aa52fb6866825f35ac65c7cfd + end5d2a9d3aa52fb6866825f35ac65c7cfd: + ; + // match: (NeqFat (Load ptr mem) y) + // cond: y.Op == OpConst + // result: (NeqPtr (Load ptr mem) (Const [0])) + { + if v.Args[0].Op != OpLoad { + goto endf2f18052c2d999a7ac883c441c3b7ade + } + ptr := v.Args[0].Args[0] + mem := v.Args[0].Args[1] + y := v.Args[1] + if !(y.Op == OpConst) { + goto endf2f18052c2d999a7ac883c441c3b7ade + } + v.Op = OpNeqPtr + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpLoad, TypeInvalid) + v0.Type = config.Uintptr + v0.AddArg(ptr) + v0.AddArg(mem) + v.AddArg(v0) + v1 := v.Block.NewValue0(v.Line, OpConst, TypeInvalid) + v1.Type = config.Uintptr + v1.AuxInt = 0 + v.AddArg(v1) + return true + } + goto endf2f18052c2d999a7ac883c441c3b7ade + endf2f18052c2d999a7ac883c441c3b7ade: + ; case OpPtrIndex: // match: (PtrIndex ptr idx) // cond: -- cgit v1.3 From 2a5e6c47bc2e56296204aa721dec90804bee1501 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Thu, 23 Jul 2015 14:35:02 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: redo how sign extension is handled For integer types less than a machine register, we have to decide what the invariants are for the high bits of the register. We used to set the high bits to the correct extension (sign or zero, as determined by the type) of the low bits. This CL makes the compiler ignore the high bits of the register altogether (they are junk). On this plus side, this means ops that generate subword results don't have to worry about correctly extending them. On the minus side, ops that consume subword arguments have to deal with the input registers not being correctly extended. For x86, this tradeoff is probably worth it. Almost all opcodes have versions that use only the correct subword piece of their inputs. (The one big exception is array indexing.) Not many opcodes can correctly sign extend on output. For other architectures, the tradeoff is probably not so clear, as they don't have many subword-safe opcodes (e.g. 16-bit compare, ignoring the high 16/48 bits). Fortunately we can decide whether we do this per-architecture. For the machine-independent opcodes, we pretend that the "register" size is equal to the type width, so sign extension is immaterial. Opcodes that care about the signedness of the input (e.g. compare, right shift) have two different variants. Change-Id: I465484c5734545ee697afe83bc8bf4b53bd9df8d Reviewed-on: https://go-review.googlesource.com/12600 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/gc/ssa.go | 189 +++++- src/cmd/compile/internal/ssa/config.go | 5 + src/cmd/compile/internal/ssa/gen/AMD64.rules | 107 ++-- src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 4 +- src/cmd/compile/internal/ssa/gen/generic.rules | 2 - src/cmd/compile/internal/ssa/gen/genericOps.go | 50 +- src/cmd/compile/internal/ssa/opGen.go | 197 +++--- src/cmd/compile/internal/ssa/rewriteAMD64.go | 800 ++++++++++++------------- src/cmd/compile/internal/ssa/rewritegeneric.go | 46 -- 9 files changed, 707 insertions(+), 693 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 0a45be0078..b6b345f205 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -662,51 +662,51 @@ type opAndType struct { var opToSSA = map[opAndType]ssa.Op{ opAndType{OADD, TINT8}: ssa.OpAdd8, - opAndType{OADD, TUINT8}: ssa.OpAdd8U, + opAndType{OADD, TUINT8}: ssa.OpAdd8, opAndType{OADD, TINT16}: ssa.OpAdd16, - opAndType{OADD, TUINT16}: ssa.OpAdd16U, + opAndType{OADD, TUINT16}: ssa.OpAdd16, opAndType{OADD, TINT32}: ssa.OpAdd32, - opAndType{OADD, TUINT32}: ssa.OpAdd32U, + opAndType{OADD, TUINT32}: ssa.OpAdd32, opAndType{OADD, TINT64}: ssa.OpAdd64, - opAndType{OADD, TUINT64}: ssa.OpAdd64U, + opAndType{OADD, TUINT64}: ssa.OpAdd64, opAndType{OSUB, TINT8}: ssa.OpSub8, - opAndType{OSUB, TUINT8}: ssa.OpSub8U, + opAndType{OSUB, TUINT8}: ssa.OpSub8, opAndType{OSUB, TINT16}: ssa.OpSub16, - opAndType{OSUB, TUINT16}: ssa.OpSub16U, + opAndType{OSUB, TUINT16}: ssa.OpSub16, opAndType{OSUB, TINT32}: ssa.OpSub32, - opAndType{OSUB, TUINT32}: ssa.OpSub32U, + opAndType{OSUB, TUINT32}: ssa.OpSub32, opAndType{OSUB, TINT64}: ssa.OpSub64, - opAndType{OSUB, TUINT64}: ssa.OpSub64U, + opAndType{OSUB, TUINT64}: ssa.OpSub64, opAndType{ONOT, TBOOL}: ssa.OpNot, opAndType{OMINUS, TINT8}: ssa.OpNeg8, - opAndType{OMINUS, TUINT8}: ssa.OpNeg8U, + opAndType{OMINUS, TUINT8}: ssa.OpNeg8, opAndType{OMINUS, TINT16}: ssa.OpNeg16, - opAndType{OMINUS, TUINT16}: ssa.OpNeg16U, + opAndType{OMINUS, TUINT16}: ssa.OpNeg16, opAndType{OMINUS, TINT32}: ssa.OpNeg32, - opAndType{OMINUS, TUINT32}: ssa.OpNeg32U, + opAndType{OMINUS, TUINT32}: ssa.OpNeg32, opAndType{OMINUS, TINT64}: ssa.OpNeg64, - opAndType{OMINUS, TUINT64}: ssa.OpNeg64U, + opAndType{OMINUS, TUINT64}: ssa.OpNeg64, opAndType{OMUL, TINT8}: ssa.OpMul8, - opAndType{OMUL, TUINT8}: ssa.OpMul8U, + opAndType{OMUL, TUINT8}: ssa.OpMul8, opAndType{OMUL, TINT16}: ssa.OpMul16, - opAndType{OMUL, TUINT16}: ssa.OpMul16U, + opAndType{OMUL, TUINT16}: ssa.OpMul16, opAndType{OMUL, TINT32}: ssa.OpMul32, - opAndType{OMUL, TUINT32}: ssa.OpMul32U, + opAndType{OMUL, TUINT32}: ssa.OpMul32, opAndType{OMUL, TINT64}: ssa.OpMul64, - opAndType{OMUL, TUINT64}: ssa.OpMul64U, + opAndType{OMUL, TUINT64}: ssa.OpMul64, opAndType{OAND, TINT8}: ssa.OpAnd8, - opAndType{OAND, TUINT8}: ssa.OpAnd8U, + opAndType{OAND, TUINT8}: ssa.OpAnd8, opAndType{OAND, TINT16}: ssa.OpAnd16, - opAndType{OAND, TUINT16}: ssa.OpAnd16U, + opAndType{OAND, TUINT16}: ssa.OpAnd16, opAndType{OAND, TINT32}: ssa.OpAnd32, - opAndType{OAND, TUINT32}: ssa.OpAnd32U, + opAndType{OAND, TUINT32}: ssa.OpAnd32, opAndType{OAND, TINT64}: ssa.OpAnd64, - opAndType{OAND, TUINT64}: ssa.OpAnd64U, + opAndType{OAND, TUINT64}: ssa.OpAnd64, opAndType{OLSH, TINT8}: ssa.OpLsh8, opAndType{OLSH, TUINT8}: ssa.OpLsh8, @@ -797,20 +797,31 @@ var opToSSA = map[opAndType]ssa.Op{ opAndType{OGE, TUINT64}: ssa.OpGeq64U, } -func (s *state) ssaOp(op uint8, t *Type) ssa.Op { - etype := t.Etype - switch etype { +func (s *state) concreteEtype(t *Type) uint8 { + e := t.Etype + switch e { + default: + return e case TINT: - etype = TINT32 - if s.config.PtrSize == 8 { - etype = TINT64 + if s.config.IntSize == 8 { + return TINT64 } + return TINT32 case TUINT: - etype = TUINT32 + if s.config.IntSize == 8 { + return TUINT64 + } + return TUINT32 + case TUINTPTR: if s.config.PtrSize == 8 { - etype = TUINT64 + return TUINT64 } + return TUINT32 } +} + +func (s *state) ssaOp(op uint8, t *Type) ssa.Op { + etype := s.concreteEtype(t) x, ok := opToSSA[opAndType{op, etype}] if !ok { s.Unimplementedf("unhandled binary op %s etype=%s", opnames[op], Econv(int(etype), 0)) @@ -854,7 +865,71 @@ func (s *state) expr(n *Node) *ssa.Value { return s.newValue1(ssa.OpConvNop, n.Type, x) case OCONV: x := s.expr(n.Left) - return s.newValue1(ssa.OpConvert, n.Type, x) + 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.OpConvNop + } 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) + } + s.Unimplementedf("unhandled OCONV %s -> %s", n.Left.Type, n.Type) + return nil // binary ops case OLT, OEQ, ONE, OLE, OGE, OGT: @@ -933,6 +1008,7 @@ func (s *state) expr(n *Node) *ssa.Value { if n.Left.Type.Bound >= 0 { // array or string a := s.expr(n.Left) i := s.expr(n.Right) + i = s.extendIndex(i) var elemtype *Type var len *ssa.Value if n.Left.Type.IsString() { @@ -1099,6 +1175,7 @@ func (s *state) addr(n *Node) *ssa.Value { if n.Left.Type.IsSlice() { a := s.expr(n.Left) i := s.expr(n.Right) + i = s.extendIndex(i) len := s.newValue1(ssa.OpSliceLen, s.config.Uintptr, a) s.boundsCheck(i, len) p := s.newValue1(ssa.OpSlicePtr, Ptrto(n.Left.Type.Type), a) @@ -1106,6 +1183,7 @@ func (s *state) addr(n *Node) *ssa.Value { } else { // array a := s.addr(n.Left) i := s.expr(n.Right) + i = s.extendIndex(i) len := s.constInt(s.config.Uintptr, n.Left.Type.Bound) s.boundsCheck(i, len) return s.newValue2(ssa.OpPtrIndex, Ptrto(n.Left.Type.Type), a, i) @@ -1623,7 +1701,7 @@ func genValue(v *ssa.Value) { p.From.Offset = v.AuxInt p.To.Type = obj.TYPE_REG p.To.Reg = x - case ssa.OpAMD64MOVQload, ssa.OpAMD64MOVLload, ssa.OpAMD64MOVWload, ssa.OpAMD64MOVBload: + case ssa.OpAMD64MOVQload, ssa.OpAMD64MOVLload, ssa.OpAMD64MOVWload, ssa.OpAMD64MOVBload, ssa.OpAMD64MOVBQSXload, ssa.OpAMD64MOVBQZXload: p := Prog(v.Op.Asm()) p.From.Type = obj.TYPE_MEM p.From.Reg = regnum(v.Args[0]) @@ -1646,7 +1724,7 @@ func genValue(v *ssa.Value) { p.To.Type = obj.TYPE_MEM p.To.Reg = regnum(v.Args[0]) addAux(&p.To, v) - case ssa.OpAMD64MOVLQSX, ssa.OpAMD64MOVWQSX, ssa.OpAMD64MOVBQSX: + case ssa.OpAMD64MOVLQSX, ssa.OpAMD64MOVWQSX, ssa.OpAMD64MOVBQSX, ssa.OpAMD64MOVLQZX, ssa.OpAMD64MOVWQZX, ssa.OpAMD64MOVBQZX: p := Prog(v.Op.Asm()) p.From.Type = obj.TYPE_REG p.From.Reg = regnum(v.Args[0]) @@ -1868,6 +1946,55 @@ func addAux(a *obj.Addr, v *ssa.Value) { } } +// extendIndex extends v to a full pointer width. +func (s *state) extendIndex(v *ssa.Value) *ssa.Value { + size := v.Type.Size() + if size == s.config.PtrSize { + return v + } + if size > s.config.PtrSize { + // 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.PtrSize { + 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.PtrSize { + 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, s.config.Uintptr, v) +} + // ssaRegToReg maps ssa register numbers to obj register numbers. var ssaRegToReg = [...]int16{ x86.REG_AX, diff --git a/src/cmd/compile/internal/ssa/config.go b/src/cmd/compile/internal/ssa/config.go index d3d2c66b7f..cabf62e463 100644 --- a/src/cmd/compile/internal/ssa/config.go +++ b/src/cmd/compile/internal/ssa/config.go @@ -6,6 +6,7 @@ package ssa type Config struct { arch string // "amd64", etc. + IntSize int64 // 4 or 8 PtrSize int64 // 4 or 8 Uintptr Type // pointer arithmetic type Int Type @@ -36,10 +37,12 @@ func NewConfig(arch string, fe Frontend) *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 @@ -52,6 +55,8 @@ func NewConfig(arch string, fe Frontend) *Config { c.Int = TypeInt32 if c.PtrSize == 8 { c.Uintptr = TypeUInt64 + } + if c.IntSize == 8 { c.Int = TypeInt64 } diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index ea3974935f..0be4d7d22b 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -3,10 +3,7 @@ // license that can be found in the LICENSE file. // x86 register conventions: -// - Integer types live in the low portion of registers. -// Upper portions are correctly extended. -// TODO: reconsider? The current choice means we need no extension for indexing, -// but we do need extension for e.g. 32-bit signed adds. +// - 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. @@ -14,78 +11,75 @@ // Lowering arithmetic (Add64 x y) -> (ADDQ x y) -(Add64U x y) -> (ADDQ x y) (AddPtr x y) -> (ADDQ x y) -(Add32U x y) -> (ADDL x y) -(Add32 x y) -> (MOVLQSX (ADDL x y)) -(Add16U x y) -> (ADDW x y) -(Add16 x y) -> (MOVWQSX (ADDW x y)) -(Add8U x y) -> (ADDB x y) -(Add8 x y) -> (MOVBQSX (ADDB x y)) +(Add32 x y) -> (ADDL x y) +(Add16 x y) -> (ADDW x y) +(Add8 x y) -> (ADDB x y) (And64 x y) -> (ANDQ x y) -(And64U x y) -> (ANDQ x y) -(And32U x y) -> (ANDL x y) -(And32 x y) -> (MOVLQSX (ANDL x y)) -(And16U x y) -> (ANDW x y) -(And16 x y) -> (MOVWQSX (ANDW x y)) -(And8U x y) -> (ANDB x y) -(And8 x y) -> (MOVBQSX (ANDB x y)) +(And32 x y) -> (ANDL x y) +(And16 x y) -> (ANDW x y) +(And8 x y) -> (ANDB x y) (Sub64 x y) -> (SUBQ x y) -(Sub64U x y) -> (SUBQ x y) -(Sub32U x y) -> (SUBL x y) -(Sub32 x y) -> (MOVLQSX (SUBL x y)) -(Sub16U x y) -> (SUBW x y) -(Sub16 x y) -> (MOVWQSX (SUBW x y)) -(Sub8U x y) -> (SUBB x y) -(Sub8 x y) -> (MOVBQSX (SUBB x y)) +(Sub32 x y) -> (SUBL x y) +(Sub16 x y) -> (SUBW x y) +(Sub8 x y) -> (SUBB x y) (Neg64 x) -> (NEGQ x) -(Neg64U x) -> (NEGQ x) -(Neg32U x) -> (NEGL x) -(Neg32 x) -> (MOVLQSX (NEGL x)) -(Neg16U x) -> (NEGW x) -(Neg16 x) -> (MOVWQSX (NEGW x)) -(Neg8U x) -> (NEGB x) -(Neg8 x) -> (MOVBQSX (NEGB x)) +(Neg32 x) -> (NEGL x) +(Neg16 x) -> (NEGW x) +(Neg8 x) -> (NEGB x) (Mul64 x y) -> (MULQ x y) -(Mul64U x y) -> (MULQ x y) (MulPtr x y) -> (MULQ x y) -(Mul32 x y) -> (MOVLQSX (MULL x y)) -(Mul32U x y) -> (MULL x y) -(Mul16 x y) -> (MOVWQSX (MULW x y)) -(Mul16U x y) -> (MULW x y) +(Mul32 x y) -> (MULL x y) +(Mul16 x y) -> (MULW x y) // Note: we use 16-bit multiply instructions for 8-bit multiplies because // the 16-bit multiply instructions are more forgiving (they operate on // any register instead of just AX/DX). -(Mul8 x y) -> (MOVBQSX (MULW x y)) -(Mul8U x y) -> (MOVBQZX (MULW x y)) +(Mul8 x y) -> (MULW x y) + +// 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) + +// Because we ignore high parts of registers, truncates are just copies. +(Trunc16to8 x) -> (Copy x) +(Trunc32to8 x) -> (Copy x) +(Trunc32to16 x) -> (Copy x) +(Trunc64to8 x) -> (Copy x) +(Trunc64to16 x) -> (Copy x) +(Trunc64to32 x) -> (Copy x) -(MOVLstore ptr (MOVLQSX x) mem) -> (MOVLstore ptr x mem) -(MOVWstore ptr (MOVWQSX x) mem) -> (MOVWstore ptr x mem) -(MOVBstore ptr (MOVBQSX x) mem) -> (MOVBstore ptr x mem) -(MOVLstore ptr (MOVLQZX x) mem) -> (MOVLstore ptr x mem) -(MOVWstore ptr (MOVWQZX x) mem) -> (MOVWstore ptr x mem) -(MOVBstore ptr (MOVBQZX x) mem) -> (MOVBstore ptr x mem) - -(Convert x) && t.IsInteger() && x.Type.IsInteger() -> (Copy x) (ConvNop x) && t == x.Type -> (Copy x) +(ConvNop x) && t.IsInteger() && x.Type.IsInteger() && t.Size() == x.Type.Size() -> (Copy x) +// TODO: other ConvNops are safe? Maybe all of them? // Lowering shifts // Note: unsigned shifts need to return 0 if shift amount is >= 64. // mask = shift >= 64 ? 0 : 0xffffffffffffffff // result = mask & arg << shift -(Lsh64 x y) -> +(Lsh64 x y) && y.Type.Size() == 8 -> (ANDQ (SHLQ x y) (SBBQcarrymask (CMPQconst [64] y))) -(Rsh64U x y) -> +(Rsh64U x y) && y.Type.Size() == 8 -> (ANDQ (SHRQ x y) (SBBQcarrymask (CMPQconst [64] y))) // Note: signed right shift needs to return 0/-1 if shift amount is >= 64. // if shift > 63 { shift = 63 } // result = arg >> shift -(Rsh64 x y) -> +(Rsh64 x y) && y.Type.Size() == 8 -> (SARQ x (CMOVQCC (CMPQconst [64] y) (Const [63]) @@ -187,6 +181,19 @@ (SETL (InvertFlags x)) -> (SETG x) (SETG (InvertFlags x)) -> (SETL x) +// sign extended loads +(MOVBQSX (MOVBload ptr mem)) -> (MOVBQSXload ptr mem) +(MOVBQZX (MOVBload ptr mem)) -> (MOVBQZXload ptr mem) +// TODO: more + +// Don't extend before storing +(MOVLstore ptr (MOVLQSX x) mem) -> (MOVLstore ptr x mem) +(MOVWstore ptr (MOVWQSX x) mem) -> (MOVWstore ptr x mem) +(MOVBstore ptr (MOVBQSX x) mem) -> (MOVBstore ptr x mem) +(MOVLstore ptr (MOVLQZX x) mem) -> (MOVLstore ptr x mem) +(MOVWstore ptr (MOVWQZX x) mem) -> (MOVWstore ptr x mem) +(MOVBstore ptr (MOVBQZX x) mem) -> (MOVBstore 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 diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 1a0a8e28e5..64095c5654 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -146,8 +146,8 @@ func init() { {name: "LEAQ8", reg: gp21sb}, // arg0 + 8*arg1 + auxint {name: "MOVBload", reg: gpload, asm: "MOVB"}, // load byte from arg0+auxint. arg1=mem - {name: "MOVBQZXload", reg: gpload}, // ditto, extend to uint64 - {name: "MOVBQSXload", reg: gpload}, // ditto, extend to int64 + {name: "MOVBQSXload", reg: gpload, asm: "MOVBQSX"}, // ditto, extend to int64 + {name: "MOVBQZXload", reg: gpload, asm: "MOVBQZX"}, // ditto, extend to uint64 {name: "MOVWload", reg: gpload, asm: "MOVW"}, // load 2 bytes from arg0+auxint. arg1=mem {name: "MOVLload", reg: gpload, asm: "MOVL"}, // load 4 bytes from arg0+auxint. arg1=mem {name: "MOVQload", reg: gpload, asm: "MOVQ"}, // load 8 bytes from arg0+auxint. arg1=mem diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index dd48706e63..d13466f06a 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -21,10 +21,8 @@ // constant folding (Add64 (Const [c]) (Const [d])) -> (Const [c+d]) -(Add64U (Const [c]) (Const [d])) -> (Const [c+d]) (AddPtr (Const [c]) (Const [d])) -> (Const [c+d]) (Mul64 (Const [c]) (Const [d])) -> (Const [c*d]) -(Mul64U (Const [c]) (Const [d])) -> (Const [c*d]) (MulPtr (Const [c]) (Const [d])) -> (Const [c*d]) (IsInBounds (Const [c]) (Const [d])) -> (Const {inBounds(c,d)}) diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index c67643d94e..2dcaa67bd1 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -12,10 +12,6 @@ var genericOps = []opData{ {name: "Add16"}, {name: "Add32"}, {name: "Add64"}, - {name: "Add8U"}, - {name: "Add16U"}, - {name: "Add32U"}, - {name: "Add64U"}, {name: "AddPtr"}, // TODO: Add32F, Add64F, Add64C, Add128C @@ -23,30 +19,18 @@ var genericOps = []opData{ {name: "Sub16"}, {name: "Sub32"}, {name: "Sub64"}, - {name: "Sub8U"}, - {name: "Sub16U"}, - {name: "Sub32U"}, - {name: "Sub64U"}, // TODO: Sub32F, Sub64F, Sub64C, Sub128C {name: "Mul8"}, // arg0 * arg1 {name: "Mul16"}, {name: "Mul32"}, {name: "Mul64"}, - {name: "Mul8U"}, - {name: "Mul16U"}, - {name: "Mul32U"}, - {name: "Mul64U"}, {name: "MulPtr"}, // MulPtr is used for address calculations {name: "And8"}, // arg0 & arg1 {name: "And16"}, {name: "And32"}, {name: "And64"}, - {name: "And8U"}, - {name: "And16U"}, - {name: "And32U"}, - {name: "And64U"}, {name: "Lsh8"}, // arg0 << arg1 {name: "Lsh16"}, @@ -120,10 +104,6 @@ var genericOps = []opData{ {name: "Neg16"}, {name: "Neg32"}, {name: "Neg64"}, - {name: "Neg8U"}, - {name: "Neg16U"}, - {name: "Neg32U"}, - {name: "Neg64U"}, // Data movement {name: "Phi"}, // select an argument based on which predecessor block we came from @@ -132,9 +112,9 @@ var genericOps = []opData{ // constants. Constant values are stored in the aux field. // booleans have a bool aux field, strings have a string aux // field, and so on. All integer types store their value - // in the aux field as an int64 (including int, uint64, etc.). - // We could store int8 as an int8, but that won't work for int, - // as it may be different widths on the host and target. + // in the AuxInt field as an int64 (including int, uint64, etc.). + // For integer types smaller than 64 bits, only the low-order + // bits of the AuxInt field matter. {name: "Const"}, // Constant-like things @@ -162,9 +142,27 @@ var genericOps = []opData{ {name: "ClosureCall"}, // arg0=code pointer, arg1=context ptr, arg2=memory. Returns memory. {name: "StaticCall"}, // call function aux.(*gc.Sym), arg0=memory. Returns memory. - // Conversions - {name: "Convert"}, // convert arg0 to another type - {name: "ConvNop"}, // interpret arg0 as another type + // Conversions: signed extensions, zero (unsigned) extensions, truncations, and no-op (type only) + {name: "SignExt8to16"}, + {name: "SignExt8to32"}, + {name: "SignExt8to64"}, + {name: "SignExt16to32"}, + {name: "SignExt16to64"}, + {name: "SignExt32to64"}, + {name: "ZeroExt8to16"}, + {name: "ZeroExt8to32"}, + {name: "ZeroExt8to64"}, + {name: "ZeroExt16to32"}, + {name: "ZeroExt16to64"}, + {name: "ZeroExt32to64"}, + {name: "Trunc16to8"}, + {name: "Trunc32to8"}, + {name: "Trunc32to16"}, + {name: "Trunc64to8"}, + {name: "Trunc64to16"}, + {name: "Trunc64to32"}, + + {name: "ConvNop"}, // Automatically inserted safety checks {name: "IsNonNil"}, // arg0 != nil diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index d83f87305d..532c0558e0 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -92,8 +92,8 @@ const ( OpAMD64LEAQ4 OpAMD64LEAQ8 OpAMD64MOVBload - OpAMD64MOVBQZXload OpAMD64MOVBQSXload + OpAMD64MOVBQZXload OpAMD64MOVWload OpAMD64MOVLload OpAMD64MOVQload @@ -137,36 +137,20 @@ const ( OpAdd16 OpAdd32 OpAdd64 - OpAdd8U - OpAdd16U - OpAdd32U - OpAdd64U OpAddPtr OpSub8 OpSub16 OpSub32 OpSub64 - OpSub8U - OpSub16U - OpSub32U - OpSub64U OpMul8 OpMul16 OpMul32 OpMul64 - OpMul8U - OpMul16U - OpMul32U - OpMul64U OpMulPtr OpAnd8 OpAnd16 OpAnd32 OpAnd64 - OpAnd8U - OpAnd16U - OpAnd32U - OpAnd64U OpLsh8 OpLsh16 OpLsh32 @@ -228,10 +212,6 @@ const ( OpNeg16 OpNeg32 OpNeg64 - OpNeg8U - OpNeg16U - OpNeg32U - OpNeg64U OpPhi OpCopy OpConst @@ -246,7 +226,24 @@ const ( OpZero OpClosureCall OpStaticCall - OpConvert + OpSignExt8to16 + OpSignExt8to32 + OpSignExt8to64 + OpSignExt16to32 + OpSignExt16to64 + OpSignExt32to64 + OpZeroExt8to16 + OpZeroExt8to32 + OpZeroExt8to64 + OpZeroExt16to32 + OpZeroExt16to64 + OpZeroExt32to64 + OpTrunc16to8 + OpTrunc32to8 + OpTrunc32to16 + OpTrunc64to8 + OpTrunc64to16 + OpTrunc64to32 OpConvNop OpIsNonNil OpIsInBounds @@ -769,7 +766,8 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVBQZXload", + name: "MOVBQSXload", + asm: x86.AMOVBQSX, reg: regInfo{ inputs: []regMask{ 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB @@ -781,7 +779,8 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVBQSXload", + name: "MOVBQZXload", + asm: x86.AMOVBQZX, reg: regInfo{ inputs: []regMask{ 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB @@ -1237,22 +1236,6 @@ var opcodeTable = [...]opInfo{ name: "Add64", generic: true, }, - { - name: "Add8U", - generic: true, - }, - { - name: "Add16U", - generic: true, - }, - { - name: "Add32U", - generic: true, - }, - { - name: "Add64U", - generic: true, - }, { name: "AddPtr", generic: true, @@ -1273,22 +1256,6 @@ var opcodeTable = [...]opInfo{ name: "Sub64", generic: true, }, - { - name: "Sub8U", - generic: true, - }, - { - name: "Sub16U", - generic: true, - }, - { - name: "Sub32U", - generic: true, - }, - { - name: "Sub64U", - generic: true, - }, { name: "Mul8", generic: true, @@ -1305,22 +1272,6 @@ var opcodeTable = [...]opInfo{ name: "Mul64", generic: true, }, - { - name: "Mul8U", - generic: true, - }, - { - name: "Mul16U", - generic: true, - }, - { - name: "Mul32U", - generic: true, - }, - { - name: "Mul64U", - generic: true, - }, { name: "MulPtr", generic: true, @@ -1341,22 +1292,6 @@ var opcodeTable = [...]opInfo{ name: "And64", generic: true, }, - { - name: "And8U", - generic: true, - }, - { - name: "And16U", - generic: true, - }, - { - name: "And32U", - generic: true, - }, - { - name: "And64U", - generic: true, - }, { name: "Lsh8", generic: true, @@ -1601,22 +1536,6 @@ var opcodeTable = [...]opInfo{ name: "Neg64", generic: true, }, - { - name: "Neg8U", - generic: true, - }, - { - name: "Neg16U", - generic: true, - }, - { - name: "Neg32U", - generic: true, - }, - { - name: "Neg64U", - generic: true, - }, { name: "Phi", generic: true, @@ -1674,7 +1593,75 @@ var opcodeTable = [...]opInfo{ generic: true, }, { - name: "Convert", + name: "SignExt8to16", + generic: true, + }, + { + name: "SignExt8to32", + generic: true, + }, + { + name: "SignExt8to64", + generic: true, + }, + { + name: "SignExt16to32", + generic: true, + }, + { + name: "SignExt16to64", + generic: true, + }, + { + name: "SignExt32to64", + generic: true, + }, + { + name: "ZeroExt8to16", + generic: true, + }, + { + name: "ZeroExt8to32", + generic: true, + }, + { + name: "ZeroExt8to64", + generic: true, + }, + { + name: "ZeroExt16to32", + generic: true, + }, + { + name: "ZeroExt16to64", + generic: true, + }, + { + name: "ZeroExt32to64", + generic: true, + }, + { + name: "Trunc16to8", + generic: true, + }, + { + name: "Trunc32to8", + generic: true, + }, + { + name: "Trunc32to16", + generic: true, + }, + { + name: "Trunc64to8", + generic: true, + }, + { + name: "Trunc64to16", + generic: true, + }, + { + name: "Trunc64to32", generic: true, }, { diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 41bb6213f1..038275d21b 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -196,27 +196,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { case OpAdd16: // match: (Add16 x y) // cond: - // result: (MOVWQSX (ADDW x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64MOVWQSX - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64ADDW, TypeInvalid) - v0.Type = v.Type - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - return true - } - goto end2aef2dab49f6b2ca337f58ad0a8209ae - end2aef2dab49f6b2ca337f58ad0a8209ae: - ; - case OpAdd16U: - // match: (Add16U x y) - // cond: // result: (ADDW x y) { x := v.Args[0] @@ -229,33 +208,12 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(y) return true } - goto end8ca34beeb0897b0c70352ba90cca4a1d - end8ca34beeb0897b0c70352ba90cca4a1d: + goto ende604481c6de9fe4574cb2954ba2ddc67 + ende604481c6de9fe4574cb2954ba2ddc67: ; case OpAdd32: // match: (Add32 x y) // cond: - // result: (MOVLQSX (ADDL x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64MOVLQSX - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64ADDL, TypeInvalid) - v0.Type = v.Type - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - return true - } - goto end7f18bca004d8c158f50b04e7511af49f - end7f18bca004d8c158f50b04e7511af49f: - ; - case OpAdd32U: - // match: (Add32U x y) - // cond: // result: (ADDL x y) { x := v.Args[0] @@ -268,8 +226,8 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(y) return true } - goto end72ff71aa883fa569307ae06289ac1e30 - end72ff71aa883fa569307ae06289ac1e30: + goto endc445ea2a65385445676cd684ae9a42b5 + endc445ea2a65385445676cd684ae9a42b5: ; case OpAdd64: // match: (Add64 x y) @@ -289,48 +247,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endd88f18b3f39e3ccc201477a616f0abc0 endd88f18b3f39e3ccc201477a616f0abc0: ; - case OpAdd64U: - // match: (Add64U x y) - // cond: - // result: (ADDQ x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ADDQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto endee28cc0dbdf2664cb3f6a5ddb3960b1b - endee28cc0dbdf2664cb3f6a5ddb3960b1b: - ; case OpAdd8: // match: (Add8 x y) // cond: - // result: (MOVBQSX (ADDB x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64MOVBQSX - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64ADDB, TypeInvalid) - v0.Type = v.Type - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - return true - } - goto end7078e2b21b2da3acc80e79ba1386d098 - end7078e2b21b2da3acc80e79ba1386d098: - ; - case OpAdd8U: - // match: (Add8U x y) - // cond: // result: (ADDB x y) { x := v.Args[0] @@ -343,8 +262,8 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(y) return true } - goto endb5cb0e4b3566464c17acf1df5e4b0543 - endb5cb0e4b3566464c17acf1df5e4b0543: + goto end6117c84a6b75c1b816b3fb095bc5f656 + end6117c84a6b75c1b816b3fb095bc5f656: ; case OpAddPtr: // match: (AddPtr x y) @@ -385,27 +304,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { case OpAnd16: // match: (And16 x y) // cond: - // result: (MOVWQSX (ANDW x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64MOVWQSX - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64ANDW, TypeInvalid) - v0.Type = v.Type - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - return true - } - goto end566a8c12ea6f1c18d200aaf3a911e2e5 - end566a8c12ea6f1c18d200aaf3a911e2e5: - ; - case OpAnd16U: - // match: (And16U x y) - // cond: // result: (ANDW x y) { x := v.Args[0] @@ -418,33 +316,12 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(y) return true } - goto end248cfb532a3bb6b244ed5e9124b35c13 - end248cfb532a3bb6b244ed5e9124b35c13: + goto end1c01f04a173d86ce1a6d1ef59e753014 + end1c01f04a173d86ce1a6d1ef59e753014: ; case OpAnd32: // match: (And32 x y) // cond: - // result: (MOVLQSX (ANDL x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64MOVLQSX - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64ANDL, TypeInvalid) - v0.Type = v.Type - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - return true - } - goto ende53f2add9b41c8a17440e9c72372c8c4 - ende53f2add9b41c8a17440e9c72372c8c4: - ; - case OpAnd32U: - // match: (And32U x y) - // cond: // result: (ANDL x y) { x := v.Args[0] @@ -457,8 +334,8 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(y) return true } - goto endaceb9ea4ffc888774cfa38ed13d860d6 - endaceb9ea4ffc888774cfa38ed13d860d6: + goto end6b9eb9375b3a859028a6ba6bf6b8ec88 + end6b9eb9375b3a859028a6ba6bf6b8ec88: ; case OpAnd64: // match: (And64 x y) @@ -478,48 +355,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto enda0bde5853819d05fa2b7d3b723629552 enda0bde5853819d05fa2b7d3b723629552: ; - case OpAnd64U: - // match: (And64U x y) - // cond: - // result: (ANDQ x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ANDQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto end7d0ff84f3ba7cf7880e73176b38d0a4b - end7d0ff84f3ba7cf7880e73176b38d0a4b: - ; case OpAnd8: // match: (And8 x y) // cond: - // result: (MOVBQSX (ANDB x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64MOVBQSX - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64ANDB, TypeInvalid) - v0.Type = v.Type - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - return true - } - goto endb570a5dfeea1414989cb9c8ab0b9c329 - endb570a5dfeea1414989cb9c8ab0b9c329: - ; - case OpAnd8U: - // match: (And8U x y) - // cond: // result: (ANDB x y) { x := v.Args[0] @@ -532,8 +370,8 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(y) return true } - goto end6a9db8b74df974171e72ce228b3e2c98 - end6a9db8b74df974171e72ce228b3e2c98: + goto end0f53bee6291f1229b43aa1b5f977b4f2 + end0f53bee6291f1229b43aa1b5f977b4f2: ; case OpAMD64CMOVQCC: // match: (CMOVQCC (CMPQconst [c] (MOVQconst [d])) _ x) @@ -748,15 +586,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end6c588ed8aedc7dca8c06b4ada77e3ddd end6c588ed8aedc7dca8c06b4ada77e3ddd: ; - case OpConvert: - // match: (Convert x) - // cond: t.IsInteger() && x.Type.IsInteger() + // match: (ConvNop x) + // cond: t.IsInteger() && x.Type.IsInteger() && t.Size() == x.Type.Size() // result: (Copy x) { t := v.Type x := v.Args[0] - if !(t.IsInteger() && x.Type.IsInteger()) { - goto endcc7894224d4f6b0bcabcece5d0185912 + if !(t.IsInteger() && x.Type.IsInteger() && t.Size() == x.Type.Size()) { + goto endfb3563f9df3468ad8123dbaa962cdbf7 } v.Op = OpCopy v.AuxInt = 0 @@ -765,8 +602,8 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(x) return true } - goto endcc7894224d4f6b0bcabcece5d0185912 - endcc7894224d4f6b0bcabcece5d0185912: + goto endfb3563f9df3468ad8123dbaa962cdbf7 + endfb3563f9df3468ad8123dbaa962cdbf7: ; case OpEq16: // match: (Eq16 x y) @@ -1085,12 +922,15 @@ func rewriteValueAMD64(v *Value, config *Config) bool { ; case OpLsh64: // match: (Lsh64 x y) - // cond: + // cond: y.Type.Size() == 8 // result: (ANDQ (SHLQ x y) (SBBQcarrymask (CMPQconst [64] y))) { t := v.Type x := v.Args[0] y := v.Args[1] + if !(y.Type.Size() == 8) { + goto end04273c7a426341c8f3ecfaa5d653dc6b + } v.Op = OpAMD64ANDQ v.AuxInt = 0 v.Aux = nil @@ -1110,8 +950,50 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto end02b17b9d1aca859d392e527fe6fc58da - end02b17b9d1aca859d392e527fe6fc58da: + goto end04273c7a426341c8f3ecfaa5d653dc6b + end04273c7a426341c8f3ecfaa5d653dc6b: + ; + case OpAMD64MOVBQSX: + // match: (MOVBQSX (MOVBload ptr mem)) + // cond: + // result: (MOVBQSXload ptr mem) + { + if v.Args[0].Op != OpAMD64MOVBload { + goto enda3a5eeb5767e31f42b0b6c1db8311ebb + } + ptr := v.Args[0].Args[0] + mem := v.Args[0].Args[1] + v.Op = OpAMD64MOVBQSXload + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto enda3a5eeb5767e31f42b0b6c1db8311ebb + enda3a5eeb5767e31f42b0b6c1db8311ebb: + ; + case OpAMD64MOVBQZX: + // match: (MOVBQZX (MOVBload ptr mem)) + // cond: + // result: (MOVBQZXload ptr mem) + { + if v.Args[0].Op != OpAMD64MOVBload { + goto end9510a482da21d9945d53c4233b19e825 + } + ptr := v.Args[0].Args[0] + mem := v.Args[0].Args[1] + v.Op = OpAMD64MOVBQZXload + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto end9510a482da21d9945d53c4233b19e825 + end9510a482da21d9945d53c4233b19e825: ; case OpAMD64MOVBstore: // match: (MOVBstore ptr (MOVBQSX x) mem) @@ -1670,27 +1552,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { case OpMul16: // match: (Mul16 x y) // cond: - // result: (MOVWQSX (MULW x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64MOVWQSX - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64MULW, TypeInvalid) - v0.Type = v.Type - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - return true - } - goto end395fc5128ed3789326d04b4555ecfd16 - end395fc5128ed3789326d04b4555ecfd16: - ; - case OpMul16U: - // match: (Mul16U x y) - // cond: // result: (MULW x y) { x := v.Args[0] @@ -1703,33 +1564,12 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(y) return true } - goto endec860875a3c61ac3738fa330a3857bb3 - endec860875a3c61ac3738fa330a3857bb3: + goto end1addf5ea2c885aa1729b8f944859d00c + end1addf5ea2c885aa1729b8f944859d00c: ; case OpMul32: // match: (Mul32 x y) // cond: - // result: (MOVLQSX (MULL x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64MOVLQSX - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64MULL, TypeInvalid) - v0.Type = v.Type - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - return true - } - goto endb756489a642e438ff6e89e55754334e2 - endb756489a642e438ff6e89e55754334e2: - ; - case OpMul32U: - // match: (Mul32U x y) - // cond: // result: (MULL x y) { x := v.Args[0] @@ -1742,8 +1582,8 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(y) return true } - goto ende4c566176fb13075292de5ccb016c5fc - ende4c566176fb13075292de5ccb016c5fc: + goto ende144381f85808e5144782804768e2859 + ende144381f85808e5144782804768e2859: ; case OpMul64: // match: (Mul64 x y) @@ -1763,65 +1603,23 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end38da21e77ac329eb643b20e7d97d5853 end38da21e77ac329eb643b20e7d97d5853: ; - case OpMul64U: - // match: (Mul64U x y) - // cond: - // result: (MULQ x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64MULQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto end3da28ba90850e15f0ed2c37fbce90650 - end3da28ba90850e15f0ed2c37fbce90650: - ; case OpMul8: // match: (Mul8 x y) // cond: - // result: (MOVBQSX (MULW x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64MOVBQSX - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64MULW, TypeInvalid) - v0.Type = TypeInt16 - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - return true - } - goto end418ba69107bb1e02d5015c73c9f9a5c9 - end418ba69107bb1e02d5015c73c9f9a5c9: - ; - case OpMul8U: - // match: (Mul8U x y) - // cond: - // result: (MOVBQZX (MULW x y)) + // result: (MULW x y) { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64MOVBQZX + v.Op = OpAMD64MULW v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64MULW, TypeInvalid) - v0.Type = TypeUInt16 - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) + v.AddArg(x) + v.AddArg(y) return true } - goto end9d0a972d9b8a32b84ed38a32bfeb01b6 - end9d0a972d9b8a32b84ed38a32bfeb01b6: + goto end861428e804347e8489a6424f2e6ce71c + end861428e804347e8489a6424f2e6ce71c: ; case OpMulPtr: // match: (MulPtr x y) @@ -1844,25 +1642,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { case OpNeg16: // match: (Neg16 x) // cond: - // result: (MOVWQSX (NEGW x)) - { - x := v.Args[0] - v.Op = OpAMD64MOVWQSX - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64NEGW, TypeInvalid) - v0.Type = v.Type - v0.AddArg(x) - v.AddArg(v0) - return true - } - goto end089988d857b555c3065177bcad1eface - end089988d857b555c3065177bcad1eface: - ; - case OpNeg16U: - // match: (Neg16U x) - // cond: // result: (NEGW x) { x := v.Args[0] @@ -1873,31 +1652,12 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(x) return true } - goto end8f43be5b376227e92d70b382bded232b - end8f43be5b376227e92d70b382bded232b: + goto end7a8c652f4ffeb49656119af69512edb2 + end7a8c652f4ffeb49656119af69512edb2: ; case OpNeg32: // match: (Neg32 x) // cond: - // result: (MOVLQSX (NEGL x)) - { - x := v.Args[0] - v.Op = OpAMD64MOVLQSX - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64NEGL, TypeInvalid) - v0.Type = v.Type - v0.AddArg(x) - v.AddArg(v0) - return true - } - goto end2217d3f168126b2ee157cb33befba76d - end2217d3f168126b2ee157cb33befba76d: - ; - case OpNeg32U: - // match: (Neg32U x) - // cond: // result: (NEGL x) { x := v.Args[0] @@ -1908,8 +1668,8 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(x) return true } - goto end1fe0112076c436ffceabac066776cd18 - end1fe0112076c436ffceabac066776cd18: + goto endce1f7e17fc193f6c076e47d5e401e126 + endce1f7e17fc193f6c076e47d5e401e126: ; case OpNeg64: // match: (Neg64 x) @@ -1927,44 +1687,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto enda06c5b1718f2b96aba10bf5a5c437c6c enda06c5b1718f2b96aba10bf5a5c437c6c: ; - case OpNeg64U: - // match: (Neg64U x) - // cond: - // result: (NEGQ x) - { - x := v.Args[0] - v.Op = OpAMD64NEGQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto endbc6beca972ff7f28273a1cdd146e3959 - endbc6beca972ff7f28273a1cdd146e3959: - ; case OpNeg8: // match: (Neg8 x) // cond: - // result: (MOVBQSX (NEGB x)) - { - x := v.Args[0] - v.Op = OpAMD64MOVBQSX - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64NEGB, TypeInvalid) - v0.Type = v.Type - v0.AddArg(x) - v.AddArg(v0) - return true - } - goto end9cfacf0b7d826b85041092625ed494c1 - end9cfacf0b7d826b85041092625ed494c1: - ; - case OpNeg8U: - // match: (Neg8U x) - // cond: // result: (NEGB x) { x := v.Args[0] @@ -1975,8 +1700,8 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(x) return true } - goto enda1ffb93a68702148c5fd18e2b72964d0 - enda1ffb93a68702148c5fd18e2b72964d0: + goto end1e5f495a2ac6cdea47b1ae5ba62aa95d + end1e5f495a2ac6cdea47b1ae5ba62aa95d: ; case OpNeq16: // match: (Neq16 x y) @@ -2120,12 +1845,15 @@ func rewriteValueAMD64(v *Value, config *Config) bool { ; case OpRsh64: // match: (Rsh64 x y) - // cond: + // cond: y.Type.Size() == 8 // result: (SARQ x (CMOVQCC (CMPQconst [64] y) (Const [63]) y)) { t := v.Type x := v.Args[0] y := v.Args[1] + if !(y.Type.Size() == 8) { + goto end16bda9bd1611d415969fdbec55ed4330 + } v.Op = OpAMD64SARQ v.AuxInt = 0 v.Aux = nil @@ -2147,17 +1875,20 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end831ac9db492245c5e6c83d0b2a96b2d3 - end831ac9db492245c5e6c83d0b2a96b2d3: + goto end16bda9bd1611d415969fdbec55ed4330 + end16bda9bd1611d415969fdbec55ed4330: ; case OpRsh64U: // match: (Rsh64U x y) - // cond: + // cond: y.Type.Size() == 8 // result: (ANDQ (SHRQ x y) (SBBQcarrymask (CMPQconst [64] y))) { t := v.Type x := v.Args[0] y := v.Args[1] + if !(y.Type.Size() == 8) { + goto endfd6815c0dc9f8dff6c3ec6add7a23569 + } v.Op = OpAMD64ANDQ v.AuxInt = 0 v.Aux = nil @@ -2177,8 +1908,8 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto end90c34fa7de598170ea23d23d9a03ebfc - end90c34fa7de598170ea23d23d9a03ebfc: + goto endfd6815c0dc9f8dff6c3ec6add7a23569 + endfd6815c0dc9f8dff6c3ec6add7a23569: ; case OpAMD64SARQ: // match: (SARQ x (MOVQconst [c])) @@ -2377,6 +2108,102 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end78e66b6fc298684ff4ac8aec5ce873c9 end78e66b6fc298684ff4ac8aec5ce873c9: ; + case OpSignExt16to32: + // match: (SignExt16to32 x) + // cond: + // result: (MOVWQSX x) + { + x := v.Args[0] + v.Op = OpAMD64MOVWQSX + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end21e4271c2b48a5aa3561ccfa8fa67cd9 + end21e4271c2b48a5aa3561ccfa8fa67cd9: + ; + case OpSignExt16to64: + // match: (SignExt16to64 x) + // cond: + // result: (MOVWQSX x) + { + x := v.Args[0] + v.Op = OpAMD64MOVWQSX + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto endc6d242ee3a3e195ef0f9e8dae47ada75 + endc6d242ee3a3e195ef0f9e8dae47ada75: + ; + case OpSignExt32to64: + // match: (SignExt32to64 x) + // cond: + // result: (MOVLQSX x) + { + x := v.Args[0] + v.Op = OpAMD64MOVLQSX + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto endb9f1a8b2d01eee44964a71a01bca165c + endb9f1a8b2d01eee44964a71a01bca165c: + ; + case OpSignExt8to16: + // match: (SignExt8to16 x) + // cond: + // result: (MOVBQSX x) + { + x := v.Args[0] + v.Op = OpAMD64MOVBQSX + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end372869f08e147404b80634e5f83fd506 + end372869f08e147404b80634e5f83fd506: + ; + case OpSignExt8to32: + // match: (SignExt8to32 x) + // cond: + // result: (MOVBQSX x) + { + x := v.Args[0] + v.Op = OpAMD64MOVBQSX + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end913e3575e5b4cf7f60585c108db40464 + end913e3575e5b4cf7f60585c108db40464: + ; + case OpSignExt8to64: + // match: (SignExt8to64 x) + // cond: + // result: (MOVBQSX x) + { + x := v.Args[0] + v.Op = OpAMD64MOVBQSX + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto endcef6d6001d3f25cf5dacee11a46e5c8c + endcef6d6001d3f25cf5dacee11a46e5c8c: + ; case OpStaticCall: // match: (StaticCall [argwid] {target} mem) // cond: @@ -2511,32 +2338,29 @@ func rewriteValueAMD64(v *Value, config *Config) bool { case OpSub16: // match: (Sub16 x y) // cond: - // result: (MOVWQSX (SUBW x y)) + // result: (SUBW x y) { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64MOVWQSX + v.Op = OpAMD64SUBW v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64SUBW, TypeInvalid) - v0.Type = v.Type - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) + v.AddArg(x) + v.AddArg(y) return true } - goto endf9d14f07ce4212200662acd073b77a79 - endf9d14f07ce4212200662acd073b77a79: + goto end54adc5de883c0460ca71c6ee464d4244 + end54adc5de883c0460ca71c6ee464d4244: ; - case OpSub16U: - // match: (Sub16U x y) + case OpSub32: + // match: (Sub32 x y) // cond: - // result: (SUBW x y) + // result: (SUBL x y) { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SUBW + v.Op = OpAMD64SUBL v.AuxInt = 0 v.Aux = nil v.resetArgs() @@ -2544,38 +2368,35 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(y) return true } - goto end1d72e18fad1c22bb770963f167b98c96 - end1d72e18fad1c22bb770963f167b98c96: + goto enddc3a2a488bda8c5856f93343e5ffe5f8 + enddc3a2a488bda8c5856f93343e5ffe5f8: ; - case OpSub32: - // match: (Sub32 x y) + case OpSub64: + // match: (Sub64 x y) // cond: - // result: (MOVLQSX (SUBL x y)) + // result: (SUBQ x y) { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64MOVLQSX + v.Op = OpAMD64SUBQ v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64SUBL, TypeInvalid) - v0.Type = v.Type - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) + v.AddArg(x) + v.AddArg(y) return true } - goto end4c091fbf93fb9599a70c001845424614 - end4c091fbf93fb9599a70c001845424614: + goto endd88d5646309fd9174584888ecc8aca2c + endd88d5646309fd9174584888ecc8aca2c: ; - case OpSub32U: - // match: (Sub32U x y) + case OpSub8: + // match: (Sub8 x y) // cond: - // result: (SUBL x y) + // result: (SUBB x y) { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SUBL + v.Op = OpAMD64SUBB v.AuxInt = 0 v.Aux = nil v.resetArgs() @@ -2583,83 +2404,104 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(y) return true } - goto end281d1020f0e75fce9df321580f07c4d5 - end281d1020f0e75fce9df321580f07c4d5: + goto end7d33bf9bdfa505f96b930563eca7955f + end7d33bf9bdfa505f96b930563eca7955f: ; - case OpSub64: - // match: (Sub64 x y) + case OpTrunc16to8: + // match: (Trunc16to8 x) // cond: - // result: (SUBQ x y) + // result: (Copy x) { x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SUBQ + v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AddArg(x) - v.AddArg(y) return true } - goto endd88d5646309fd9174584888ecc8aca2c - endd88d5646309fd9174584888ecc8aca2c: + goto end18a19bd8418f9079595720df0874e90a + end18a19bd8418f9079595720df0874e90a: ; - case OpSub64U: - // match: (Sub64U x y) + case OpTrunc32to16: + // match: (Trunc32to16 x) // cond: - // result: (SUBQ x y) + // result: (Copy x) { x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SUBQ + v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AddArg(x) - v.AddArg(y) return true } - goto end288f94a53865cdb00a0290d8358bb7da - end288f94a53865cdb00a0290d8358bb7da: + goto end217b00780a8b1139d068680ed9d61cb0 + end217b00780a8b1139d068680ed9d61cb0: ; - case OpSub8: - // match: (Sub8 x y) + case OpTrunc32to8: + // match: (Trunc32to8 x) // cond: - // result: (MOVBQSX (SUBB x y)) + // result: (Copy x) { x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64MOVBQSX + v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64SUBB, TypeInvalid) - v0.Type = v.Type - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) + v.AddArg(x) return true } - goto endfa3ef95107dcb01ae343f2243e485e80 - endfa3ef95107dcb01ae343f2243e485e80: + goto end05d10e0a1c707d66b11b2d342634efd0 + end05d10e0a1c707d66b11b2d342634efd0: ; - case OpSub8U: - // match: (Sub8U x y) + case OpTrunc64to16: + // match: (Trunc64to16 x) // cond: - // result: (SUBB x y) + // result: (Copy x) { x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SUBB + v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AddArg(x) - v.AddArg(y) return true } - goto end8f5160f898dfa43da7d7d9f8cbaf9615 - end8f5160f898dfa43da7d7d9f8cbaf9615: + goto end4623ae65eb76feca3936354f22d45fa7 + end4623ae65eb76feca3936354f22d45fa7: + ; + case OpTrunc64to32: + // match: (Trunc64to32 x) + // cond: + // result: (Copy x) + { + x := v.Args[0] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end93e0b16b58a717a3e4f5c2ca67b6be87 + end93e0b16b58a717a3e4f5c2ca67b6be87: + ; + case OpTrunc64to8: + // match: (Trunc64to8 x) + // cond: + // result: (Copy x) + { + x := v.Args[0] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto endc4c1a1b86edd0f082339d17eb5096ad0 + endc4c1a1b86edd0f082339d17eb5096ad0: ; case OpZero: // match: (Zero [0] _ mem) @@ -2831,6 +2673,102 @@ func rewriteValueAMD64(v *Value, config *Config) bool { } goto end7a358169d20d6834b21f2e03fbf351b2 end7a358169d20d6834b21f2e03fbf351b2: + ; + case OpZeroExt16to32: + // match: (ZeroExt16to32 x) + // cond: + // result: (MOVWQZX x) + { + x := v.Args[0] + v.Op = OpAMD64MOVWQZX + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto endbfff79412a2cc96095069c66812844b4 + endbfff79412a2cc96095069c66812844b4: + ; + case OpZeroExt16to64: + // match: (ZeroExt16to64 x) + // cond: + // result: (MOVWQZX x) + { + x := v.Args[0] + v.Op = OpAMD64MOVWQZX + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end7a40262c5c856101058d2bd518ed0910 + end7a40262c5c856101058d2bd518ed0910: + ; + case OpZeroExt32to64: + // match: (ZeroExt32to64 x) + // cond: + // result: (MOVLQZX x) + { + x := v.Args[0] + v.Op = OpAMD64MOVLQZX + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto enddf83bdc8cc6c5673a9ef7aca7affe45a + enddf83bdc8cc6c5673a9ef7aca7affe45a: + ; + case OpZeroExt8to16: + // match: (ZeroExt8to16 x) + // cond: + // result: (MOVBQZX x) + { + x := v.Args[0] + v.Op = OpAMD64MOVBQZX + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto endd03d53d2a585727e4107ae1a3cc55479 + endd03d53d2a585727e4107ae1a3cc55479: + ; + case OpZeroExt8to32: + // match: (ZeroExt8to32 x) + // cond: + // result: (MOVBQZX x) + { + x := v.Args[0] + v.Op = OpAMD64MOVBQZX + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto endcbd33e965b3dab14fced5ae93d8949de + endcbd33e965b3dab14fced5ae93d8949de: + ; + case OpZeroExt8to64: + // match: (ZeroExt8to64 x) + // cond: + // result: (MOVBQZX x) + { + x := v.Args[0] + v.Op = OpAMD64MOVBQZX + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end63ae7cc15db9d15189b2f1342604b2cb + end63ae7cc15db9d15189b2f1342604b2cb: } return false } diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index 976fbc94a0..2c2a48693a 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -27,29 +27,6 @@ func rewriteValuegeneric(v *Value, config *Config) bool { goto endd2f4bfaaf6c937171a287b73e5c2f73e endd2f4bfaaf6c937171a287b73e5c2f73e: ; - case OpAdd64U: - // match: (Add64U (Const [c]) (Const [d])) - // cond: - // result: (Const [c+d]) - { - if v.Args[0].Op != OpConst { - goto endfedc373d8be0243cb5dbbc948996fe3a - } - c := v.Args[0].AuxInt - if v.Args[1].Op != OpConst { - goto endfedc373d8be0243cb5dbbc948996fe3a - } - d := v.Args[1].AuxInt - v.Op = OpConst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c + d - return true - } - goto endfedc373d8be0243cb5dbbc948996fe3a - endfedc373d8be0243cb5dbbc948996fe3a: - ; case OpAddPtr: // match: (AddPtr (Const [c]) (Const [d])) // cond: @@ -261,29 +238,6 @@ func rewriteValuegeneric(v *Value, config *Config) bool { goto endf4ba5346dc8a624781afaa68a8096a9a endf4ba5346dc8a624781afaa68a8096a9a: ; - case OpMul64U: - // match: (Mul64U (Const [c]) (Const [d])) - // cond: - // result: (Const [c*d]) - { - if v.Args[0].Op != OpConst { - goto end88b6638d23b281a90172e80ab26549cb - } - c := v.Args[0].AuxInt - if v.Args[1].Op != OpConst { - goto end88b6638d23b281a90172e80ab26549cb - } - d := v.Args[1].AuxInt - v.Op = OpConst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c * d - return true - } - goto end88b6638d23b281a90172e80ab26549cb - end88b6638d23b281a90172e80ab26549cb: - ; case OpMulPtr: // match: (MulPtr (Const [c]) (Const [d])) // cond: -- cgit v1.3 From 6b41665039e278a83823051b44628e25415b0205 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Tue, 28 Jul 2015 10:56:39 -0700 Subject: [dev.ssa] cmd/compile: implement static data generation The existing backend recognizes special assignment statements as being implementable with static data rather than code. Unfortunately, it assumes that it is in the middle of codegen; it emits data and modifies the AST. This does not play well with SSA's two-phase bootstrapping approach, in which we attempt to compile code but fall back to the existing backend if something goes wrong. To work around this: * Add the ability to inquire about static data without side-effects. * Save the static data required for a function. * Emit that static data during SSA codegen. Change-Id: I2e8a506c866ea3e27dffb597095833c87f62d87e Reviewed-on: https://go-review.googlesource.com/12790 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/gen.go | 2 +- src/cmd/compile/internal/gc/sinit.go | 39 ++++++++++++++++++++++++------------ src/cmd/compile/internal/gc/ssa.go | 20 ++++++++++++++++++ src/cmd/compile/internal/ssa/func.go | 15 +++++++------- 4 files changed, 55 insertions(+), 21 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/gen.go b/src/cmd/compile/internal/gc/gen.go index 6390818e16..4ff4f7a2c8 100644 --- a/src/cmd/compile/internal/gc/gen.go +++ b/src/cmd/compile/internal/gc/gen.go @@ -853,7 +853,7 @@ func gen(n *Node) { 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/sinit.go b/src/cmd/compile/internal/gc/sinit.go index 7875d16380..099c10a8bc 100644 --- a/src/cmd/compile/internal/gc/sinit.go +++ b/src/cmd/compile/internal/gc/sinit.go @@ -1236,6 +1236,7 @@ func getlit(lit *Node) int { 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 @@ -1408,7 +1409,9 @@ func entry(p *InitPlan) *InitEntry { 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 @@ -1457,7 +1460,9 @@ func gen_as_init(n *Node) bool { 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 + if !reportOnly { + gused(nil) // in case the data is the dest of a goto + } nl := nr if nr == nil || nr.Op != OADDR { goto no @@ -1472,16 +1477,18 @@ func gen_as_init(n *Node) bool { 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 } @@ -1512,13 +1519,19 @@ func gen_as_init(n *Node) bool { 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 index b6b345f205..29b6a141a5 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -462,6 +462,17 @@ func (s *state) stmt(n *Node) { addEdge(b, 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 + } s.assign(n.Op, n.Left, n.Right) case OIF: @@ -1484,6 +1495,15 @@ func genssa(f *ssa.Func, ptxt *obj.Prog, gcargs, gclocals *Sym) { Pc.As = obj.ARET // overwrite AEND + // Emit static data + if f.StaticData != nil { + for _, n := range f.StaticData.([]*Node) { + if !gen_as_init(n, false) { + Fatal("non-static data marked as static: %v\n\n", n, f) + } + } + } + // TODO: liveness // TODO: gcargs // TODO: gclocals diff --git a/src/cmd/compile/internal/ssa/func.go b/src/cmd/compile/internal/ssa/func.go index 34d2780104..e0f7c9ff60 100644 --- a/src/cmd/compile/internal/ssa/func.go +++ b/src/cmd/compile/internal/ssa/func.go @@ -9,13 +9,14 @@ import "sync" // 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 - Name string // e.g. bytes·Compare - Type Type // type signature of the function. - 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 + Config *Config // architecture information + 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 // when register allocation is done, maps value ids to locations RegAlloc []Location -- cgit v1.3 From 67df7934cc9f11a31395e2ade1d6c332aab67e23 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Tue, 28 Jul 2015 11:08:44 -0700 Subject: [dev.ssa] cmd/compile: respect Xoffset of static data Together with teaching SSA to generate static data, this fixes the encoding/pem and hash/adler32 tests. Change-Id: I75f81f6c995dcb9c6d99bd3acda94a4feea8b87b Reviewed-on: https://go-review.googlesource.com/12791 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 29b6a141a5..c33c1224f1 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1161,7 +1161,12 @@ func (s *state) addr(n *Node) *ssa.Value { case PEXTERN: // global variable aux := &ssa.ExternSymbol{n.Type, n.Sym} - return s.entryNewValue1A(ssa.OpAddr, Ptrto(n.Type), aux, s.sb) + v := s.entryNewValue1A(ssa.OpAddr, Ptrto(n.Type), 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, PPARAMOUT, PAUTO: // parameter/result slot or local variable v := s.decladdrs[n] -- cgit v1.3 From 3e3d162f50e4677f08a44c3955090c27998224e6 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Mon, 27 Jul 2015 16:36:36 -0700 Subject: [dev.ssa] cmd/compile: implement genValue for MOVQstoreidx8 Change-Id: I6b13a26e01ef8739ed60e6fd5f5c1ea045bea581 Reviewed-on: https://go-review.googlesource.com/12793 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 9 +++++++++ src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 24 ++++++++++++------------ src/cmd/compile/internal/ssa/opGen.go | 1 + 3 files changed, 22 insertions(+), 12 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index c33c1224f1..e435850b47 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1749,6 +1749,15 @@ func genValue(v *ssa.Value) { p.To.Type = obj.TYPE_MEM p.To.Reg = regnum(v.Args[0]) addAux(&p.To, v) + case ssa.OpAMD64MOVQstoreidx8: + p := Prog(x86.AMOVQ) + 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.OpAMD64MOVLQSX, ssa.OpAMD64MOVWQSX, ssa.OpAMD64MOVBQSX, ssa.OpAMD64MOVLQZX, ssa.OpAMD64MOVWQZX, ssa.OpAMD64MOVBQZX: p := Prog(v.Op.Asm()) p.From.Type = obj.TYPE_REG diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 64095c5654..9b5c302217 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -145,18 +145,18 @@ func init() { {name: "LEAQ4", reg: gp21sb}, // arg0 + 4*arg1 + auxint {name: "LEAQ8", reg: gp21sb}, // arg0 + 8*arg1 + auxint - {name: "MOVBload", reg: gpload, asm: "MOVB"}, // load byte from arg0+auxint. arg1=mem - {name: "MOVBQSXload", reg: gpload, asm: "MOVBQSX"}, // ditto, extend to int64 - {name: "MOVBQZXload", reg: gpload, asm: "MOVBQZX"}, // ditto, extend to uint64 - {name: "MOVWload", reg: gpload, asm: "MOVW"}, // load 2 bytes from arg0+auxint. arg1=mem - {name: "MOVLload", reg: gpload, asm: "MOVL"}, // load 4 bytes from arg0+auxint. arg1=mem - {name: "MOVQload", reg: gpload, asm: "MOVQ"}, // load 8 bytes from arg0+auxint. arg1=mem - {name: "MOVQloadidx8", reg: gploadidx, asm: "MOVQ"}, // load 8 bytes from arg0+8*arg1+auxint. arg2=mem - {name: "MOVBstore", reg: gpstore, asm: "MOVB"}, // store byte in arg1 to arg0+auxint. arg2=mem - {name: "MOVWstore", reg: gpstore, asm: "MOVW"}, // store 2 bytes in arg1 to arg0+auxint. arg2=mem - {name: "MOVLstore", reg: gpstore, asm: "MOVL"}, // store 4 bytes in arg1 to arg0+auxint. arg2=mem - {name: "MOVQstore", reg: gpstore, asm: "MOVQ"}, // store 8 bytes in arg1 to arg0+auxint. arg2=mem - {name: "MOVQstoreidx8", reg: gpstoreidx}, // store 8 bytes in arg2 to arg0+8*arg1+auxint. arg3=mem + {name: "MOVBload", reg: gpload, asm: "MOVB"}, // load byte from arg0+auxint. arg1=mem + {name: "MOVBQSXload", reg: gpload, asm: "MOVBQSX"}, // ditto, extend to int64 + {name: "MOVBQZXload", reg: gpload, asm: "MOVBQZX"}, // ditto, extend to uint64 + {name: "MOVWload", reg: gpload, asm: "MOVW"}, // load 2 bytes from arg0+auxint. arg1=mem + {name: "MOVLload", reg: gpload, asm: "MOVL"}, // load 4 bytes from arg0+auxint. arg1=mem + {name: "MOVQload", reg: gpload, asm: "MOVQ"}, // load 8 bytes from arg0+auxint. arg1=mem + {name: "MOVQloadidx8", reg: gploadidx, asm: "MOVQ"}, // load 8 bytes from arg0+8*arg1+auxint. arg2=mem + {name: "MOVBstore", reg: gpstore, asm: "MOVB"}, // store byte in arg1 to arg0+auxint. arg2=mem + {name: "MOVWstore", reg: gpstore, asm: "MOVW"}, // store 2 bytes in arg1 to arg0+auxint. arg2=mem + {name: "MOVLstore", reg: gpstore, asm: "MOVL"}, // store 4 bytes in arg1 to arg0+auxint. arg2=mem + {name: "MOVQstore", reg: gpstore, asm: "MOVQ"}, // store 8 bytes in arg1 to arg0+auxint. arg2=mem + {name: "MOVQstoreidx8", reg: gpstoreidx, asm: "MOVQ"}, // store 8 bytes in arg2 to arg0+8*arg1+auxint. arg3=mem {name: "MOVXzero", reg: gpstoreconst}, // store auxint 0 bytes into arg0 using a series of MOV instructions. arg1=mem. // TODO: implement this when register clobbering works diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 532c0558e0..0d56e647af 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -890,6 +890,7 @@ var opcodeTable = [...]opInfo{ }, { name: "MOVQstoreidx8", + asm: x86.AMOVQ, reg: regInfo{ inputs: []regMask{ 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB -- cgit v1.3 From 71a4c4bb8d20e2ea7f4aa9f34b2a3c833de372f8 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Mon, 27 Jul 2015 16:37:22 -0700 Subject: [dev.ssa] cmd/compile: finish InvertFlags rewrites Change-Id: I61b2d2be18f905a17e8ee765a4494b763a425c55 Reviewed-on: https://go-review.googlesource.com/12794 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/gen/AMD64.rules | 8 ++ src/cmd/compile/internal/ssa/rewriteAMD64.go | 152 +++++++++++++++++++++++++++ 2 files changed, 160 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 0be4d7d22b..d881aaa693 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -180,6 +180,14 @@ // 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 (MOVBQSX (MOVBload ptr mem)) -> (MOVBQSXload ptr mem) diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 038275d21b..c21f3ab7a7 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -1983,6 +1983,101 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end4157ddea9c4f71bfabfd6fa50e1208ed end4157ddea9c4f71bfabfd6fa50e1208ed: ; + case OpAMD64SETA: + // match: (SETA (InvertFlags x)) + // cond: + // result: (SETB x) + { + if v.Args[0].Op != OpAMD64InvertFlags { + goto enda4ac36e94fc279d762b5a6c7c6cc665d + } + x := v.Args[0].Args[0] + v.Op = OpAMD64SETB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto enda4ac36e94fc279d762b5a6c7c6cc665d + enda4ac36e94fc279d762b5a6c7c6cc665d: + ; + case OpAMD64SETAE: + // match: (SETAE (InvertFlags x)) + // cond: + // result: (SETBE x) + { + if v.Args[0].Op != OpAMD64InvertFlags { + goto end0468f5be6caf682fdea6b91d6648991e + } + x := v.Args[0].Args[0] + v.Op = OpAMD64SETBE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end0468f5be6caf682fdea6b91d6648991e + end0468f5be6caf682fdea6b91d6648991e: + ; + case OpAMD64SETB: + // match: (SETB (InvertFlags x)) + // cond: + // result: (SETA x) + { + if v.Args[0].Op != OpAMD64InvertFlags { + goto endc9eba7aa1e54a228570d2f5cc96f3565 + } + x := v.Args[0].Args[0] + v.Op = OpAMD64SETA + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto endc9eba7aa1e54a228570d2f5cc96f3565 + endc9eba7aa1e54a228570d2f5cc96f3565: + ; + case OpAMD64SETBE: + // match: (SETBE (InvertFlags x)) + // cond: + // result: (SETAE x) + { + if v.Args[0].Op != OpAMD64InvertFlags { + goto end9d9031643469798b14b8cad1f5a7a1ba + } + x := v.Args[0].Args[0] + v.Op = OpAMD64SETAE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end9d9031643469798b14b8cad1f5a7a1ba + end9d9031643469798b14b8cad1f5a7a1ba: + ; + case OpAMD64SETEQ: + // match: (SETEQ (InvertFlags x)) + // cond: + // result: (SETEQ x) + { + if v.Args[0].Op != OpAMD64InvertFlags { + goto end5d2039c9368d8c0cfba23b5a85b459e1 + } + x := v.Args[0].Args[0] + v.Op = OpAMD64SETEQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end5d2039c9368d8c0cfba23b5a85b459e1 + end5d2039c9368d8c0cfba23b5a85b459e1: + ; case OpAMD64SETG: // match: (SETG (InvertFlags x)) // cond: @@ -2002,6 +2097,25 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endf7586738694c9cd0b74ae28bbadb649f endf7586738694c9cd0b74ae28bbadb649f: ; + case OpAMD64SETGE: + // match: (SETGE (InvertFlags x)) + // cond: + // result: (SETLE x) + { + if v.Args[0].Op != OpAMD64InvertFlags { + goto end82c11eff6f842159f564f2dad3d2eedc + } + x := v.Args[0].Args[0] + v.Op = OpAMD64SETLE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end82c11eff6f842159f564f2dad3d2eedc + end82c11eff6f842159f564f2dad3d2eedc: + ; case OpAMD64SETL: // match: (SETL (InvertFlags x)) // cond: @@ -2021,6 +2135,44 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto ende33160cd86b9d4d3b77e02fb4658d5d3 ende33160cd86b9d4d3b77e02fb4658d5d3: ; + case OpAMD64SETLE: + // match: (SETLE (InvertFlags x)) + // cond: + // result: (SETGE x) + { + if v.Args[0].Op != OpAMD64InvertFlags { + goto end9307d96753efbeb888d1c98a6aba7a29 + } + x := v.Args[0].Args[0] + v.Op = OpAMD64SETGE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end9307d96753efbeb888d1c98a6aba7a29 + end9307d96753efbeb888d1c98a6aba7a29: + ; + case OpAMD64SETNE: + // match: (SETNE (InvertFlags x)) + // cond: + // result: (SETNE x) + { + if v.Args[0].Op != OpAMD64InvertFlags { + goto endbc71811b789475308014550f638026eb + } + x := v.Args[0].Args[0] + v.Op = OpAMD64SETNE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto endbc71811b789475308014550f638026eb + endbc71811b789475308014550f638026eb: + ; case OpAMD64SHLQ: // match: (SHLQ x (MOVQconst [c])) // cond: -- cgit v1.3 From 25d1916816c7fae4049b47efdc5fde37ce4a9be1 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Tue, 28 Jul 2015 12:37:46 -0700 Subject: [dev.ssa] cmd/compile: implement OINDREG in expr context Change-Id: I1922656c99773255e5bc15b5a2bd79f19a2fe82c Reviewed-on: https://go-review.googlesource.com/12796 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index e435850b47..6866f4942e 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1000,6 +1000,14 @@ func (s *state) expr(n *Node) *ssa.Value { case OADDR: return s.addr(n.Left) + 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) @@ -1184,8 +1192,12 @@ func (s *state) addr(n *Node) *ssa.Value { return nil } case OINDREG: - // indirect off a register (TODO: always SP?) + // 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, Ptrto(n.Type), n.Xoffset, s.sp) case OINDEX: if n.Left.Type.IsSlice() { -- cgit v1.3 From 9cb332efd445a7e0672b96f9bc703c93f02879a5 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Tue, 28 Jul 2015 14:19:20 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: Split OpConst into an OpConst8, OpConst16, ... Convert the polymorphic OpConst into monomorphic variants. Change-Id: I90bb8894fbac04ca5e5484ea260c131ef8b506fb Reviewed-on: https://go-review.googlesource.com/12798 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/gc/ssa.go | 124 +++++++++++--- src/cmd/compile/internal/ssa/deadcode_test.go | 8 +- src/cmd/compile/internal/ssa/deadstore_test.go | 6 +- src/cmd/compile/internal/ssa/dom_test.go | 28 +-- src/cmd/compile/internal/ssa/func.go | 20 ++- src/cmd/compile/internal/ssa/func_test.go | 46 ++--- src/cmd/compile/internal/ssa/gen/AMD64.rules | 30 ++-- src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 16 +- src/cmd/compile/internal/ssa/gen/generic.rules | 30 ++-- src/cmd/compile/internal/ssa/gen/genericOps.go | 10 +- src/cmd/compile/internal/ssa/gen/rulegen.go | 3 + src/cmd/compile/internal/ssa/opGen.go | 70 +++++++- src/cmd/compile/internal/ssa/rewriteAMD64.go | 226 ++++++++++++++++--------- src/cmd/compile/internal/ssa/rewritegeneric.go | 218 ++++++++++++------------ src/cmd/compile/internal/ssa/schedule_test.go | 4 +- src/cmd/compile/internal/ssa/shift_test.go | 2 +- 16 files changed, 537 insertions(+), 304 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 6866f4942e..e26412cf46 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -347,9 +347,33 @@ func (s *state) entryNewValue2(op ssa.Op, t ssa.Type, arg0, arg1 *ssa.Value) *ss return s.f.Entry.NewValue2(s.peekLine(), op, t, arg0, arg1) } -// constInt adds a new const int value to the entry block. +// constInt* routines add a new const int value to the entry block. +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) constIntPtr(t ssa.Type, c int64) *ssa.Value { + if s.config.PtrSize == 4 && int64(int32(c)) != c { + s.Fatalf("pointer constant too big %d", c) + } + return s.f.ConstIntPtr(s.peekLine(), t, c) +} func (s *state) constInt(t ssa.Type, c int64) *ssa.Value { - return s.f.ConstInt(s.peekLine(), t, c) + 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)) } // ssaStmtList converts the statement n to SSA and adds it to s. @@ -584,7 +608,7 @@ func (s *state) stmt(n *Node) { if n.Left != nil { cond = s.expr(n.Left) } else { - cond = s.entryNewValue0A(ssa.OpConst, Types[TBOOL], true) + cond = s.entryNewValue0A(ssa.OpConstBool, Types[TBOOL], true) } b = s.endBlock() b.Kind = ssa.BlockIf @@ -862,11 +886,26 @@ func (s *state) expr(n *Node) *ssa.Value { case OLITERAL: switch n.Val().Ctype() { case CTINT: - return s.constInt(n.Type, Mpgetfix(n.Val().U.(*Mpint))) - case CTSTR, CTBOOL: - return s.entryNewValue0A(ssa.OpConst, n.Type, n.Val().U) + 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: + return s.entryNewValue0A(ssa.OpConstBool, n.Type, n.Val().U) case CTNIL: - return s.entryNewValue0(ssa.OpConst, n.Type) + return s.entryNewValue0(ssa.OpConstNil, n.Type) default: s.Unimplementedf("unhandled OLITERAL %v", n.Val().Ctype()) return nil @@ -1020,7 +1059,7 @@ func (s *state) expr(n *Node) *ssa.Value { case ODOTPTR: p := s.expr(n.Left) s.nilCheck(p) - p = s.newValue2(ssa.OpAddPtr, p.Type, p, s.constInt(s.config.Uintptr, n.Xoffset)) + p = s.newValue2(ssa.OpAddPtr, p.Type, p, s.constIntPtr(s.config.Uintptr, n.Xoffset)) return s.newValue2(ssa.OpLoad, n.Type, p, s.mem()) case OINDEX: @@ -1031,10 +1070,10 @@ func (s *state) expr(n *Node) *ssa.Value { var elemtype *Type var len *ssa.Value if n.Left.Type.IsString() { - len = s.newValue1(ssa.OpStringLen, s.config.Uintptr, a) + len = s.newValue1(ssa.OpStringLen, s.config.Int, a) elemtype = Types[TUINT8] } else { - len = s.constInt(s.config.Uintptr, n.Left.Type.Bound) + len = s.constInt(s.config.Int, n.Left.Type.Bound) elemtype = n.Left.Type.Type } s.boundsCheck(i, len) @@ -1149,12 +1188,25 @@ func (s *state) assign(op uint8, left *Node, right *Node) { // 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.IsString(): - return s.entryNewValue0A(ssa.OpConst, t, "") - case t.IsInteger() || t.IsPtr(): - return s.entryNewValue0(ssa.OpConst, t) + return s.entryNewValue0A(ssa.OpConstString, t, "") + case t.IsPtr(): + return s.entryNewValue0(ssa.OpConstNil, t) case t.IsBoolean(): - return s.entryNewValue0A(ssa.OpConst, t, false) // TODO: store bools as 0/1 in AuxInt? + return s.entryNewValue0A(ssa.OpConstBool, t, false) // TODO: store bools as 0/1 in AuxInt? } s.Unimplementedf("zero for type %v not implemented", t) return nil @@ -1212,7 +1264,7 @@ func (s *state) addr(n *Node) *ssa.Value { a := s.addr(n.Left) i := s.expr(n.Right) i = s.extendIndex(i) - len := s.constInt(s.config.Uintptr, n.Left.Type.Bound) + len := s.constInt(s.config.Int, n.Left.Type.Bound) s.boundsCheck(i, len) return s.newValue2(ssa.OpPtrIndex, Ptrto(n.Left.Type.Type), a, i) } @@ -1222,11 +1274,11 @@ func (s *state) addr(n *Node) *ssa.Value { return p case ODOT: p := s.addr(n.Left) - return s.newValue2(ssa.OpAddPtr, p.Type, p, s.constInt(s.config.Uintptr, n.Xoffset)) + return s.newValue2(ssa.OpAddPtr, p.Type, p, s.constIntPtr(s.config.Uintptr, n.Xoffset)) case ODOTPTR: p := s.expr(n.Left) s.nilCheck(p) - return s.newValue2(ssa.OpAddPtr, p.Type, p, s.constInt(s.config.Uintptr, n.Xoffset)) + return s.newValue2(ssa.OpAddPtr, p.Type, p, s.constIntPtr(s.config.Uintptr, n.Xoffset)) default: s.Unimplementedf("addr: bad op %v", Oconv(int(n.Op), 0)) return nil @@ -1570,7 +1622,7 @@ func genValue(v *ssa.Value) { x := regnum(v.Args[0]) y := regnum(v.Args[1]) if x != r && y != r { - p := Prog(x86.AMOVQ) + p := Prog(regMoveAMD64(v.Type.Size())) p.From.Type = obj.TYPE_REG p.From.Reg = x p.To.Type = obj.TYPE_REG @@ -1731,11 +1783,22 @@ func genValue(v *ssa.Value) { p.From.Reg = regnum(v.Args[0]) p.To.Type = obj.TYPE_CONST p.To.Offset = v.AuxInt - case ssa.OpAMD64MOVQconst: + case ssa.OpAMD64MOVBconst, ssa.OpAMD64MOVWconst, ssa.OpAMD64MOVLconst, ssa.OpAMD64MOVQconst: x := regnum(v) - p := Prog(x86.AMOVQ) + p := Prog(v.Op.Asm()) p.From.Type = obj.TYPE_CONST - p.From.Offset = v.AuxInt + var i int64 + switch v.Op { + case ssa.OpAMD64MOVBconst: + i = int64(int8(v.AuxInt)) + case ssa.OpAMD64MOVWconst: + i = int64(int16(v.AuxInt)) + case ssa.OpAMD64MOVLconst: + i = int64(int32(v.AuxInt)) + case ssa.OpAMD64MOVQconst: + i = v.AuxInt + } + p.From.Offset = i p.To.Type = obj.TYPE_REG p.To.Reg = x case ssa.OpAMD64MOVQload, ssa.OpAMD64MOVLload, ssa.OpAMD64MOVWload, ssa.OpAMD64MOVBload, ssa.OpAMD64MOVBQSXload, ssa.OpAMD64MOVBQZXload: @@ -1836,7 +1899,7 @@ func genValue(v *ssa.Value) { v.Fatalf("phi arg at different location than phi %v %v %v %v", v, loc, a, f.RegAlloc[a.ID]) } } - case ssa.OpConst: + case ssa.OpConst8, ssa.OpConst16, ssa.OpConst32, ssa.OpConst64, ssa.OpConstString, ssa.OpConstNil, ssa.OpConstBool: if v.Block.Func.RegAlloc[v.ID] != nil { v.Fatalf("const value %v shouldn't have a location", v) } @@ -2079,6 +2142,23 @@ var ssaRegToReg = [...]int16{ // TODO: arch-dependent } +// regMoveAMD64 returns the register->register move opcode for the given width. +// TODO: generalize for all architectures? +func regMoveAMD64(width int64) int { + switch width { + case 1: + return x86.AMOVB + case 2: + return x86.AMOVW + case 4: + return x86.AMOVL + case 8: + return x86.AMOVQ + default: + panic("bad register width") + } +} + // regnum returns the register (in cmd/internal/obj numbering) to // which v has been allocated. Panics if v is not assigned to a // register. diff --git a/src/cmd/compile/internal/ssa/deadcode_test.go b/src/cmd/compile/internal/ssa/deadcode_test.go index c63b8e4106..9ec8959571 100644 --- a/src/cmd/compile/internal/ssa/deadcode_test.go +++ b/src/cmd/compile/internal/ssa/deadcode_test.go @@ -17,7 +17,7 @@ func TestDeadLoop(t *testing.T) { // dead loop Bloc("deadblock", // dead value in dead block - Valu("deadval", OpConst, TypeBool, 0, true), + Valu("deadval", OpConstBool, TypeBool, 0, true), If("deadval", "deadblock", "exit"))) CheckFunc(fun.f) @@ -41,7 +41,7 @@ func TestDeadValue(t *testing.T) { fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), - Valu("deadval", OpConst, TypeInt64, 37, nil), + Valu("deadval", OpConst64, TypeInt64, 37, nil), Goto("exit")), Bloc("exit", Exit("mem"))) @@ -63,7 +63,7 @@ func TestNeverTaken(t *testing.T) { c := NewConfig("amd64", DummyFrontend{t}) fun := Fun(c, "entry", Bloc("entry", - Valu("cond", OpConst, TypeBool, 0, false), + Valu("cond", OpConstBool, TypeBool, 0, false), Valu("mem", OpArg, TypeMem, 0, ".mem"), If("cond", "then", "else")), Bloc("then", @@ -99,7 +99,7 @@ func TestNestedDeadBlocks(t *testing.T) { fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), - Valu("cond", OpConst, TypeBool, 0, false), + Valu("cond", OpConstBool, TypeBool, 0, false), If("cond", "b2", "b4")), Bloc("b2", If("cond", "b3", "b4")), diff --git a/src/cmd/compile/internal/ssa/deadstore_test.go b/src/cmd/compile/internal/ssa/deadstore_test.go index 3b29e1c430..5b318eb2d2 100644 --- a/src/cmd/compile/internal/ssa/deadstore_test.go +++ b/src/cmd/compile/internal/ssa/deadstore_test.go @@ -15,7 +15,7 @@ func TestDeadStore(t *testing.T) { Bloc("entry", Valu("start", OpArg, TypeMem, 0, ".mem"), Valu("sb", OpSB, TypeInvalid, 0, nil), - Valu("v", OpConst, TypeBool, 0, true), + Valu("v", OpConstBool, TypeBool, 0, true), Valu("addr1", OpAddr, ptrType, 0, nil, "sb"), Valu("addr2", OpAddr, ptrType, 0, nil, "sb"), Valu("store1", OpStore, TypeMem, 0, nil, "addr1", "v", "start"), @@ -42,7 +42,7 @@ func TestDeadStorePhi(t *testing.T) { Bloc("entry", Valu("start", OpArg, TypeMem, 0, ".mem"), Valu("sb", OpSB, TypeInvalid, 0, nil), - Valu("v", OpConst, TypeBool, 0, true), + Valu("v", OpConstBool, TypeBool, 0, true), Valu("addr", OpAddr, ptrType, 0, nil, "sb"), Goto("loop")), Bloc("loop", @@ -69,7 +69,7 @@ func TestDeadStoreTypes(t *testing.T) { Bloc("entry", Valu("start", OpArg, TypeMem, 0, ".mem"), Valu("sb", OpSB, TypeInvalid, 0, nil), - Valu("v", OpConst, TypeBool, 0, true), + Valu("v", OpConstBool, TypeBool, 0, true), Valu("addr1", OpAddr, t1, 0, nil, "sb"), Valu("addr2", OpAddr, t2, 0, nil, "sb"), Valu("store1", OpStore, TypeMem, 0, nil, "addr1", "v", "start"), diff --git a/src/cmd/compile/internal/ssa/dom_test.go b/src/cmd/compile/internal/ssa/dom_test.go index 5209e307b7..1f3124167a 100644 --- a/src/cmd/compile/internal/ssa/dom_test.go +++ b/src/cmd/compile/internal/ssa/dom_test.go @@ -44,7 +44,7 @@ func genFwdBack(size int) []bloc { blocs = append(blocs, Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), - Valu("p", OpConst, TypeBool, 0, true), + Valu("p", OpConstBool, TypeBool, 0, true), Goto(blockn(0)), ), ) @@ -74,7 +74,7 @@ func genManyPred(size int) []bloc { blocs = append(blocs, Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), - Valu("p", OpConst, TypeBool, 0, true), + Valu("p", OpConstBool, TypeBool, 0, true), Goto(blockn(0)), ), ) @@ -85,15 +85,15 @@ func genManyPred(size int) []bloc { switch i % 3 { case 0: blocs = append(blocs, Bloc(blockn(i), - Valu("a", OpConst, TypeBool, 0, true), + Valu("a", OpConstBool, TypeBool, 0, true), Goto(blockn(i+1)))) case 1: blocs = append(blocs, Bloc(blockn(i), - Valu("a", OpConst, TypeBool, 0, true), + Valu("a", OpConstBool, TypeBool, 0, true), If("p", blockn(i+1), blockn(0)))) case 2: blocs = append(blocs, Bloc(blockn(i), - Valu("a", OpConst, TypeBool, 0, true), + Valu("a", OpConstBool, TypeBool, 0, true), If("p", blockn(i+1), blockn(size)))) } } @@ -112,7 +112,7 @@ func genMaxPred(size int) []bloc { blocs = append(blocs, Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), - Valu("p", OpConst, TypeBool, 0, true), + Valu("p", OpConstBool, TypeBool, 0, true), Goto(blockn(0)), ), ) @@ -137,14 +137,14 @@ func genMaxPredValue(size int) []bloc { blocs = append(blocs, Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), - Valu("p", OpConst, TypeBool, 0, true), + Valu("p", OpConstBool, TypeBool, 0, true), Goto(blockn(0)), ), ) for i := 0; i < size; i++ { blocs = append(blocs, Bloc(blockn(i), - Valu("a", OpConst, TypeBool, 0, true), + Valu("a", OpConstBool, TypeBool, 0, true), If("p", blockn(i+1), "exit"))) } @@ -267,7 +267,7 @@ func TestDominatorsMultPredFwd(t *testing.T) { fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), - Valu("p", OpConst, TypeBool, 0, true), + Valu("p", OpConstBool, TypeBool, 0, true), If("p", "a", "c")), Bloc("a", If("p", "b", "c")), @@ -295,7 +295,7 @@ func TestDominatorsDeadCode(t *testing.T) { fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), - Valu("p", OpConst, TypeBool, 0, false), + Valu("p", OpConstBool, TypeBool, 0, false), If("p", "b3", "b5")), Bloc("b2", Exit("mem")), Bloc("b3", Goto("b2")), @@ -318,7 +318,7 @@ func TestDominatorsMultPredRev(t *testing.T) { fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), - Valu("p", OpConst, TypeBool, 0, true), + Valu("p", OpConstBool, TypeBool, 0, true), Goto("a")), Bloc("a", If("p", "b", "entry")), @@ -346,7 +346,7 @@ func TestDominatorsMultPred(t *testing.T) { fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), - Valu("p", OpConst, TypeBool, 0, true), + Valu("p", OpConstBool, TypeBool, 0, true), If("p", "a", "c")), Bloc("a", If("p", "b", "c")), @@ -374,7 +374,7 @@ func TestPostDominators(t *testing.T) { fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), - Valu("p", OpConst, TypeBool, 0, true), + Valu("p", OpConstBool, TypeBool, 0, true), If("p", "a", "c")), Bloc("a", If("p", "b", "c")), @@ -401,7 +401,7 @@ func TestInfiniteLoop(t *testing.T) { fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), - Valu("p", OpConst, TypeBool, 0, true), + Valu("p", OpConstBool, TypeBool, 0, true), Goto("a")), Bloc("a", Goto("b")), diff --git a/src/cmd/compile/internal/ssa/func.go b/src/cmd/compile/internal/ssa/func.go index e0f7c9ff60..ce13075f19 100644 --- a/src/cmd/compile/internal/ssa/func.go +++ b/src/cmd/compile/internal/ssa/func.go @@ -248,9 +248,25 @@ func (b *Block) NewValue3(line int32, op Op, t Type, arg0, arg1, arg2 *Value) *V } // ConstInt returns an int constant representing its argument. -func (f *Func) ConstInt(line int32, t Type, c int64) *Value { +func (f *Func) ConstInt8(line int32, t Type, c int8) *Value { // TODO: cache? - return f.Entry.NewValue0I(line, OpConst, t, c) + return f.Entry.NewValue0I(line, OpConst8, t, int64(c)) +} +func (f *Func) ConstInt16(line int32, t Type, c int16) *Value { + // TODO: cache? + return f.Entry.NewValue0I(line, OpConst16, t, int64(c)) +} +func (f *Func) ConstInt32(line int32, t Type, c int32) *Value { + // TODO: cache? + return f.Entry.NewValue0I(line, OpConst32, t, int64(c)) +} +func (f *Func) ConstInt64(line int32, t Type, c int64) *Value { + // TODO: cache? + return f.Entry.NewValue0I(line, OpConst64, t, c) +} +func (f *Func) ConstIntPtr(line int32, t Type, c int64) *Value { + // TODO: cache? + return f.Entry.NewValue0I(line, OpConstPtr, t, c) } func (f *Func) Logf(msg string, args ...interface{}) { f.Config.Logf(msg, args...) } diff --git a/src/cmd/compile/internal/ssa/func_test.go b/src/cmd/compile/internal/ssa/func_test.go index edea8f78d1..dda96317fe 100644 --- a/src/cmd/compile/internal/ssa/func_test.go +++ b/src/cmd/compile/internal/ssa/func_test.go @@ -23,7 +23,7 @@ // Bloc("exit", // Exit("mem")), // Bloc("deadblock", -// Valu("deadval", OpConst, TypeBool, 0, true), +// Valu("deadval", OpConstBool, TypeBool, 0, true), // If("deadval", "deadblock", "exit"))) // // and the Blocks or Values used in the Func can be accessed @@ -265,8 +265,8 @@ func TestArgs(t *testing.T) { c := NewConfig("amd64", DummyFrontend{t}) fun := Fun(c, "entry", Bloc("entry", - Valu("a", OpConst, TypeInt64, 14, nil), - Valu("b", OpConst, TypeInt64, 26, nil), + Valu("a", OpConst64, TypeInt64, 14, nil), + Valu("b", OpConst64, TypeInt64, 26, nil), Valu("sum", OpAdd64, TypeInt64, 0, nil, "a", "b"), Valu("mem", OpArg, TypeMem, 0, ".mem"), Goto("exit")), @@ -288,8 +288,8 @@ func TestEquiv(t *testing.T) { { Fun(c, "entry", Bloc("entry", - Valu("a", OpConst, TypeInt64, 14, nil), - Valu("b", OpConst, TypeInt64, 26, nil), + Valu("a", OpConst64, TypeInt64, 14, nil), + Valu("b", OpConst64, TypeInt64, 26, nil), Valu("sum", OpAdd64, TypeInt64, 0, nil, "a", "b"), Valu("mem", OpArg, TypeMem, 0, ".mem"), Goto("exit")), @@ -297,8 +297,8 @@ func TestEquiv(t *testing.T) { Exit("mem"))), Fun(c, "entry", Bloc("entry", - Valu("a", OpConst, TypeInt64, 14, nil), - Valu("b", OpConst, TypeInt64, 26, nil), + Valu("a", OpConst64, TypeInt64, 14, nil), + Valu("b", OpConst64, TypeInt64, 26, nil), Valu("sum", OpAdd64, TypeInt64, 0, nil, "a", "b"), Valu("mem", OpArg, TypeMem, 0, ".mem"), Goto("exit")), @@ -309,8 +309,8 @@ func TestEquiv(t *testing.T) { { Fun(c, "entry", Bloc("entry", - Valu("a", OpConst, TypeInt64, 14, nil), - Valu("b", OpConst, TypeInt64, 26, nil), + Valu("a", OpConst64, TypeInt64, 14, nil), + Valu("b", OpConst64, TypeInt64, 26, nil), Valu("sum", OpAdd64, TypeInt64, 0, nil, "a", "b"), Valu("mem", OpArg, TypeMem, 0, ".mem"), Goto("exit")), @@ -320,8 +320,8 @@ func TestEquiv(t *testing.T) { Bloc("exit", Exit("mem")), Bloc("entry", - Valu("a", OpConst, TypeInt64, 14, nil), - Valu("b", OpConst, TypeInt64, 26, nil), + Valu("a", OpConst64, TypeInt64, 14, nil), + Valu("b", OpConst64, TypeInt64, 26, nil), Valu("sum", OpAdd64, TypeInt64, 0, nil, "a", "b"), Valu("mem", OpArg, TypeMem, 0, ".mem"), Goto("exit"))), @@ -354,14 +354,14 @@ func TestEquiv(t *testing.T) { Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), - Valu("b", OpConst, TypeInt64, 26, nil), - Valu("a", OpConst, TypeInt64, 14, nil), + Valu("b", OpConst64, TypeInt64, 26, nil), + Valu("a", OpConst64, TypeInt64, 14, nil), Exit("mem"))), Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), - Valu("a", OpConst, TypeInt64, 14, nil), - Valu("b", OpConst, TypeInt64, 26, nil), + Valu("a", OpConst64, TypeInt64, 14, nil), + Valu("b", OpConst64, TypeInt64, 26, nil), Exit("mem"))), }, // value auxint different @@ -369,12 +369,12 @@ func TestEquiv(t *testing.T) { Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), - Valu("a", OpConst, TypeInt64, 14, nil), + Valu("a", OpConst64, TypeInt64, 14, nil), Exit("mem"))), Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), - Valu("a", OpConst, TypeInt64, 26, nil), + Valu("a", OpConst64, TypeInt64, 26, nil), Exit("mem"))), }, // value aux different @@ -382,12 +382,12 @@ func TestEquiv(t *testing.T) { Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), - Valu("a", OpConst, TypeInt64, 0, 14), + Valu("a", OpConst64, TypeInt64, 0, 14), Exit("mem"))), Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), - Valu("a", OpConst, TypeInt64, 0, 26), + Valu("a", OpConst64, TypeInt64, 0, 26), Exit("mem"))), }, // value args different @@ -395,15 +395,15 @@ func TestEquiv(t *testing.T) { Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), - Valu("a", OpConst, TypeInt64, 14, nil), - Valu("b", OpConst, TypeInt64, 26, nil), + Valu("a", OpConst64, TypeInt64, 14, nil), + Valu("b", OpConst64, TypeInt64, 26, nil), Valu("sum", OpAdd64, TypeInt64, 0, nil, "a", "b"), Exit("mem"))), Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), - Valu("a", OpConst, TypeInt64, 0, nil), - Valu("b", OpConst, TypeInt64, 14, nil), + Valu("a", OpConst64, TypeInt64, 0, nil), + Valu("b", OpConst64, TypeInt64, 14, nil), Valu("sum", OpAdd64, TypeInt64, 0, nil, "b", "a"), Exit("mem"))), }, diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index d881aaa693..5680dc58e3 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -82,7 +82,7 @@ (Rsh64 x y) && y.Type.Size() == 8 -> (SARQ x (CMOVQCC (CMPQconst [64] y) - (Const [63]) + (MOVQconst [63]) y)) (Less64 x y) -> (SETL (CMPQ x y)) @@ -116,16 +116,20 @@ (IsNonNil p) -> (SETNE (TESTQ p p)) (IsInBounds idx len) -> (SETB (CMPQ idx len)) -(Move [size] dst src mem) -> (REPMOVSB dst src (Const [size]) mem) +(Move [size] dst src mem) -> (REPMOVSB dst src (MOVQconst [size]) mem) (Not x) -> (XORQconst [1] x) (OffPtr [off] ptr) -> (ADDQconst [off] ptr) -(Const [val]) && t.IsInteger() -> (MOVQconst [val]) -(Const ) && t.IsPtr() -> (MOVQconst [0]) // nil is the only const pointer -(Const ) && t.IsBoolean() && !v.Aux.(bool) -> (MOVQconst [0]) -(Const ) && t.IsBoolean() && v.Aux.(bool) -> (MOVQconst [1]) +(Const8 [val]) -> (MOVBconst [val]) +(Const16 [val]) -> (MOVWconst [val]) +(Const32 [val]) -> (MOVLconst [val]) +(Const64 [val]) -> (MOVQconst [val]) +(ConstPtr [val]) -> (MOVQconst [val]) +(ConstNil) -> (MOVQconst [0]) +(ConstBool {b}) && !b.(bool) -> (MOVBconst [0]) +(ConstBool {b}) && b.(bool) -> (MOVBconst [1]) (Addr {sym} base) -> (LEAQ {sym} base) @@ -226,15 +230,15 @@ // lower Zero instructions with word sizes (Zero [0] _ mem) -> (Copy mem) -(Zero [1] destptr mem) -> (MOVBstore destptr (Const [0]) mem) -(Zero [2] destptr mem) -> (MOVWstore destptr (Const [0]) mem) -(Zero [4] destptr mem) -> (MOVLstore destptr (Const [0]) mem) -(Zero [8] destptr mem) -> (MOVQstore destptr (Const [0]) mem) +(Zero [1] destptr mem) -> (MOVBstore destptr (MOVBconst [0]) mem) +(Zero [2] destptr mem) -> (MOVWstore destptr (MOVWconst [0]) mem) +(Zero [4] destptr mem) -> (MOVLstore destptr (MOVLconst [0]) mem) +(Zero [8] destptr mem) -> (MOVQstore destptr (MOVQconst [0]) mem) // rewrite anything less than 4 words into a series of MOV[BWLQ] $0, ptr(off) instructions (Zero [size] destptr mem) && size < 4*8 -> (MOVXzero [size] destptr mem) // Use STOSQ to zero memory. Rewrite this into storing the words with REPSTOSQ and then filling in the remainder with linear moves -(Zero [size] destptr mem) && size >= 4*8 -> (Zero [size%8] (OffPtr [size-(size%8)] destptr) (REPSTOSQ destptr (Const [size/8]) mem)) +(Zero [size] destptr mem) && size >= 4*8 -> (Zero [size%8] (OffPtr [size-(size%8)] destptr) (REPSTOSQ destptr (MOVQconst [size/8]) mem)) // Absorb InvertFlags into branches. (LT (InvertFlags cmp) yes no) -> (GT cmp yes no) @@ -249,8 +253,8 @@ (NE (InvertFlags cmp) yes no) -> (NE cmp yes no) // get rid of >=64 code for constant shifts -(SBBQcarrymask (CMPQconst [c] (MOVQconst [d]))) && inBounds(d, c) -> (Const [-1]) -(SBBQcarrymask (CMPQconst [c] (MOVQconst [d]))) && !inBounds(d, c) -> (Const [0]) +(SBBQcarrymask (CMPQconst [c] (MOVQconst [d]))) && inBounds(d, c) -> (MOVQconst [-1]) +(SBBQcarrymask (CMPQconst [c] (MOVQconst [d]))) && !inBounds(d, c) -> (MOVQconst [0]) (ANDQconst [0] _) -> (MOVQconst [0]) (ANDQconst [-1] x) -> (Copy x) (CMOVQCC (CMPQconst [c] (MOVQconst [d])) _ x) && inBounds(d, c) -> (Copy x) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 9b5c302217..40f7b1680f 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -138,12 +138,16 @@ func init() { {name: "MOVLQSX", reg: gp11, asm: "MOVLQSX"}, // sign extend arg0 from int32 to int64 {name: "MOVLQZX", reg: gp11, asm: "MOVLQZX"}, // zero extend arg0 from int32 to int64 - {name: "MOVQconst", reg: gp01}, // auxint - {name: "LEAQ", reg: gp11sb}, // arg0 + auxint + offset encoded in aux - {name: "LEAQ1", reg: gp21sb}, // arg0 + arg1 + auxint - {name: "LEAQ2", reg: gp21sb}, // arg0 + 2*arg1 + auxint - {name: "LEAQ4", reg: gp21sb}, // arg0 + 4*arg1 + auxint - {name: "LEAQ8", reg: gp21sb}, // arg0 + 8*arg1 + auxint + {name: "MOVBconst", reg: gp01, asm: "MOVB"}, // 8 low bits of auxint + {name: "MOVWconst", reg: gp01, asm: "MOVW"}, // 16 low bits of auxint + {name: "MOVLconst", reg: gp01, asm: "MOVL"}, // 32 low bits of auxint + {name: "MOVQconst", reg: gp01, asm: "MOVQ"}, // auxint + + {name: "LEAQ", reg: gp11sb}, // arg0 + auxint + offset encoded in aux + {name: "LEAQ1", reg: gp21sb}, // arg0 + arg1 + auxint + {name: "LEAQ2", reg: gp21sb}, // arg0 + 2*arg1 + auxint + {name: "LEAQ4", reg: gp21sb}, // arg0 + 4*arg1 + auxint + {name: "LEAQ8", reg: gp21sb}, // arg0 + 8*arg1 + auxint {name: "MOVBload", reg: gpload, asm: "MOVB"}, // load byte from arg0+auxint. arg1=mem {name: "MOVBQSXload", reg: gpload, asm: "MOVBQSX"}, // ditto, extend to int64 diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index d13466f06a..49c70af4cc 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -20,31 +20,31 @@ // For now, the generated successors must be a permutation of the matched successors. // constant folding -(Add64 (Const [c]) (Const [d])) -> (Const [c+d]) -(AddPtr (Const [c]) (Const [d])) -> (Const [c+d]) -(Mul64 (Const [c]) (Const [d])) -> (Const [c*d]) -(MulPtr (Const [c]) (Const [d])) -> (Const [c*d]) -(IsInBounds (Const [c]) (Const [d])) -> (Const {inBounds(c,d)}) +(Add64 (Const64 [c]) (Const64 [d])) -> (Const64 [c+d]) +(AddPtr (ConstPtr [c]) (ConstPtr [d])) -> (ConstPtr [c+d]) +(Mul64 (Const64 [c]) (Const64 [d])) -> (Const64 [c*d]) +(MulPtr (ConstPtr [c]) (ConstPtr [d])) -> (ConstPtr [c*d]) +(IsInBounds (ConstPtr [c]) (ConstPtr [d])) -> (ConstPtr {inBounds(c,d)}) // tear apart slices // TODO: anything that generates a slice needs to go in here. (SlicePtr (Load ptr mem)) -> (Load ptr mem) -(SliceLen (Load ptr mem)) -> (Load (AddPtr ptr (Const [config.PtrSize])) mem) -(SliceCap (Load ptr mem)) -> (Load (AddPtr ptr (Const [config.PtrSize*2])) mem) +(SliceLen (Load ptr mem)) -> (Load (AddPtr ptr (ConstPtr [config.PtrSize])) mem) +(SliceCap (Load ptr mem)) -> (Load (AddPtr ptr (ConstPtr [config.PtrSize*2])) mem) // slice and interface comparisons // the frontend ensures that we can only compare against nil // start by putting nil on the right to simplify the other rules -(EqFat x y) && x.Op == OpConst && y.Op != OpConst -> (EqFat y x) -(NeqFat x y) && x.Op == OpConst && y.Op != OpConst -> (NeqFat y x) +(EqFat x y) && x.Op == OpConstNil && y.Op != OpConstNil -> (EqFat y x) +(NeqFat x y) && x.Op == OpConstNil && y.Op != OpConstNil -> (NeqFat y x) // it suffices to check the first word (backing array for slices, dynamic type for interfaces) -(EqFat (Load ptr mem) y) && y.Op == OpConst -> (EqPtr (Load ptr mem) (Const [0])) -(NeqFat (Load ptr mem) y) && y.Op == OpConst -> (NeqPtr (Load ptr mem) (Const [0])) +(EqFat (Load ptr mem) (ConstNil)) -> (EqPtr (Load ptr mem) (ConstPtr [0])) +(NeqFat (Load ptr mem) (ConstNil)) -> (NeqPtr (Load ptr mem) (ConstPtr [0])) // indexing operations // Note: bounds check has already been done (ArrayIndex (Load ptr mem) idx) -> (Load (PtrIndex ptr idx) mem) -(PtrIndex ptr idx) -> (AddPtr ptr (MulPtr idx (Const [t.Elem().Size()]))) +(PtrIndex ptr idx) -> (AddPtr ptr (MulPtr idx (ConstPtr [t.Elem().Size()]))) (StructSelect [idx] (Load ptr mem)) -> (Load (OffPtr [idx] ptr) mem) // big-object moves @@ -52,12 +52,12 @@ (Store dst (Load src mem) mem) && t.Size() > 8 -> (Move [t.Size()] dst src mem) // string ops -(Const {s}) && t.IsString() -> (StringMake (Addr {config.fe.StringData(s.(string))} (SB )) (Const [int64(len(s.(string)))])) +(ConstString {s}) -> (StringMake (Addr {config.fe.StringData(s.(string))} (SB )) (ConstPtr [int64(len(s.(string)))])) (Load ptr mem) && t.IsString() -> (StringMake (Load ptr mem) (Load (OffPtr [config.PtrSize] ptr) mem)) (StringPtr (StringMake ptr _)) -> ptr (StringLen (StringMake _ len)) -> len (Store dst str mem) && str.Type.IsString() -> (Store (OffPtr [config.PtrSize] dst) (StringLen str) (Store dst (StringPtr str) mem)) (If (Not cond) yes no) -> (If cond no yes) -(If (Const {c}) yes no) && c.(bool) -> (Plain nil yes) -(If (Const {c}) yes no) && !c.(bool) -> (Plain nil no) +(If (ConstBool {c}) yes no) && c.(bool) -> (Plain nil yes) +(If (ConstBool {c}) yes no) && !c.(bool) -> (Plain nil no) diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 2dcaa67bd1..732641319f 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -115,7 +115,15 @@ var genericOps = []opData{ // in the AuxInt field as an int64 (including int, uint64, etc.). // For integer types smaller than 64 bits, only the low-order // bits of the AuxInt field matter. - {name: "Const"}, + {name: "ConstBool"}, + {name: "ConstString"}, + {name: "ConstNil"}, + {name: "Const8"}, + {name: "Const16"}, + {name: "Const32"}, + {name: "Const64"}, + {name: "ConstPtr"}, // pointer-sized integer constant + // TODO: Const32F, ... // Constant-like things {name: "Arg"}, // memory input to the function. diff --git a/src/cmd/compile/internal/ssa/gen/rulegen.go b/src/cmd/compile/internal/ssa/gen/rulegen.go index 8dca0bca1f..03cbf7cd57 100644 --- a/src/cmd/compile/internal/ssa/gen/rulegen.go +++ b/src/cmd/compile/internal/ssa/gen/rulegen.go @@ -81,6 +81,9 @@ func genRules(arch arch) { 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) } else { diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 0d56e647af..358459ea8e 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -85,6 +85,9 @@ const ( OpAMD64MOVWQZX OpAMD64MOVLQSX OpAMD64MOVLQZX + OpAMD64MOVBconst + OpAMD64MOVWconst + OpAMD64MOVLconst OpAMD64MOVQconst OpAMD64LEAQ OpAMD64LEAQ1 @@ -214,7 +217,14 @@ const ( OpNeg64 OpPhi OpCopy - OpConst + OpConstBool + OpConstString + OpConstNil + OpConst8 + OpConst16 + OpConst32 + OpConst64 + OpConstPtr OpArg OpAddr OpSP @@ -685,8 +695,36 @@ var opcodeTable = [...]opInfo{ }, }, }, + { + name: "MOVBconst", + 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", + 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", + 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", + asm: x86.AMOVQ, reg: regInfo{ outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -1546,7 +1584,35 @@ var opcodeTable = [...]opInfo{ generic: true, }, { - name: "Const", + name: "ConstBool", + generic: true, + }, + { + name: "ConstString", + generic: true, + }, + { + name: "ConstNil", + generic: true, + }, + { + name: "Const8", + generic: true, + }, + { + name: "Const16", + generic: true, + }, + { + name: "Const32", + generic: true, + }, + { + name: "Const64", + generic: true, + }, + { + name: "ConstPtr", generic: true, }, { diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index c21f3ab7a7..abf504e6b4 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -492,16 +492,44 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endfd75d26316012d86cb71d0dd1214259b endfd75d26316012d86cb71d0dd1214259b: ; - case OpConst: - // match: (Const [val]) - // cond: t.IsInteger() + case OpConst16: + // match: (Const16 [val]) + // cond: + // result: (MOVWconst [val]) + { + val := v.AuxInt + v.Op = OpAMD64MOVWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = val + return true + } + goto end2c6c92f297873b8ac12bd035d56d001e + end2c6c92f297873b8ac12bd035d56d001e: + ; + case OpConst32: + // match: (Const32 [val]) + // cond: + // result: (MOVLconst [val]) + { + val := v.AuxInt + v.Op = OpAMD64MOVLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = val + return true + } + goto enddae5807662af67143a3ac3ad9c63bae5 + enddae5807662af67143a3ac3ad9c63bae5: + ; + case OpConst64: + // match: (Const64 [val]) + // cond: // result: (MOVQconst [val]) { - t := v.Type val := v.AuxInt - if !(t.IsInteger()) { - goto end4c8bfe9df26fc5aa2bd76b211792732a - } v.Op = OpAMD64MOVQconst v.AuxInt = 0 v.Aux = nil @@ -509,35 +537,67 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = val return true } - goto end4c8bfe9df26fc5aa2bd76b211792732a - end4c8bfe9df26fc5aa2bd76b211792732a: + goto endc630434ae7f143ab69d5f482a9b52b5f + endc630434ae7f143ab69d5f482a9b52b5f: ; - // match: (Const ) - // cond: t.IsPtr() - // result: (MOVQconst [0]) + case OpConst8: + // match: (Const8 [val]) + // cond: + // result: (MOVBconst [val]) { - t := v.Type - if !(t.IsPtr()) { - goto endd23abe8d7061f11c260b162e24eec060 + val := v.AuxInt + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = val + return true + } + goto end200524c722ed14ca935ba47f8f30327d + end200524c722ed14ca935ba47f8f30327d: + ; + case OpConstBool: + // match: (ConstBool {b}) + // cond: !b.(bool) + // result: (MOVBconst [0]) + { + b := v.Aux + if !(!b.(bool)) { + goto end876159ea073d2dcefcc251667c1a7780 } - v.Op = OpAMD64MOVQconst + v.Op = OpAMD64MOVBconst v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AuxInt = 0 return true } - goto endd23abe8d7061f11c260b162e24eec060 - endd23abe8d7061f11c260b162e24eec060: + goto end876159ea073d2dcefcc251667c1a7780 + end876159ea073d2dcefcc251667c1a7780: ; - // match: (Const ) - // cond: t.IsBoolean() && !v.Aux.(bool) - // result: (MOVQconst [0]) + // match: (ConstBool {b}) + // cond: b.(bool) + // result: (MOVBconst [1]) { - t := v.Type - if !(t.IsBoolean() && !v.Aux.(bool)) { - goto end7b1347fd0902b990ee1e49145c7e8c31 + b := v.Aux + if !(b.(bool)) { + goto end0dacad3f7cad53905aad5303391447f6 } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 1 + return true + } + goto end0dacad3f7cad53905aad5303391447f6 + end0dacad3f7cad53905aad5303391447f6: + ; + case OpConstNil: + // match: (ConstNil) + // cond: + // result: (MOVQconst [0]) + { v.Op = OpAMD64MOVQconst v.AuxInt = 0 v.Aux = nil @@ -545,26 +605,24 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 return true } - goto end7b1347fd0902b990ee1e49145c7e8c31 - end7b1347fd0902b990ee1e49145c7e8c31: + goto endea557d921056c25b945a49649e4b9b91 + endea557d921056c25b945a49649e4b9b91: ; - // match: (Const ) - // cond: t.IsBoolean() && v.Aux.(bool) - // result: (MOVQconst [1]) + case OpConstPtr: + // match: (ConstPtr [val]) + // cond: + // result: (MOVQconst [val]) { - t := v.Type - if !(t.IsBoolean() && v.Aux.(bool)) { - goto ende0d1c954b5ab5af7227bff9635774f1c - } + val := v.AuxInt v.Op = OpAMD64MOVQconst v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = 1 + v.AuxInt = val return true } - goto ende0d1c954b5ab5af7227bff9635774f1c - ende0d1c954b5ab5af7227bff9635774f1c: + goto endc395c0a53eeccf597e225a07b53047d1 + endc395c0a53eeccf597e225a07b53047d1: ; case OpConvNop: // match: (ConvNop x) @@ -1527,7 +1585,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { case OpMove: // match: (Move [size] dst src mem) // cond: - // result: (REPMOVSB dst src (Const [size]) mem) + // result: (REPMOVSB dst src (MOVQconst [size]) mem) { size := v.AuxInt dst := v.Args[0] @@ -1539,15 +1597,15 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(dst) v.AddArg(src) - v0 := v.Block.NewValue0(v.Line, OpConst, TypeInvalid) + v0 := v.Block.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) v0.Type = TypeUInt64 v0.AuxInt = size v.AddArg(v0) v.AddArg(mem) return true } - goto end1b2d226705fd31dbbe74e3286af178ea - end1b2d226705fd31dbbe74e3286af178ea: + goto end2aab774aedae2c616ee88bfa87cdf30e + end2aab774aedae2c616ee88bfa87cdf30e: ; case OpMul16: // match: (Mul16 x y) @@ -1846,13 +1904,13 @@ func rewriteValueAMD64(v *Value, config *Config) bool { case OpRsh64: // match: (Rsh64 x y) // cond: y.Type.Size() == 8 - // result: (SARQ x (CMOVQCC (CMPQconst [64] y) (Const [63]) y)) + // result: (SARQ x (CMOVQCC (CMPQconst [64] y) (MOVQconst [63]) y)) { t := v.Type x := v.Args[0] y := v.Args[1] if !(y.Type.Size() == 8) { - goto end16bda9bd1611d415969fdbec55ed4330 + goto endd5f88a8c4f11e0e844b35fd8677bd940 } v.Op = OpAMD64SARQ v.AuxInt = 0 @@ -1867,7 +1925,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1.AuxInt = 64 v1.AddArg(y) v0.AddArg(v1) - v2 := v.Block.NewValue0(v.Line, OpConst, TypeInvalid) + v2 := v.Block.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) v2.Type = t v2.AuxInt = 63 v0.AddArg(v2) @@ -1875,8 +1933,8 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end16bda9bd1611d415969fdbec55ed4330 - end16bda9bd1611d415969fdbec55ed4330: + goto endd5f88a8c4f11e0e844b35fd8677bd940 + endd5f88a8c4f11e0e844b35fd8677bd940: ; case OpRsh64U: // match: (Rsh64U x y) @@ -1935,53 +1993,53 @@ func rewriteValueAMD64(v *Value, config *Config) bool { case OpAMD64SBBQcarrymask: // match: (SBBQcarrymask (CMPQconst [c] (MOVQconst [d]))) // cond: inBounds(d, c) - // result: (Const [-1]) + // result: (MOVQconst [-1]) { if v.Args[0].Op != OpAMD64CMPQconst { - goto endf67d323ecef000dbcd15d7e031c3475e + goto end378de7e659770f877c08b6b269073069 } c := v.Args[0].AuxInt if v.Args[0].Args[0].Op != OpAMD64MOVQconst { - goto endf67d323ecef000dbcd15d7e031c3475e + goto end378de7e659770f877c08b6b269073069 } d := v.Args[0].Args[0].AuxInt if !(inBounds(d, c)) { - goto endf67d323ecef000dbcd15d7e031c3475e + goto end378de7e659770f877c08b6b269073069 } - v.Op = OpConst + v.Op = OpAMD64MOVQconst v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AuxInt = -1 return true } - goto endf67d323ecef000dbcd15d7e031c3475e - endf67d323ecef000dbcd15d7e031c3475e: + goto end378de7e659770f877c08b6b269073069 + end378de7e659770f877c08b6b269073069: ; // match: (SBBQcarrymask (CMPQconst [c] (MOVQconst [d]))) // cond: !inBounds(d, c) - // result: (Const [0]) + // result: (MOVQconst [0]) { if v.Args[0].Op != OpAMD64CMPQconst { - goto end4157ddea9c4f71bfabfd6fa50e1208ed + goto enda7bfd1974bf83ca79653c560a718a86c } c := v.Args[0].AuxInt if v.Args[0].Args[0].Op != OpAMD64MOVQconst { - goto end4157ddea9c4f71bfabfd6fa50e1208ed + goto enda7bfd1974bf83ca79653c560a718a86c } d := v.Args[0].Args[0].AuxInt if !(!inBounds(d, c)) { - goto end4157ddea9c4f71bfabfd6fa50e1208ed + goto enda7bfd1974bf83ca79653c560a718a86c } - v.Op = OpConst + v.Op = OpAMD64MOVQconst v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AuxInt = 0 return true } - goto end4157ddea9c4f71bfabfd6fa50e1208ed - end4157ddea9c4f71bfabfd6fa50e1208ed: + goto enda7bfd1974bf83ca79653c560a718a86c + enda7bfd1974bf83ca79653c560a718a86c: ; case OpAMD64SETA: // match: (SETA (InvertFlags x)) @@ -2676,10 +2734,10 @@ func rewriteValueAMD64(v *Value, config *Config) bool { ; // match: (Zero [1] destptr mem) // cond: - // result: (MOVBstore destptr (Const [0]) mem) + // result: (MOVBstore destptr (MOVBconst [0]) mem) { if v.AuxInt != 1 { - goto end09ec7b1fc5ad40534e0e25c896323f5c + goto end16839f51d2e9cf9548f216848406bd97 } destptr := v.Args[0] mem := v.Args[1] @@ -2688,22 +2746,22 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(destptr) - v0 := v.Block.NewValue0(v.Line, OpConst, TypeInvalid) + v0 := v.Block.NewValue0(v.Line, OpAMD64MOVBconst, TypeInvalid) v0.Type = TypeInt8 v0.AuxInt = 0 v.AddArg(v0) v.AddArg(mem) return true } - goto end09ec7b1fc5ad40534e0e25c896323f5c - end09ec7b1fc5ad40534e0e25c896323f5c: + goto end16839f51d2e9cf9548f216848406bd97 + end16839f51d2e9cf9548f216848406bd97: ; // match: (Zero [2] destptr mem) // cond: - // result: (MOVWstore destptr (Const [0]) mem) + // result: (MOVWstore destptr (MOVWconst [0]) mem) { if v.AuxInt != 2 { - goto end2dee246789dbd305bb1eaec768bdae14 + goto enddc4a090329efde9ca19983ad18174cbb } destptr := v.Args[0] mem := v.Args[1] @@ -2712,22 +2770,22 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(destptr) - v0 := v.Block.NewValue0(v.Line, OpConst, TypeInvalid) + v0 := v.Block.NewValue0(v.Line, OpAMD64MOVWconst, TypeInvalid) v0.Type = TypeInt16 v0.AuxInt = 0 v.AddArg(v0) v.AddArg(mem) return true } - goto end2dee246789dbd305bb1eaec768bdae14 - end2dee246789dbd305bb1eaec768bdae14: + goto enddc4a090329efde9ca19983ad18174cbb + enddc4a090329efde9ca19983ad18174cbb: ; // match: (Zero [4] destptr mem) // cond: - // result: (MOVLstore destptr (Const [0]) mem) + // result: (MOVLstore destptr (MOVLconst [0]) mem) { if v.AuxInt != 4 { - goto ende2bf4ecf21bc9e76700a9c5f62546e78 + goto end365a027b67399ad8d5d2d5eca847f7d8 } destptr := v.Args[0] mem := v.Args[1] @@ -2736,22 +2794,22 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(destptr) - v0 := v.Block.NewValue0(v.Line, OpConst, TypeInvalid) + v0 := v.Block.NewValue0(v.Line, OpAMD64MOVLconst, TypeInvalid) v0.Type = TypeInt32 v0.AuxInt = 0 v.AddArg(v0) v.AddArg(mem) return true } - goto ende2bf4ecf21bc9e76700a9c5f62546e78 - ende2bf4ecf21bc9e76700a9c5f62546e78: + goto end365a027b67399ad8d5d2d5eca847f7d8 + end365a027b67399ad8d5d2d5eca847f7d8: ; // match: (Zero [8] destptr mem) // cond: - // result: (MOVQstore destptr (Const [0]) mem) + // result: (MOVQstore destptr (MOVQconst [0]) mem) { if v.AuxInt != 8 { - goto enda65d5d60783daf9b9405f04c44f7adaf + goto end5808a5e9c68555a82c3514db39017e56 } destptr := v.Args[0] mem := v.Args[1] @@ -2760,15 +2818,15 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(destptr) - v0 := v.Block.NewValue0(v.Line, OpConst, TypeInvalid) + v0 := v.Block.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) v0.Type = TypeInt64 v0.AuxInt = 0 v.AddArg(v0) v.AddArg(mem) return true } - goto enda65d5d60783daf9b9405f04c44f7adaf - enda65d5d60783daf9b9405f04c44f7adaf: + goto end5808a5e9c68555a82c3514db39017e56 + end5808a5e9c68555a82c3514db39017e56: ; // match: (Zero [size] destptr mem) // cond: size < 4*8 @@ -2794,13 +2852,13 @@ func rewriteValueAMD64(v *Value, config *Config) bool { ; // match: (Zero [size] destptr mem) // cond: size >= 4*8 - // result: (Zero [size%8] (OffPtr [size-(size%8)] destptr) (REPSTOSQ destptr (Const [size/8]) mem)) + // result: (Zero [size%8] (OffPtr [size-(size%8)] destptr) (REPSTOSQ destptr (MOVQconst [size/8]) mem)) { size := v.AuxInt destptr := v.Args[0] mem := v.Args[1] if !(size >= 4*8) { - goto end7a358169d20d6834b21f2e03fbf351b2 + goto endb3058a90f909821d5689fb358519828b } v.Op = OpZero v.AuxInt = 0 @@ -2815,7 +2873,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1 := v.Block.NewValue0(v.Line, OpAMD64REPSTOSQ, TypeInvalid) v1.Type = TypeMem v1.AddArg(destptr) - v2 := v.Block.NewValue0(v.Line, OpConst, TypeInvalid) + v2 := v.Block.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) v2.Type = TypeUInt64 v2.AuxInt = size / 8 v1.AddArg(v2) @@ -2823,8 +2881,8 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto end7a358169d20d6834b21f2e03fbf351b2 - end7a358169d20d6834b21f2e03fbf351b2: + goto endb3058a90f909821d5689fb358519828b + endb3058a90f909821d5689fb358519828b: ; case OpZeroExt16to32: // match: (ZeroExt16to32 x) diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index 2c2a48693a..8fa3b6ded1 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -5,50 +5,50 @@ package ssa func rewriteValuegeneric(v *Value, config *Config) bool { switch v.Op { case OpAdd64: - // match: (Add64 (Const [c]) (Const [d])) + // match: (Add64 (Const64 [c]) (Const64 [d])) // cond: - // result: (Const [c+d]) + // result: (Const64 [c+d]) { - if v.Args[0].Op != OpConst { - goto endd2f4bfaaf6c937171a287b73e5c2f73e + if v.Args[0].Op != OpConst64 { + goto end8c46df6f85a11cb1d594076b0e467908 } c := v.Args[0].AuxInt - if v.Args[1].Op != OpConst { - goto endd2f4bfaaf6c937171a287b73e5c2f73e + if v.Args[1].Op != OpConst64 { + goto end8c46df6f85a11cb1d594076b0e467908 } d := v.Args[1].AuxInt - v.Op = OpConst + v.Op = OpConst64 v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AuxInt = c + d return true } - goto endd2f4bfaaf6c937171a287b73e5c2f73e - endd2f4bfaaf6c937171a287b73e5c2f73e: + goto end8c46df6f85a11cb1d594076b0e467908 + end8c46df6f85a11cb1d594076b0e467908: ; case OpAddPtr: - // match: (AddPtr (Const [c]) (Const [d])) + // match: (AddPtr (ConstPtr [c]) (ConstPtr [d])) // cond: - // result: (Const [c+d]) + // result: (ConstPtr [c+d]) { - if v.Args[0].Op != OpConst { - goto end67284cb7ae441d6c763096b49a3569a3 + if v.Args[0].Op != OpConstPtr { + goto end145c1aec793b2befff34bc8983b48a38 } c := v.Args[0].AuxInt - if v.Args[1].Op != OpConst { - goto end67284cb7ae441d6c763096b49a3569a3 + if v.Args[1].Op != OpConstPtr { + goto end145c1aec793b2befff34bc8983b48a38 } d := v.Args[1].AuxInt - v.Op = OpConst + v.Op = OpConstPtr v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AuxInt = c + d return true } - goto end67284cb7ae441d6c763096b49a3569a3 - end67284cb7ae441d6c763096b49a3569a3: + goto end145c1aec793b2befff34bc8983b48a38 + end145c1aec793b2befff34bc8983b48a38: ; case OpArrayIndex: // match: (ArrayIndex (Load ptr mem) idx) @@ -76,16 +76,12 @@ func rewriteValuegeneric(v *Value, config *Config) bool { goto end4894dd7b58383fee5f8a92be08437c33 end4894dd7b58383fee5f8a92be08437c33: ; - case OpConst: - // match: (Const {s}) - // cond: t.IsString() - // result: (StringMake (Addr {config.fe.StringData(s.(string))} (SB )) (Const [int64(len(s.(string)))])) + case OpConstString: + // match: (ConstString {s}) + // cond: + // result: (StringMake (Addr {config.fe.StringData(s.(string))} (SB )) (ConstPtr [int64(len(s.(string)))])) { - t := v.Type s := v.Aux - if !(t.IsString()) { - goto enda6f250a3c775ae5a239ece8074b46cea - } v.Op = OpStringMake v.AuxInt = 0 v.Aux = nil @@ -97,24 +93,24 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v1.Type = config.Uintptr v0.AddArg(v1) v.AddArg(v0) - v2 := v.Block.NewValue0(v.Line, OpConst, TypeInvalid) + v2 := v.Block.NewValue0(v.Line, OpConstPtr, TypeInvalid) v2.Type = config.Uintptr v2.AuxInt = int64(len(s.(string))) v.AddArg(v2) return true } - goto enda6f250a3c775ae5a239ece8074b46cea - enda6f250a3c775ae5a239ece8074b46cea: + goto end1a01fc02fad8727f9a3b716cfdac3a44 + end1a01fc02fad8727f9a3b716cfdac3a44: ; case OpEqFat: // match: (EqFat x y) - // cond: x.Op == OpConst && y.Op != OpConst + // cond: x.Op == OpConstNil && y.Op != OpConstNil // result: (EqFat y x) { x := v.Args[0] y := v.Args[1] - if !(x.Op == OpConst && y.Op != OpConst) { - goto end4540bddcf0fc8e4b71fac6e9edbb8eec + if !(x.Op == OpConstNil && y.Op != OpConstNil) { + goto endcea7f7399afcff860c54d82230a9a934 } v.Op = OpEqFat v.AuxInt = 0 @@ -124,21 +120,20 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.AddArg(x) return true } - goto end4540bddcf0fc8e4b71fac6e9edbb8eec - end4540bddcf0fc8e4b71fac6e9edbb8eec: + goto endcea7f7399afcff860c54d82230a9a934 + endcea7f7399afcff860c54d82230a9a934: ; - // match: (EqFat (Load ptr mem) y) - // cond: y.Op == OpConst - // result: (EqPtr (Load ptr mem) (Const [0])) + // match: (EqFat (Load ptr mem) (ConstNil)) + // cond: + // result: (EqPtr (Load ptr mem) (ConstPtr [0])) { if v.Args[0].Op != OpLoad { - goto end779b0e24e33d8eff668c368b90387caa + goto end2597220d1792c84d362da7901d2065d2 } ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] - y := v.Args[1] - if !(y.Op == OpConst) { - goto end779b0e24e33d8eff668c368b90387caa + if v.Args[1].Op != OpConstNil { + goto end2597220d1792c84d362da7901d2065d2 } v.Op = OpEqPtr v.AuxInt = 0 @@ -149,37 +144,37 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v0.AddArg(ptr) v0.AddArg(mem) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpConst, TypeInvalid) + v1 := v.Block.NewValue0(v.Line, OpConstPtr, TypeInvalid) v1.Type = config.Uintptr v1.AuxInt = 0 v.AddArg(v1) return true } - goto end779b0e24e33d8eff668c368b90387caa - end779b0e24e33d8eff668c368b90387caa: + goto end2597220d1792c84d362da7901d2065d2 + end2597220d1792c84d362da7901d2065d2: ; case OpIsInBounds: - // match: (IsInBounds (Const [c]) (Const [d])) + // match: (IsInBounds (ConstPtr [c]) (ConstPtr [d])) // cond: - // result: (Const {inBounds(c,d)}) + // result: (ConstPtr {inBounds(c,d)}) { - if v.Args[0].Op != OpConst { - goto enda96ccac78df2d17ae96c8baf2af2e189 + if v.Args[0].Op != OpConstPtr { + goto enddfd340bc7103ca323354aec96b113c23 } c := v.Args[0].AuxInt - if v.Args[1].Op != OpConst { - goto enda96ccac78df2d17ae96c8baf2af2e189 + if v.Args[1].Op != OpConstPtr { + goto enddfd340bc7103ca323354aec96b113c23 } d := v.Args[1].AuxInt - v.Op = OpConst + v.Op = OpConstPtr v.AuxInt = 0 v.Aux = nil v.resetArgs() v.Aux = inBounds(c, d) return true } - goto enda96ccac78df2d17ae96c8baf2af2e189 - enda96ccac78df2d17ae96c8baf2af2e189: + goto enddfd340bc7103ca323354aec96b113c23 + enddfd340bc7103ca323354aec96b113c23: ; case OpLoad: // match: (Load ptr mem) @@ -216,60 +211,60 @@ func rewriteValuegeneric(v *Value, config *Config) bool { endce3ba169a57b8a9f6b12751d49b4e23a: ; case OpMul64: - // match: (Mul64 (Const [c]) (Const [d])) + // match: (Mul64 (Const64 [c]) (Const64 [d])) // cond: - // result: (Const [c*d]) + // result: (Const64 [c*d]) { - if v.Args[0].Op != OpConst { - goto endf4ba5346dc8a624781afaa68a8096a9a + if v.Args[0].Op != OpConst64 { + goto end7aea1048b5d1230974b97f17238380ae } c := v.Args[0].AuxInt - if v.Args[1].Op != OpConst { - goto endf4ba5346dc8a624781afaa68a8096a9a + if v.Args[1].Op != OpConst64 { + goto end7aea1048b5d1230974b97f17238380ae } d := v.Args[1].AuxInt - v.Op = OpConst + v.Op = OpConst64 v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AuxInt = c * d return true } - goto endf4ba5346dc8a624781afaa68a8096a9a - endf4ba5346dc8a624781afaa68a8096a9a: + goto end7aea1048b5d1230974b97f17238380ae + end7aea1048b5d1230974b97f17238380ae: ; case OpMulPtr: - // match: (MulPtr (Const [c]) (Const [d])) + // match: (MulPtr (ConstPtr [c]) (ConstPtr [d])) // cond: - // result: (Const [c*d]) + // result: (ConstPtr [c*d]) { - if v.Args[0].Op != OpConst { - goto end10541de7ea2bce703c1e372ac9a271e7 + if v.Args[0].Op != OpConstPtr { + goto end808c190f346658bb1ad032bf37a1059f } c := v.Args[0].AuxInt - if v.Args[1].Op != OpConst { - goto end10541de7ea2bce703c1e372ac9a271e7 + if v.Args[1].Op != OpConstPtr { + goto end808c190f346658bb1ad032bf37a1059f } d := v.Args[1].AuxInt - v.Op = OpConst + v.Op = OpConstPtr v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AuxInt = c * d return true } - goto end10541de7ea2bce703c1e372ac9a271e7 - end10541de7ea2bce703c1e372ac9a271e7: + goto end808c190f346658bb1ad032bf37a1059f + end808c190f346658bb1ad032bf37a1059f: ; case OpNeqFat: // match: (NeqFat x y) - // cond: x.Op == OpConst && y.Op != OpConst + // cond: x.Op == OpConstNil && y.Op != OpConstNil // result: (NeqFat y x) { x := v.Args[0] y := v.Args[1] - if !(x.Op == OpConst && y.Op != OpConst) { - goto end5d2a9d3aa52fb6866825f35ac65c7cfd + if !(x.Op == OpConstNil && y.Op != OpConstNil) { + goto end94c68f7dc30c66ed42e507e01c4e5dc7 } v.Op = OpNeqFat v.AuxInt = 0 @@ -279,21 +274,20 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.AddArg(x) return true } - goto end5d2a9d3aa52fb6866825f35ac65c7cfd - end5d2a9d3aa52fb6866825f35ac65c7cfd: + goto end94c68f7dc30c66ed42e507e01c4e5dc7 + end94c68f7dc30c66ed42e507e01c4e5dc7: ; - // match: (NeqFat (Load ptr mem) y) - // cond: y.Op == OpConst - // result: (NeqPtr (Load ptr mem) (Const [0])) + // match: (NeqFat (Load ptr mem) (ConstNil)) + // cond: + // result: (NeqPtr (Load ptr mem) (ConstPtr [0])) { if v.Args[0].Op != OpLoad { - goto endf2f18052c2d999a7ac883c441c3b7ade + goto end03a0fc8dde062c55439174f70c19e6ce } ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] - y := v.Args[1] - if !(y.Op == OpConst) { - goto endf2f18052c2d999a7ac883c441c3b7ade + if v.Args[1].Op != OpConstNil { + goto end03a0fc8dde062c55439174f70c19e6ce } v.Op = OpNeqPtr v.AuxInt = 0 @@ -304,19 +298,19 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v0.AddArg(ptr) v0.AddArg(mem) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpConst, TypeInvalid) + v1 := v.Block.NewValue0(v.Line, OpConstPtr, TypeInvalid) v1.Type = config.Uintptr v1.AuxInt = 0 v.AddArg(v1) return true } - goto endf2f18052c2d999a7ac883c441c3b7ade - endf2f18052c2d999a7ac883c441c3b7ade: + goto end03a0fc8dde062c55439174f70c19e6ce + end03a0fc8dde062c55439174f70c19e6ce: ; case OpPtrIndex: // match: (PtrIndex ptr idx) // cond: - // result: (AddPtr ptr (MulPtr idx (Const [t.Elem().Size()]))) + // result: (AddPtr ptr (MulPtr idx (ConstPtr [t.Elem().Size()]))) { t := v.Type ptr := v.Args[0] @@ -329,23 +323,23 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v0 := v.Block.NewValue0(v.Line, OpMulPtr, TypeInvalid) v0.Type = config.Uintptr v0.AddArg(idx) - v1 := v.Block.NewValue0(v.Line, OpConst, TypeInvalid) + v1 := v.Block.NewValue0(v.Line, OpConstPtr, TypeInvalid) v1.Type = config.Uintptr v1.AuxInt = t.Elem().Size() v0.AddArg(v1) v.AddArg(v0) return true } - goto endb39bbe157d1791123f6083b2cfc59ddc - endb39bbe157d1791123f6083b2cfc59ddc: + goto endfb3e605edaa4c3c0684c4fa9c8f150ee + endfb3e605edaa4c3c0684c4fa9c8f150ee: ; case OpSliceCap: // match: (SliceCap (Load ptr mem)) // cond: - // result: (Load (AddPtr ptr (Const [config.PtrSize*2])) mem) + // result: (Load (AddPtr ptr (ConstPtr [config.PtrSize*2])) mem) { if v.Args[0].Op != OpLoad { - goto end83c0ff7760465a4184bad9e4b47f7be8 + goto end18c7acae3d96b30b9e5699194df4a687 } ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] @@ -356,7 +350,7 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v0 := v.Block.NewValue0(v.Line, OpAddPtr, TypeInvalid) v0.Type = ptr.Type v0.AddArg(ptr) - v1 := v.Block.NewValue0(v.Line, OpConst, TypeInvalid) + v1 := v.Block.NewValue0(v.Line, OpConstPtr, TypeInvalid) v1.Type = config.Uintptr v1.AuxInt = config.PtrSize * 2 v0.AddArg(v1) @@ -364,16 +358,16 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto end83c0ff7760465a4184bad9e4b47f7be8 - end83c0ff7760465a4184bad9e4b47f7be8: + goto end18c7acae3d96b30b9e5699194df4a687 + end18c7acae3d96b30b9e5699194df4a687: ; case OpSliceLen: // match: (SliceLen (Load ptr mem)) // cond: - // result: (Load (AddPtr ptr (Const [config.PtrSize])) mem) + // result: (Load (AddPtr ptr (ConstPtr [config.PtrSize])) mem) { if v.Args[0].Op != OpLoad { - goto end20579b262d017d875d579683996f0ef9 + goto end2dc65aee31bb0d91847032be777777d2 } ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] @@ -384,7 +378,7 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v0 := v.Block.NewValue0(v.Line, OpAddPtr, TypeInvalid) v0.Type = ptr.Type v0.AddArg(ptr) - v1 := v.Block.NewValue0(v.Line, OpConst, TypeInvalid) + v1 := v.Block.NewValue0(v.Line, OpConstPtr, TypeInvalid) v1.Type = config.Uintptr v1.AuxInt = config.PtrSize v0.AddArg(v1) @@ -392,8 +386,8 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto end20579b262d017d875d579683996f0ef9 - end20579b262d017d875d579683996f0ef9: + goto end2dc65aee31bb0d91847032be777777d2 + end2dc65aee31bb0d91847032be777777d2: ; case OpSlicePtr: // match: (SlicePtr (Load ptr mem)) @@ -573,19 +567,19 @@ func rewriteBlockgeneric(b *Block) bool { goto endebe19c1c3c3bec068cdb2dd29ef57f96 endebe19c1c3c3bec068cdb2dd29ef57f96: ; - // match: (If (Const {c}) yes no) + // match: (If (ConstBool {c}) yes no) // cond: c.(bool) // result: (Plain nil yes) { v := b.Control - if v.Op != OpConst { - goto end915e334b6388fed7d63e09aa69ecb05c + if v.Op != OpConstBool { + goto end9ff0273f9b1657f4afc287562ca889f0 } c := v.Aux yes := b.Succs[0] no := b.Succs[1] if !(c.(bool)) { - goto end915e334b6388fed7d63e09aa69ecb05c + goto end9ff0273f9b1657f4afc287562ca889f0 } v.Block.Func.removePredecessor(b, no) b.Kind = BlockPlain @@ -594,22 +588,22 @@ func rewriteBlockgeneric(b *Block) bool { b.Succs[0] = yes return true } - goto end915e334b6388fed7d63e09aa69ecb05c - end915e334b6388fed7d63e09aa69ecb05c: + goto end9ff0273f9b1657f4afc287562ca889f0 + end9ff0273f9b1657f4afc287562ca889f0: ; - // match: (If (Const {c}) yes no) + // match: (If (ConstBool {c}) yes no) // cond: !c.(bool) // result: (Plain nil no) { v := b.Control - if v.Op != OpConst { - goto end6452ee3a5bb02c708bddc3181c3ea3cb + if v.Op != OpConstBool { + goto endf401a4553c3c7c6bed64801da7bba076 } c := v.Aux yes := b.Succs[0] no := b.Succs[1] if !(!c.(bool)) { - goto end6452ee3a5bb02c708bddc3181c3ea3cb + goto endf401a4553c3c7c6bed64801da7bba076 } v.Block.Func.removePredecessor(b, yes) b.Kind = BlockPlain @@ -618,8 +612,8 @@ func rewriteBlockgeneric(b *Block) bool { b.Succs[0] = no return true } - goto end6452ee3a5bb02c708bddc3181c3ea3cb - end6452ee3a5bb02c708bddc3181c3ea3cb: + goto endf401a4553c3c7c6bed64801da7bba076 + endf401a4553c3c7c6bed64801da7bba076: } return false } diff --git a/src/cmd/compile/internal/ssa/schedule_test.go b/src/cmd/compile/internal/ssa/schedule_test.go index 3a89483a9a..e724871bd0 100644 --- a/src/cmd/compile/internal/ssa/schedule_test.go +++ b/src/cmd/compile/internal/ssa/schedule_test.go @@ -12,8 +12,8 @@ func TestSchedule(t *testing.T) { Fun(c, "entry", Bloc("entry", Valu("mem0", OpArg, TypeMem, 0, ".mem"), - Valu("ptr", OpConst, TypeInt64, 0xABCD, nil), - Valu("v", OpConst, TypeInt64, 12, nil), + Valu("ptr", OpConst64, TypeInt64, 0xABCD, nil), + Valu("v", OpConst64, TypeInt64, 12, nil), Valu("mem1", OpStore, TypeMem, 0, nil, "ptr", "v", "mem0"), Valu("mem2", OpStore, TypeMem, 0, nil, "ptr", "v", "mem1"), Valu("mem3", OpStore, TypeInt64, 0, nil, "ptr", "sum", "mem2"), diff --git a/src/cmd/compile/internal/ssa/shift_test.go b/src/cmd/compile/internal/ssa/shift_test.go index cde48d355a..c32e48d93f 100644 --- a/src/cmd/compile/internal/ssa/shift_test.go +++ b/src/cmd/compile/internal/ssa/shift_test.go @@ -33,7 +33,7 @@ func makeConstShiftFunc(c *Config, amount int64, op Op, typ Type) fun { Valu("argptr", OpOffPtr, ptyp, 8, nil, "SP"), Valu("resptr", OpOffPtr, ptyp, 16, nil, "SP"), Valu("load", OpLoad, typ, 0, nil, "argptr", "mem"), - Valu("c", OpConst, TypeUInt64, amount, nil), + Valu("c", OpConst64, TypeUInt64, amount, nil), Valu("shift", op, typ, 0, nil, "load", "c"), Valu("store", OpStore, TypeMem, 0, nil, "resptr", "shift", "mem"), Exit("store"))) -- cgit v1.3 From 1bab5b9b414a6c4290c9118a85fb316aacea7cf3 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Tue, 28 Jul 2015 14:14:25 -0700 Subject: [dev.ssa] cmd/compile: add a few more binary ops With this, all non-float, non-complex binary ops found in the standard library are implemented. Change-Id: I6087f115229888c0dce10ab35db3fd36a0e0a8b1 Reviewed-on: https://go-review.googlesource.com/12799 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 70 ++++++++++++++++++++------------------ 1 file changed, 37 insertions(+), 33 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index e26412cf46..8eeb29d4bd 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -702,8 +702,10 @@ var opToSSA = map[opAndType]ssa.Op{ 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{OSUB, TINT8}: ssa.OpSub8, opAndType{OSUB, TUINT8}: ssa.OpSub8, @@ -761,39 +763,41 @@ var opToSSA = map[opAndType]ssa.Op{ opAndType{ORSH, TINT64}: ssa.OpRsh64, opAndType{ORSH, TUINT64}: ssa.OpRsh64U, - 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, TPTR64}: ssa.OpEq64, - opAndType{OEQ, TINTER}: ssa.OpEqFat, // e == nil only - opAndType{OEQ, TARRAY}: ssa.OpEqFat, // slice only; a == nil only - opAndType{OEQ, TFUNC}: ssa.OpEqPtr, - opAndType{OEQ, TMAP}: ssa.OpEqPtr, - opAndType{OEQ, TCHAN}: ssa.OpEqPtr, - opAndType{OEQ, TUINTPTR}: ssa.OpEqPtr, - - 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, TPTR64}: ssa.OpNeq64, - opAndType{ONE, TINTER}: ssa.OpNeqFat, // e != nil only - opAndType{ONE, TARRAY}: ssa.OpNeqFat, // slice only; a != nil only - opAndType{ONE, TFUNC}: ssa.OpNeqPtr, - opAndType{ONE, TMAP}: ssa.OpNeqPtr, - opAndType{ONE, TCHAN}: ssa.OpNeqPtr, - opAndType{ONE, TUINTPTR}: ssa.OpNeqPtr, + 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, TPTR64}: ssa.OpEq64, + opAndType{OEQ, TINTER}: ssa.OpEqFat, // e == nil only + opAndType{OEQ, TARRAY}: ssa.OpEqFat, // slice only; a == nil only + opAndType{OEQ, TFUNC}: ssa.OpEqPtr, + opAndType{OEQ, TMAP}: ssa.OpEqPtr, + opAndType{OEQ, TCHAN}: ssa.OpEqPtr, + opAndType{OEQ, TUINTPTR}: ssa.OpEqPtr, + opAndType{OEQ, TUNSAFEPTR}: ssa.OpEqPtr, + + 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, TPTR64}: ssa.OpNeq64, + opAndType{ONE, TINTER}: ssa.OpNeqFat, // e != nil only + opAndType{ONE, TARRAY}: ssa.OpNeqFat, // slice only; a != nil only + opAndType{ONE, TFUNC}: ssa.OpNeqPtr, + opAndType{ONE, TMAP}: ssa.OpNeqPtr, + opAndType{ONE, TCHAN}: ssa.OpNeqPtr, + opAndType{ONE, TUINTPTR}: ssa.OpNeqPtr, + opAndType{ONE, TUNSAFEPTR}: ssa.OpNeqPtr, opAndType{OLT, TINT8}: ssa.OpLess8, opAndType{OLT, TUINT8}: ssa.OpLess8U, -- cgit v1.3 From 9f8a677eabe573c3640605e4c541e968367cc02e Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Tue, 28 Jul 2015 14:36:14 -0700 Subject: [dev.ssa] cmd/compile: lower all integer comparisons Change-Id: I683281e1293d3df3c39772e7b08f0b55a3b61404 Reviewed-on: https://go-review.googlesource.com/12811 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/gen/AMD64.rules | 35 ++ src/cmd/compile/internal/ssa/rewriteAMD64.go | 588 +++++++++++++++++++++++++++ 2 files changed, 623 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 5680dc58e3..3e667c8951 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -86,9 +86,44 @@ y)) (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)) + (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)) + (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)) + (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)) (Eq64 x y) -> (SETEQ (CMPQ x y)) (Eq32 x y) -> (SETEQ (CMPL x y)) diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index abf504e6b4..b172cf3527 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -768,6 +768,90 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end6de1d39c9d151e5e503d643bd835356e end6de1d39c9d151e5e503d643bd835356e: ; + case OpGeq16: + // match: (Geq16 x y) + // cond: + // result: (SETGE (CMPW x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETGE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto end26084bf821f9e418934fee812632b774 + end26084bf821f9e418934fee812632b774: + ; + case OpGeq16U: + // match: (Geq16U x y) + // cond: + // result: (SETAE (CMPW x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETAE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto end20b00f850ca834cb2013414645c19ad9 + end20b00f850ca834cb2013414645c19ad9: + ; + case OpGeq32: + // match: (Geq32 x y) + // cond: + // result: (SETGE (CMPL x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETGE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto end713c3dfa0f7247dcc232bcfc916fb044 + end713c3dfa0f7247dcc232bcfc916fb044: + ; + case OpGeq32U: + // match: (Geq32U x y) + // cond: + // result: (SETAE (CMPL x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETAE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto endac2cde17ec6ab0107eabbda6407d1004 + endac2cde17ec6ab0107eabbda6407d1004: + ; case OpGeq64: // match: (Geq64 x y) // cond: @@ -789,6 +873,153 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end63f44e3fec8d92723b5bde42d6d7eea0 end63f44e3fec8d92723b5bde42d6d7eea0: ; + case OpGeq64U: + // match: (Geq64U x y) + // cond: + // result: (SETAE (CMPQ x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETAE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto endd8d2d9faa19457f6a7b0635a756d234f + endd8d2d9faa19457f6a7b0635a756d234f: + ; + case OpGeq8: + // match: (Geq8 x y) + // cond: + // result: (SETGE (CMPB x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETGE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto endb5f40ee158007e675b2113c3ce962382 + endb5f40ee158007e675b2113c3ce962382: + ; + case OpGeq8U: + // match: (Geq8U x y) + // cond: + // result: (SETAE (CMPB x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETAE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto endd30ee67afc0284c419cef70261f61452 + endd30ee67afc0284c419cef70261f61452: + ; + case OpGreater16: + // match: (Greater16 x y) + // cond: + // result: (SETG (CMPW x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETG + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto end5bc9fdb7e563a6b949e42d721903cb58 + end5bc9fdb7e563a6b949e42d721903cb58: + ; + case OpGreater16U: + // match: (Greater16U x y) + // cond: + // result: (SETA (CMPW x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETA + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto endd5b646f04fd839d11082a9ff6adb4a3f + endd5b646f04fd839d11082a9ff6adb4a3f: + ; + case OpGreater32: + // match: (Greater32 x y) + // cond: + // result: (SETG (CMPL x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETG + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto endbf0b2b1368aadff48969a7386eee5795 + endbf0b2b1368aadff48969a7386eee5795: + ; + case OpGreater32U: + // match: (Greater32U x y) + // cond: + // result: (SETA (CMPL x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETA + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto end033c944272dc0af6fafe33f667cf7485 + end033c944272dc0af6fafe33f667cf7485: + ; case OpGreater64: // match: (Greater64 x y) // cond: @@ -810,6 +1041,69 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endaef0cfa5e27e23cf5e527061cf251069 endaef0cfa5e27e23cf5e527061cf251069: ; + case OpGreater64U: + // match: (Greater64U x y) + // cond: + // result: (SETA (CMPQ x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETA + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto end2afc16a19fe1073dfa86770a78eba2b4 + end2afc16a19fe1073dfa86770a78eba2b4: + ; + case OpGreater8: + // match: (Greater8 x y) + // cond: + // result: (SETG (CMPB x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETG + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto endbdb1e5f6b760cf02e0fc2f474622e6be + endbdb1e5f6b760cf02e0fc2f474622e6be: + ; + case OpGreater8U: + // match: (Greater8U x y) + // cond: + // result: (SETA (CMPB x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETA + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto end22eaafbcfe70447f79d9b3e6cc395bbd + end22eaafbcfe70447f79d9b3e6cc395bbd: + ; case OpIsInBounds: // match: (IsInBounds idx len) // cond: @@ -851,6 +1145,90 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endff508c3726edfb573abc6128c177e76c endff508c3726edfb573abc6128c177e76c: ; + case OpLeq16: + // match: (Leq16 x y) + // cond: + // result: (SETLE (CMPW x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETLE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto endc1916dfcb3eae58ab237e40a57e1ff16 + endc1916dfcb3eae58ab237e40a57e1ff16: + ; + case OpLeq16U: + // match: (Leq16U x y) + // cond: + // result: (SETBE (CMPW x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETBE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto end627e261aea217b5d17177b52711b8c82 + end627e261aea217b5d17177b52711b8c82: + ; + case OpLeq32: + // match: (Leq32 x y) + // cond: + // result: (SETLE (CMPL x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETLE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto endf422ecc8da0033e22242de9c67112537 + endf422ecc8da0033e22242de9c67112537: + ; + case OpLeq32U: + // match: (Leq32U x y) + // cond: + // result: (SETBE (CMPL x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETBE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto end1b39c9661896abdff8a29de509311b96 + end1b39c9661896abdff8a29de509311b96: + ; case OpLeq64: // match: (Leq64 x y) // cond: @@ -872,6 +1250,153 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endf03da5e28dccdb4797671f39e824fb10 endf03da5e28dccdb4797671f39e824fb10: ; + case OpLeq64U: + // match: (Leq64U x y) + // cond: + // result: (SETBE (CMPQ x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETBE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto end37302777dd91a5d0c6f410a5444ccb38 + end37302777dd91a5d0c6f410a5444ccb38: + ; + case OpLeq8: + // match: (Leq8 x y) + // cond: + // result: (SETLE (CMPB x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETLE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto end03be536eea60fdd98d48b17681acaf5a + end03be536eea60fdd98d48b17681acaf5a: + ; + case OpLeq8U: + // match: (Leq8U x y) + // cond: + // result: (SETBE (CMPB x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETBE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto end661377f6745450bb1fa7fd0608ef0a86 + end661377f6745450bb1fa7fd0608ef0a86: + ; + case OpLess16: + // match: (Less16 x y) + // cond: + // result: (SETL (CMPW x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto endeb09704ef62ba2695a967b6fcb42e562 + endeb09704ef62ba2695a967b6fcb42e562: + ; + case OpLess16U: + // match: (Less16U x y) + // cond: + // result: (SETB (CMPW x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto end2209a57bd887f68ad732aa7da2bc7286 + end2209a57bd887f68ad732aa7da2bc7286: + ; + case OpLess32: + // match: (Less32 x y) + // cond: + // result: (SETL (CMPL x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto end8da8d2030c0a323a84503c1240c566ae + end8da8d2030c0a323a84503c1240c566ae: + ; + case OpLess32U: + // match: (Less32U x y) + // cond: + // result: (SETB (CMPL x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto enddcfbbb482eb194146f4f7c8f12029a7a + enddcfbbb482eb194146f4f7c8f12029a7a: + ; case OpLess64: // match: (Less64 x y) // cond: @@ -893,6 +1418,69 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endf8e7a24c25692045bbcfd2c9356d1a8c endf8e7a24c25692045bbcfd2c9356d1a8c: ; + case OpLess64U: + // match: (Less64U x y) + // cond: + // result: (SETB (CMPQ x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto end2fac0a2c2e972b5e04b5062d5786b87d + end2fac0a2c2e972b5e04b5062d5786b87d: + ; + case OpLess8: + // match: (Less8 x y) + // cond: + // result: (SETL (CMPB x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto end445ad05f8d23dfecf246ce083f1ea167 + end445ad05f8d23dfecf246ce083f1ea167: + ; + case OpLess8U: + // match: (Less8U x y) + // cond: + // result: (SETB (CMPB x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto end816d1dff858c45836dfa337262e04649 + end816d1dff858c45836dfa337262e04649: + ; case OpLoad: // match: (Load ptr mem) // cond: (is64BitInt(t) || isPtr(t)) -- cgit v1.3 From 7402416a8b0dd30c7a245ca053561a87d4021be6 Mon Sep 17 00:00:00 2001 From: Alexandru Moșoi Date: Wed, 29 Jul 2015 17:52:25 +0200 Subject: [dev.ssa] cmd/compile/internal/ssa/gen: implement OOR. From compiling go there were 761 functions where OR was needed. Change-Id: Ied8bf59cec50a3175273387bc7416bd042def6d8 Reviewed-on: https://go-review.googlesource.com/12766 Reviewed-by: Keith Randall Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/gc/ssa.go | 14 +++- src/cmd/compile/internal/gc/testdata/arith_ssa.go | 22 ++++++ src/cmd/compile/internal/ssa/gen/AMD64.rules | 5 ++ src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 6 ++ src/cmd/compile/internal/ssa/gen/genericOps.go | 5 ++ src/cmd/compile/internal/ssa/opGen.go | 89 +++++++++++++++++++++++ src/cmd/compile/internal/ssa/rewriteAMD64.go | 72 ++++++++++++++++++ 7 files changed, 211 insertions(+), 2 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 8eeb29d4bd..4334dc729a 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -745,6 +745,15 @@ var opToSSA = map[opAndType]ssa.Op{ 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{OLSH, TINT8}: ssa.OpLsh8, opAndType{OLSH, TUINT8}: ssa.OpLsh8, opAndType{OLSH, TINT16}: ssa.OpLsh16, @@ -990,7 +999,7 @@ func (s *state) expr(n *Node) *ssa.Value { a := s.expr(n.Left) b := s.expr(n.Right) return s.newValue2(s.ssaOp(n.Op, n.Left.Type), ssa.TypeBool, a, b) - case OADD, OSUB, OMUL, OLSH, ORSH, OAND: + case OADD, OAND, OLSH, OMUL, OOR, ORSH, OSUB: a := s.expr(n.Left) b := s.expr(n.Right) return s.newValue2(s.ssaOp(n.Op, n.Type), a.Type, a, b) @@ -1621,7 +1630,8 @@ func genValue(v *ssa.Value) { p.To.Reg = regnum(v) case ssa.OpAMD64ADDB, ssa.OpAMD64ANDQ, ssa.OpAMD64ANDL, ssa.OpAMD64ANDW, ssa.OpAMD64ANDB, - ssa.OpAMD64MULQ, ssa.OpAMD64MULL, ssa.OpAMD64MULW: + ssa.OpAMD64MULQ, ssa.OpAMD64MULL, ssa.OpAMD64MULW, + ssa.OpAMD64ORQ, ssa.OpAMD64ORL, ssa.OpAMD64ORW, ssa.OpAMD64ORB: r := regnum(v) x := regnum(v.Args[0]) y := regnum(v.Args[1]) diff --git a/src/cmd/compile/internal/gc/testdata/arith_ssa.go b/src/cmd/compile/internal/gc/testdata/arith_ssa.go index 22fc034a1c..2731337dbf 100644 --- a/src/cmd/compile/internal/gc/testdata/arith_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/arith_ssa.go @@ -53,6 +53,28 @@ 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) + } + if want, got := uint32(1333785343), testBitwiseOr_ssa(a, b); want != got { + println("testBitwiseAnd failed, wanted", want, "got", got) + } +} + +func testBitwiseAnd_ssa(a, b uint32) uint32 { + switch { // prevent inlining + } + return a & b +} + +func testBitwiseOr_ssa(a, b uint32) uint32 { + switch { // prevent inlining + } + return a | b +} + var failed = false func main() { diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 3e667c8951..4ceb6185c5 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -21,6 +21,11 @@ (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) + (Sub64 x y) -> (SUBQ x y) (Sub32 x y) -> (SUBL x y) (Sub16 x y) -> (SUBW x y) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 40f7b1680f..1983ae8c44 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -203,6 +203,12 @@ func init() { {name: "ANDW", reg: gp21, asm: "ANDW"}, // arg0 & arg1 {name: "ANDB", reg: gp21, asm: "ANDB"}, // arg0 & arg1 + {name: "ORQ", reg: gp21, asm: "ORQ"}, // arg0 | arg1 + {name: "ORQconst", reg: gp11, asm: "ORQ"}, // arg0 | auxint + {name: "ORL", reg: gp21, asm: "ORL"}, // arg0 | arg1 + {name: "ORW", reg: gp21, asm: "ORW"}, // arg0 | arg1 + {name: "ORB", reg: gp21, asm: "ORB"}, // arg0 | arg1 + // (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. diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 732641319f..0459a2edc0 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -32,6 +32,11 @@ var genericOps = []opData{ {name: "And32"}, {name: "And64"}, + {name: "Or8"}, // arg0 | arg1 + {name: "Or16"}, + {name: "Or32"}, + {name: "Or64"}, + {name: "Lsh8"}, // arg0 << arg1 {name: "Lsh16"}, {name: "Lsh32"}, diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 358459ea8e..4fe098136f 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -134,6 +134,11 @@ const ( OpAMD64ANDL OpAMD64ANDW OpAMD64ANDB + OpAMD64ORQ + OpAMD64ORQconst + OpAMD64ORL + OpAMD64ORW + OpAMD64ORB OpAMD64InvertFlags OpAdd8 @@ -154,6 +159,10 @@ const ( OpAnd16 OpAnd32 OpAnd64 + OpOr8 + OpOr16 + OpOr32 + OpOr64 OpLsh8 OpLsh16 OpLsh32 @@ -1254,6 +1263,70 @@ var opcodeTable = [...]opInfo{ }, }, }, + { + name: "ORQ", + asm: x86.AORQ, + reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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: "ORQconst", + asm: x86.AORQ, + reg: regInfo{ + inputs: []regMask{ + 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: "ORL", + asm: x86.AORL, + reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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: "ORW", + asm: x86.AORW, + reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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: "ORB", + asm: x86.AORB, + reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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: "InvertFlags", reg: regInfo{}, @@ -1331,6 +1404,22 @@ var opcodeTable = [...]opInfo{ name: "And64", generic: true, }, + { + name: "Or8", + generic: true, + }, + { + name: "Or16", + generic: true, + }, + { + name: "Or32", + generic: true, + }, + { + name: "Or64", + generic: true, + }, { name: "Lsh8", generic: true, diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index b172cf3527..ec8e381201 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -2489,6 +2489,78 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end0429f947ee7ac49ff45a243e461a5290 end0429f947ee7ac49ff45a243e461a5290: ; + case OpOr16: + // match: (Or16 x y) + // cond: + // result: (ORW x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ORW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end8fedf2c79d5607b7056b0ff015199cbd + end8fedf2c79d5607b7056b0ff015199cbd: + ; + case OpOr32: + // match: (Or32 x y) + // cond: + // result: (ORL x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ORL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto endea45bed9ca97d2995b68b53e6012d384 + endea45bed9ca97d2995b68b53e6012d384: + ; + case OpOr64: + // match: (Or64 x y) + // cond: + // result: (ORQ x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ORQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end3a446becaf2461f4f1a41faeef313f41 + end3a446becaf2461f4f1a41faeef313f41: + ; + case OpOr8: + // match: (Or8 x y) + // cond: + // result: (ORB x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ORB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end6f8a8c559a167d1f0a5901d09a1fb248 + end6f8a8c559a167d1f0a5901d09a1fb248: + ; case OpRsh64: // match: (Rsh64 x y) // cond: y.Type.Size() == 8 -- cgit v1.3 From 20550cbaf1ebbb51227cb09b6890edd864026f06 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Tue, 28 Jul 2015 16:04:50 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: implement lots of small (<8byte) ops. Lots and lots of ops! Also XOR for good measure. Add a pass to the compiler generator to check that all of the architecture-specific opcodes are handled by genValue. We will catch any missing ones if we come across them during compilation, but probably better to catch them statically. Change-Id: Ic4adfbec55c8257f88117bc732fa664486262868 Reviewed-on: https://go-review.googlesource.com/12813 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/gc/ssa.go | 132 +- src/cmd/compile/internal/ssa/gen/AMD64.rules | 154 ++- src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 142 +- src/cmd/compile/internal/ssa/gen/genericOps.go | 5 + src/cmd/compile/internal/ssa/gen/main.go | 23 + src/cmd/compile/internal/ssa/opGen.go | 1311 +++++++++++++----- src/cmd/compile/internal/ssa/rewriteAMD64.go | 1729 +++++++++++++++++++++--- 7 files changed, 2865 insertions(+), 631 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 4334dc729a..7344d222cd 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1628,10 +1628,12 @@ func genValue(v *ssa.Value) { p.From.Index = regnum(v.Args[1]) p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v) + // 2-address opcode arithmetic, symmetric case ssa.OpAMD64ADDB, ssa.OpAMD64ANDQ, ssa.OpAMD64ANDL, ssa.OpAMD64ANDW, ssa.OpAMD64ANDB, - ssa.OpAMD64MULQ, ssa.OpAMD64MULL, ssa.OpAMD64MULW, - ssa.OpAMD64ORQ, ssa.OpAMD64ORL, ssa.OpAMD64ORW, ssa.OpAMD64ORB: + ssa.OpAMD64ORQ, ssa.OpAMD64ORL, ssa.OpAMD64ORW, ssa.OpAMD64ORB, + ssa.OpAMD64XORQ, ssa.OpAMD64XORL, ssa.OpAMD64XORW, ssa.OpAMD64XORB, + ssa.OpAMD64MULQ, ssa.OpAMD64MULL, ssa.OpAMD64MULW: r := regnum(v) x := regnum(v.Args[0]) y := regnum(v.Args[1]) @@ -1652,59 +1654,47 @@ func genValue(v *ssa.Value) { } else { p.From.Reg = x } - case ssa.OpAMD64ADDQconst: - // TODO: use addq instead of leaq if target is in the right register. - p := Prog(x86.ALEAQ) - p.From.Type = obj.TYPE_MEM - p.From.Reg = regnum(v.Args[0]) - p.From.Offset = v.AuxInt - p.To.Type = obj.TYPE_REG - p.To.Reg = regnum(v) - case ssa.OpAMD64MULQconst: + // 2-address opcode arithmetic, not symmetric + case ssa.OpAMD64SUBQ, ssa.OpAMD64SUBL, ssa.OpAMD64SUBW, ssa.OpAMD64SUBB: r := regnum(v) x := regnum(v.Args[0]) - if r != x { - p := Prog(x86.AMOVQ) + y := regnum(v.Args[1]) + var neg bool + if y == r { + // compute -(y-x) instead + x, y = y, x + neg = true + } + if x != r { + p := Prog(regMoveAMD64(v.Type.Size())) p.From.Type = obj.TYPE_REG p.From.Reg = x p.To.Type = obj.TYPE_REG p.To.Reg = r } - p := Prog(x86.AIMULQ) - p.From.Type = obj.TYPE_CONST - p.From.Offset = v.AuxInt + + p := Prog(v.Op.Asm()) + p.From.Type = obj.TYPE_REG 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: - // 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(x86.AMOVQ) + p.From.Reg = y + if neg { + p := Prog(x86.ANEGQ) // TODO: use correct size? This is mostly a hack until regalloc does 2-address correctly p.From.Type = obj.TYPE_REG - p.From.Reg = x + p.From.Reg = r p.To.Type = obj.TYPE_REG p.To.Reg = r } - p := Prog(x86.ASUBQ) - p.From.Type = obj.TYPE_CONST - p.From.Offset = v.AuxInt - p.To.Type = obj.TYPE_REG - p.To.Reg = r - case ssa.OpAMD64SHLQ, ssa.OpAMD64SHRQ, ssa.OpAMD64SARQ: + 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(x86.AMOVQ) + p := Prog(regMoveAMD64(v.Type.Size())) p.From.Type = obj.TYPE_REG p.From.Reg = x p.To.Type = obj.TYPE_REG @@ -1715,11 +1705,57 @@ func genValue(v *ssa.Value) { p.From.Reg = regnum(v.Args[1]) // should be CX p.To.Type = obj.TYPE_REG p.To.Reg = r - case ssa.OpAMD64ANDQconst, ssa.OpAMD64SHLQconst, ssa.OpAMD64SHRQconst, ssa.OpAMD64SARQconst, ssa.OpAMD64XORQconst: + case ssa.OpAMD64ADDQconst, ssa.OpAMD64ADDLconst, ssa.OpAMD64ADDWconst: + // TODO: use addq instead of leaq if target is in the right register. + var asm int + switch v.Op { + case ssa.OpAMD64ADDQconst: + asm = x86.ALEAQ + case ssa.OpAMD64ADDLconst: + asm = x86.ALEAL + case ssa.OpAMD64ADDWconst: + asm = x86.ALEAW + } + p := Prog(asm) + p.From.Type = obj.TYPE_MEM + p.From.Reg = regnum(v.Args[0]) + p.From.Offset = v.AuxInt + p.To.Type = obj.TYPE_REG + p.To.Reg = regnum(v) + case ssa.OpAMD64MULQconst, ssa.OpAMD64MULLconst, ssa.OpAMD64MULWconst: + r := regnum(v) + x := regnum(v.Args[0]) + if r != x { + p := Prog(regMoveAMD64(v.Type.Size())) + 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.AuxInt + 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.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.OpAMD64SUBQconst, ssa.OpAMD64SUBLconst, ssa.OpAMD64SUBWconst, 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: + // 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(x86.AMOVQ) + p := Prog(regMoveAMD64(v.Type.Size())) p.From.Type = obj.TYPE_REG p.From.Reg = x p.To.Type = obj.TYPE_REG @@ -1732,7 +1768,7 @@ func genValue(v *ssa.Value) { p.To.Reg = r case ssa.OpAMD64SBBQcarrymask: r := regnum(v) - p := Prog(x86.ASBBQ) + p := Prog(v.Op.Asm()) p.From.Type = obj.TYPE_REG p.From.Reg = r p.To.Type = obj.TYPE_REG @@ -1785,14 +1821,16 @@ func genValue(v *ssa.Value) { 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.OpAMD64TESTB, ssa.OpAMD64TESTQ: + case ssa.OpAMD64CMPQ, ssa.OpAMD64CMPL, ssa.OpAMD64CMPW, ssa.OpAMD64CMPB, + ssa.OpAMD64TESTQ, ssa.OpAMD64TESTL, ssa.OpAMD64TESTW, ssa.OpAMD64TESTB: 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.Args[1]) - case ssa.OpAMD64CMPQconst: - p := Prog(x86.ACMPQ) + case ssa.OpAMD64CMPQconst, ssa.OpAMD64CMPLconst, ssa.OpAMD64CMPWconst, ssa.OpAMD64CMPBconst, + ssa.OpAMD64TESTQconst, ssa.OpAMD64TESTLconst, ssa.OpAMD64TESTWconst, ssa.OpAMD64TESTBconst: + p := Prog(v.Op.Asm()) p.From.Type = obj.TYPE_REG p.From.Reg = regnum(v.Args[0]) p.To.Type = obj.TYPE_CONST @@ -1943,6 +1981,16 @@ func genValue(v *ssa.Value) { p := Prog(v.Op.Asm()) p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v) + case ssa.OpAMD64InvertFlags: + v.Fatalf("InvertFlags should never make it to codegen %v", v) + case ssa.OpAMD64REPSTOSQ: + Prog(x86.AREP) + Prog(x86.ASTOSQ) + v.Unimplementedf("REPSTOSQ clobbers not implemented: %s", v.LongString()) + case ssa.OpAMD64REPMOVSB: + Prog(x86.AREP) + Prog(x86.AMOVSB) + v.Unimplementedf("REPMOVSB clobbers not implemented: %s", v.LongString()) default: v.Unimplementedf("genValue not implemented: %s", v.LongString()) } diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 4ceb6185c5..08c1d98481 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -16,6 +16,20 @@ (Add16 x y) -> (ADDW x y) (Add8 x y) -> (ADDB x y) +(Sub64 x y) -> (SUBQ x y) +(Sub32 x y) -> (SUBL x y) +(Sub16 x y) -> (SUBW x y) +(Sub8 x y) -> (SUBB x y) + +(Mul64 x y) -> (MULQ x y) +(MulPtr x y) -> (MULQ x y) +(Mul32 x y) -> (MULL x y) +(Mul16 x y) -> (MULW x y) +// Note: we use 16-bit multiply instructions for 8-bit multiplies because +// the 16-bit multiply instructions are more forgiving (they operate on +// any register instead of just AX/DX). +(Mul8 x y) -> (MULW x y) + (And64 x y) -> (ANDQ x y) (And32 x y) -> (ANDL x y) (And16 x y) -> (ANDW x y) @@ -26,25 +40,16 @@ (Or16 x y) -> (ORW x y) (Or8 x y) -> (ORB x y) -(Sub64 x y) -> (SUBQ x y) -(Sub32 x y) -> (SUBL x y) -(Sub16 x y) -> (SUBW x y) -(Sub8 x y) -> (SUBB 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) -(Mul64 x y) -> (MULQ x y) -(MulPtr x y) -> (MULQ x y) -(Mul32 x y) -> (MULL x y) -(Mul16 x y) -> (MULW x y) -// Note: we use 16-bit multiply instructions for 8-bit multiplies because -// the 16-bit multiply instructions are more forgiving (they operate on -// any register instead of just AX/DX). -(Mul8 x y) -> (MULW x y) - // 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) @@ -76,8 +81,43 @@ // Note: unsigned shifts need to return 0 if shift amount is >= 64. // mask = shift >= 64 ? 0 : 0xffffffffffffffff // result = mask & arg << shift +// TODO: define ops per right-hand side size, like Lsh64x32 for int64(x)< x y) && y.Type.Size() == 8 -> (ANDQ (SHLQ x y) (SBBQcarrymask (CMPQconst [64] y))) +(Lsh64 x y) && y.Type.Size() == 4 -> + (ANDQ (SHLQ x y) (SBBQcarrymask (CMPLconst [64] y))) +(Lsh64 x y) && y.Type.Size() == 2 -> + (ANDQ (SHLQ x y) (SBBQcarrymask (CMPWconst [64] y))) +(Lsh64 x y) && y.Type.Size() == 1 -> + (ANDQ (SHLQ x y) (SBBQcarrymask (CMPBconst [64] y))) + +(Lsh32 x y) && y.Type.Size() == 8 -> + (ANDL (SHLL x y) (SBBQcarrymask (CMPQconst [32] y))) +(Lsh32 x y) && y.Type.Size() == 4 -> + (ANDL (SHLL x y) (SBBQcarrymask (CMPLconst [32] y))) +(Lsh32 x y) && y.Type.Size() == 2 -> + (ANDL (SHLL x y) (SBBQcarrymask (CMPWconst [32] y))) +(Lsh32 x y) && y.Type.Size() == 1 -> + (ANDL (SHLL x y) (SBBQcarrymask (CMPBconst [32] y))) + +(Lsh16 x y) && y.Type.Size() == 8 -> + (ANDW (SHLW x y) (SBBQcarrymask (CMPQconst [16] y))) +(Lsh16 x y) && y.Type.Size() == 4 -> + (ANDW (SHLW x y) (SBBQcarrymask (CMPLconst [16] y))) +(Lsh16 x y) && y.Type.Size() == 2 -> + (ANDW (SHLW x y) (SBBQcarrymask (CMPWconst [16] y))) +(Lsh16 x y) && y.Type.Size() == 1 -> + (ANDW (SHLW x y) (SBBQcarrymask (CMPBconst [16] y))) + +(Lsh8 x y) && y.Type.Size() == 8 -> + (ANDB (SHLB x y) (SBBQcarrymask (CMPQconst [8] y))) +(Lsh8 x y) && y.Type.Size() == 4 -> + (ANDB (SHLB x y) (SBBQcarrymask (CMPLconst [8] y))) +(Lsh8 x y) && y.Type.Size() == 2 -> + (ANDB (SHLB x y) (SBBQcarrymask (CMPWconst [8] y))) +(Lsh8 x y) && y.Type.Size() == 1 -> + (ANDB (SHLB x y) (SBBQcarrymask (CMPBconst [8] y))) + (Rsh64U x y) && y.Type.Size() == 8 -> (ANDQ (SHRQ x y) (SBBQcarrymask (CMPQconst [64] y))) @@ -158,7 +198,7 @@ (Move [size] dst src mem) -> (REPMOVSB dst src (MOVQconst [size]) mem) -(Not x) -> (XORQconst [1] x) +(Not x) -> (XORBconst [1] x) (OffPtr [off] ptr) -> (ADDQconst [off] ptr) @@ -193,20 +233,86 @@ // TODO: Should this be a separate pass? // fold constants into instructions -// TODO: restrict c to int32 range for all? (ADDQ x (MOVQconst [c])) && is32Bit(c) -> (ADDQconst [c] x) (ADDQ (MOVQconst [c]) x) && is32Bit(c) -> (ADDQconst [c] x) -(SUBQ x (MOVQconst [c])) -> (SUBQconst x [c]) -(SUBQ (MOVQconst [c]) x) -> (NEGQ (SUBQconst x [c])) +(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 x [c])) +(SUBL x (MOVLconst [c])) -> (SUBLconst x [c]) +(SUBL (MOVLconst [c]) x) -> (NEGL (SUBLconst x [c])) +(SUBW x (MOVWconst [c])) -> (SUBWconst x [c]) +(SUBW (MOVWconst [c]) x) -> (NEGW (SUBWconst x [c])) +(SUBB x (MOVBconst [c])) -> (SUBBconst x [c]) +(SUBB (MOVBconst [c]) x) -> (NEGB (SUBBconst x [c])) + (MULQ x (MOVQconst [c])) && is32Bit(c) -> (MULQconst [c] x) (MULQ (MOVQconst [c]) x) && is32Bit(c) -> (MULQconst [c] x) -(ANDQ x (MOVQconst [c])) -> (ANDQconst [c] x) -(ANDQ (MOVQconst [c]) x) -> (ANDQconst [c] x) -(SHLQ x (MOVQconst [c])) -> (SHLQconst [c] x) -(SHRQ x (MOVQconst [c])) -> (SHRQconst [c] x) -(SARQ x (MOVQconst [c])) -> (SARQconst [c] x) -(CMPQ x (MOVQconst [c])) -> (CMPQconst x [c]) -(CMPQ (MOVQconst [c]) x) -> (InvertFlags (CMPQconst x [c])) +(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) + +(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 (MOVWconst [c])) -> (ANDWconst [c] x) +(ANDW (MOVWconst [c]) x) -> (ANDWconst [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) +(SHLL x (MOVLconst [c])) -> (SHLLconst [c&31] x) +(SHLW x (MOVWconst [c])) -> (SHLWconst [c&31] x) +(SHLB x (MOVBconst [c])) -> (SHLBconst [c&31] x) + +(SHRQ x (MOVQconst [c])) -> (SHRQconst [c&63] x) +(SHRL x (MOVLconst [c])) -> (SHRLconst [c&31] x) +(SHRW x (MOVWconst [c])) -> (SHRWconst [c&31] x) +(SHRB x (MOVBconst [c])) -> (SHRBconst [c&31] x) + +(SARQ x (MOVQconst [c])) -> (SARQconst [c&63] x) +(SARL x (MOVLconst [c])) -> (SARLconst [c&31] x) +(SARW x (MOVWconst [c])) -> (SARWconst [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) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 1983ae8c44..a595469134 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -96,25 +96,110 @@ func init() { // TODO: 2-address instructions. Mark ops as needing matching input/output regs. var AMD64ops = []opData{ + // binary ops + {name: "ADDQ", reg: gp21, asm: "ADDQ"}, // arg0 + arg1 + {name: "ADDL", reg: gp21, asm: "ADDL"}, // arg0 + arg1 + {name: "ADDW", reg: gp21, asm: "ADDW"}, // arg0 + arg1 + {name: "ADDB", reg: gp21, asm: "ADDB"}, // arg0 + arg1 + {name: "ADDQconst", reg: gp11, asm: "ADDQ"}, // arg0 + auxint + {name: "ADDLconst", reg: gp11, asm: "ADDL"}, // arg0 + auxint + {name: "ADDWconst", reg: gp11, asm: "ADDW"}, // arg0 + auxint + {name: "ADDBconst", reg: gp11, asm: "ADDB"}, // arg0 + auxint + + {name: "SUBQ", reg: gp21, asm: "SUBQ"}, // arg0 - arg1 + {name: "SUBL", reg: gp21, asm: "SUBL"}, // arg0 - arg1 + {name: "SUBW", reg: gp21, asm: "SUBW"}, // arg0 - arg1 + {name: "SUBB", reg: gp21, asm: "SUBB"}, // arg0 - arg1 + {name: "SUBQconst", reg: gp11, asm: "SUBQ"}, // arg0 - auxint + {name: "SUBLconst", reg: gp11, asm: "SUBL"}, // arg0 - auxint + {name: "SUBWconst", reg: gp11, asm: "SUBW"}, // arg0 - auxint + {name: "SUBBconst", reg: gp11, asm: "SUBB"}, // arg0 - auxint + {name: "MULQ", reg: gp21, asm: "IMULQ"}, // arg0 * arg1 + {name: "MULL", reg: gp21, asm: "IMULL"}, // arg0 * arg1 + {name: "MULW", reg: gp21, asm: "IMULW"}, // arg0 * arg1 {name: "MULQconst", reg: gp11, asm: "IMULQ"}, // arg0 * auxint - {name: "SHLQ", reg: gp21shift, asm: "SHLQ"}, // arg0 << arg1, shift amount is mod 64 - {name: "SHLQconst", reg: gp11, asm: "SHLQ"}, // arg0 << auxint, shift amount 0-63 - {name: "SHRQ", reg: gp21shift, asm: "SHRQ"}, // unsigned arg0 >> arg1, shift amount is mod 64 - {name: "SHRQconst", reg: gp11, asm: "SHRQ"}, // unsigned arg0 >> auxint, shift amount 0-63 - {name: "SARQ", reg: gp21shift, asm: "SARQ"}, // signed arg0 >> arg1, shift amount is mod 64 - {name: "SARQconst", reg: gp11, asm: "SARQ"}, // signed arg0 >> auxint, shift amount 0-63 + {name: "MULLconst", reg: gp11, asm: "IMULL"}, // arg0 * auxint + {name: "MULWconst", reg: gp11, asm: "IMULW"}, // arg0 * auxint + + {name: "ANDQ", reg: gp21, asm: "ANDQ"}, // arg0 & arg1 + {name: "ANDL", reg: gp21, asm: "ANDL"}, // arg0 & arg1 + {name: "ANDW", reg: gp21, asm: "ANDW"}, // arg0 & arg1 + {name: "ANDB", reg: gp21, asm: "ANDB"}, // arg0 & arg1 + {name: "ANDQconst", reg: gp11, asm: "ANDQ"}, // arg0 & auxint + {name: "ANDLconst", reg: gp11, asm: "ANDL"}, // arg0 & auxint + {name: "ANDWconst", reg: gp11, asm: "ANDW"}, // arg0 & auxint + {name: "ANDBconst", reg: gp11, asm: "ANDB"}, // arg0 & auxint + + {name: "ORQ", reg: gp21, asm: "ORQ"}, // arg0 | arg1 + {name: "ORL", reg: gp21, asm: "ORL"}, // arg0 | arg1 + {name: "ORW", reg: gp21, asm: "ORW"}, // arg0 | arg1 + {name: "ORB", reg: gp21, asm: "ORB"}, // arg0 | arg1 + {name: "ORQconst", reg: gp11, asm: "ORQ"}, // arg0 | auxint + {name: "ORLconst", reg: gp11, asm: "ORL"}, // arg0 | auxint + {name: "ORWconst", reg: gp11, asm: "ORW"}, // arg0 | auxint + {name: "ORBconst", reg: gp11, asm: "ORB"}, // arg0 | auxint - {name: "XORQconst", reg: gp11, asm: "XORQ"}, // arg0^auxint + {name: "XORQ", reg: gp21, asm: "XORQ"}, // arg0 ^ arg1 + {name: "XORL", reg: gp21, asm: "XORL"}, // arg0 ^ arg1 + {name: "XORW", reg: gp21, asm: "XORW"}, // arg0 ^ arg1 + {name: "XORB", reg: gp21, asm: "XORB"}, // arg0 ^ arg1 + {name: "XORQconst", reg: gp11, asm: "XORQ"}, // arg0 ^ auxint + {name: "XORLconst", reg: gp11, asm: "XORL"}, // arg0 ^ auxint + {name: "XORWconst", reg: gp11, asm: "XORW"}, // arg0 ^ auxint + {name: "XORBconst", reg: gp11, asm: "XORB"}, // arg0 ^ auxint {name: "CMPQ", reg: gp2flags, asm: "CMPQ"}, // arg0 compare to arg1 - {name: "CMPQconst", reg: gp1flags, asm: "CMPQ"}, // arg0 compare to auxint {name: "CMPL", reg: gp2flags, asm: "CMPL"}, // arg0 compare to arg1 {name: "CMPW", reg: gp2flags, asm: "CMPW"}, // arg0 compare to arg1 {name: "CMPB", reg: gp2flags, asm: "CMPB"}, // arg0 compare to arg1 + {name: "CMPQconst", reg: gp1flags, asm: "CMPQ"}, // arg0 compare to auxint + {name: "CMPLconst", reg: gp1flags, asm: "CMPL"}, // arg0 compare to auxint + {name: "CMPWconst", reg: gp1flags, asm: "CMPW"}, // arg0 compare to auxint + {name: "CMPBconst", reg: gp1flags, asm: "CMPB"}, // arg0 compare to auxint - {name: "TESTQ", reg: gp2flags, asm: "TESTQ"}, // (arg0 & arg1) compare to 0 - {name: "TESTB", reg: gp2flags, asm: "TESTB"}, // (arg0 & arg1) compare to 0 + {name: "TESTQ", reg: gp2flags, asm: "TESTQ"}, // (arg0 & arg1) compare to 0 + {name: "TESTL", reg: gp2flags, asm: "TESTL"}, // (arg0 & arg1) compare to 0 + {name: "TESTW", reg: gp2flags, asm: "TESTW"}, // (arg0 & arg1) compare to 0 + {name: "TESTB", reg: gp2flags, asm: "TESTB"}, // (arg0 & arg1) compare to 0 + {name: "TESTQconst", reg: gp1flags, asm: "TESTQ"}, // (arg0 & auxint) compare to 0 + {name: "TESTLconst", reg: gp1flags, asm: "TESTL"}, // (arg0 & auxint) compare to 0 + {name: "TESTWconst", reg: gp1flags, asm: "TESTW"}, // (arg0 & auxint) compare to 0 + {name: "TESTBconst", reg: gp1flags, asm: "TESTB"}, // (arg0 & auxint) compare to 0 + + {name: "SHLQ", reg: gp21shift, asm: "SHLQ"}, // arg0 << arg1, shift amount is mod 64 + {name: "SHLL", reg: gp21shift, asm: "SHLL"}, // arg0 << arg1, shift amount is mod 32 + {name: "SHLW", reg: gp21shift, asm: "SHLW"}, // arg0 << arg1, shift amount is mod 32 + {name: "SHLB", reg: gp21shift, asm: "SHLB"}, // arg0 << arg1, shift amount is mod 32 + {name: "SHLQconst", reg: gp11, asm: "SHLQ"}, // arg0 << auxint, shift amount 0-63 + {name: "SHLLconst", reg: gp11, asm: "SHLL"}, // arg0 << auxint, shift amount 0-31 + {name: "SHLWconst", reg: gp11, asm: "SHLW"}, // arg0 << auxint, shift amount 0-31 + {name: "SHLBconst", reg: gp11, asm: "SHLB"}, // 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", reg: gp21shift, asm: "SHRQ"}, // unsigned arg0 >> arg1, shift amount is mod 64 + {name: "SHRL", reg: gp21shift, asm: "SHRL"}, // unsigned arg0 >> arg1, shift amount is mod 32 + {name: "SHRW", reg: gp21shift, asm: "SHRW"}, // unsigned arg0 >> arg1, shift amount is mod 32 + {name: "SHRB", reg: gp21shift, asm: "SHRB"}, // unsigned arg0 >> arg1, shift amount is mod 32 + {name: "SHRQconst", reg: gp11, asm: "SHRQ"}, // unsigned arg0 >> auxint, shift amount 0-63 + {name: "SHRLconst", reg: gp11, asm: "SHRL"}, // unsigned arg0 >> auxint, shift amount 0-31 + {name: "SHRWconst", reg: gp11, asm: "SHRW"}, // unsigned arg0 >> auxint, shift amount 0-31 + {name: "SHRBconst", reg: gp11, asm: "SHRB"}, // unsigned arg0 >> auxint, shift amount 0-31 + + {name: "SARQ", reg: gp21shift, asm: "SARQ"}, // signed arg0 >> arg1, shift amount is mod 64 + {name: "SARL", reg: gp21shift, asm: "SARL"}, // signed arg0 >> arg1, shift amount is mod 32 + {name: "SARW", reg: gp21shift, asm: "SARW"}, // signed arg0 >> arg1, shift amount is mod 32 + {name: "SARB", reg: gp21shift, asm: "SARB"}, // signed arg0 >> arg1, shift amount is mod 32 + {name: "SARQconst", reg: gp11, asm: "SARQ"}, // signed arg0 >> auxint, shift amount 0-63 + {name: "SARLconst", reg: gp11, asm: "SARL"}, // signed arg0 >> auxint, shift amount 0-31 + {name: "SARWconst", reg: gp11, asm: "SARW"}, // signed arg0 >> auxint, shift amount 0-31 + {name: "SARBconst", reg: gp11, asm: "SARB"}, // signed arg0 >> auxint, shift amount 0-31 + + // unary ops + {name: "NEGQ", reg: gp11, asm: "NEGQ"}, // -arg0 + {name: "NEGL", reg: gp11, asm: "NEGL"}, // -arg0 + {name: "NEGW", reg: gp11, asm: "NEGW"}, // -arg0 + {name: "NEGB", reg: gp11, asm: "NEGB"}, // -arg0 {name: "SBBQcarrymask", reg: flagsgp1, asm: "SBBQ"}, // (int64)(-1) if carry is set, 0 if carry is clear. @@ -166,49 +251,12 @@ func init() { // TODO: implement this when register clobbering works {name: "REPSTOSQ", reg: regInfo{[]regMask{buildReg("DI"), buildReg("CX")}, buildReg("DI AX CX"), nil}}, // store arg1 8-byte words containing zero into arg0 using STOSQ. arg2=mem. - // Load/store from global. Same as the above loads, but arg0 is missing and - // aux is a GlobalOffset instead of an int64. - {name: "MOVQloadglobal"}, // Load from aux.(GlobalOffset). arg0 = memory - {name: "MOVQstoreglobal"}, // store arg0 to aux.(GlobalOffset). arg1=memory, returns memory. - //TODO: set register clobber to everything? {name: "CALLstatic"}, // call static function aux.(*gc.Sym). arg0=mem, returns mem {name: "CALLclosure", reg: regInfo{[]regMask{gpsp, buildReg("DX"), 0}, 0, nil}}, // call function via closure. arg0=codeptr, arg1=closure, arg2=mem returns mem {name: "REPMOVSB", reg: regInfo{[]regMask{buildReg("DI"), buildReg("SI"), buildReg("CX")}, buildReg("DI SI CX"), nil}}, // move arg2 bytes from arg1 to arg0. arg3=mem, returns memory - {name: "ADDQ", reg: gp21}, // arg0 + arg1 - {name: "ADDQconst", reg: gp11}, // arg0 + auxint - {name: "ADDL", reg: gp21, asm: "ADDL"}, // arg0 + arg1 - {name: "ADDW", reg: gp21, asm: "ADDW"}, // arg0 + arg1 - {name: "ADDB", reg: gp21, asm: "ADDB"}, // arg0 + arg1 - - {name: "SUBQ", reg: gp21, asm: "SUBQ"}, // arg0 - arg1 - {name: "SUBQconst", reg: gp11, asm: "SUBQ"}, // arg0 - auxint - {name: "SUBL", reg: gp21, asm: "SUBL"}, // arg0 - arg1 - {name: "SUBW", reg: gp21, asm: "SUBW"}, // arg0 - arg1 - {name: "SUBB", reg: gp21, asm: "SUBB"}, // arg0 - arg1 - - {name: "NEGQ", reg: gp11, asm: "NEGQ"}, // -arg0 - {name: "NEGL", reg: gp11, asm: "NEGL"}, // -arg0 - {name: "NEGW", reg: gp11, asm: "NEGW"}, // -arg0 - {name: "NEGB", reg: gp11, asm: "NEGB"}, // -arg0 - - {name: "MULL", reg: gp21, asm: "IMULL"}, // arg0*arg1 - {name: "MULW", reg: gp21, asm: "IMULW"}, // arg0*arg1 - - {name: "ANDQ", reg: gp21, asm: "ANDQ"}, // arg0 & arg1 - {name: "ANDQconst", reg: gp11, asm: "ANDQ"}, // arg0 & auxint - {name: "ANDL", reg: gp21, asm: "ANDL"}, // arg0 & arg1 - {name: "ANDW", reg: gp21, asm: "ANDW"}, // arg0 & arg1 - {name: "ANDB", reg: gp21, asm: "ANDB"}, // arg0 & arg1 - - {name: "ORQ", reg: gp21, asm: "ORQ"}, // arg0 | arg1 - {name: "ORQconst", reg: gp11, asm: "ORQ"}, // arg0 | auxint - {name: "ORL", reg: gp21, asm: "ORL"}, // arg0 | arg1 - {name: "ORW", reg: gp21, asm: "ORW"}, // arg0 | arg1 - {name: "ORB", reg: gp21, asm: "ORB"}, // arg0 | arg1 - // (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. diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 0459a2edc0..9e71dbdb74 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -37,6 +37,11 @@ var genericOps = []opData{ {name: "Or32"}, {name: "Or64"}, + {name: "Xor8"}, // arg0 ^ arg1 + {name: "Xor16"}, + {name: "Xor32"}, + {name: "Xor64"}, + {name: "Lsh8"}, // arg0 << arg1 {name: "Lsh16"}, {name: "Lsh32"}, diff --git a/src/cmd/compile/internal/ssa/gen/main.go b/src/cmd/compile/internal/ssa/gen/main.go index 007d33ec23..ddc2c6df96 100644 --- a/src/cmd/compile/internal/ssa/gen/main.go +++ b/src/cmd/compile/internal/ssa/gen/main.go @@ -13,6 +13,7 @@ import ( "go/format" "io/ioutil" "log" + "regexp" ) type arch struct { @@ -164,6 +165,28 @@ func genOp() { 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. diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 4fe098136f..c4b4e80a11 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -51,22 +51,96 @@ func (k BlockKind) String() string { return blockString[k] } const ( OpInvalid Op = iota + OpAMD64ADDQ + OpAMD64ADDL + OpAMD64ADDW + OpAMD64ADDB + OpAMD64ADDQconst + OpAMD64ADDLconst + OpAMD64ADDWconst + OpAMD64ADDBconst + OpAMD64SUBQ + OpAMD64SUBL + OpAMD64SUBW + OpAMD64SUBB + OpAMD64SUBQconst + OpAMD64SUBLconst + OpAMD64SUBWconst + OpAMD64SUBBconst OpAMD64MULQ + OpAMD64MULL + OpAMD64MULW OpAMD64MULQconst - OpAMD64SHLQ - OpAMD64SHLQconst - OpAMD64SHRQ - OpAMD64SHRQconst - OpAMD64SARQ - OpAMD64SARQconst + OpAMD64MULLconst + OpAMD64MULWconst + 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 - OpAMD64CMPQconst OpAMD64CMPL OpAMD64CMPW OpAMD64CMPB + OpAMD64CMPQconst + OpAMD64CMPLconst + OpAMD64CMPWconst + OpAMD64CMPBconst 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 + OpAMD64NEGQ + OpAMD64NEGL + OpAMD64NEGW + OpAMD64NEGB OpAMD64SBBQcarrymask OpAMD64SETEQ OpAMD64SETNE @@ -108,37 +182,9 @@ const ( OpAMD64MOVQstoreidx8 OpAMD64MOVXzero OpAMD64REPSTOSQ - OpAMD64MOVQloadglobal - OpAMD64MOVQstoreglobal OpAMD64CALLstatic OpAMD64CALLclosure OpAMD64REPMOVSB - OpAMD64ADDQ - OpAMD64ADDQconst - OpAMD64ADDL - OpAMD64ADDW - OpAMD64ADDB - OpAMD64SUBQ - OpAMD64SUBQconst - OpAMD64SUBL - OpAMD64SUBW - OpAMD64SUBB - OpAMD64NEGQ - OpAMD64NEGL - OpAMD64NEGW - OpAMD64NEGB - OpAMD64MULL - OpAMD64MULW - OpAMD64ANDQ - OpAMD64ANDQconst - OpAMD64ANDL - OpAMD64ANDW - OpAMD64ANDB - OpAMD64ORQ - OpAMD64ORQconst - OpAMD64ORL - OpAMD64ORW - OpAMD64ORB OpAMD64InvertFlags OpAdd8 @@ -163,6 +209,10 @@ const ( OpOr16 OpOr32 OpOr64 + OpXor8 + OpXor16 + OpXor32 + OpXor64 OpLsh8 OpLsh16 OpLsh32 @@ -286,8 +336,8 @@ var opcodeTable = [...]opInfo{ {name: "OpInvalid"}, { - name: "MULQ", - asm: x86.AIMULQ, + name: "ADDQ", + asm: x86.AADDQ, reg: regInfo{ inputs: []regMask{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -299,11 +349,12 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MULQconst", - asm: x86.AIMULQ, + name: "ADDL", + asm: x86.AADDL, reg: regInfo{ inputs: []regMask{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 @@ -311,12 +362,12 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SHLQ", - asm: x86.ASHLQ, + name: "ADDW", + asm: x86.AADDW, reg: regInfo{ inputs: []regMask{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 2, // .CX + 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 @@ -324,11 +375,12 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SHLQconst", - asm: x86.ASHLQ, + name: "ADDB", + asm: x86.AADDB, reg: regInfo{ inputs: []regMask{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 @@ -336,12 +388,11 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SHRQ", - asm: x86.ASHRQ, + name: "ADDQconst", + asm: x86.AADDQ, reg: regInfo{ inputs: []regMask{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 2, // .CX }, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -349,8 +400,8 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SHRQconst", - asm: x86.ASHRQ, + name: "ADDLconst", + asm: x86.AADDL, reg: regInfo{ inputs: []regMask{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -361,12 +412,11 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SARQ", - asm: x86.ASARQ, + name: "ADDWconst", + asm: x86.AADDW, reg: regInfo{ inputs: []regMask{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 2, // .CX }, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -374,8 +424,8 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SARQconst", - asm: x86.ASARQ, + name: "ADDBconst", + asm: x86.AADDB, reg: regInfo{ inputs: []regMask{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -386,11 +436,12 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "XORQconst", - asm: x86.AXORQ, + name: "SUBQ", + asm: x86.ASUBQ, reg: regInfo{ inputs: []regMask{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 @@ -398,101 +449,99 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "CMPQ", - asm: x86.ACMPQ, + name: "SUBL", + asm: x86.ASUBL, reg: regInfo{ inputs: []regMask{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, outputs: []regMask{ - 8589934592, // .FLAGS + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, { - name: "CMPQconst", - asm: x86.ACMPQ, + name: "SUBW", + asm: x86.ASUBW, reg: regInfo{ inputs: []regMask{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, outputs: []regMask{ - 8589934592, // .FLAGS + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, { - name: "CMPL", - asm: x86.ACMPL, + name: "SUBB", + asm: x86.ASUBB, reg: regInfo{ inputs: []regMask{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, outputs: []regMask{ - 8589934592, // .FLAGS + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, { - name: "CMPW", - asm: x86.ACMPW, + name: "SUBQconst", + asm: x86.ASUBQ, reg: regInfo{ inputs: []regMask{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, outputs: []regMask{ - 8589934592, // .FLAGS + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, { - name: "CMPB", - asm: x86.ACMPB, + name: "SUBLconst", + asm: x86.ASUBL, reg: regInfo{ inputs: []regMask{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, outputs: []regMask{ - 8589934592, // .FLAGS + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, { - name: "TESTQ", - asm: x86.ATESTQ, + name: "SUBWconst", + asm: x86.ASUBW, reg: regInfo{ inputs: []regMask{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, outputs: []regMask{ - 8589934592, // .FLAGS + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, { - name: "TESTB", - asm: x86.ATESTB, + name: "SUBBconst", + asm: x86.ASUBB, reg: regInfo{ inputs: []regMask{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, outputs: []regMask{ - 8589934592, // .FLAGS + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, { - name: "SBBQcarrymask", - asm: x86.ASBBQ, + name: "MULQ", + asm: x86.AIMULQ, reg: regInfo{ inputs: []regMask{ - 8589934592, // .FLAGS + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 @@ -500,11 +549,12 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SETEQ", - asm: x86.ASETEQ, + name: "MULL", + asm: x86.AIMULL, reg: regInfo{ inputs: []regMask{ - 8589934592, // .FLAGS + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 @@ -512,11 +562,12 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SETNE", - asm: x86.ASETNE, + name: "MULW", + asm: x86.AIMULW, reg: regInfo{ inputs: []regMask{ - 8589934592, // .FLAGS + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 @@ -524,11 +575,11 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SETL", - asm: x86.ASETLT, + name: "MULQconst", + asm: x86.AIMULQ, reg: regInfo{ inputs: []regMask{ - 8589934592, // .FLAGS + 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 @@ -536,11 +587,11 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SETLE", - asm: x86.ASETLE, + name: "MULLconst", + asm: x86.AIMULL, reg: regInfo{ inputs: []regMask{ - 8589934592, // .FLAGS + 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 @@ -548,11 +599,11 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SETG", - asm: x86.ASETGT, + name: "MULWconst", + asm: x86.AIMULW, reg: regInfo{ inputs: []regMask{ - 8589934592, // .FLAGS + 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 @@ -560,11 +611,12 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SETGE", - asm: x86.ASETGE, + name: "ANDQ", + asm: x86.AANDQ, reg: regInfo{ inputs: []regMask{ - 8589934592, // .FLAGS + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 @@ -572,11 +624,12 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SETB", - asm: x86.ASETCS, + name: "ANDL", + asm: x86.AANDL, reg: regInfo{ inputs: []regMask{ - 8589934592, // .FLAGS + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 @@ -584,11 +637,12 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SETBE", - asm: x86.ASETLS, + name: "ANDW", + asm: x86.AANDW, reg: regInfo{ inputs: []regMask{ - 8589934592, // .FLAGS + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 @@ -596,11 +650,12 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SETA", - asm: x86.ASETHI, + name: "ANDB", + asm: x86.AANDB, reg: regInfo{ inputs: []regMask{ - 8589934592, // .FLAGS + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 @@ -608,11 +663,11 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SETAE", - asm: x86.ASETCC, + name: "ANDQconst", + asm: x86.AANDQ, reg: regInfo{ inputs: []regMask{ - 8589934592, // .FLAGS + 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 @@ -620,12 +675,11 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "CMOVQCC", + name: "ANDLconst", + asm: x86.AANDL, reg: regInfo{ inputs: []regMask{ - 8589934592, // .FLAGS - 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 @@ -633,8 +687,8 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVBQSX", - asm: x86.AMOVBQSX, + name: "ANDWconst", + asm: x86.AANDW, reg: regInfo{ inputs: []regMask{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -645,8 +699,8 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVBQZX", - asm: x86.AMOVBQZX, + name: "ANDBconst", + asm: x86.AANDB, reg: regInfo{ inputs: []regMask{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -657,11 +711,12 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVWQSX", - asm: x86.AMOVWQSX, + name: "ORQ", + asm: x86.AORQ, reg: regInfo{ inputs: []regMask{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 @@ -669,11 +724,12 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVWQZX", - asm: x86.AMOVWQZX, + name: "ORL", + asm: x86.AORL, reg: regInfo{ inputs: []regMask{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 @@ -681,11 +737,12 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVLQSX", - asm: x86.AMOVLQSX, + name: "ORW", + asm: x86.AORW, reg: regInfo{ inputs: []regMask{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 @@ -693,11 +750,12 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVLQZX", - asm: x86.AMOVLQZX, + name: "ORB", + asm: x86.AORB, reg: regInfo{ inputs: []regMask{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 @@ -705,46 +763,511 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVBconst", - asm: x86.AMOVB, + name: "ORQconst", + asm: x86.AORQ, reg: regInfo{ - outputs: []regMask{ + inputs: []regMask{ + 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: "ORLconst", + asm: x86.AORL, + reg: regInfo{ + inputs: []regMask{ + 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: "ORWconst", + asm: x86.AORW, + reg: regInfo{ + inputs: []regMask{ + 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: "ORBconst", + asm: x86.AORB, + reg: regInfo{ + inputs: []regMask{ + 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: "XORQ", + asm: x86.AXORQ, + reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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: "XORL", + asm: x86.AXORL, + reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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: "XORW", + asm: x86.AXORW, + reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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: "XORB", + asm: x86.AXORB, + reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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: "XORQconst", + asm: x86.AXORQ, + reg: regInfo{ + inputs: []regMask{ + 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: "XORLconst", + asm: x86.AXORL, + reg: regInfo{ + inputs: []regMask{ + 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: "XORWconst", + asm: x86.AXORW, + reg: regInfo{ + inputs: []regMask{ + 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: "XORBconst", + asm: x86.AXORB, + reg: regInfo{ + inputs: []regMask{ + 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: "CMPQ", + asm: x86.ACMPQ, + reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + outputs: []regMask{ + 8589934592, // .FLAGS + }, + }, + }, + { + name: "CMPL", + asm: x86.ACMPL, + reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + outputs: []regMask{ + 8589934592, // .FLAGS + }, + }, + }, + { + name: "CMPW", + asm: x86.ACMPW, + reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + outputs: []regMask{ + 8589934592, // .FLAGS + }, + }, + }, + { + name: "CMPB", + asm: x86.ACMPB, + reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + outputs: []regMask{ + 8589934592, // .FLAGS + }, + }, + }, + { + name: "CMPQconst", + asm: x86.ACMPQ, + reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + outputs: []regMask{ + 8589934592, // .FLAGS + }, + }, + }, + { + name: "CMPLconst", + asm: x86.ACMPL, + reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + outputs: []regMask{ + 8589934592, // .FLAGS + }, + }, + }, + { + name: "CMPWconst", + asm: x86.ACMPW, + reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + outputs: []regMask{ + 8589934592, // .FLAGS + }, + }, + }, + { + name: "CMPBconst", + asm: x86.ACMPB, + reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + outputs: []regMask{ + 8589934592, // .FLAGS + }, + }, + }, + { + name: "TESTQ", + asm: x86.ATESTQ, + reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + outputs: []regMask{ + 8589934592, // .FLAGS + }, + }, + }, + { + name: "TESTL", + asm: x86.ATESTL, + reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + outputs: []regMask{ + 8589934592, // .FLAGS + }, + }, + }, + { + name: "TESTW", + asm: x86.ATESTW, + reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + outputs: []regMask{ + 8589934592, // .FLAGS + }, + }, + }, + { + name: "TESTB", + asm: x86.ATESTB, + reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + outputs: []regMask{ + 8589934592, // .FLAGS + }, + }, + }, + { + name: "TESTQconst", + asm: x86.ATESTQ, + reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + outputs: []regMask{ + 8589934592, // .FLAGS + }, + }, + }, + { + name: "TESTLconst", + asm: x86.ATESTL, + reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + outputs: []regMask{ + 8589934592, // .FLAGS + }, + }, + }, + { + name: "TESTWconst", + asm: x86.ATESTW, + reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + outputs: []regMask{ + 8589934592, // .FLAGS + }, + }, + }, + { + name: "TESTBconst", + asm: x86.ATESTB, + reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + outputs: []regMask{ + 8589934592, // .FLAGS + }, + }, + }, + { + name: "SHLQ", + asm: x86.ASHLQ, + reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 2, // .CX + }, + outputs: []regMask{ + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + }, + }, + { + name: "SHLL", + asm: x86.ASHLL, + reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 2, // .CX + }, + outputs: []regMask{ + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + }, + }, + { + name: "SHLW", + asm: x86.ASHLW, + reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 2, // .CX + }, + outputs: []regMask{ + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + }, + }, + { + name: "SHLB", + asm: x86.ASHLB, + reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 2, // .CX + }, + outputs: []regMask{ + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + }, + }, + { + name: "SHLQconst", + asm: x86.ASHLQ, + reg: regInfo{ + inputs: []regMask{ + 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: "SHLLconst", + asm: x86.ASHLL, + reg: regInfo{ + inputs: []regMask{ + 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: "SHLWconst", + asm: x86.ASHLW, + reg: regInfo{ + inputs: []regMask{ + 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: "SHLBconst", + asm: x86.ASHLB, + reg: regInfo{ + inputs: []regMask{ + 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: "SHRQ", + asm: x86.ASHRQ, + reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 2, // .CX + }, + outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, { - name: "MOVWconst", - asm: x86.AMOVW, + name: "SHRL", + asm: x86.ASHRL, reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 2, // .CX + }, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, { - name: "MOVLconst", - asm: x86.AMOVL, + name: "SHRW", + asm: x86.ASHRW, reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 2, // .CX + }, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, { - name: "MOVQconst", - asm: x86.AMOVQ, + name: "SHRB", + asm: x86.ASHRB, reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 2, // .CX + }, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, { - name: "LEAQ", + name: "SHRQconst", + asm: x86.ASHRQ, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB + 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 @@ -752,11 +1275,11 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "LEAQ1", + name: "SHRLconst", + asm: x86.ASHRL, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 @@ -764,11 +1287,11 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "LEAQ2", + name: "SHRWconst", + asm: x86.ASHRW, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 @@ -776,11 +1299,11 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "LEAQ4", + name: "SHRBconst", + asm: x86.ASHRB, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 @@ -788,11 +1311,12 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "LEAQ8", + name: "SARQ", + asm: x86.ASARQ, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 2, // .CX }, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -800,12 +1324,12 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVBload", - asm: x86.AMOVB, + name: "SARL", + asm: x86.ASARL, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB - 0, + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 2, // .CX }, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -813,12 +1337,12 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVBQSXload", - asm: x86.AMOVBQSX, + name: "SARW", + asm: x86.ASARW, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB - 0, + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 2, // .CX }, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -826,12 +1350,12 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVBQZXload", - asm: x86.AMOVBQZX, + name: "SARB", + asm: x86.ASARB, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB - 0, + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 2, // .CX }, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -839,12 +1363,11 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVWload", - asm: x86.AMOVW, + name: "SARQconst", + asm: x86.ASARQ, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB - 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 @@ -852,12 +1375,11 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVLload", - asm: x86.AMOVL, + name: "SARLconst", + asm: x86.ASARL, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB - 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 @@ -865,12 +1387,11 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVQload", - asm: x86.AMOVQ, + name: "SARWconst", + asm: x86.ASARW, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB - 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 @@ -878,13 +1399,11 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVQloadidx8", - asm: x86.AMOVQ, + name: "SARBconst", + asm: x86.ASARB, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 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 @@ -892,119 +1411,192 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVBstore", - asm: x86.AMOVB, + name: "NEGQ", + asm: x86.ANEGQ, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 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: "MOVWstore", - asm: x86.AMOVW, + name: "NEGL", + asm: x86.ANEGL, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 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: "MOVLstore", - asm: x86.AMOVL, + name: "NEGW", + asm: x86.ANEGW, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 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: "MOVQstore", - asm: x86.AMOVQ, + name: "NEGB", + asm: x86.ANEGB, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 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: "MOVQstoreidx8", - asm: x86.AMOVQ, + name: "SBBQcarrymask", + asm: x86.ASBBQ, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 0, + 8589934592, // .FLAGS + }, + outputs: []regMask{ + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, { - name: "MOVXzero", + name: "SETEQ", + asm: x86.ASETEQ, reg: regInfo{ inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB - 0, + 8589934592, // .FLAGS + }, + outputs: []regMask{ + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, { - name: "REPSTOSQ", + name: "SETNE", + asm: x86.ASETNE, reg: regInfo{ inputs: []regMask{ - 128, // .DI - 2, // .CX + 8589934592, // .FLAGS + }, + outputs: []regMask{ + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, - clobbers: 131, // .AX .CX .DI }, }, { - name: "MOVQloadglobal", - reg: regInfo{}, + name: "SETL", + asm: x86.ASETLT, + reg: regInfo{ + inputs: []regMask{ + 8589934592, // .FLAGS + }, + outputs: []regMask{ + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + }, }, { - name: "MOVQstoreglobal", - reg: regInfo{}, + name: "SETLE", + asm: x86.ASETLE, + reg: regInfo{ + inputs: []regMask{ + 8589934592, // .FLAGS + }, + outputs: []regMask{ + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + }, }, { - name: "CALLstatic", - reg: regInfo{}, + name: "SETG", + asm: x86.ASETGT, + reg: regInfo{ + inputs: []regMask{ + 8589934592, // .FLAGS + }, + outputs: []regMask{ + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + }, }, { - name: "CALLclosure", + name: "SETGE", + asm: x86.ASETGE, reg: regInfo{ inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 4, // .DX - 0, + 8589934592, // .FLAGS + }, + outputs: []regMask{ + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, { - name: "REPMOVSB", + name: "SETB", + asm: x86.ASETCS, reg: regInfo{ inputs: []regMask{ - 128, // .DI - 64, // .SI - 2, // .CX + 8589934592, // .FLAGS + }, + outputs: []regMask{ + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + }, + }, + { + name: "SETBE", + asm: x86.ASETLS, + reg: regInfo{ + inputs: []regMask{ + 8589934592, // .FLAGS + }, + outputs: []regMask{ + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + }, + }, + { + name: "SETA", + asm: x86.ASETHI, + reg: regInfo{ + inputs: []regMask{ + 8589934592, // .FLAGS + }, + outputs: []regMask{ + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + }, + }, + { + name: "SETAE", + asm: x86.ASETCC, + reg: regInfo{ + inputs: []regMask{ + 8589934592, // .FLAGS + }, + outputs: []regMask{ + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, - clobbers: 194, // .CX .SI .DI }, }, { - name: "ADDQ", + name: "CMOVQCC", reg: regInfo{ inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 8589934592, // .FLAGS + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 65519, // .AX .CX .DX .BX .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 @@ -1012,7 +1604,8 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "ADDQconst", + name: "MOVBQSX", + asm: x86.AMOVBQSX, reg: regInfo{ inputs: []regMask{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -1023,12 +1616,11 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "ADDL", - asm: x86.AADDL, + name: "MOVBQZX", + asm: x86.AMOVBQZX, reg: regInfo{ inputs: []regMask{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 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 @@ -1036,12 +1628,11 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "ADDW", - asm: x86.AADDW, + name: "MOVWQSX", + asm: x86.AMOVWQSX, reg: regInfo{ inputs: []regMask{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 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 @@ -1049,12 +1640,11 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "ADDB", - asm: x86.AADDB, + name: "MOVWQZX", + asm: x86.AMOVWQZX, reg: regInfo{ inputs: []regMask{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 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 @@ -1062,12 +1652,11 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SUBQ", - asm: x86.ASUBQ, + name: "MOVLQSX", + asm: x86.AMOVLQSX, reg: regInfo{ inputs: []regMask{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 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 @@ -1075,8 +1664,8 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SUBQconst", - asm: x86.ASUBQ, + name: "MOVLQZX", + asm: x86.AMOVLQZX, reg: regInfo{ inputs: []regMask{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -1087,50 +1676,46 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SUBL", - asm: x86.ASUBL, + name: "MOVBconst", + asm: x86.AMOVB, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 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: "SUBW", - asm: x86.ASUBW, + name: "MOVWconst", + asm: x86.AMOVW, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 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: "SUBB", - asm: x86.ASUBB, + name: "MOVLconst", + asm: x86.AMOVL, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 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: "MOVQconst", + asm: x86.AMOVQ, + reg: regInfo{ outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, { - name: "NEGQ", - asm: x86.ANEGQ, + name: "LEAQ", reg: regInfo{ inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 @@ -1138,11 +1723,11 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "NEGL", - asm: x86.ANEGL, + name: "LEAQ1", reg: regInfo{ inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB + 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 @@ -1150,11 +1735,11 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "NEGW", - asm: x86.ANEGW, + name: "LEAQ2", reg: regInfo{ inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB + 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 @@ -1162,11 +1747,11 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "NEGB", - asm: x86.ANEGB, + name: "LEAQ4", reg: regInfo{ inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB + 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 @@ -1174,12 +1759,11 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MULL", - asm: x86.AIMULL, + name: "LEAQ8", reg: regInfo{ inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB + 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 @@ -1187,12 +1771,12 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MULW", - asm: x86.AIMULW, + name: "MOVBload", + asm: x86.AMOVB, reg: regInfo{ inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB + 0, }, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -1200,12 +1784,12 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "ANDQ", - asm: x86.AANDQ, + name: "MOVBQSXload", + asm: x86.AMOVBQSX, reg: regInfo{ inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB + 0, }, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -1213,11 +1797,12 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "ANDQconst", - asm: x86.AANDQ, + name: "MOVBQZXload", + asm: x86.AMOVBQZX, reg: regInfo{ inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB + 0, }, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -1225,12 +1810,12 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "ANDL", - asm: x86.AANDL, + name: "MOVWload", + asm: x86.AMOVW, reg: regInfo{ inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB + 0, }, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -1238,12 +1823,12 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "ANDW", - asm: x86.AANDW, + name: "MOVLload", + asm: x86.AMOVL, reg: regInfo{ inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB + 0, }, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -1251,12 +1836,12 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "ANDB", - asm: x86.AANDB, + name: "MOVQload", + asm: x86.AMOVQ, reg: regInfo{ inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB + 0, }, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -1264,12 +1849,13 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "ORQ", - asm: x86.AORQ, + name: "MOVQloadidx8", + asm: x86.AMOVQ, reg: regInfo{ inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 0, }, outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -1277,54 +1863,103 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "ORQconst", - asm: x86.AORQ, + name: "MOVBstore", + asm: x86.AMOVB, reg: regInfo{ inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 0, }, - outputs: []regMask{ - 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + }, + { + name: "MOVWstore", + asm: x86.AMOVW, + reg: regInfo{ + inputs: []regMask{ + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 0, }, }, }, { - name: "ORL", - asm: x86.AORL, + name: "MOVLstore", + asm: x86.AMOVL, reg: regInfo{ inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 0, }, - outputs: []regMask{ - 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + }, + { + name: "MOVQstore", + asm: x86.AMOVQ, + reg: regInfo{ + inputs: []regMask{ + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 0, }, }, }, { - name: "ORW", - asm: x86.AORW, + name: "MOVQstoreidx8", + asm: x86.AMOVQ, reg: regInfo{ inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 0, }, - outputs: []regMask{ - 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + }, + { + name: "MOVXzero", + reg: regInfo{ + inputs: []regMask{ + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB + 0, }, }, }, { - name: "ORB", - asm: x86.AORB, + name: "REPSTOSQ", + reg: regInfo{ + inputs: []regMask{ + 128, // .DI + 2, // .CX + }, + clobbers: 131, // .AX .CX .DI + }, + }, + { + name: "CALLstatic", + reg: regInfo{}, + }, + { + name: "CALLclosure", reg: regInfo{ inputs: []regMask{ 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 4, // .DX + 0, }, - outputs: []regMask{ - 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + }, + { + name: "REPMOVSB", + reg: regInfo{ + inputs: []regMask{ + 128, // .DI + 64, // .SI + 2, // .CX }, + clobbers: 194, // .CX .SI .DI }, }, { @@ -1420,6 +2055,22 @@ var opcodeTable = [...]opInfo{ name: "Or64", generic: true, }, + { + name: "Xor8", + generic: true, + }, + { + name: "Xor16", + generic: true, + }, + { + name: "Xor32", + generic: true, + }, + { + name: "Xor64", + generic: true, + }, { name: "Lsh8", generic: true, diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index ec8e381201..398ea231f1 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -4,6 +4,88 @@ package ssa func rewriteValueAMD64(v *Value, config *Config) bool { switch v.Op { + case OpAMD64ADDB: + // match: (ADDB x (MOVBconst [c])) + // cond: + // result: (ADDBconst [c] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVBconst { + goto endab690db69bfd8192eea57a2f9f76bf84 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64ADDBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto endab690db69bfd8192eea57a2f9f76bf84 + endab690db69bfd8192eea57a2f9f76bf84: + ; + // match: (ADDB (MOVBconst [c]) x) + // cond: + // result: (ADDBconst [c] x) + { + if v.Args[0].Op != OpAMD64MOVBconst { + goto end28aa1a4abe7e1abcdd64135e9967d39d + } + c := v.Args[0].AuxInt + x := v.Args[1] + v.Op = OpAMD64ADDBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end28aa1a4abe7e1abcdd64135e9967d39d + end28aa1a4abe7e1abcdd64135e9967d39d: + ; + case OpAMD64ADDL: + // match: (ADDL x (MOVLconst [c])) + // cond: + // result: (ADDLconst [c] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVLconst { + goto end8d6d3b99a7be8da6b7a254b7e709cc95 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64ADDLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end8d6d3b99a7be8da6b7a254b7e709cc95 + end8d6d3b99a7be8da6b7a254b7e709cc95: + ; + // match: (ADDL (MOVLconst [c]) x) + // cond: + // result: (ADDLconst [c] x) + { + if v.Args[0].Op != OpAMD64MOVLconst { + goto end739561e08a561e26ce3634dc0d5ec733 + } + c := v.Args[0].AuxInt + x := v.Args[1] + v.Op = OpAMD64ADDLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end739561e08a561e26ce3634dc0d5ec733 + end739561e08a561e26ce3634dc0d5ec733: + ; case OpAMD64ADDQ: // match: (ADDQ x (MOVQconst [c])) // cond: is32Bit(c) @@ -116,16 +198,142 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end288952f259d4a1842f1e8d5c389b3f28 end288952f259d4a1842f1e8d5c389b3f28: ; + case OpAMD64ADDW: + // match: (ADDW x (MOVWconst [c])) + // cond: + // result: (ADDWconst [c] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVWconst { + goto end1aabd2317de77c7dfc4876fd7e4c5011 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64ADDWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end1aabd2317de77c7dfc4876fd7e4c5011 + end1aabd2317de77c7dfc4876fd7e4c5011: + ; + // match: (ADDW (MOVWconst [c]) x) + // cond: + // result: (ADDWconst [c] x) + { + if v.Args[0].Op != OpAMD64MOVWconst { + goto ende3aede99966f388afc624f9e86676fd2 + } + c := v.Args[0].AuxInt + x := v.Args[1] + v.Op = OpAMD64ADDWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto ende3aede99966f388afc624f9e86676fd2 + ende3aede99966f388afc624f9e86676fd2: + ; + case OpAMD64ANDB: + // match: (ANDB x (MOVBconst [c])) + // cond: + // result: (ANDBconst [c] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVBconst { + goto endd275ec2e73768cb3d201478fc934e06c + } + c := v.Args[1].AuxInt + v.Op = OpAMD64ANDBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto endd275ec2e73768cb3d201478fc934e06c + endd275ec2e73768cb3d201478fc934e06c: + ; + // match: (ANDB (MOVBconst [c]) x) + // cond: + // result: (ANDBconst [c] x) + { + if v.Args[0].Op != OpAMD64MOVBconst { + goto end4068edac2ae0f354cf581db210288b98 + } + c := v.Args[0].AuxInt + x := v.Args[1] + v.Op = OpAMD64ANDBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end4068edac2ae0f354cf581db210288b98 + end4068edac2ae0f354cf581db210288b98: + ; + case OpAMD64ANDL: + // match: (ANDL x (MOVLconst [c])) + // cond: + // result: (ANDLconst [c] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVLconst { + goto end0a4c49d9a26759c0fd21369dafcd7abb + } + c := v.Args[1].AuxInt + v.Op = OpAMD64ANDLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end0a4c49d9a26759c0fd21369dafcd7abb + end0a4c49d9a26759c0fd21369dafcd7abb: + ; + // match: (ANDL (MOVLconst [c]) x) + // cond: + // result: (ANDLconst [c] x) + { + if v.Args[0].Op != OpAMD64MOVLconst { + goto end0529ba323d9b6f15c41add401ef67959 + } + c := v.Args[0].AuxInt + x := v.Args[1] + v.Op = OpAMD64ANDLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end0529ba323d9b6f15c41add401ef67959 + end0529ba323d9b6f15c41add401ef67959: + ; case OpAMD64ANDQ: // match: (ANDQ x (MOVQconst [c])) - // cond: + // cond: is32Bit(c) // result: (ANDQconst [c] x) { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVQconst { - goto endb98096e3bbb90933e39c88bf41c688a9 + goto end048fadc69e81103480015b84b9cafff7 } c := v.Args[1].AuxInt + if !(is32Bit(c)) { + goto end048fadc69e81103480015b84b9cafff7 + } v.Op = OpAMD64ANDQconst v.AuxInt = 0 v.Aux = nil @@ -134,18 +342,21 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(x) return true } - goto endb98096e3bbb90933e39c88bf41c688a9 - endb98096e3bbb90933e39c88bf41c688a9: + goto end048fadc69e81103480015b84b9cafff7 + end048fadc69e81103480015b84b9cafff7: ; // match: (ANDQ (MOVQconst [c]) x) - // cond: + // cond: is32Bit(c) // result: (ANDQconst [c] x) { if v.Args[0].Op != OpAMD64MOVQconst { - goto endd313fd1897a0d2bc79eff70159a81b6b + goto end3035a3bf650b708705fd27dd857ab0a4 } c := v.Args[0].AuxInt x := v.Args[1] + if !(is32Bit(c)) { + goto end3035a3bf650b708705fd27dd857ab0a4 + } v.Op = OpAMD64ANDQconst v.AuxInt = 0 v.Aux = nil @@ -154,8 +365,8 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(x) return true } - goto endd313fd1897a0d2bc79eff70159a81b6b - endd313fd1897a0d2bc79eff70159a81b6b: + goto end3035a3bf650b708705fd27dd857ab0a4 + end3035a3bf650b708705fd27dd857ab0a4: ; case OpAMD64ANDQconst: // match: (ANDQconst [0] _) @@ -193,6 +404,47 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end646afc7b328db89ad16ebfa156ae26e5 end646afc7b328db89ad16ebfa156ae26e5: ; + case OpAMD64ANDW: + // match: (ANDW x (MOVWconst [c])) + // cond: + // result: (ANDWconst [c] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVWconst { + goto enda77a39f65a5eb3436a5842eab69a3103 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64ANDWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto enda77a39f65a5eb3436a5842eab69a3103 + enda77a39f65a5eb3436a5842eab69a3103: + ; + // match: (ANDW (MOVWconst [c]) x) + // cond: + // result: (ANDWconst [c] x) + { + if v.Args[0].Op != OpAMD64MOVWconst { + goto endea2a25eb525a5dbf6d5132d84ea4e7a5 + } + c := v.Args[0].AuxInt + x := v.Args[1] + v.Op = OpAMD64ANDWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto endea2a25eb525a5dbf6d5132d84ea4e7a5 + endea2a25eb525a5dbf6d5132d84ea4e7a5: + ; case OpAdd16: // match: (Add16 x y) // cond: @@ -426,17 +678,17 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end6ad8b1758415a9afe758272b34970d5d end6ad8b1758415a9afe758272b34970d5d: ; - case OpAMD64CMPQ: - // match: (CMPQ x (MOVQconst [c])) + case OpAMD64CMPB: + // match: (CMPB x (MOVBconst [c])) // cond: - // result: (CMPQconst x [c]) + // result: (CMPBconst x [c]) { x := v.Args[0] - if v.Args[1].Op != OpAMD64MOVQconst { - goto end32ef1328af280ac18fa8045a3502dae9 + if v.Args[1].Op != OpAMD64MOVBconst { + goto end52190c0b8759133aa6c540944965c4c0 } c := v.Args[1].AuxInt - v.Op = OpAMD64CMPQconst + v.Op = OpAMD64CMPBconst v.AuxInt = 0 v.Aux = nil v.resetArgs() @@ -444,15 +696,15 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = c return true } - goto end32ef1328af280ac18fa8045a3502dae9 - end32ef1328af280ac18fa8045a3502dae9: + goto end52190c0b8759133aa6c540944965c4c0 + end52190c0b8759133aa6c540944965c4c0: ; - // match: (CMPQ (MOVQconst [c]) x) + // match: (CMPB (MOVBconst [c]) x) // cond: - // result: (InvertFlags (CMPQconst x [c])) + // result: (InvertFlags (CMPBconst x [c])) { - if v.Args[0].Op != OpAMD64MOVQconst { - goto endf8ca12fe79290bc82b11cfa463bc9413 + if v.Args[0].Op != OpAMD64MOVBconst { + goto end6798593f4f9a27e90de089b3248187fd } c := v.Args[0].AuxInt x := v.Args[1] @@ -460,88 +712,226 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AuxInt = c v.AddArg(v0) return true } - goto endf8ca12fe79290bc82b11cfa463bc9413 - endf8ca12fe79290bc82b11cfa463bc9413: + goto end6798593f4f9a27e90de089b3248187fd + end6798593f4f9a27e90de089b3248187fd: ; - case OpClosureCall: - // match: (ClosureCall [argwid] entry closure mem) + case OpAMD64CMPL: + // match: (CMPL x (MOVLconst [c])) // cond: - // result: (CALLclosure [argwid] entry closure mem) + // result: (CMPLconst x [c]) { - argwid := v.AuxInt - entry := v.Args[0] - closure := v.Args[1] - mem := v.Args[2] - v.Op = OpAMD64CALLclosure + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVLconst { + goto end49ff4559c4bdecb2aef0c905e2d9a6cf + } + c := v.Args[1].AuxInt + v.Op = OpAMD64CMPLconst v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = argwid - v.AddArg(entry) - v.AddArg(closure) - v.AddArg(mem) + v.AddArg(x) + v.AuxInt = c return true } - goto endfd75d26316012d86cb71d0dd1214259b - endfd75d26316012d86cb71d0dd1214259b: + goto end49ff4559c4bdecb2aef0c905e2d9a6cf + end49ff4559c4bdecb2aef0c905e2d9a6cf: ; - case OpConst16: - // match: (Const16 [val]) + // match: (CMPL (MOVLconst [c]) x) // cond: - // result: (MOVWconst [val]) + // result: (InvertFlags (CMPLconst x [c])) { - val := v.AuxInt - v.Op = OpAMD64MOVWconst + if v.Args[0].Op != OpAMD64MOVLconst { + goto end3c04e861f07a442be9e2f5e0e0d07cce + } + c := v.Args[0].AuxInt + x := v.Args[1] + v.Op = OpAMD64InvertFlags v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = val + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AuxInt = c + v.AddArg(v0) return true } - goto end2c6c92f297873b8ac12bd035d56d001e - end2c6c92f297873b8ac12bd035d56d001e: + goto end3c04e861f07a442be9e2f5e0e0d07cce + end3c04e861f07a442be9e2f5e0e0d07cce: ; - case OpConst32: - // match: (Const32 [val]) - // cond: - // result: (MOVLconst [val]) + case OpAMD64CMPQ: + // match: (CMPQ x (MOVQconst [c])) + // cond: is32Bit(c) + // result: (CMPQconst x [c]) { - val := v.AuxInt - v.Op = OpAMD64MOVLconst + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVQconst { + goto end3bbb2c6caa57853a7561738ce3c0c630 + } + c := v.Args[1].AuxInt + if !(is32Bit(c)) { + goto end3bbb2c6caa57853a7561738ce3c0c630 + } + v.Op = OpAMD64CMPQconst v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = val + v.AddArg(x) + v.AuxInt = c return true } - goto enddae5807662af67143a3ac3ad9c63bae5 - enddae5807662af67143a3ac3ad9c63bae5: + goto end3bbb2c6caa57853a7561738ce3c0c630 + end3bbb2c6caa57853a7561738ce3c0c630: ; - case OpConst64: - // match: (Const64 [val]) - // cond: - // result: (MOVQconst [val]) + // match: (CMPQ (MOVQconst [c]) x) + // cond: is32Bit(c) + // result: (InvertFlags (CMPQconst x [c])) { - val := v.AuxInt - v.Op = OpAMD64MOVQconst + if v.Args[0].Op != OpAMD64MOVQconst { + goto end5edbe48a495a51ecabd3b2c0ed44a3d3 + } + c := v.Args[0].AuxInt + x := v.Args[1] + if !(is32Bit(c)) { + goto end5edbe48a495a51ecabd3b2c0ed44a3d3 + } + v.Op = OpAMD64InvertFlags v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = val + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AuxInt = c + v.AddArg(v0) return true } - goto endc630434ae7f143ab69d5f482a9b52b5f - endc630434ae7f143ab69d5f482a9b52b5f: + goto end5edbe48a495a51ecabd3b2c0ed44a3d3 + end5edbe48a495a51ecabd3b2c0ed44a3d3: ; - case OpConst8: - // match: (Const8 [val]) + case OpAMD64CMPW: + // match: (CMPW x (MOVWconst [c])) + // cond: + // result: (CMPWconst x [c]) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVWconst { + goto end310a9ba58ac35c97587e08c63fe8a46c + } + c := v.Args[1].AuxInt + v.Op = OpAMD64CMPWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AuxInt = c + return true + } + goto end310a9ba58ac35c97587e08c63fe8a46c + end310a9ba58ac35c97587e08c63fe8a46c: + ; + // match: (CMPW (MOVWconst [c]) x) + // cond: + // result: (InvertFlags (CMPWconst x [c])) + { + if v.Args[0].Op != OpAMD64MOVWconst { + goto end1ce191aaab0f4dd3b98dafdfbfac13ce + } + c := v.Args[0].AuxInt + x := v.Args[1] + v.Op = OpAMD64InvertFlags + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AuxInt = c + v.AddArg(v0) + return true + } + goto end1ce191aaab0f4dd3b98dafdfbfac13ce + end1ce191aaab0f4dd3b98dafdfbfac13ce: + ; + case OpClosureCall: + // match: (ClosureCall [argwid] entry closure mem) + // cond: + // result: (CALLclosure [argwid] entry closure mem) + { + argwid := v.AuxInt + entry := v.Args[0] + closure := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64CALLclosure + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = argwid + v.AddArg(entry) + v.AddArg(closure) + v.AddArg(mem) + return true + } + goto endfd75d26316012d86cb71d0dd1214259b + endfd75d26316012d86cb71d0dd1214259b: + ; + case OpConst16: + // match: (Const16 [val]) + // cond: + // result: (MOVWconst [val]) + { + val := v.AuxInt + v.Op = OpAMD64MOVWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = val + return true + } + goto end2c6c92f297873b8ac12bd035d56d001e + end2c6c92f297873b8ac12bd035d56d001e: + ; + case OpConst32: + // match: (Const32 [val]) + // cond: + // result: (MOVLconst [val]) + { + val := v.AuxInt + v.Op = OpAMD64MOVLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = val + return true + } + goto enddae5807662af67143a3ac3ad9c63bae5 + enddae5807662af67143a3ac3ad9c63bae5: + ; + case OpConst64: + // match: (Const64 [val]) + // cond: + // result: (MOVQconst [val]) + { + val := v.AuxInt + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = val + return true + } + goto endc630434ae7f143ab69d5f482a9b52b5f + endc630434ae7f143ab69d5f482a9b52b5f: + ; + case OpConst8: + // match: (Const8 [val]) // cond: // result: (MOVBconst [val]) { @@ -1415,189 +1805,672 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto endf8e7a24c25692045bbcfd2c9356d1a8c - endf8e7a24c25692045bbcfd2c9356d1a8c: + goto endf8e7a24c25692045bbcfd2c9356d1a8c + endf8e7a24c25692045bbcfd2c9356d1a8c: + ; + case OpLess64U: + // match: (Less64U x y) + // cond: + // result: (SETB (CMPQ x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto end2fac0a2c2e972b5e04b5062d5786b87d + end2fac0a2c2e972b5e04b5062d5786b87d: + ; + case OpLess8: + // match: (Less8 x y) + // cond: + // result: (SETL (CMPB x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto end445ad05f8d23dfecf246ce083f1ea167 + end445ad05f8d23dfecf246ce083f1ea167: + ; + case OpLess8U: + // match: (Less8U x y) + // cond: + // result: (SETB (CMPB x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto end816d1dff858c45836dfa337262e04649 + end816d1dff858c45836dfa337262e04649: + ; + case OpLoad: + // match: (Load ptr mem) + // cond: (is64BitInt(t) || isPtr(t)) + // result: (MOVQload ptr mem) + { + t := v.Type + ptr := v.Args[0] + mem := v.Args[1] + if !(is64BitInt(t) || isPtr(t)) { + goto end7c4c53acf57ebc5f03273652ba1d5934 + } + v.Op = OpAMD64MOVQload + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto end7c4c53acf57ebc5f03273652ba1d5934 + end7c4c53acf57ebc5f03273652ba1d5934: + ; + // match: (Load ptr mem) + // cond: is32BitInt(t) + // result: (MOVLload ptr mem) + { + t := v.Type + ptr := v.Args[0] + mem := v.Args[1] + if !(is32BitInt(t)) { + goto ende1cfcb15bfbcfd448ce303d0882a4057 + } + v.Op = OpAMD64MOVLload + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto ende1cfcb15bfbcfd448ce303d0882a4057 + ende1cfcb15bfbcfd448ce303d0882a4057: + ; + // match: (Load ptr mem) + // cond: is16BitInt(t) + // result: (MOVWload ptr mem) + { + t := v.Type + ptr := v.Args[0] + mem := v.Args[1] + if !(is16BitInt(t)) { + goto end2d0a1304501ed9f4e9e2d288505a9c7c + } + v.Op = OpAMD64MOVWload + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto end2d0a1304501ed9f4e9e2d288505a9c7c + end2d0a1304501ed9f4e9e2d288505a9c7c: + ; + // match: (Load ptr mem) + // cond: (t.IsBoolean() || is8BitInt(t)) + // result: (MOVBload ptr mem) + { + t := v.Type + ptr := v.Args[0] + mem := v.Args[1] + if !(t.IsBoolean() || is8BitInt(t)) { + goto end8f83bf72293670e75b22d6627bd13f0b + } + v.Op = OpAMD64MOVBload + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto end8f83bf72293670e75b22d6627bd13f0b + end8f83bf72293670e75b22d6627bd13f0b: + ; + case OpLsh16: + // match: (Lsh16 x y) + // cond: y.Type.Size() == 8 + // result: (ANDW (SHLW x y) (SBBQcarrymask (CMPQconst [16] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + if !(y.Type.Size() == 8) { + goto end9166a3780ca3803c83366354d3a65f97 + } + v.Op = OpAMD64ANDW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64SHLW, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1.Type = t + v2 := v.Block.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v2.Type = TypeFlags + v2.AuxInt = 16 + v2.AddArg(y) + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto end9166a3780ca3803c83366354d3a65f97 + end9166a3780ca3803c83366354d3a65f97: + ; + // match: (Lsh16 x y) + // cond: y.Type.Size() == 4 + // result: (ANDW (SHLW x y) (SBBQcarrymask (CMPLconst [16] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + if !(y.Type.Size() == 4) { + goto end98eca16b509ba61a4f1a2a88515c361a + } + v.Op = OpAMD64ANDW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64SHLW, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1.Type = t + v2 := v.Block.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v2.Type = TypeFlags + v2.AuxInt = 16 + v2.AddArg(y) + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto end98eca16b509ba61a4f1a2a88515c361a + end98eca16b509ba61a4f1a2a88515c361a: + ; + // match: (Lsh16 x y) + // cond: y.Type.Size() == 2 + // result: (ANDW (SHLW x y) (SBBQcarrymask (CMPWconst [16] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + if !(y.Type.Size() == 2) { + goto endc7fcf199a736cb4d357cf3fcb7c50a8c + } + v.Op = OpAMD64ANDW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64SHLW, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1.Type = t + v2 := v.Block.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v2.Type = TypeFlags + v2.AuxInt = 16 + v2.AddArg(y) + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto endc7fcf199a736cb4d357cf3fcb7c50a8c + endc7fcf199a736cb4d357cf3fcb7c50a8c: + ; + // match: (Lsh16 x y) + // cond: y.Type.Size() == 1 + // result: (ANDW (SHLW x y) (SBBQcarrymask (CMPBconst [16] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + if !(y.Type.Size() == 1) { + goto end9e3a5a11aba0afdb8ca441ffce4753d9 + } + v.Op = OpAMD64ANDW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64SHLW, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1.Type = t + v2 := v.Block.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + v2.Type = TypeFlags + v2.AuxInt = 16 + v2.AddArg(y) + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto end9e3a5a11aba0afdb8ca441ffce4753d9 + end9e3a5a11aba0afdb8ca441ffce4753d9: + ; + case OpLsh32: + // match: (Lsh32 x y) + // cond: y.Type.Size() == 8 + // result: (ANDL (SHLL x y) (SBBQcarrymask (CMPQconst [32] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + if !(y.Type.Size() == 8) { + goto endab577f61b4a2efbe1237218f1b54549a + } + v.Op = OpAMD64ANDL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64SHLL, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1.Type = t + v2 := v.Block.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v2.Type = TypeFlags + v2.AuxInt = 32 + v2.AddArg(y) + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto endab577f61b4a2efbe1237218f1b54549a + endab577f61b4a2efbe1237218f1b54549a: + ; + // match: (Lsh32 x y) + // cond: y.Type.Size() == 4 + // result: (ANDL (SHLL x y) (SBBQcarrymask (CMPLconst [32] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + if !(y.Type.Size() == 4) { + goto enda578175209f6057910ff36338eda5fb1 + } + v.Op = OpAMD64ANDL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64SHLL, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1.Type = t + v2 := v.Block.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v2.Type = TypeFlags + v2.AuxInt = 32 + v2.AddArg(y) + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto enda578175209f6057910ff36338eda5fb1 + enda578175209f6057910ff36338eda5fb1: + ; + // match: (Lsh32 x y) + // cond: y.Type.Size() == 2 + // result: (ANDL (SHLL x y) (SBBQcarrymask (CMPWconst [32] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + if !(y.Type.Size() == 2) { + goto enda2c69e15bc12bbc7dd51384b20cb506b + } + v.Op = OpAMD64ANDL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64SHLL, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1.Type = t + v2 := v.Block.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v2.Type = TypeFlags + v2.AuxInt = 32 + v2.AddArg(y) + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto enda2c69e15bc12bbc7dd51384b20cb506b + enda2c69e15bc12bbc7dd51384b20cb506b: + ; + // match: (Lsh32 x y) + // cond: y.Type.Size() == 1 + // result: (ANDL (SHLL x y) (SBBQcarrymask (CMPBconst [32] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + if !(y.Type.Size() == 1) { + goto endd92c60db1f5cd24f7362925f3867b0b8 + } + v.Op = OpAMD64ANDL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64SHLL, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1.Type = t + v2 := v.Block.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + v2.Type = TypeFlags + v2.AuxInt = 32 + v2.AddArg(y) + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto endd92c60db1f5cd24f7362925f3867b0b8 + endd92c60db1f5cd24f7362925f3867b0b8: ; - case OpLess64U: - // match: (Less64U x y) - // cond: - // result: (SETB (CMPQ x y)) + case OpLsh64: + // match: (Lsh64 x y) + // cond: y.Type.Size() == 8 + // result: (ANDQ (SHLQ x y) (SBBQcarrymask (CMPQconst [64] y))) { + t := v.Type x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETB + if !(y.Type.Size() == 8) { + goto end04273c7a426341c8f3ecfaa5d653dc6b + } + v.Op = OpAMD64ANDQ v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) - v0.Type = TypeFlags + v0 := v.Block.NewValue0(v.Line, OpAMD64SHLQ, TypeInvalid) + v0.Type = t v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) + v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1.Type = t + v2 := v.Block.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v2.Type = TypeFlags + v2.AuxInt = 64 + v2.AddArg(y) + v1.AddArg(v2) + v.AddArg(v1) return true } - goto end2fac0a2c2e972b5e04b5062d5786b87d - end2fac0a2c2e972b5e04b5062d5786b87d: + goto end04273c7a426341c8f3ecfaa5d653dc6b + end04273c7a426341c8f3ecfaa5d653dc6b: ; - case OpLess8: - // match: (Less8 x y) - // cond: - // result: (SETL (CMPB x y)) + // match: (Lsh64 x y) + // cond: y.Type.Size() == 4 + // result: (ANDQ (SHLQ x y) (SBBQcarrymask (CMPLconst [64] y))) { + t := v.Type x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETL + if !(y.Type.Size() == 4) { + goto end3125a3a8c16279a0b5564bf85f86b80e + } + v.Op = OpAMD64ANDQ v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) - v0.Type = TypeFlags + v0 := v.Block.NewValue0(v.Line, OpAMD64SHLQ, TypeInvalid) + v0.Type = t v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) + v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1.Type = t + v2 := v.Block.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v2.Type = TypeFlags + v2.AuxInt = 64 + v2.AddArg(y) + v1.AddArg(v2) + v.AddArg(v1) return true } - goto end445ad05f8d23dfecf246ce083f1ea167 - end445ad05f8d23dfecf246ce083f1ea167: + goto end3125a3a8c16279a0b5564bf85f86b80e + end3125a3a8c16279a0b5564bf85f86b80e: ; - case OpLess8U: - // match: (Less8U x y) - // cond: - // result: (SETB (CMPB x y)) + // match: (Lsh64 x y) + // cond: y.Type.Size() == 2 + // result: (ANDQ (SHLQ x y) (SBBQcarrymask (CMPWconst [64] y))) { + t := v.Type x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETB + if !(y.Type.Size() == 2) { + goto end09bfd4e5a4caa96665f86d9f011096d1 + } + v.Op = OpAMD64ANDQ v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) - v0.Type = TypeFlags + v0 := v.Block.NewValue0(v.Line, OpAMD64SHLQ, TypeInvalid) + v0.Type = t v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) + v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1.Type = t + v2 := v.Block.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v2.Type = TypeFlags + v2.AuxInt = 64 + v2.AddArg(y) + v1.AddArg(v2) + v.AddArg(v1) return true } - goto end816d1dff858c45836dfa337262e04649 - end816d1dff858c45836dfa337262e04649: + goto end09bfd4e5a4caa96665f86d9f011096d1 + end09bfd4e5a4caa96665f86d9f011096d1: ; - case OpLoad: - // match: (Load ptr mem) - // cond: (is64BitInt(t) || isPtr(t)) - // result: (MOVQload ptr mem) + // match: (Lsh64 x y) + // cond: y.Type.Size() == 1 + // result: (ANDQ (SHLQ x y) (SBBQcarrymask (CMPBconst [64] y))) { t := v.Type - ptr := v.Args[0] - mem := v.Args[1] - if !(is64BitInt(t) || isPtr(t)) { - goto end7c4c53acf57ebc5f03273652ba1d5934 + x := v.Args[0] + y := v.Args[1] + if !(y.Type.Size() == 1) { + goto endac7a6dc89cc3a624c731db84269c45dc } - v.Op = OpAMD64MOVQload + v.Op = OpAMD64ANDQ v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AddArg(ptr) - v.AddArg(mem) + v0 := v.Block.NewValue0(v.Line, OpAMD64SHLQ, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1.Type = t + v2 := v.Block.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + v2.Type = TypeFlags + v2.AuxInt = 64 + v2.AddArg(y) + v1.AddArg(v2) + v.AddArg(v1) return true } - goto end7c4c53acf57ebc5f03273652ba1d5934 - end7c4c53acf57ebc5f03273652ba1d5934: + goto endac7a6dc89cc3a624c731db84269c45dc + endac7a6dc89cc3a624c731db84269c45dc: ; - // match: (Load ptr mem) - // cond: is32BitInt(t) - // result: (MOVLload ptr mem) + case OpLsh8: + // match: (Lsh8 x y) + // cond: y.Type.Size() == 8 + // result: (ANDB (SHLB x y) (SBBQcarrymask (CMPQconst [8] y))) { t := v.Type - ptr := v.Args[0] - mem := v.Args[1] - if !(is32BitInt(t)) { - goto ende1cfcb15bfbcfd448ce303d0882a4057 + x := v.Args[0] + y := v.Args[1] + if !(y.Type.Size() == 8) { + goto end0ea866cfdfddf55bae152ae48bbcb493 } - v.Op = OpAMD64MOVLload + v.Op = OpAMD64ANDB v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AddArg(ptr) - v.AddArg(mem) + v0 := v.Block.NewValue0(v.Line, OpAMD64SHLB, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1.Type = t + v2 := v.Block.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v2.Type = TypeFlags + v2.AuxInt = 8 + v2.AddArg(y) + v1.AddArg(v2) + v.AddArg(v1) return true } - goto ende1cfcb15bfbcfd448ce303d0882a4057 - ende1cfcb15bfbcfd448ce303d0882a4057: + goto end0ea866cfdfddf55bae152ae48bbcb493 + end0ea866cfdfddf55bae152ae48bbcb493: ; - // match: (Load ptr mem) - // cond: is16BitInt(t) - // result: (MOVWload ptr mem) + // match: (Lsh8 x y) + // cond: y.Type.Size() == 4 + // result: (ANDB (SHLB x y) (SBBQcarrymask (CMPLconst [8] y))) { t := v.Type - ptr := v.Args[0] - mem := v.Args[1] - if !(is16BitInt(t)) { - goto end2d0a1304501ed9f4e9e2d288505a9c7c + x := v.Args[0] + y := v.Args[1] + if !(y.Type.Size() == 4) { + goto ende5a086576704a75e2f863a67b5a05775 } - v.Op = OpAMD64MOVWload + v.Op = OpAMD64ANDB v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AddArg(ptr) - v.AddArg(mem) + v0 := v.Block.NewValue0(v.Line, OpAMD64SHLB, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1.Type = t + v2 := v.Block.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v2.Type = TypeFlags + v2.AuxInt = 8 + v2.AddArg(y) + v1.AddArg(v2) + v.AddArg(v1) return true } - goto end2d0a1304501ed9f4e9e2d288505a9c7c - end2d0a1304501ed9f4e9e2d288505a9c7c: + goto ende5a086576704a75e2f863a67b5a05775 + ende5a086576704a75e2f863a67b5a05775: ; - // match: (Load ptr mem) - // cond: (t.IsBoolean() || is8BitInt(t)) - // result: (MOVBload ptr mem) + // match: (Lsh8 x y) + // cond: y.Type.Size() == 2 + // result: (ANDB (SHLB x y) (SBBQcarrymask (CMPWconst [8] y))) { t := v.Type - ptr := v.Args[0] - mem := v.Args[1] - if !(t.IsBoolean() || is8BitInt(t)) { - goto end8f83bf72293670e75b22d6627bd13f0b + x := v.Args[0] + y := v.Args[1] + if !(y.Type.Size() == 2) { + goto enda094363dfc1068d4b96c55fcc60d1101 } - v.Op = OpAMD64MOVBload + v.Op = OpAMD64ANDB v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AddArg(ptr) - v.AddArg(mem) + v0 := v.Block.NewValue0(v.Line, OpAMD64SHLB, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1.Type = t + v2 := v.Block.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v2.Type = TypeFlags + v2.AuxInt = 8 + v2.AddArg(y) + v1.AddArg(v2) + v.AddArg(v1) return true } - goto end8f83bf72293670e75b22d6627bd13f0b - end8f83bf72293670e75b22d6627bd13f0b: + goto enda094363dfc1068d4b96c55fcc60d1101 + enda094363dfc1068d4b96c55fcc60d1101: ; - case OpLsh64: - // match: (Lsh64 x y) - // cond: y.Type.Size() == 8 - // result: (ANDQ (SHLQ x y) (SBBQcarrymask (CMPQconst [64] y))) + // match: (Lsh8 x y) + // cond: y.Type.Size() == 1 + // result: (ANDB (SHLB x y) (SBBQcarrymask (CMPBconst [8] y))) { t := v.Type x := v.Args[0] y := v.Args[1] - if !(y.Type.Size() == 8) { - goto end04273c7a426341c8f3ecfaa5d653dc6b + if !(y.Type.Size() == 1) { + goto end099e72e70658eeb9e3cad6e1f9ad0137 } - v.Op = OpAMD64ANDQ + v.Op = OpAMD64ANDB v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64SHLQ, TypeInvalid) + v0 := v.Block.NewValue0(v.Line, OpAMD64SHLB, TypeInvalid) v0.Type = t v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) v1.Type = t - v2 := v.Block.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v2 := v.Block.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) v2.Type = TypeFlags - v2.AuxInt = 64 + v2.AuxInt = 8 v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) return true } - goto end04273c7a426341c8f3ecfaa5d653dc6b - end04273c7a426341c8f3ecfaa5d653dc6b: + goto end099e72e70658eeb9e3cad6e1f9ad0137 + end099e72e70658eeb9e3cad6e1f9ad0137: ; case OpAMD64MOVBQSX: // match: (MOVBQSX (MOVBload ptr mem)) @@ -1992,6 +2865,47 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end4e7df15ee55bdd73d8ecd61b759134d4 end4e7df15ee55bdd73d8ecd61b759134d4: ; + case OpAMD64MULL: + // match: (MULL x (MOVLconst [c])) + // cond: + // result: (MULLconst [c] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVLconst { + goto end893477a261bcad6c2821b77c83075c6c + } + c := v.Args[1].AuxInt + v.Op = OpAMD64MULLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end893477a261bcad6c2821b77c83075c6c + end893477a261bcad6c2821b77c83075c6c: + ; + // match: (MULL (MOVLconst [c]) x) + // cond: + // result: (MULLconst [c] x) + { + if v.Args[0].Op != OpAMD64MOVLconst { + goto end8a0f957c528a54eecb0dbfc5d96e017a + } + c := v.Args[0].AuxInt + x := v.Args[1] + v.Op = OpAMD64MULLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end8a0f957c528a54eecb0dbfc5d96e017a + end8a0f957c528a54eecb0dbfc5d96e017a: + ; case OpAMD64MULQ: // match: (MULQ x (MOVQconst [c])) // cond: is32Bit(c) @@ -2163,12 +3077,53 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = log2(c) + v.AuxInt = log2(c) + v.AddArg(x) + return true + } + goto end75076953dbfe022526a153eda99b39b2 + end75076953dbfe022526a153eda99b39b2: + ; + case OpAMD64MULW: + // match: (MULW x (MOVWconst [c])) + // cond: + // result: (MULWconst [c] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVWconst { + goto end542112cc08217d4bdffc1a645d290ffb + } + c := v.Args[1].AuxInt + v.Op = OpAMD64MULWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end542112cc08217d4bdffc1a645d290ffb + end542112cc08217d4bdffc1a645d290ffb: + ; + // match: (MULW (MOVWconst [c]) x) + // cond: + // result: (MULWconst [c] x) + { + if v.Args[0].Op != OpAMD64MOVWconst { + goto endd97b4245ced2b3d27d8c555b06281de4 + } + c := v.Args[0].AuxInt + x := v.Args[1] + v.Op = OpAMD64MULWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c v.AddArg(x) return true } - goto end75076953dbfe022526a153eda99b39b2 - end75076953dbfe022526a153eda99b39b2: + goto endd97b4245ced2b3d27d8c555b06281de4 + endd97b4245ced2b3d27d8c555b06281de4: ; case OpMove: // match: (Move [size] dst src mem) @@ -2457,10 +3412,10 @@ func rewriteValueAMD64(v *Value, config *Config) bool { case OpNot: // match: (Not x) // cond: - // result: (XORQconst [1] x) + // result: (XORBconst [1] x) { x := v.Args[0] - v.Op = OpAMD64XORQconst + v.Op = OpAMD64XORBconst v.AuxInt = 0 v.Aux = nil v.resetArgs() @@ -2468,8 +3423,8 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(x) return true } - goto endaabd7f5e27417cf3182cd5e4f4360410 - endaabd7f5e27417cf3182cd5e4f4360410: + goto end73973101aad60079c62fa64624e21db1 + end73973101aad60079c62fa64624e21db1: ; case OpOffPtr: // match: (OffPtr [off] ptr) @@ -2629,26 +3584,89 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endfd6815c0dc9f8dff6c3ec6add7a23569 endfd6815c0dc9f8dff6c3ec6add7a23569: ; + case OpAMD64SARB: + // match: (SARB x (MOVBconst [c])) + // cond: + // result: (SARBconst [c&31] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVBconst { + goto end3bf3d17717aa6c04462e56d1c87902ce + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SARBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 31 + v.AddArg(x) + return true + } + goto end3bf3d17717aa6c04462e56d1c87902ce + end3bf3d17717aa6c04462e56d1c87902ce: + ; + case OpAMD64SARL: + // match: (SARL x (MOVLconst [c])) + // cond: + // result: (SARLconst [c&31] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVLconst { + goto ende586a72c1b232ee0b63e37c71eeb8470 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SARLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 31 + v.AddArg(x) + return true + } + goto ende586a72c1b232ee0b63e37c71eeb8470 + ende586a72c1b232ee0b63e37c71eeb8470: + ; case OpAMD64SARQ: // match: (SARQ x (MOVQconst [c])) // cond: - // result: (SARQconst [c] x) + // result: (SARQconst [c&63] x) { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVQconst { - goto end031712b4008075e25a5827dcb8dd3ebb + goto end25e720ab203be2745dded5550e6d8a7c } c := v.Args[1].AuxInt v.Op = OpAMD64SARQconst v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = c + v.AuxInt = c & 63 + v.AddArg(x) + return true + } + goto end25e720ab203be2745dded5550e6d8a7c + end25e720ab203be2745dded5550e6d8a7c: + ; + case OpAMD64SARW: + // match: (SARW x (MOVWconst [c])) + // cond: + // result: (SARWconst [c&31] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVWconst { + goto endc46e3f211f94238f9a0aec3c498af490 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SARWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 31 v.AddArg(x) return true } - goto end031712b4008075e25a5827dcb8dd3ebb - end031712b4008075e25a5827dcb8dd3ebb: + goto endc46e3f211f94238f9a0aec3c498af490 + endc46e3f211f94238f9a0aec3c498af490: ; case OpAMD64SBBQcarrymask: // match: (SBBQcarrymask (CMPQconst [c] (MOVQconst [d]))) @@ -2891,58 +3909,275 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endbc71811b789475308014550f638026eb endbc71811b789475308014550f638026eb: ; + case OpAMD64SHLB: + // match: (SHLB x (MOVBconst [c])) + // cond: + // result: (SHLBconst [c&31] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVBconst { + goto end2d0d0111d831d8a575b5627284a6337a + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SHLBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 31 + v.AddArg(x) + return true + } + goto end2d0d0111d831d8a575b5627284a6337a + end2d0d0111d831d8a575b5627284a6337a: + ; + case OpAMD64SHLL: + // match: (SHLL x (MOVLconst [c])) + // cond: + // result: (SHLLconst [c&31] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVLconst { + goto end633f9ddcfbb63374c895a5f78da75d25 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SHLLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 31 + v.AddArg(x) + return true + } + goto end633f9ddcfbb63374c895a5f78da75d25 + end633f9ddcfbb63374c895a5f78da75d25: + ; case OpAMD64SHLQ: // match: (SHLQ x (MOVQconst [c])) // cond: - // result: (SHLQconst [c] x) + // result: (SHLQconst [c&63] x) { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVQconst { - goto endcca412bead06dc3d56ef034a82d184d6 + goto end4d7e3a945cacdd6b6c8c0de6f465d4ae } c := v.Args[1].AuxInt v.Op = OpAMD64SHLQconst v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = c + v.AuxInt = c & 63 + v.AddArg(x) + return true + } + goto end4d7e3a945cacdd6b6c8c0de6f465d4ae + end4d7e3a945cacdd6b6c8c0de6f465d4ae: + ; + case OpAMD64SHLW: + // match: (SHLW x (MOVWconst [c])) + // cond: + // result: (SHLWconst [c&31] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVWconst { + goto endba96a52aa58d28b3357828051e0e695c + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SHLWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 31 + v.AddArg(x) + return true + } + goto endba96a52aa58d28b3357828051e0e695c + endba96a52aa58d28b3357828051e0e695c: + ; + case OpAMD64SHRB: + // match: (SHRB x (MOVBconst [c])) + // cond: + // result: (SHRBconst [c&31] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVBconst { + goto enddb1cd5aaa826d43fa4f6d1b2b8795e58 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SHRBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 31 + v.AddArg(x) + return true + } + goto enddb1cd5aaa826d43fa4f6d1b2b8795e58 + enddb1cd5aaa826d43fa4f6d1b2b8795e58: + ; + case OpAMD64SHRL: + // match: (SHRL x (MOVLconst [c])) + // cond: + // result: (SHRLconst [c&31] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVLconst { + goto end344b8b9202e1925e8d0561f1c21412fc + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SHRLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 31 v.AddArg(x) return true } - goto endcca412bead06dc3d56ef034a82d184d6 - endcca412bead06dc3d56ef034a82d184d6: + goto end344b8b9202e1925e8d0561f1c21412fc + end344b8b9202e1925e8d0561f1c21412fc: ; case OpAMD64SHRQ: // match: (SHRQ x (MOVQconst [c])) // cond: - // result: (SHRQconst [c] x) + // result: (SHRQconst [c&63] x) { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVQconst { - goto endbb0d3a04dd2b810cb3dbdf7ef665f22b + goto end699d35e2d5cfa08b8a3b1c8a183ddcf3 } c := v.Args[1].AuxInt v.Op = OpAMD64SHRQconst v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.AuxInt = c & 63 + v.AddArg(x) + return true + } + goto end699d35e2d5cfa08b8a3b1c8a183ddcf3 + end699d35e2d5cfa08b8a3b1c8a183ddcf3: + ; + case OpAMD64SHRW: + // match: (SHRW x (MOVWconst [c])) + // cond: + // result: (SHRWconst [c&31] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVWconst { + goto endd75ff1f9b3e9ec9c942a39b6179da1b3 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SHRWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 31 + v.AddArg(x) + return true + } + goto endd75ff1f9b3e9ec9c942a39b6179da1b3 + endd75ff1f9b3e9ec9c942a39b6179da1b3: + ; + case OpAMD64SUBB: + // match: (SUBB x (MOVBconst [c])) + // cond: + // result: (SUBBconst x [c]) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVBconst { + goto end9ca5d2a70e2df1a5a3ed6786bce1f7b2 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SUBBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) v.AuxInt = c + return true + } + goto end9ca5d2a70e2df1a5a3ed6786bce1f7b2 + end9ca5d2a70e2df1a5a3ed6786bce1f7b2: + ; + // match: (SUBB (MOVBconst [c]) x) + // cond: + // result: (NEGB (SUBBconst x [c])) + { + if v.Args[0].Op != OpAMD64MOVBconst { + goto endc288755d69b04d24a6aac32a73956411 + } + c := v.Args[0].AuxInt + x := v.Args[1] + v.Op = OpAMD64NEGB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64SUBBconst, TypeInvalid) + v0.Type = v.Type + v0.AddArg(x) + v0.AuxInt = c + v.AddArg(v0) + return true + } + goto endc288755d69b04d24a6aac32a73956411 + endc288755d69b04d24a6aac32a73956411: + ; + case OpAMD64SUBL: + // match: (SUBL x (MOVLconst [c])) + // cond: + // result: (SUBLconst x [c]) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVLconst { + goto end178c1d6c86f9c16f6497586c2f7d8625 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SUBLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() v.AddArg(x) + v.AuxInt = c + return true + } + goto end178c1d6c86f9c16f6497586c2f7d8625 + end178c1d6c86f9c16f6497586c2f7d8625: + ; + // match: (SUBL (MOVLconst [c]) x) + // cond: + // result: (NEGL (SUBLconst x [c])) + { + if v.Args[0].Op != OpAMD64MOVLconst { + goto endb0efe6e15ec20486b849534a00483ae2 + } + c := v.Args[0].AuxInt + x := v.Args[1] + v.Op = OpAMD64NEGL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64SUBLconst, TypeInvalid) + v0.Type = v.Type + v0.AddArg(x) + v0.AuxInt = c + v.AddArg(v0) return true } - goto endbb0d3a04dd2b810cb3dbdf7ef665f22b - endbb0d3a04dd2b810cb3dbdf7ef665f22b: + goto endb0efe6e15ec20486b849534a00483ae2 + endb0efe6e15ec20486b849534a00483ae2: ; case OpAMD64SUBQ: // match: (SUBQ x (MOVQconst [c])) - // cond: + // cond: is32Bit(c) // result: (SUBQconst x [c]) { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVQconst { - goto end5a74a63bd9ad15437717c6df3b25eebb + goto end9bbb7b20824a498752c605942fad89c2 } c := v.Args[1].AuxInt + if !(is32Bit(c)) { + goto end9bbb7b20824a498752c605942fad89c2 + } v.Op = OpAMD64SUBQconst v.AuxInt = 0 v.Aux = nil @@ -2951,32 +4186,78 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = c return true } - goto end5a74a63bd9ad15437717c6df3b25eebb - end5a74a63bd9ad15437717c6df3b25eebb: + goto end9bbb7b20824a498752c605942fad89c2 + end9bbb7b20824a498752c605942fad89c2: ; - // match: (SUBQ (MOVQconst [c]) x) - // cond: - // result: (NEGQ (SUBQconst x [c])) + // match: (SUBQ (MOVQconst [c]) x) + // cond: is32Bit(c) + // result: (NEGQ (SUBQconst x [c])) { - t := v.Type if v.Args[0].Op != OpAMD64MOVQconst { - goto end78e66b6fc298684ff4ac8aec5ce873c9 + goto end8beb96de3efee9206d1bd4b7d777d2cb } c := v.Args[0].AuxInt x := v.Args[1] + if !(is32Bit(c)) { + goto end8beb96de3efee9206d1bd4b7d777d2cb + } v.Op = OpAMD64NEGQ v.AuxInt = 0 v.Aux = nil v.resetArgs() v0 := v.Block.NewValue0(v.Line, OpAMD64SUBQconst, TypeInvalid) - v0.Type = t + v0.Type = v.Type + v0.AddArg(x) + v0.AuxInt = c + v.AddArg(v0) + return true + } + goto end8beb96de3efee9206d1bd4b7d777d2cb + end8beb96de3efee9206d1bd4b7d777d2cb: + ; + case OpAMD64SUBW: + // match: (SUBW x (MOVWconst [c])) + // cond: + // result: (SUBWconst x [c]) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVWconst { + goto end135aa9100b2f61d58b37cede37b63731 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SUBWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AuxInt = c + return true + } + goto end135aa9100b2f61d58b37cede37b63731 + end135aa9100b2f61d58b37cede37b63731: + ; + // match: (SUBW (MOVWconst [c]) x) + // cond: + // result: (NEGW (SUBWconst x [c])) + { + if v.Args[0].Op != OpAMD64MOVWconst { + goto end44d23f7e65a4b1c42d0e6463f8e493b6 + } + c := v.Args[0].AuxInt + x := v.Args[1] + v.Op = OpAMD64NEGW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64SUBWconst, TypeInvalid) + v0.Type = v.Type v0.AddArg(x) v0.AuxInt = c v.AddArg(v0) return true } - goto end78e66b6fc298684ff4ac8aec5ce873c9 - end78e66b6fc298684ff4ac8aec5ce873c9: + goto end44d23f7e65a4b1c42d0e6463f8e493b6 + end44d23f7e65a4b1c42d0e6463f8e493b6: ; case OpSignExt16to32: // match: (SignExt16to32 x) @@ -3373,6 +4654,78 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endc4c1a1b86edd0f082339d17eb5096ad0 endc4c1a1b86edd0f082339d17eb5096ad0: ; + case OpXor16: + // match: (Xor16 x y) + // cond: + // result: (XORW x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64XORW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end20efdd5dfd5130abf818de5546a991a0 + end20efdd5dfd5130abf818de5546a991a0: + ; + case OpXor32: + // match: (Xor32 x y) + // cond: + // result: (XORL x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64XORL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end9da6bce98b437e2609488346116a75d8 + end9da6bce98b437e2609488346116a75d8: + ; + case OpXor64: + // match: (Xor64 x y) + // cond: + // result: (XORQ x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64XORQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto endc88cd189c2a6f07ecff324ed94809f8f + endc88cd189c2a6f07ecff324ed94809f8f: + ; + case OpXor8: + // match: (Xor8 x y) + // cond: + // result: (XORB x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64XORB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end50f4434ef96916d3e65ad3cc236d1723 + end50f4434ef96916d3e65ad3cc236d1723: + ; case OpZero: // match: (Zero [0] _ mem) // cond: -- cgit v1.3 From bdb2d2810de66864cd77fbe95a602d53c851d889 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Thu, 30 Jul 2015 10:36:37 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: update generated code Missed somehow in #12813 Change-Id: I28f2789e33822a4ff884d8a3f474522747f61c73 Reviewed-on: https://go-review.googlesource.com/12868 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/rewriteAMD64.go | 340 +++++++++++++++++++++++++++ 1 file changed, 340 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 398ea231f1..a1c7866a7e 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -3426,6 +3426,176 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end73973101aad60079c62fa64624e21db1 end73973101aad60079c62fa64624e21db1: ; + case OpAMD64ORB: + // match: (ORB x (MOVBconst [c])) + // cond: + // result: (ORBconst [c] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVBconst { + goto end7b63870decde2515cb77ec4f8f76817c + } + c := v.Args[1].AuxInt + v.Op = OpAMD64ORBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end7b63870decde2515cb77ec4f8f76817c + end7b63870decde2515cb77ec4f8f76817c: + ; + // match: (ORB (MOVBconst [c]) x) + // cond: + // result: (ORBconst [c] x) + { + if v.Args[0].Op != OpAMD64MOVBconst { + goto end70b43d531e2097a4f6293f66256a642e + } + c := v.Args[0].AuxInt + x := v.Args[1] + v.Op = OpAMD64ORBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end70b43d531e2097a4f6293f66256a642e + end70b43d531e2097a4f6293f66256a642e: + ; + case OpAMD64ORL: + // match: (ORL x (MOVLconst [c])) + // cond: + // result: (ORLconst [c] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVLconst { + goto end1b883e30d860b6fac14ae98462c4f61a + } + c := v.Args[1].AuxInt + v.Op = OpAMD64ORLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end1b883e30d860b6fac14ae98462c4f61a + end1b883e30d860b6fac14ae98462c4f61a: + ; + // match: (ORL (MOVLconst [c]) x) + // cond: + // result: (ORLconst [c] x) + { + if v.Args[0].Op != OpAMD64MOVLconst { + goto enda5bc49524a0cbd2241f792837d0a48a8 + } + c := v.Args[0].AuxInt + x := v.Args[1] + v.Op = OpAMD64ORLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto enda5bc49524a0cbd2241f792837d0a48a8 + enda5bc49524a0cbd2241f792837d0a48a8: + ; + case OpAMD64ORQ: + // match: (ORQ x (MOVQconst [c])) + // cond: is32Bit(c) + // result: (ORQconst [c] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVQconst { + goto end601f2bb3ccda102e484ff60adeaf6d26 + } + c := v.Args[1].AuxInt + if !(is32Bit(c)) { + goto end601f2bb3ccda102e484ff60adeaf6d26 + } + v.Op = OpAMD64ORQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end601f2bb3ccda102e484ff60adeaf6d26 + end601f2bb3ccda102e484ff60adeaf6d26: + ; + // match: (ORQ (MOVQconst [c]) x) + // cond: is32Bit(c) + // result: (ORQconst [c] x) + { + if v.Args[0].Op != OpAMD64MOVQconst { + goto end010afbebcd314e288509d79a16a6d5cc + } + c := v.Args[0].AuxInt + x := v.Args[1] + if !(is32Bit(c)) { + goto end010afbebcd314e288509d79a16a6d5cc + } + v.Op = OpAMD64ORQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end010afbebcd314e288509d79a16a6d5cc + end010afbebcd314e288509d79a16a6d5cc: + ; + case OpAMD64ORW: + // match: (ORW x (MOVWconst [c])) + // cond: + // result: (ORWconst [c] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVWconst { + goto end9f98df10892dbf170b49aace86ee0d7f + } + c := v.Args[1].AuxInt + v.Op = OpAMD64ORWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end9f98df10892dbf170b49aace86ee0d7f + end9f98df10892dbf170b49aace86ee0d7f: + ; + // match: (ORW (MOVWconst [c]) x) + // cond: + // result: (ORWconst [c] x) + { + if v.Args[0].Op != OpAMD64MOVWconst { + goto end96405942c9ceb5fcb0ddb85a8709d015 + } + c := v.Args[0].AuxInt + x := v.Args[1] + v.Op = OpAMD64ORWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end96405942c9ceb5fcb0ddb85a8709d015 + end96405942c9ceb5fcb0ddb85a8709d015: + ; case OpOffPtr: // match: (OffPtr [off] ptr) // cond: @@ -4654,6 +4824,176 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endc4c1a1b86edd0f082339d17eb5096ad0 endc4c1a1b86edd0f082339d17eb5096ad0: ; + case OpAMD64XORB: + // match: (XORB x (MOVBconst [c])) + // cond: + // result: (XORBconst [c] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVBconst { + goto enda9ed9fdd115ffdffa8127c007c34d7b7 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64XORBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto enda9ed9fdd115ffdffa8127c007c34d7b7 + enda9ed9fdd115ffdffa8127c007c34d7b7: + ; + // match: (XORB (MOVBconst [c]) x) + // cond: + // result: (XORBconst [c] x) + { + if v.Args[0].Op != OpAMD64MOVBconst { + goto endb02a07d9dc7b802c59f013116e952f3f + } + c := v.Args[0].AuxInt + x := v.Args[1] + v.Op = OpAMD64XORBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto endb02a07d9dc7b802c59f013116e952f3f + endb02a07d9dc7b802c59f013116e952f3f: + ; + case OpAMD64XORL: + // match: (XORL x (MOVLconst [c])) + // cond: + // result: (XORLconst [c] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVLconst { + goto enda9459d509d3416da67d13a22dd074a9c + } + c := v.Args[1].AuxInt + v.Op = OpAMD64XORLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto enda9459d509d3416da67d13a22dd074a9c + enda9459d509d3416da67d13a22dd074a9c: + ; + // match: (XORL (MOVLconst [c]) x) + // cond: + // result: (XORLconst [c] x) + { + if v.Args[0].Op != OpAMD64MOVLconst { + goto end9c1a0af00eeadd8aa325e55f1f3fb89c + } + c := v.Args[0].AuxInt + x := v.Args[1] + v.Op = OpAMD64XORLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end9c1a0af00eeadd8aa325e55f1f3fb89c + end9c1a0af00eeadd8aa325e55f1f3fb89c: + ; + case OpAMD64XORQ: + // match: (XORQ x (MOVQconst [c])) + // cond: is32Bit(c) + // result: (XORQconst [c] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVQconst { + goto end452341f950062e0483f16438fb9ec500 + } + c := v.Args[1].AuxInt + if !(is32Bit(c)) { + goto end452341f950062e0483f16438fb9ec500 + } + v.Op = OpAMD64XORQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end452341f950062e0483f16438fb9ec500 + end452341f950062e0483f16438fb9ec500: + ; + // match: (XORQ (MOVQconst [c]) x) + // cond: is32Bit(c) + // result: (XORQconst [c] x) + { + if v.Args[0].Op != OpAMD64MOVQconst { + goto endd221a7e3daaaaa29ee385ad36e061b57 + } + c := v.Args[0].AuxInt + x := v.Args[1] + if !(is32Bit(c)) { + goto endd221a7e3daaaaa29ee385ad36e061b57 + } + v.Op = OpAMD64XORQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto endd221a7e3daaaaa29ee385ad36e061b57 + endd221a7e3daaaaa29ee385ad36e061b57: + ; + case OpAMD64XORW: + // match: (XORW x (MOVWconst [c])) + // cond: + // result: (XORWconst [c] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVWconst { + goto end2ca109efd66c221a5691a4da95ec6c67 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64XORWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end2ca109efd66c221a5691a4da95ec6c67 + end2ca109efd66c221a5691a4da95ec6c67: + ; + // match: (XORW (MOVWconst [c]) x) + // cond: + // result: (XORWconst [c] x) + { + if v.Args[0].Op != OpAMD64MOVWconst { + goto end51ee62a06d4301e5a4aed7a6639b1d53 + } + c := v.Args[0].AuxInt + x := v.Args[1] + v.Op = OpAMD64XORWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end51ee62a06d4301e5a4aed7a6639b1d53 + end51ee62a06d4301e5a4aed7a6639b1d53: + ; case OpXor16: // match: (Xor16 x y) // cond: -- cgit v1.3 From 4b803151ce02aa8372488dd6e50f26f5bc0b2120 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Wed, 29 Jul 2015 17:07:09 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: fix shift operations Convert shift ops to also encode the size of the shift amount. Change signed right shift from using CMOV to using bit twiddles. It is a little bit better (5 instructions instead of 4, but fewer bytes and slightly faster code). It's also a bit faster than the 4-instruction branch version, even with a very predictable branch. As tested on my machine, YMMV. Implement OCOM while we are here. Change-Id: I8ca12dd62fae5d626dc0e6da5d4bbd34fd9640d2 Reviewed-on: https://go-review.googlesource.com/12867 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/gc/ssa.go | 153 +- src/cmd/compile/internal/ssa/gen/AMD64.rules | 179 +- src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 10 +- src/cmd/compile/internal/ssa/gen/genericOps.go | 71 +- src/cmd/compile/internal/ssa/opGen.go | 327 +++- src/cmd/compile/internal/ssa/rewriteAMD64.go | 2451 +++++++++++++++++++++--- src/cmd/compile/internal/ssa/shift_test.go | 12 +- 7 files changed, 2751 insertions(+), 452 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 7344d222cd..32844093d2 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -727,6 +727,15 @@ var opToSSA = map[opAndType]ssa.Op{ opAndType{OMINUS, TINT64}: ssa.OpNeg64, opAndType{OMINUS, TUINT64}: ssa.OpNeg64, + 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{OMUL, TINT8}: ssa.OpMul8, opAndType{OMUL, TUINT8}: ssa.OpMul8, opAndType{OMUL, TINT16}: ssa.OpMul16, @@ -754,24 +763,6 @@ var opToSSA = map[opAndType]ssa.Op{ opAndType{OOR, TINT64}: ssa.OpOr64, opAndType{OOR, TUINT64}: ssa.OpOr64, - opAndType{OLSH, TINT8}: ssa.OpLsh8, - opAndType{OLSH, TUINT8}: ssa.OpLsh8, - opAndType{OLSH, TINT16}: ssa.OpLsh16, - opAndType{OLSH, TUINT16}: ssa.OpLsh16, - opAndType{OLSH, TINT32}: ssa.OpLsh32, - opAndType{OLSH, TUINT32}: ssa.OpLsh32, - opAndType{OLSH, TINT64}: ssa.OpLsh64, - opAndType{OLSH, TUINT64}: ssa.OpLsh64, - - opAndType{ORSH, TINT8}: ssa.OpRsh8, - opAndType{ORSH, TUINT8}: ssa.OpRsh8U, - opAndType{ORSH, TINT16}: ssa.OpRsh16, - opAndType{ORSH, TUINT16}: ssa.OpRsh16U, - opAndType{ORSH, TINT32}: ssa.OpRsh32, - opAndType{ORSH, TUINT32}: ssa.OpRsh32U, - opAndType{ORSH, TINT64}: ssa.OpRsh64, - opAndType{ORSH, TUINT64}: ssa.OpRsh64U, - opAndType{OEQ, TBOOL}: ssa.OpEq8, opAndType{OEQ, TINT8}: ssa.OpEq8, opAndType{OEQ, TUINT8}: ssa.OpEq8, @@ -877,6 +868,96 @@ func (s *state) ssaOp(op uint8, t *Type) ssa.Op { return x } +type opAndTwoTypes struct { + op uint8 + etype1 uint8 + etype2 uint8 +} + +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 uint8, 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(int(etype1), 0), Econv(int(etype2), 0)) + } + 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) @@ -999,10 +1080,14 @@ func (s *state) expr(n *Node) *ssa.Value { a := s.expr(n.Left) b := s.expr(n.Right) return s.newValue2(s.ssaOp(n.Op, n.Left.Type), ssa.TypeBool, a, b) - case OADD, OAND, OLSH, OMUL, OOR, ORSH, OSUB: + case OADD, OSUB, OMUL, OAND, OOR: 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 OANDAND, OOROR: // To implement OANDAND (and OOROR), we introduce a // new temporary variable to hold the result. The @@ -1045,7 +1130,7 @@ func (s *state) expr(n *Node) *ssa.Value { return s.variable(n, n.Type) // unary ops - case ONOT, OMINUS: + case ONOT, OMINUS, OCOM: a := s.expr(n.Left) return s.newValue1(s.ssaOp(n.Op, n.Type), a.Type, a) @@ -1766,36 +1851,13 @@ func genValue(v *ssa.Value) { p.From.Offset = v.AuxInt p.To.Type = obj.TYPE_REG p.To.Reg = r - case ssa.OpAMD64SBBQcarrymask: + 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.OpAMD64CMOVQCC: - r := regnum(v) - x := regnum(v.Args[1]) - y := regnum(v.Args[2]) - if x != r && y != r { - p := Prog(x86.AMOVQ) - p.From.Type = obj.TYPE_REG - p.From.Reg = x - p.To.Type = obj.TYPE_REG - p.To.Reg = r - x = r - } - var p *obj.Prog - if x == r { - p = Prog(x86.ACMOVQCS) - p.From.Reg = y - } else { - p = Prog(x86.ACMOVQCC) - p.From.Reg = x - } - p.From.Type = obj.TYPE_REG - 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 @@ -1967,7 +2029,8 @@ func genValue(v *ssa.Value) { p := Prog(obj.ACALL) p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v.Args[0]) - case ssa.OpAMD64NEGQ, ssa.OpAMD64NEGL, ssa.OpAMD64NEGW, ssa.OpAMD64NEGB: + case ssa.OpAMD64NEGQ, ssa.OpAMD64NEGL, ssa.OpAMD64NEGW, ssa.OpAMD64NEGB, + ssa.OpAMD64NOTQ, ssa.OpAMD64NOTL, ssa.OpAMD64NOTW, ssa.OpAMD64NOTB: p := Prog(v.Op.Asm()) p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v.Args[0]) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 08c1d98481..0aa9c73279 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -50,6 +50,11 @@ (Neg16 x) -> (NEGW x) (Neg8 x) -> (NEGB x) +(Com64 x) -> (NOTQ x) +(Com32 x) -> (NOTL x) +(Com16 x) -> (NOTW x) +(Com8 x) -> (NOTB 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) @@ -78,57 +83,71 @@ // TODO: other ConvNops are safe? Maybe all of them? // Lowering shifts -// Note: unsigned shifts need to return 0 if shift amount is >= 64. -// mask = shift >= 64 ? 0 : 0xffffffffffffffff -// result = mask & arg << shift -// TODO: define ops per right-hand side size, like Lsh64x32 for int64(x)< x y) && y.Type.Size() == 8 -> - (ANDQ (SHLQ x y) (SBBQcarrymask (CMPQconst [64] y))) -(Lsh64 x y) && y.Type.Size() == 4 -> - (ANDQ (SHLQ x y) (SBBQcarrymask (CMPLconst [64] y))) -(Lsh64 x y) && y.Type.Size() == 2 -> - (ANDQ (SHLQ x y) (SBBQcarrymask (CMPWconst [64] y))) -(Lsh64 x y) && y.Type.Size() == 1 -> - (ANDQ (SHLQ x y) (SBBQcarrymask (CMPBconst [64] y))) - -(Lsh32 x y) && y.Type.Size() == 8 -> - (ANDL (SHLL x y) (SBBQcarrymask (CMPQconst [32] y))) -(Lsh32 x y) && y.Type.Size() == 4 -> - (ANDL (SHLL x y) (SBBQcarrymask (CMPLconst [32] y))) -(Lsh32 x y) && y.Type.Size() == 2 -> - (ANDL (SHLL x y) (SBBQcarrymask (CMPWconst [32] y))) -(Lsh32 x y) && y.Type.Size() == 1 -> - (ANDL (SHLL x y) (SBBQcarrymask (CMPBconst [32] y))) - -(Lsh16 x y) && y.Type.Size() == 8 -> - (ANDW (SHLW x y) (SBBQcarrymask (CMPQconst [16] y))) -(Lsh16 x y) && y.Type.Size() == 4 -> - (ANDW (SHLW x y) (SBBQcarrymask (CMPLconst [16] y))) -(Lsh16 x y) && y.Type.Size() == 2 -> - (ANDW (SHLW x y) (SBBQcarrymask (CMPWconst [16] y))) -(Lsh16 x y) && y.Type.Size() == 1 -> - (ANDW (SHLW x y) (SBBQcarrymask (CMPBconst [16] y))) - -(Lsh8 x y) && y.Type.Size() == 8 -> - (ANDB (SHLB x y) (SBBQcarrymask (CMPQconst [8] y))) -(Lsh8 x y) && y.Type.Size() == 4 -> - (ANDB (SHLB x y) (SBBQcarrymask (CMPLconst [8] y))) -(Lsh8 x y) && y.Type.Size() == 2 -> - (ANDB (SHLB x y) (SBBQcarrymask (CMPWconst [8] y))) -(Lsh8 x y) && y.Type.Size() == 1 -> - (ANDB (SHLB x y) (SBBQcarrymask (CMPBconst [8] y))) - -(Rsh64U x y) && y.Type.Size() == 8 -> - (ANDQ (SHRQ x y) (SBBQcarrymask (CMPQconst [64] y))) - -// Note: signed right shift needs to return 0/-1 if shift amount is >= 64. -// if shift > 63 { shift = 63 } -// result = arg >> shift -(Rsh64 x y) && y.Type.Size() == 8 -> - (SARQ x (CMOVQCC - (CMPQconst [64] y) - (MOVQconst [63]) - y)) +// 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 x y) -> (ANDQ (SHLQ x y) (SBBQcarrymask (CMPQconst [64] y))) +(Lsh64x32 x y) -> (ANDQ (SHLQ x y) (SBBQcarrymask (CMPLconst [64] y))) +(Lsh64x16 x y) -> (ANDQ (SHLQ x y) (SBBQcarrymask (CMPWconst [64] y))) +(Lsh64x8 x y) -> (ANDQ (SHLQ x y) (SBBQcarrymask (CMPBconst [64] y))) + +(Lsh32x64 x y) -> (ANDL (SHLL x y) (SBBLcarrymask (CMPQconst [32] y))) +(Lsh32x32 x y) -> (ANDL (SHLL x y) (SBBLcarrymask (CMPLconst [32] y))) +(Lsh32x16 x y) -> (ANDL (SHLL x y) (SBBLcarrymask (CMPWconst [32] y))) +(Lsh32x8 x y) -> (ANDL (SHLL x y) (SBBLcarrymask (CMPBconst [32] y))) + +(Lsh16x64 x y) -> (ANDW (SHLW x y) (SBBLcarrymask (CMPQconst [16] y))) +(Lsh16x32 x y) -> (ANDW (SHLW x y) (SBBLcarrymask (CMPLconst [16] y))) +(Lsh16x16 x y) -> (ANDW (SHLW x y) (SBBLcarrymask (CMPWconst [16] y))) +(Lsh16x8 x y) -> (ANDW (SHLW x y) (SBBLcarrymask (CMPBconst [16] y))) + +(Lsh8x64 x y) -> (ANDB (SHLB x y) (SBBLcarrymask (CMPQconst [8] y))) +(Lsh8x32 x y) -> (ANDB (SHLB x y) (SBBLcarrymask (CMPLconst [8] y))) +(Lsh8x16 x y) -> (ANDB (SHLB x y) (SBBLcarrymask (CMPWconst [8] y))) +(Lsh8x8 x y) -> (ANDB (SHLB x y) (SBBLcarrymask (CMPBconst [8] y))) + +(Rsh64Ux64 x y) -> (ANDQ (SHRQ x y) (SBBQcarrymask (CMPQconst [64] y))) +(Rsh64Ux32 x y) -> (ANDQ (SHRQ x y) (SBBQcarrymask (CMPLconst [64] y))) +(Rsh64Ux16 x y) -> (ANDQ (SHRQ x y) (SBBQcarrymask (CMPWconst [64] y))) +(Rsh64Ux8 x y) -> (ANDQ (SHRQ x y) (SBBQcarrymask (CMPBconst [64] y))) + +(Rsh32Ux64 x y) -> (ANDL (SHRL x y) (SBBLcarrymask (CMPQconst [32] y))) +(Rsh32Ux32 x y) -> (ANDL (SHRL x y) (SBBLcarrymask (CMPLconst [32] y))) +(Rsh32Ux16 x y) -> (ANDL (SHRL x y) (SBBLcarrymask (CMPWconst [32] y))) +(Rsh32Ux8 x y) -> (ANDL (SHRL x y) (SBBLcarrymask (CMPBconst [32] y))) + +(Rsh16Ux64 x y) -> (ANDW (SHRW x y) (SBBLcarrymask (CMPQconst [16] y))) +(Rsh16Ux32 x y) -> (ANDW (SHRW x y) (SBBLcarrymask (CMPLconst [16] y))) +(Rsh16Ux16 x y) -> (ANDW (SHRW x y) (SBBLcarrymask (CMPWconst [16] y))) +(Rsh16Ux8 x y) -> (ANDW (SHRW x y) (SBBLcarrymask (CMPBconst [16] y))) + +(Rsh8Ux64 x y) -> (ANDB (SHRB x y) (SBBLcarrymask (CMPQconst [8] y))) +(Rsh8Ux32 x y) -> (ANDB (SHRB x y) (SBBLcarrymask (CMPLconst [8] y))) +(Rsh8Ux16 x y) -> (ANDB (SHRB x y) (SBBLcarrymask (CMPWconst [8] y))) +(Rsh8Ux8 x y) -> (ANDB (SHRB x y) (SBBLcarrymask (CMPBconst [8] y))) + +// 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 x y) -> (SARQ x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst [64] y))))) +(Rsh64x32 x y) -> (SARQ x (ORL y (NOTL (SBBLcarrymask (CMPLconst [64] y))))) +(Rsh64x16 x y) -> (SARQ x (ORW y (NOTL (SBBLcarrymask (CMPWconst [64] y))))) +(Rsh64x8 x y) -> (SARQ x (ORB y (NOTL (SBBLcarrymask (CMPBconst [64] y))))) + +(Rsh32x64 x y) -> (SARL x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst [32] y))))) +(Rsh32x32 x y) -> (SARL x (ORL y (NOTL (SBBLcarrymask (CMPLconst [32] y))))) +(Rsh32x16 x y) -> (SARL x (ORW y (NOTL (SBBLcarrymask (CMPWconst [32] y))))) +(Rsh32x8 x y) -> (SARL x (ORB y (NOTL (SBBLcarrymask (CMPBconst [32] y))))) + +(Rsh16x64 x y) -> (SARW x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst [16] y))))) +(Rsh16x32 x y) -> (SARW x (ORL y (NOTL (SBBLcarrymask (CMPLconst [16] y))))) +(Rsh16x16 x y) -> (SARW x (ORW y (NOTL (SBBLcarrymask (CMPWconst [16] y))))) +(Rsh16x8 x y) -> (SARW x (ORB y (NOTL (SBBLcarrymask (CMPBconst [16] y))))) + +(Rsh8x64 x y) -> (SARB x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst [8] y))))) +(Rsh8x32 x y) -> (SARB x (ORL y (NOTL (SBBLcarrymask (CMPLconst [8] y))))) +(Rsh8x16 x y) -> (SARB x (ORW y (NOTL (SBBLcarrymask (CMPWconst [8] y))))) +(Rsh8x8 x y) -> (SARB x (ORB y (NOTL (SBBLcarrymask (CMPBconst [8] y))))) (Less64 x y) -> (SETL (CMPQ x y)) (Less32 x y) -> (SETL (CMPL x y)) @@ -398,10 +417,58 @@ (EQ (InvertFlags cmp) yes no) -> (EQ cmp yes no) (NE (InvertFlags cmp) yes no) -> (NE cmp yes no) -// get rid of >=64 code for constant shifts +// get rid of overflow code for constant shifts (SBBQcarrymask (CMPQconst [c] (MOVQconst [d]))) && inBounds(d, c) -> (MOVQconst [-1]) (SBBQcarrymask (CMPQconst [c] (MOVQconst [d]))) && !inBounds(d, c) -> (MOVQconst [0]) -(ANDQconst [0] _) -> (MOVQconst [0]) -(ANDQconst [-1] x) -> (Copy x) -(CMOVQCC (CMPQconst [c] (MOVQconst [d])) _ x) && inBounds(d, c) -> (Copy x) -(CMOVQCC (CMPQconst [c] (MOVQconst [d])) x _) && !inBounds(d, c) -> (Copy x) +(SBBQcarrymask (CMPLconst [c] (MOVLconst [d]))) && inBounds(int64(int32(d)), int64(int32(c))) -> (MOVQconst [-1]) +(SBBQcarrymask (CMPLconst [c] (MOVLconst [d]))) && !inBounds(int64(int32(d)), int64(int32(c))) -> (MOVQconst [0]) +(SBBQcarrymask (CMPWconst [c] (MOVWconst [d]))) && inBounds(int64(int16(d)), int64(int16(c))) -> (MOVQconst [-1]) +(SBBQcarrymask (CMPWconst [c] (MOVWconst [d]))) && !inBounds(int64(int16(d)), int64(int16(c))) -> (MOVQconst [0]) +(SBBQcarrymask (CMPBconst [c] (MOVBconst [d]))) && inBounds(int64(int8(d)), int64(int8(c))) -> (MOVQconst [-1]) +(SBBQcarrymask (CMPBconst [c] (MOVBconst [d]))) && !inBounds(int64(int8(d)), int64(int8(c))) -> (MOVQconst [0]) +(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) -> (Copy x) +(ANDLconst [c] x) && int32(c)==-1 -> (Copy x) +(ANDWconst [c] x) && int16(c)==-1 -> (Copy x) +(ANDBconst [c] x) && int8(c)==-1 -> (Copy x) +(ORQconst [0] x) -> (Copy x) +(ORLconst [c] x) && int32(c)==0 -> (Copy x) +(ORWconst [c] x) && int16(c)==0 -> (Copy x) +(ORBconst [c] x) && int8(c)==0 -> (Copy 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]) + +// 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]) +(SUBQconst [c] (MOVQconst [d])) -> (MOVQconst [c-d]) +(SUBLconst [c] (MOVLconst [d])) -> (MOVLconst [c-d]) +(SUBWconst [c] (MOVWconst [d])) -> (MOVWconst [c-d]) +(SUBBconst [c] (MOVBconst [d])) -> (MOVBconst [c-d]) +(MULQconst [c] (MOVQconst [d])) -> (MOVQconst [c*d]) +(MULLconst [c] (MOVLconst [d])) -> (MOVLconst [c*d]) +(MULWconst [c] (MOVWconst [d])) -> (MOVWconst [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]) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index a595469134..626e2175a9 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -89,7 +89,6 @@ func init() { gpstoreconst := regInfo{[]regMask{gpspsb, 0}, 0, nil} gpstoreidx := regInfo{[]regMask{gpspsb, gpsp, gpsp, 0}, 0, nil} flagsgp := regInfo{[]regMask{flags}, 0, []regMask{gp}} - cmov := regInfo{[]regMask{flags, gp, gp}, 0, []regMask{gp}} // Suffixes encode the bit width of various instructions. // Q = 64 bit, L = 32 bit, W = 16 bit, B = 8 bit @@ -201,7 +200,14 @@ func init() { {name: "NEGW", reg: gp11, asm: "NEGW"}, // -arg0 {name: "NEGB", reg: gp11, asm: "NEGB"}, // -arg0 + {name: "NOTQ", reg: gp11, asm: "NOTQ"}, // ^arg0 + {name: "NOTL", reg: gp11, asm: "NOTL"}, // ^arg0 + {name: "NOTW", reg: gp11, asm: "NOTW"}, // ^arg0 + {name: "NOTB", reg: gp11, asm: "NOTB"}, // ^arg0 + {name: "SBBQcarrymask", reg: flagsgp1, asm: "SBBQ"}, // (int64)(-1) if carry is set, 0 if carry is clear. + {name: "SBBLcarrymask", reg: flagsgp1, asm: "SBBL"}, // (int32)(-1) if carry is set, 0 if carry is clear. + // Note: SBBW and SBBB are subsumed by SBBL {name: "SETEQ", reg: flagsgp, asm: "SETEQ"}, // extract == condition from arg0 {name: "SETNE", reg: flagsgp, asm: "SETNE"}, // extract != condition from arg0 @@ -214,8 +220,6 @@ func init() { {name: "SETA", reg: flagsgp, asm: "SETHI"}, // extract unsigned > condition from arg0 {name: "SETAE", reg: flagsgp, asm: "SETCC"}, // extract unsigned >= condition from arg0 - {name: "CMOVQCC", reg: cmov}, // carry clear - {name: "MOVBQSX", reg: gp11, asm: "MOVBQSX"}, // sign extend arg0 from int8 to int64 {name: "MOVBQZX", reg: gp11, asm: "MOVBQZX"}, // zero extend arg0 from int8 to int64 {name: "MOVWQSX", reg: gp11, asm: "MOVWQSX"}, // sign extend arg0 from int16 to int64 diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 9e71dbdb74..bc1fdc86a2 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -42,19 +42,57 @@ var genericOps = []opData{ {name: "Xor32"}, {name: "Xor64"}, - {name: "Lsh8"}, // arg0 << arg1 - {name: "Lsh16"}, - {name: "Lsh32"}, - {name: "Lsh64"}, - - {name: "Rsh8"}, // arg0 >> arg1 - {name: "Rsh8U"}, - {name: "Rsh16"}, - {name: "Rsh16U"}, - {name: "Rsh32"}, - {name: "Rsh32U"}, - {name: "Rsh64"}, - {name: "Rsh64U"}, + // For shifts, AxB means the shifted value has A bits and the shift amount has B bits. + {name: "Lsh8x8"}, // arg0 << arg1 + {name: "Lsh8x16"}, + {name: "Lsh8x32"}, + {name: "Lsh8x64"}, + {name: "Lsh16x8"}, + {name: "Lsh16x16"}, + {name: "Lsh16x32"}, + {name: "Lsh16x64"}, + {name: "Lsh32x8"}, + {name: "Lsh32x16"}, + {name: "Lsh32x32"}, + {name: "Lsh32x64"}, + {name: "Lsh64x8"}, + {name: "Lsh64x16"}, + {name: "Lsh64x32"}, + {name: "Lsh64x64"}, + + {name: "Rsh8x8"}, // arg0 >> arg1, signed + {name: "Rsh8x16"}, + {name: "Rsh8x32"}, + {name: "Rsh8x64"}, + {name: "Rsh16x8"}, + {name: "Rsh16x16"}, + {name: "Rsh16x32"}, + {name: "Rsh16x64"}, + {name: "Rsh32x8"}, + {name: "Rsh32x16"}, + {name: "Rsh32x32"}, + {name: "Rsh32x64"}, + {name: "Rsh64x8"}, + {name: "Rsh64x16"}, + {name: "Rsh64x32"}, + {name: "Rsh64x64"}, + + {name: "Rsh8Ux8"}, // arg0 >> arg1, unsigned + {name: "Rsh8Ux16"}, + {name: "Rsh8Ux32"}, + {name: "Rsh8Ux64"}, + {name: "Rsh16Ux8"}, + {name: "Rsh16Ux16"}, + {name: "Rsh16Ux32"}, + {name: "Rsh16Ux64"}, + {name: "Rsh32Ux8"}, + {name: "Rsh32Ux16"}, + {name: "Rsh32Ux32"}, + {name: "Rsh32Ux64"}, + {name: "Rsh64Ux8"}, + {name: "Rsh64Ux16"}, + {name: "Rsh64Ux32"}, + {name: "Rsh64Ux64"}, // 2-input comparisons {name: "Eq8"}, // arg0 == arg1 @@ -110,11 +148,16 @@ var genericOps = []opData{ // 1-input ops {name: "Not"}, // !arg0 - {name: "Neg8"}, // - arg0 + {name: "Neg8"}, // -arg0 {name: "Neg16"}, {name: "Neg32"}, {name: "Neg64"}, + {name: "Com8"}, // ^arg0 + {name: "Com16"}, + {name: "Com32"}, + {name: "Com64"}, + // Data movement {name: "Phi"}, // select an argument based on which predecessor block we came from {name: "Copy"}, // output = arg0 diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index c4b4e80a11..f5f6e139f5 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -141,7 +141,12 @@ const ( OpAMD64NEGL OpAMD64NEGW OpAMD64NEGB + OpAMD64NOTQ + OpAMD64NOTL + OpAMD64NOTW + OpAMD64NOTB OpAMD64SBBQcarrymask + OpAMD64SBBLcarrymask OpAMD64SETEQ OpAMD64SETNE OpAMD64SETL @@ -152,7 +157,6 @@ const ( OpAMD64SETBE OpAMD64SETA OpAMD64SETAE - OpAMD64CMOVQCC OpAMD64MOVBQSX OpAMD64MOVBQZX OpAMD64MOVWQSX @@ -213,18 +217,54 @@ const ( OpXor16 OpXor32 OpXor64 - OpLsh8 - OpLsh16 - OpLsh32 - OpLsh64 - OpRsh8 - OpRsh8U - OpRsh16 - OpRsh16U - OpRsh32 - OpRsh32U - OpRsh64 - OpRsh64U + 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 OpEq8 OpEq16 OpEq32 @@ -274,6 +314,10 @@ const ( OpNeg16 OpNeg32 OpNeg64 + OpCom8 + OpCom16 + OpCom32 + OpCom64 OpPhi OpCopy OpConstBool @@ -1458,6 +1502,54 @@ var opcodeTable = [...]opInfo{ }, }, }, + { + name: "NOTQ", + asm: x86.ANOTQ, + reg: regInfo{ + inputs: []regMask{ + 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: "NOTL", + asm: x86.ANOTL, + reg: regInfo{ + inputs: []regMask{ + 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: "NOTW", + asm: x86.ANOTW, + reg: regInfo{ + inputs: []regMask{ + 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: "NOTB", + asm: x86.ANOTB, + reg: regInfo{ + inputs: []regMask{ + 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: "SBBQcarrymask", asm: x86.ASBBQ, @@ -1470,6 +1562,18 @@ var opcodeTable = [...]opInfo{ }, }, }, + { + name: "SBBLcarrymask", + asm: x86.ASBBL, + reg: regInfo{ + inputs: []regMask{ + 8589934592, // .FLAGS + }, + outputs: []regMask{ + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + }, + }, { name: "SETEQ", asm: x86.ASETEQ, @@ -1590,19 +1694,6 @@ var opcodeTable = [...]opInfo{ }, }, }, - { - name: "CMOVQCC", - reg: regInfo{ - inputs: []regMask{ - 8589934592, // .FLAGS - 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65519, // .AX .CX .DX .BX .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: "MOVBQSX", asm: x86.AMOVBQSX, @@ -2072,51 +2163,195 @@ var opcodeTable = [...]opInfo{ generic: true, }, { - name: "Lsh8", + name: "Lsh8x8", + generic: true, + }, + { + name: "Lsh8x16", + generic: true, + }, + { + name: "Lsh8x32", + generic: true, + }, + { + name: "Lsh8x64", + generic: true, + }, + { + name: "Lsh16x8", + generic: true, + }, + { + name: "Lsh16x16", + generic: true, + }, + { + name: "Lsh16x32", + generic: true, + }, + { + name: "Lsh16x64", + generic: true, + }, + { + name: "Lsh32x8", + generic: true, + }, + { + name: "Lsh32x16", + generic: true, + }, + { + name: "Lsh32x32", generic: true, }, { - name: "Lsh16", + name: "Lsh32x64", generic: true, }, { - name: "Lsh32", + name: "Lsh64x8", generic: true, }, { - name: "Lsh64", + name: "Lsh64x16", generic: true, }, { - name: "Rsh8", + name: "Lsh64x32", generic: true, }, { - name: "Rsh8U", + name: "Lsh64x64", generic: true, }, { - name: "Rsh16", + name: "Rsh8x8", generic: true, }, { - name: "Rsh16U", + name: "Rsh8x16", generic: true, }, { - name: "Rsh32", + name: "Rsh8x32", generic: true, }, { - name: "Rsh32U", + name: "Rsh8x64", generic: true, }, { - name: "Rsh64", + name: "Rsh16x8", generic: true, }, { - name: "Rsh64U", + name: "Rsh16x16", + generic: true, + }, + { + name: "Rsh16x32", + generic: true, + }, + { + name: "Rsh16x64", + generic: true, + }, + { + name: "Rsh32x8", + generic: true, + }, + { + name: "Rsh32x16", + generic: true, + }, + { + name: "Rsh32x32", + generic: true, + }, + { + name: "Rsh32x64", + generic: true, + }, + { + name: "Rsh64x8", + generic: true, + }, + { + name: "Rsh64x16", + generic: true, + }, + { + name: "Rsh64x32", + generic: true, + }, + { + name: "Rsh64x64", + generic: true, + }, + { + name: "Rsh8Ux8", + generic: true, + }, + { + name: "Rsh8Ux16", + generic: true, + }, + { + name: "Rsh8Ux32", + generic: true, + }, + { + name: "Rsh8Ux64", + generic: true, + }, + { + name: "Rsh16Ux8", + generic: true, + }, + { + name: "Rsh16Ux16", + generic: true, + }, + { + name: "Rsh16Ux32", + generic: true, + }, + { + name: "Rsh16Ux64", + generic: true, + }, + { + name: "Rsh32Ux8", + generic: true, + }, + { + name: "Rsh32Ux16", + generic: true, + }, + { + name: "Rsh32Ux32", + generic: true, + }, + { + name: "Rsh32Ux64", + generic: true, + }, + { + name: "Rsh64Ux8", + generic: true, + }, + { + name: "Rsh64Ux16", + generic: true, + }, + { + name: "Rsh64Ux32", + generic: true, + }, + { + name: "Rsh64Ux64", generic: true, }, { @@ -2315,6 +2550,22 @@ var opcodeTable = [...]opInfo{ name: "Neg64", generic: true, }, + { + name: "Com8", + generic: true, + }, + { + name: "Com16", + generic: true, + }, + { + name: "Com32", + generic: true, + }, + { + name: "Com64", + generic: true, + }, { name: "Phi", generic: true, diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index a1c7866a7e..eb1428e87e 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -45,6 +45,26 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end28aa1a4abe7e1abcdd64135e9967d39d end28aa1a4abe7e1abcdd64135e9967d39d: ; + case OpAMD64ADDBconst: + // match: (ADDBconst [c] (MOVBconst [d])) + // cond: + // result: (MOVBconst [c+d]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVBconst { + goto enda9b1e9e31ccdf0af5f4fe57bf4b1343f + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + d + return true + } + goto enda9b1e9e31ccdf0af5f4fe57bf4b1343f + enda9b1e9e31ccdf0af5f4fe57bf4b1343f: + ; case OpAMD64ADDL: // match: (ADDL x (MOVLconst [c])) // cond: @@ -86,6 +106,26 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end739561e08a561e26ce3634dc0d5ec733 end739561e08a561e26ce3634dc0d5ec733: ; + case OpAMD64ADDLconst: + // match: (ADDLconst [c] (MOVLconst [d])) + // cond: + // result: (MOVLconst [c+d]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVLconst { + goto ende04850e987890abf1d66199042a19c23 + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + d + return true + } + goto ende04850e987890abf1d66199042a19c23 + ende04850e987890abf1d66199042a19c23: + ; case OpAMD64ADDQ: // match: (ADDQ x (MOVQconst [c])) // cond: is32Bit(c) @@ -198,6 +238,25 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end288952f259d4a1842f1e8d5c389b3f28 end288952f259d4a1842f1e8d5c389b3f28: ; + // match: (ADDQconst [c] (MOVQconst [d])) + // cond: + // result: (MOVQconst [c+d]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVQconst { + goto end09dc54395b4e96e8332cf8e4e7481c52 + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + d + return true + } + goto end09dc54395b4e96e8332cf8e4e7481c52 + end09dc54395b4e96e8332cf8e4e7481c52: + ; case OpAMD64ADDW: // match: (ADDW x (MOVWconst [c])) // cond: @@ -239,6 +298,26 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto ende3aede99966f388afc624f9e86676fd2 ende3aede99966f388afc624f9e86676fd2: ; + case OpAMD64ADDWconst: + // match: (ADDWconst [c] (MOVWconst [d])) + // cond: + // result: (MOVWconst [c+d]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVWconst { + goto end32541920f2f5a920dfae41d8ebbef00f + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + d + return true + } + goto end32541920f2f5a920dfae41d8ebbef00f + end32541920f2f5a920dfae41d8ebbef00f: + ; case OpAMD64ANDB: // match: (ANDB x (MOVBconst [c])) // cond: @@ -280,6 +359,63 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end4068edac2ae0f354cf581db210288b98 end4068edac2ae0f354cf581db210288b98: ; + case OpAMD64ANDBconst: + // match: (ANDBconst [c] _) + // cond: int8(c)==0 + // result: (MOVBconst [0]) + { + c := v.AuxInt + if !(int8(c) == 0) { + goto end2106d410c949da14d7c00041f40eca76 + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end2106d410c949da14d7c00041f40eca76 + end2106d410c949da14d7c00041f40eca76: + ; + // match: (ANDBconst [c] x) + // cond: int8(c)==-1 + // result: (Copy x) + { + c := v.AuxInt + x := v.Args[0] + if !(int8(c) == -1) { + goto ende983ac58fd9834f2c8503e92e45d83db + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto ende983ac58fd9834f2c8503e92e45d83db + ende983ac58fd9834f2c8503e92e45d83db: + ; + // match: (ANDBconst [c] (MOVBconst [d])) + // cond: + // result: (MOVBconst [c&d]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVBconst { + goto end946312b1f216933da86febe293eb956f + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & d + return true + } + goto end946312b1f216933da86febe293eb956f + end946312b1f216933da86febe293eb956f: + ; case OpAMD64ANDL: // match: (ANDL x (MOVLconst [c])) // cond: @@ -321,6 +457,63 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end0529ba323d9b6f15c41add401ef67959 end0529ba323d9b6f15c41add401ef67959: ; + case OpAMD64ANDLconst: + // match: (ANDLconst [c] _) + // cond: int32(c)==0 + // result: (MOVLconst [0]) + { + c := v.AuxInt + if !(int32(c) == 0) { + goto end5efb241208aef28c950b7bcf8d85d5de + } + v.Op = OpAMD64MOVLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end5efb241208aef28c950b7bcf8d85d5de + end5efb241208aef28c950b7bcf8d85d5de: + ; + // match: (ANDLconst [c] x) + // cond: int32(c)==-1 + // result: (Copy x) + { + c := v.AuxInt + x := v.Args[0] + if !(int32(c) == -1) { + goto enda670b6e074269a5e1fcbdaec05596a28 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto enda670b6e074269a5e1fcbdaec05596a28 + enda670b6e074269a5e1fcbdaec05596a28: + ; + // match: (ANDLconst [c] (MOVLconst [d])) + // cond: + // result: (MOVLconst [c&d]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVLconst { + goto end7bfd24059369753eadd235f07e2dd7b8 + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & d + return true + } + goto end7bfd24059369753eadd235f07e2dd7b8 + end7bfd24059369753eadd235f07e2dd7b8: + ; case OpAMD64ANDQ: // match: (ANDQ x (MOVQconst [c])) // cond: is32Bit(c) @@ -374,7 +567,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { // result: (MOVQconst [0]) { if v.AuxInt != 0 { - goto endf2afa4d9d31c344d6638dcdced383cf1 + goto end57018c1d0f54fd721521095b4832bab2 } v.Op = OpAMD64MOVQconst v.AuxInt = 0 @@ -383,15 +576,15 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 return true } - goto endf2afa4d9d31c344d6638dcdced383cf1 - endf2afa4d9d31c344d6638dcdced383cf1: + goto end57018c1d0f54fd721521095b4832bab2 + end57018c1d0f54fd721521095b4832bab2: ; // match: (ANDQconst [-1] x) // cond: // result: (Copy x) { if v.AuxInt != -1 { - goto end646afc7b328db89ad16ebfa156ae26e5 + goto end993d44ced14a02748f2d0e77230e8991 } x := v.Args[0] v.Op = OpCopy @@ -401,8 +594,27 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(x) return true } - goto end646afc7b328db89ad16ebfa156ae26e5 - end646afc7b328db89ad16ebfa156ae26e5: + goto end993d44ced14a02748f2d0e77230e8991 + end993d44ced14a02748f2d0e77230e8991: + ; + // match: (ANDQconst [c] (MOVQconst [d])) + // cond: + // result: (MOVQconst [c&d]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVQconst { + goto end67ca66494705b0345a5f22c710225292 + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & d + return true + } + goto end67ca66494705b0345a5f22c710225292 + end67ca66494705b0345a5f22c710225292: ; case OpAMD64ANDW: // match: (ANDW x (MOVWconst [c])) @@ -445,6 +657,63 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endea2a25eb525a5dbf6d5132d84ea4e7a5 endea2a25eb525a5dbf6d5132d84ea4e7a5: ; + case OpAMD64ANDWconst: + // match: (ANDWconst [c] _) + // cond: int16(c)==0 + // result: (MOVWconst [0]) + { + c := v.AuxInt + if !(int16(c) == 0) { + goto end336ece33b4f0fb44dfe1f24981df7b74 + } + v.Op = OpAMD64MOVWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end336ece33b4f0fb44dfe1f24981df7b74 + end336ece33b4f0fb44dfe1f24981df7b74: + ; + // match: (ANDWconst [c] x) + // cond: int16(c)==-1 + // result: (Copy x) + { + c := v.AuxInt + x := v.Args[0] + if !(int16(c) == -1) { + goto ende01402832ff041ac3e12fc077684125f + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto ende01402832ff041ac3e12fc077684125f + ende01402832ff041ac3e12fc077684125f: + ; + // match: (ANDWconst [c] (MOVWconst [d])) + // cond: + // result: (MOVWconst [c&d]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVWconst { + goto end250eb27fcac10bf6c0d96ce66a21726e + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & d + return true + } + goto end250eb27fcac10bf6c0d96ce66a21726e + end250eb27fcac10bf6c0d96ce66a21726e: + ; case OpAdd16: // match: (Add16 x y) // cond: @@ -625,59 +894,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end0f53bee6291f1229b43aa1b5f977b4f2 end0f53bee6291f1229b43aa1b5f977b4f2: ; - case OpAMD64CMOVQCC: - // match: (CMOVQCC (CMPQconst [c] (MOVQconst [d])) _ x) - // cond: inBounds(d, c) - // result: (Copy x) - { - if v.Args[0].Op != OpAMD64CMPQconst { - goto endd5357f3fd5516dcc859c8c5b3c9efaa4 - } - c := v.Args[0].AuxInt - if v.Args[0].Args[0].Op != OpAMD64MOVQconst { - goto endd5357f3fd5516dcc859c8c5b3c9efaa4 - } - d := v.Args[0].Args[0].AuxInt - x := v.Args[2] - if !(inBounds(d, c)) { - goto endd5357f3fd5516dcc859c8c5b3c9efaa4 - } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto endd5357f3fd5516dcc859c8c5b3c9efaa4 - endd5357f3fd5516dcc859c8c5b3c9efaa4: - ; - // match: (CMOVQCC (CMPQconst [c] (MOVQconst [d])) x _) - // cond: !inBounds(d, c) - // result: (Copy x) - { - if v.Args[0].Op != OpAMD64CMPQconst { - goto end6ad8b1758415a9afe758272b34970d5d - } - c := v.Args[0].AuxInt - if v.Args[0].Args[0].Op != OpAMD64MOVQconst { - goto end6ad8b1758415a9afe758272b34970d5d - } - d := v.Args[0].Args[0].AuxInt - x := v.Args[1] - if !(!inBounds(d, c)) { - goto end6ad8b1758415a9afe758272b34970d5d - } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto end6ad8b1758415a9afe758272b34970d5d - end6ad8b1758415a9afe758272b34970d5d: - ; case OpAMD64CMPB: // match: (CMPB x (MOVBconst [c])) // cond: @@ -882,6 +1098,70 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endfd75d26316012d86cb71d0dd1214259b endfd75d26316012d86cb71d0dd1214259b: ; + case OpCom16: + // match: (Com16 x) + // cond: + // result: (NOTW x) + { + x := v.Args[0] + v.Op = OpAMD64NOTW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end1b14ba8d7d7aa585ec0a211827f280ae + end1b14ba8d7d7aa585ec0a211827f280ae: + ; + case OpCom32: + // match: (Com32 x) + // cond: + // result: (NOTL x) + { + x := v.Args[0] + v.Op = OpAMD64NOTL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end6eb124ba3bdb3fd6031414370852feb6 + end6eb124ba3bdb3fd6031414370852feb6: + ; + case OpCom64: + // match: (Com64 x) + // cond: + // result: (NOTQ x) + { + x := v.Args[0] + v.Op = OpAMD64NOTQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto endf5f3b355a87779c347e305719dddda05 + endf5f3b355a87779c347e305719dddda05: + ; + case OpCom8: + // match: (Com8 x) + // cond: + // result: (NOTB x) + { + x := v.Args[0] + v.Op = OpAMD64NOTB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end1c7c5c055d663ccf1f05fbc4883030c6 + end1c7c5c055d663ccf1f05fbc4883030c6: + ; case OpConst16: // match: (Const16 [val]) // cond: @@ -1956,17 +2236,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end8f83bf72293670e75b22d6627bd13f0b end8f83bf72293670e75b22d6627bd13f0b: ; - case OpLsh16: - // match: (Lsh16 x y) - // cond: y.Type.Size() == 8 - // result: (ANDW (SHLW x y) (SBBQcarrymask (CMPQconst [16] y))) + case OpLsh16x16: + // match: (Lsh16x16 x y) + // cond: + // result: (ANDW (SHLW x y) (SBBLcarrymask (CMPWconst [16] y))) { t := v.Type x := v.Args[0] y := v.Args[1] - if !(y.Type.Size() == 8) { - goto end9166a3780ca3803c83366354d3a65f97 - } v.Op = OpAMD64ANDW v.AuxInt = 0 v.Aux = nil @@ -1976,9 +2253,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t - v2 := v.Block.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v2 := v.Block.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) v2.Type = TypeFlags v2.AuxInt = 16 v2.AddArg(y) @@ -1986,19 +2263,17 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto end9166a3780ca3803c83366354d3a65f97 - end9166a3780ca3803c83366354d3a65f97: + goto end5b63495f0e75ac68c4ce9d4afa1472d4 + end5b63495f0e75ac68c4ce9d4afa1472d4: ; - // match: (Lsh16 x y) - // cond: y.Type.Size() == 4 - // result: (ANDW (SHLW x y) (SBBQcarrymask (CMPLconst [16] y))) + case OpLsh16x32: + // match: (Lsh16x32 x y) + // cond: + // result: (ANDW (SHLW x y) (SBBLcarrymask (CMPLconst [16] y))) { t := v.Type x := v.Args[0] y := v.Args[1] - if !(y.Type.Size() == 4) { - goto end98eca16b509ba61a4f1a2a88515c361a - } v.Op = OpAMD64ANDW v.AuxInt = 0 v.Aux = nil @@ -2008,7 +2283,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := v.Block.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) v2.Type = TypeFlags @@ -2018,19 +2293,17 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto end98eca16b509ba61a4f1a2a88515c361a - end98eca16b509ba61a4f1a2a88515c361a: + goto end6384dd9bdcec3046732d7347250d49f6 + end6384dd9bdcec3046732d7347250d49f6: ; - // match: (Lsh16 x y) - // cond: y.Type.Size() == 2 - // result: (ANDW (SHLW x y) (SBBQcarrymask (CMPWconst [16] y))) + case OpLsh16x64: + // match: (Lsh16x64 x y) + // cond: + // result: (ANDW (SHLW x y) (SBBLcarrymask (CMPQconst [16] y))) { t := v.Type x := v.Args[0] y := v.Args[1] - if !(y.Type.Size() == 2) { - goto endc7fcf199a736cb4d357cf3fcb7c50a8c - } v.Op = OpAMD64ANDW v.AuxInt = 0 v.Aux = nil @@ -2040,9 +2313,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t - v2 := v.Block.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v2 := v.Block.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) v2.Type = TypeFlags v2.AuxInt = 16 v2.AddArg(y) @@ -2050,19 +2323,17 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto endc7fcf199a736cb4d357cf3fcb7c50a8c - endc7fcf199a736cb4d357cf3fcb7c50a8c: + goto end0975ca28988350db0ad556c925d8af07 + end0975ca28988350db0ad556c925d8af07: ; - // match: (Lsh16 x y) - // cond: y.Type.Size() == 1 - // result: (ANDW (SHLW x y) (SBBQcarrymask (CMPBconst [16] y))) + case OpLsh16x8: + // match: (Lsh16x8 x y) + // cond: + // result: (ANDW (SHLW x y) (SBBLcarrymask (CMPBconst [16] y))) { t := v.Type x := v.Args[0] y := v.Args[1] - if !(y.Type.Size() == 1) { - goto end9e3a5a11aba0afdb8ca441ffce4753d9 - } v.Op = OpAMD64ANDW v.AuxInt = 0 v.Aux = nil @@ -2072,7 +2343,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := v.Block.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) v2.Type = TypeFlags @@ -2082,20 +2353,17 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto end9e3a5a11aba0afdb8ca441ffce4753d9 - end9e3a5a11aba0afdb8ca441ffce4753d9: + goto endd17c913707f29d59cfcb5d57d5f5c6ff + endd17c913707f29d59cfcb5d57d5f5c6ff: ; - case OpLsh32: - // match: (Lsh32 x y) - // cond: y.Type.Size() == 8 - // result: (ANDL (SHLL x y) (SBBQcarrymask (CMPQconst [32] y))) + case OpLsh32x16: + // match: (Lsh32x16 x y) + // cond: + // result: (ANDL (SHLL x y) (SBBLcarrymask (CMPWconst [32] y))) { t := v.Type x := v.Args[0] y := v.Args[1] - if !(y.Type.Size() == 8) { - goto endab577f61b4a2efbe1237218f1b54549a - } v.Op = OpAMD64ANDL v.AuxInt = 0 v.Aux = nil @@ -2105,9 +2373,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t - v2 := v.Block.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v2 := v.Block.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) v2.Type = TypeFlags v2.AuxInt = 32 v2.AddArg(y) @@ -2115,19 +2383,17 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto endab577f61b4a2efbe1237218f1b54549a - endab577f61b4a2efbe1237218f1b54549a: + goto end027b6f888054cc1dd8911fe16a6315a1 + end027b6f888054cc1dd8911fe16a6315a1: ; - // match: (Lsh32 x y) - // cond: y.Type.Size() == 4 - // result: (ANDL (SHLL x y) (SBBQcarrymask (CMPLconst [32] y))) + case OpLsh32x32: + // match: (Lsh32x32 x y) + // cond: + // result: (ANDL (SHLL x y) (SBBLcarrymask (CMPLconst [32] y))) { t := v.Type x := v.Args[0] y := v.Args[1] - if !(y.Type.Size() == 4) { - goto enda578175209f6057910ff36338eda5fb1 - } v.Op = OpAMD64ANDL v.AuxInt = 0 v.Aux = nil @@ -2137,7 +2403,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := v.Block.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) v2.Type = TypeFlags @@ -2147,19 +2413,17 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto enda578175209f6057910ff36338eda5fb1 - enda578175209f6057910ff36338eda5fb1: + goto endbcc31e2bd8800d5ddb27c09d37f867b9 + endbcc31e2bd8800d5ddb27c09d37f867b9: ; - // match: (Lsh32 x y) - // cond: y.Type.Size() == 2 - // result: (ANDL (SHLL x y) (SBBQcarrymask (CMPWconst [32] y))) + case OpLsh32x64: + // match: (Lsh32x64 x y) + // cond: + // result: (ANDL (SHLL x y) (SBBLcarrymask (CMPQconst [32] y))) { t := v.Type x := v.Args[0] y := v.Args[1] - if !(y.Type.Size() == 2) { - goto enda2c69e15bc12bbc7dd51384b20cb506b - } v.Op = OpAMD64ANDL v.AuxInt = 0 v.Aux = nil @@ -2169,9 +2433,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t - v2 := v.Block.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v2 := v.Block.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) v2.Type = TypeFlags v2.AuxInt = 32 v2.AddArg(y) @@ -2179,19 +2443,17 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto enda2c69e15bc12bbc7dd51384b20cb506b - enda2c69e15bc12bbc7dd51384b20cb506b: + goto end6797e3a3bbb0fe7eda819fe19a4d4b49 + end6797e3a3bbb0fe7eda819fe19a4d4b49: ; - // match: (Lsh32 x y) - // cond: y.Type.Size() == 1 - // result: (ANDL (SHLL x y) (SBBQcarrymask (CMPBconst [32] y))) + case OpLsh32x8: + // match: (Lsh32x8 x y) + // cond: + // result: (ANDL (SHLL x y) (SBBLcarrymask (CMPBconst [32] y))) { t := v.Type x := v.Args[0] y := v.Args[1] - if !(y.Type.Size() == 1) { - goto endd92c60db1f5cd24f7362925f3867b0b8 - } v.Op = OpAMD64ANDL v.AuxInt = 0 v.Aux = nil @@ -2201,7 +2463,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := v.Block.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) v2.Type = TypeFlags @@ -2211,20 +2473,17 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto endd92c60db1f5cd24f7362925f3867b0b8 - endd92c60db1f5cd24f7362925f3867b0b8: + goto end7dd2c717933f46750e8a0871aab6fc63 + end7dd2c717933f46750e8a0871aab6fc63: ; - case OpLsh64: - // match: (Lsh64 x y) - // cond: y.Type.Size() == 8 - // result: (ANDQ (SHLQ x y) (SBBQcarrymask (CMPQconst [64] y))) + case OpLsh64x16: + // match: (Lsh64x16 x y) + // cond: + // result: (ANDQ (SHLQ x y) (SBBQcarrymask (CMPWconst [64] y))) { t := v.Type x := v.Args[0] y := v.Args[1] - if !(y.Type.Size() == 8) { - goto end04273c7a426341c8f3ecfaa5d653dc6b - } v.Op = OpAMD64ANDQ v.AuxInt = 0 v.Aux = nil @@ -2236,7 +2495,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(v0) v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) v1.Type = t - v2 := v.Block.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v2 := v.Block.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) v2.Type = TypeFlags v2.AuxInt = 64 v2.AddArg(y) @@ -2244,19 +2503,17 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto end04273c7a426341c8f3ecfaa5d653dc6b - end04273c7a426341c8f3ecfaa5d653dc6b: + goto end3a2fda1dddb29e49f46ccde6f5397222 + end3a2fda1dddb29e49f46ccde6f5397222: ; - // match: (Lsh64 x y) - // cond: y.Type.Size() == 4 + case OpLsh64x32: + // match: (Lsh64x32 x y) + // cond: // result: (ANDQ (SHLQ x y) (SBBQcarrymask (CMPLconst [64] y))) { t := v.Type x := v.Args[0] y := v.Args[1] - if !(y.Type.Size() == 4) { - goto end3125a3a8c16279a0b5564bf85f86b80e - } v.Op = OpAMD64ANDQ v.AuxInt = 0 v.Aux = nil @@ -2276,19 +2533,17 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto end3125a3a8c16279a0b5564bf85f86b80e - end3125a3a8c16279a0b5564bf85f86b80e: + goto end147322aba732027ac2290fd8173d806a + end147322aba732027ac2290fd8173d806a: ; - // match: (Lsh64 x y) - // cond: y.Type.Size() == 2 - // result: (ANDQ (SHLQ x y) (SBBQcarrymask (CMPWconst [64] y))) + case OpLsh64x64: + // match: (Lsh64x64 x y) + // cond: + // result: (ANDQ (SHLQ x y) (SBBQcarrymask (CMPQconst [64] y))) { t := v.Type x := v.Args[0] y := v.Args[1] - if !(y.Type.Size() == 2) { - goto end09bfd4e5a4caa96665f86d9f011096d1 - } v.Op = OpAMD64ANDQ v.AuxInt = 0 v.Aux = nil @@ -2300,7 +2555,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(v0) v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) v1.Type = t - v2 := v.Block.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v2 := v.Block.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) v2.Type = TypeFlags v2.AuxInt = 64 v2.AddArg(y) @@ -2308,19 +2563,17 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto end09bfd4e5a4caa96665f86d9f011096d1 - end09bfd4e5a4caa96665f86d9f011096d1: + goto endeb8e78c9c960fa12e29ea07a8519649b + endeb8e78c9c960fa12e29ea07a8519649b: ; - // match: (Lsh64 x y) - // cond: y.Type.Size() == 1 + case OpLsh64x8: + // match: (Lsh64x8 x y) + // cond: // result: (ANDQ (SHLQ x y) (SBBQcarrymask (CMPBconst [64] y))) { t := v.Type x := v.Args[0] y := v.Args[1] - if !(y.Type.Size() == 1) { - goto endac7a6dc89cc3a624c731db84269c45dc - } v.Op = OpAMD64ANDQ v.AuxInt = 0 v.Aux = nil @@ -2340,20 +2593,17 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto endac7a6dc89cc3a624c731db84269c45dc - endac7a6dc89cc3a624c731db84269c45dc: + goto end42cdc11c34c81bbd5e8b4ad19ceec1ef + end42cdc11c34c81bbd5e8b4ad19ceec1ef: ; - case OpLsh8: - // match: (Lsh8 x y) - // cond: y.Type.Size() == 8 - // result: (ANDB (SHLB x y) (SBBQcarrymask (CMPQconst [8] y))) + case OpLsh8x16: + // match: (Lsh8x16 x y) + // cond: + // result: (ANDB (SHLB x y) (SBBLcarrymask (CMPWconst [8] y))) { t := v.Type x := v.Args[0] y := v.Args[1] - if !(y.Type.Size() == 8) { - goto end0ea866cfdfddf55bae152ae48bbcb493 - } v.Op = OpAMD64ANDB v.AuxInt = 0 v.Aux = nil @@ -2363,9 +2613,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t - v2 := v.Block.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v2 := v.Block.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) v2.Type = TypeFlags v2.AuxInt = 8 v2.AddArg(y) @@ -2373,19 +2623,17 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto end0ea866cfdfddf55bae152ae48bbcb493 - end0ea866cfdfddf55bae152ae48bbcb493: + goto end60bf962bf5256e20b547e18e3c886aa5 + end60bf962bf5256e20b547e18e3c886aa5: ; - // match: (Lsh8 x y) - // cond: y.Type.Size() == 4 - // result: (ANDB (SHLB x y) (SBBQcarrymask (CMPLconst [8] y))) + case OpLsh8x32: + // match: (Lsh8x32 x y) + // cond: + // result: (ANDB (SHLB x y) (SBBLcarrymask (CMPLconst [8] y))) { t := v.Type x := v.Args[0] y := v.Args[1] - if !(y.Type.Size() == 4) { - goto ende5a086576704a75e2f863a67b5a05775 - } v.Op = OpAMD64ANDB v.AuxInt = 0 v.Aux = nil @@ -2395,7 +2643,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := v.Block.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) v2.Type = TypeFlags @@ -2405,19 +2653,17 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto ende5a086576704a75e2f863a67b5a05775 - ende5a086576704a75e2f863a67b5a05775: + goto end8ed3445f6dbba1a87c80b140371445ce + end8ed3445f6dbba1a87c80b140371445ce: ; - // match: (Lsh8 x y) - // cond: y.Type.Size() == 2 - // result: (ANDB (SHLB x y) (SBBQcarrymask (CMPWconst [8] y))) + case OpLsh8x64: + // match: (Lsh8x64 x y) + // cond: + // result: (ANDB (SHLB x y) (SBBLcarrymask (CMPQconst [8] y))) { t := v.Type x := v.Args[0] y := v.Args[1] - if !(y.Type.Size() == 2) { - goto enda094363dfc1068d4b96c55fcc60d1101 - } v.Op = OpAMD64ANDB v.AuxInt = 0 v.Aux = nil @@ -2427,9 +2673,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t - v2 := v.Block.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v2 := v.Block.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) v2.Type = TypeFlags v2.AuxInt = 8 v2.AddArg(y) @@ -2437,19 +2683,17 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto enda094363dfc1068d4b96c55fcc60d1101 - enda094363dfc1068d4b96c55fcc60d1101: + goto end0a03c9cc48ef1bfd74973de5f5fb02b0 + end0a03c9cc48ef1bfd74973de5f5fb02b0: ; - // match: (Lsh8 x y) - // cond: y.Type.Size() == 1 - // result: (ANDB (SHLB x y) (SBBQcarrymask (CMPBconst [8] y))) + case OpLsh8x8: + // match: (Lsh8x8 x y) + // cond: + // result: (ANDB (SHLB x y) (SBBLcarrymask (CMPBconst [8] y))) { t := v.Type x := v.Args[0] y := v.Args[1] - if !(y.Type.Size() == 1) { - goto end099e72e70658eeb9e3cad6e1f9ad0137 - } v.Op = OpAMD64ANDB v.AuxInt = 0 v.Aux = nil @@ -2459,7 +2703,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := v.Block.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) v2.Type = TypeFlags @@ -2469,8 +2713,8 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto end099e72e70658eeb9e3cad6e1f9ad0137 - end099e72e70658eeb9e3cad6e1f9ad0137: + goto end781e3a47b186cf99fcb7137afd3432b9 + end781e3a47b186cf99fcb7137afd3432b9: ; case OpAMD64MOVBQSX: // match: (MOVBQSX (MOVBload ptr mem)) @@ -2906,6 +3150,26 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end8a0f957c528a54eecb0dbfc5d96e017a end8a0f957c528a54eecb0dbfc5d96e017a: ; + case OpAMD64MULLconst: + // match: (MULLconst [c] (MOVLconst [d])) + // cond: + // result: (MOVLconst [c*d]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVLconst { + goto endd5732835ed1276ef8b728bcfc1289f73 + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c * d + return true + } + goto endd5732835ed1276ef8b728bcfc1289f73 + endd5732835ed1276ef8b728bcfc1289f73: + ; case OpAMD64MULQ: // match: (MULQ x (MOVQconst [c])) // cond: is32Bit(c) @@ -3084,6 +3348,25 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end75076953dbfe022526a153eda99b39b2 end75076953dbfe022526a153eda99b39b2: ; + // match: (MULQconst [c] (MOVQconst [d])) + // cond: + // result: (MOVQconst [c*d]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVQconst { + goto end55c38c5c405101e610d7ba7fc702ddc0 + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c * d + return true + } + goto end55c38c5c405101e610d7ba7fc702ddc0 + end55c38c5c405101e610d7ba7fc702ddc0: + ; case OpAMD64MULW: // match: (MULW x (MOVWconst [c])) // cond: @@ -3125,6 +3408,26 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endd97b4245ced2b3d27d8c555b06281de4 endd97b4245ced2b3d27d8c555b06281de4: ; + case OpAMD64MULWconst: + // match: (MULWconst [c] (MOVWconst [d])) + // cond: + // result: (MOVWconst [c*d]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVWconst { + goto end61dbc9d9e93dd6946a20a1f475b3f74b + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c * d + return true + } + goto end61dbc9d9e93dd6946a20a1f475b3f74b + end61dbc9d9e93dd6946a20a1f475b3f74b: + ; case OpMove: // match: (Move [size] dst src mem) // cond: @@ -3240,6 +3543,82 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endbbedad106c011a93243e2062afdcc75f endbbedad106c011a93243e2062afdcc75f: ; + case OpAMD64NOTB: + // match: (NOTB (MOVBconst [c])) + // cond: + // result: (MOVBconst [^c]) + { + if v.Args[0].Op != OpAMD64MOVBconst { + goto end9e383a9ceb29a9e2bf890ec6a67212a8 + } + c := v.Args[0].AuxInt + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = ^c + return true + } + goto end9e383a9ceb29a9e2bf890ec6a67212a8 + end9e383a9ceb29a9e2bf890ec6a67212a8: + ; + case OpAMD64NOTL: + // match: (NOTL (MOVLconst [c])) + // cond: + // result: (MOVLconst [^c]) + { + if v.Args[0].Op != OpAMD64MOVLconst { + goto endcc73972c088d5e652a1370a96e56502d + } + c := v.Args[0].AuxInt + v.Op = OpAMD64MOVLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = ^c + return true + } + goto endcc73972c088d5e652a1370a96e56502d + endcc73972c088d5e652a1370a96e56502d: + ; + case OpAMD64NOTQ: + // match: (NOTQ (MOVQconst [c])) + // cond: + // result: (MOVQconst [^c]) + { + if v.Args[0].Op != OpAMD64MOVQconst { + goto endb39ddb6bf7339d46f74114baad4333b6 + } + c := v.Args[0].AuxInt + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = ^c + return true + } + goto endb39ddb6bf7339d46f74114baad4333b6 + endb39ddb6bf7339d46f74114baad4333b6: + ; + case OpAMD64NOTW: + // match: (NOTW (MOVWconst [c])) + // cond: + // result: (MOVWconst [^c]) + { + if v.Args[0].Op != OpAMD64MOVWconst { + goto end35848095ebcf894c6957ad3be5f82c43 + } + c := v.Args[0].AuxInt + v.Op = OpAMD64MOVWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = ^c + return true + } + goto end35848095ebcf894c6957ad3be5f82c43 + end35848095ebcf894c6957ad3be5f82c43: + ; case OpNeg16: // match: (Neg16 x) // cond: @@ -3467,6 +3846,63 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end70b43d531e2097a4f6293f66256a642e end70b43d531e2097a4f6293f66256a642e: ; + case OpAMD64ORBconst: + // match: (ORBconst [c] x) + // cond: int8(c)==0 + // result: (Copy x) + { + c := v.AuxInt + x := v.Args[0] + if !(int8(c) == 0) { + goto end3b9f6d1a1a523595d101f89410f453a1 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end3b9f6d1a1a523595d101f89410f453a1 + end3b9f6d1a1a523595d101f89410f453a1: + ; + // match: (ORBconst [c] _) + // cond: int8(c)==-1 + // result: (MOVBconst [-1]) + { + c := v.AuxInt + if !(int8(c) == -1) { + goto end6033c7910d8cd536b31446e179e4610d + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = -1 + return true + } + goto end6033c7910d8cd536b31446e179e4610d + end6033c7910d8cd536b31446e179e4610d: + ; + // match: (ORBconst [c] (MOVBconst [d])) + // cond: + // result: (MOVBconst [c|d]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVBconst { + goto endbe5263f022dc10a5cf53c118937d79dd + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c | d + return true + } + goto endbe5263f022dc10a5cf53c118937d79dd + endbe5263f022dc10a5cf53c118937d79dd: + ; case OpAMD64ORL: // match: (ORL x (MOVLconst [c])) // cond: @@ -3508,6 +3944,63 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto enda5bc49524a0cbd2241f792837d0a48a8 enda5bc49524a0cbd2241f792837d0a48a8: ; + case OpAMD64ORLconst: + // match: (ORLconst [c] x) + // cond: int32(c)==0 + // result: (Copy x) + { + c := v.AuxInt + x := v.Args[0] + if !(int32(c) == 0) { + goto end800adaf85f4201ebf7a0e38dc1768c86 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end800adaf85f4201ebf7a0e38dc1768c86 + end800adaf85f4201ebf7a0e38dc1768c86: + ; + // match: (ORLconst [c] _) + // cond: int32(c)==-1 + // result: (MOVLconst [-1]) + { + c := v.AuxInt + if !(int32(c) == -1) { + goto end345a8ea439ef2ef54bd84fc8a0f73e97 + } + v.Op = OpAMD64MOVLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = -1 + return true + } + goto end345a8ea439ef2ef54bd84fc8a0f73e97 + end345a8ea439ef2ef54bd84fc8a0f73e97: + ; + // match: (ORLconst [c] (MOVLconst [d])) + // cond: + // result: (MOVLconst [c|d]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVLconst { + goto ende9ca05024248f782c88084715f81d727 + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c | d + return true + } + goto ende9ca05024248f782c88084715f81d727 + ende9ca05024248f782c88084715f81d727: + ; case OpAMD64ORQ: // match: (ORQ x (MOVQconst [c])) // cond: is32Bit(c) @@ -3555,48 +4048,160 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end010afbebcd314e288509d79a16a6d5cc end010afbebcd314e288509d79a16a6d5cc: ; - case OpAMD64ORW: - // match: (ORW x (MOVWconst [c])) + case OpAMD64ORQconst: + // match: (ORQconst [0] x) // cond: - // result: (ORWconst [c] x) + // result: (Copy x) { - x := v.Args[0] - if v.Args[1].Op != OpAMD64MOVWconst { - goto end9f98df10892dbf170b49aace86ee0d7f + if v.AuxInt != 0 { + goto end98a286fc50bc6cf8ca9f5af523e2b5cd } - c := v.Args[1].AuxInt - v.Op = OpAMD64ORWconst + x := v.Args[0] + v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = c v.AddArg(x) return true } - goto end9f98df10892dbf170b49aace86ee0d7f - end9f98df10892dbf170b49aace86ee0d7f: + goto end98a286fc50bc6cf8ca9f5af523e2b5cd + end98a286fc50bc6cf8ca9f5af523e2b5cd: ; - // match: (ORW (MOVWconst [c]) x) + // match: (ORQconst [-1] _) // cond: - // result: (ORWconst [c] x) + // result: (MOVQconst [-1]) { - if v.Args[0].Op != OpAMD64MOVWconst { - goto end96405942c9ceb5fcb0ddb85a8709d015 + if v.AuxInt != -1 { + goto endcde9b9d7c4527eaa5d50b252f50b43c1 } - c := v.Args[0].AuxInt - x := v.Args[1] - v.Op = OpAMD64ORWconst + v.Op = OpAMD64MOVQconst v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = c - v.AddArg(x) + v.AuxInt = -1 return true } - goto end96405942c9ceb5fcb0ddb85a8709d015 - end96405942c9ceb5fcb0ddb85a8709d015: + goto endcde9b9d7c4527eaa5d50b252f50b43c1 + endcde9b9d7c4527eaa5d50b252f50b43c1: ; - case OpOffPtr: + // match: (ORQconst [c] (MOVQconst [d])) + // cond: + // result: (MOVQconst [c|d]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVQconst { + goto enda2488509b71db9abcb06a5115c4ddc2c + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c | d + return true + } + goto enda2488509b71db9abcb06a5115c4ddc2c + enda2488509b71db9abcb06a5115c4ddc2c: + ; + case OpAMD64ORW: + // match: (ORW x (MOVWconst [c])) + // cond: + // result: (ORWconst [c] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVWconst { + goto end9f98df10892dbf170b49aace86ee0d7f + } + c := v.Args[1].AuxInt + v.Op = OpAMD64ORWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end9f98df10892dbf170b49aace86ee0d7f + end9f98df10892dbf170b49aace86ee0d7f: + ; + // match: (ORW (MOVWconst [c]) x) + // cond: + // result: (ORWconst [c] x) + { + if v.Args[0].Op != OpAMD64MOVWconst { + goto end96405942c9ceb5fcb0ddb85a8709d015 + } + c := v.Args[0].AuxInt + x := v.Args[1] + v.Op = OpAMD64ORWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end96405942c9ceb5fcb0ddb85a8709d015 + end96405942c9ceb5fcb0ddb85a8709d015: + ; + case OpAMD64ORWconst: + // match: (ORWconst [c] x) + // cond: int16(c)==0 + // result: (Copy x) + { + c := v.AuxInt + x := v.Args[0] + if !(int16(c) == 0) { + goto end61a4fd5308425b3eafd158f13aaf8f13 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end61a4fd5308425b3eafd158f13aaf8f13 + end61a4fd5308425b3eafd158f13aaf8f13: + ; + // match: (ORWconst [c] _) + // cond: int16(c)==-1 + // result: (MOVWconst [-1]) + { + c := v.AuxInt + if !(int16(c) == -1) { + goto ended87a5775f5e04b2d2a117a63d82dd9b + } + v.Op = OpAMD64MOVWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = -1 + return true + } + goto ended87a5775f5e04b2d2a117a63d82dd9b + ended87a5775f5e04b2d2a117a63d82dd9b: + ; + // match: (ORWconst [c] (MOVWconst [d])) + // cond: + // result: (MOVWconst [c|d]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVWconst { + goto endba9221a8462b5c62e8d7c686f64c2778 + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c | d + return true + } + goto endba9221a8462b5c62e8d7c686f64c2778 + endba9221a8462b5c62e8d7c686f64c2778: + ; + case OpOffPtr: // match: (OffPtr [off] ptr) // cond: // result: (ADDQconst [off] ptr) @@ -3647,112 +4252,1068 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(y) return true } - goto endea45bed9ca97d2995b68b53e6012d384 - endea45bed9ca97d2995b68b53e6012d384: + goto endea45bed9ca97d2995b68b53e6012d384 + endea45bed9ca97d2995b68b53e6012d384: + ; + case OpOr64: + // match: (Or64 x y) + // cond: + // result: (ORQ x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ORQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end3a446becaf2461f4f1a41faeef313f41 + end3a446becaf2461f4f1a41faeef313f41: + ; + case OpOr8: + // match: (Or8 x y) + // cond: + // result: (ORB x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ORB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end6f8a8c559a167d1f0a5901d09a1fb248 + end6f8a8c559a167d1f0a5901d09a1fb248: + ; + case OpRsh16Ux16: + // match: (Rsh16Ux16 x y) + // cond: + // result: (ANDW (SHRW x y) (SBBLcarrymask (CMPWconst [16] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64SHRW, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1.Type = t + v2 := v.Block.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v2.Type = TypeFlags + v2.AuxInt = 16 + v2.AddArg(y) + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto end73239750a306668023d2c49875ac442f + end73239750a306668023d2c49875ac442f: + ; + case OpRsh16Ux32: + // match: (Rsh16Ux32 x y) + // cond: + // result: (ANDW (SHRW x y) (SBBLcarrymask (CMPLconst [16] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64SHRW, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1.Type = t + v2 := v.Block.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v2.Type = TypeFlags + v2.AuxInt = 16 + v2.AddArg(y) + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto end9951e3b2e92c892256feece722b32219 + end9951e3b2e92c892256feece722b32219: + ; + case OpRsh16Ux64: + // match: (Rsh16Ux64 x y) + // cond: + // result: (ANDW (SHRW x y) (SBBLcarrymask (CMPQconst [16] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64SHRW, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1.Type = t + v2 := v.Block.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v2.Type = TypeFlags + v2.AuxInt = 16 + v2.AddArg(y) + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto end610d56d808c204abfa40d653447b2c17 + end610d56d808c204abfa40d653447b2c17: + ; + case OpRsh16Ux8: + // match: (Rsh16Ux8 x y) + // cond: + // result: (ANDW (SHRW x y) (SBBLcarrymask (CMPBconst [16] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64SHRW, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1.Type = t + v2 := v.Block.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + v2.Type = TypeFlags + v2.AuxInt = 16 + v2.AddArg(y) + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto end45e76a8d2b004e6802d53cf12b4757b3 + end45e76a8d2b004e6802d53cf12b4757b3: + ; + case OpRsh16x16: + // match: (Rsh16x16 x y) + // cond: + // result: (SARW x (ORW y (NOTL (SBBLcarrymask (CMPWconst [16] y))))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SARW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = t + v.AddArg(x) + v0 := v.Block.NewValue0(v.Line, OpAMD64ORW, TypeInvalid) + v0.Type = y.Type + v0.AddArg(y) + v1 := v.Block.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) + v1.Type = y.Type + v2 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v2.Type = y.Type + v3 := v.Block.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v3.Type = TypeFlags + v3.AuxInt = 16 + v3.AddArg(y) + v2.AddArg(v3) + v1.AddArg(v2) + v0.AddArg(v1) + v.AddArg(v0) + return true + } + goto endbcd8fd69ada08517f6f94f35da91e1c3 + endbcd8fd69ada08517f6f94f35da91e1c3: + ; + case OpRsh16x32: + // match: (Rsh16x32 x y) + // cond: + // result: (SARW x (ORL y (NOTL (SBBLcarrymask (CMPLconst [16] y))))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SARW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = t + v.AddArg(x) + v0 := v.Block.NewValue0(v.Line, OpAMD64ORL, TypeInvalid) + v0.Type = y.Type + v0.AddArg(y) + v1 := v.Block.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) + v1.Type = y.Type + v2 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v2.Type = y.Type + v3 := v.Block.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v3.Type = TypeFlags + v3.AuxInt = 16 + v3.AddArg(y) + v2.AddArg(v3) + v1.AddArg(v2) + v0.AddArg(v1) + v.AddArg(v0) + return true + } + goto endec3994083e7f82857ecec05906c29aa6 + endec3994083e7f82857ecec05906c29aa6: + ; + case OpRsh16x64: + // match: (Rsh16x64 x y) + // cond: + // result: (SARW x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst [16] y))))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SARW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = t + v.AddArg(x) + v0 := v.Block.NewValue0(v.Line, OpAMD64ORQ, TypeInvalid) + v0.Type = y.Type + v0.AddArg(y) + v1 := v.Block.NewValue0(v.Line, OpAMD64NOTQ, TypeInvalid) + v1.Type = y.Type + v2 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v2.Type = y.Type + v3 := v.Block.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v3.Type = TypeFlags + v3.AuxInt = 16 + v3.AddArg(y) + v2.AddArg(v3) + v1.AddArg(v2) + v0.AddArg(v1) + v.AddArg(v0) + return true + } + goto end19da3883e21ffa3a45d7fc648ef38b66 + end19da3883e21ffa3a45d7fc648ef38b66: + ; + case OpRsh16x8: + // match: (Rsh16x8 x y) + // cond: + // result: (SARW x (ORB y (NOTL (SBBLcarrymask (CMPBconst [16] y))))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SARW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = t + v.AddArg(x) + v0 := v.Block.NewValue0(v.Line, OpAMD64ORB, TypeInvalid) + v0.Type = y.Type + v0.AddArg(y) + v1 := v.Block.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) + v1.Type = y.Type + v2 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v2.Type = y.Type + v3 := v.Block.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + v3.Type = TypeFlags + v3.AuxInt = 16 + v3.AddArg(y) + v2.AddArg(v3) + v1.AddArg(v2) + v0.AddArg(v1) + v.AddArg(v0) + return true + } + goto end3c989f6931d059ea04e4ba93601b6c51 + end3c989f6931d059ea04e4ba93601b6c51: + ; + case OpRsh32Ux16: + // match: (Rsh32Ux16 x y) + // cond: + // result: (ANDL (SHRL x y) (SBBLcarrymask (CMPWconst [32] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64SHRL, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1.Type = t + v2 := v.Block.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v2.Type = TypeFlags + v2.AuxInt = 32 + v2.AddArg(y) + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto end056ede9885a9fc2f32615a2a03b35388 + end056ede9885a9fc2f32615a2a03b35388: + ; + case OpRsh32Ux32: + // match: (Rsh32Ux32 x y) + // cond: + // result: (ANDL (SHRL x y) (SBBLcarrymask (CMPLconst [32] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64SHRL, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1.Type = t + v2 := v.Block.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v2.Type = TypeFlags + v2.AuxInt = 32 + v2.AddArg(y) + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto end30439bdc3517479ea25ae7f54408ba7f + end30439bdc3517479ea25ae7f54408ba7f: + ; + case OpRsh32Ux64: + // match: (Rsh32Ux64 x y) + // cond: + // result: (ANDL (SHRL x y) (SBBLcarrymask (CMPQconst [32] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64SHRL, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1.Type = t + v2 := v.Block.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v2.Type = TypeFlags + v2.AuxInt = 32 + v2.AddArg(y) + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto end49b47fd18b54461d8eea51f6e5889cd2 + end49b47fd18b54461d8eea51f6e5889cd2: + ; + case OpRsh32Ux8: + // match: (Rsh32Ux8 x y) + // cond: + // result: (ANDL (SHRL x y) (SBBLcarrymask (CMPBconst [32] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64SHRL, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1.Type = t + v2 := v.Block.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + v2.Type = TypeFlags + v2.AuxInt = 32 + v2.AddArg(y) + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto end46e045970a8b1afb9035605fc0e50c69 + end46e045970a8b1afb9035605fc0e50c69: + ; + case OpRsh32x16: + // match: (Rsh32x16 x y) + // cond: + // result: (SARL x (ORW y (NOTL (SBBLcarrymask (CMPWconst [32] y))))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SARL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = t + v.AddArg(x) + v0 := v.Block.NewValue0(v.Line, OpAMD64ORW, TypeInvalid) + v0.Type = y.Type + v0.AddArg(y) + v1 := v.Block.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) + v1.Type = y.Type + v2 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v2.Type = y.Type + v3 := v.Block.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v3.Type = TypeFlags + v3.AuxInt = 32 + v3.AddArg(y) + v2.AddArg(v3) + v1.AddArg(v2) + v0.AddArg(v1) + v.AddArg(v0) + return true + } + goto end5d1b8d7e1d1e53e621d13bb0eafc9102 + end5d1b8d7e1d1e53e621d13bb0eafc9102: + ; + case OpRsh32x32: + // match: (Rsh32x32 x y) + // cond: + // result: (SARL x (ORL y (NOTL (SBBLcarrymask (CMPLconst [32] y))))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SARL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = t + v.AddArg(x) + v0 := v.Block.NewValue0(v.Line, OpAMD64ORL, TypeInvalid) + v0.Type = y.Type + v0.AddArg(y) + v1 := v.Block.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) + v1.Type = y.Type + v2 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v2.Type = y.Type + v3 := v.Block.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v3.Type = TypeFlags + v3.AuxInt = 32 + v3.AddArg(y) + v2.AddArg(v3) + v1.AddArg(v2) + v0.AddArg(v1) + v.AddArg(v0) + return true + } + goto end9c27383961c2161a9955012fce808cab + end9c27383961c2161a9955012fce808cab: + ; + case OpRsh32x64: + // match: (Rsh32x64 x y) + // cond: + // result: (SARL x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst [32] y))))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SARL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = t + v.AddArg(x) + v0 := v.Block.NewValue0(v.Line, OpAMD64ORQ, TypeInvalid) + v0.Type = y.Type + v0.AddArg(y) + v1 := v.Block.NewValue0(v.Line, OpAMD64NOTQ, TypeInvalid) + v1.Type = y.Type + v2 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v2.Type = y.Type + v3 := v.Block.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v3.Type = TypeFlags + v3.AuxInt = 32 + v3.AddArg(y) + v2.AddArg(v3) + v1.AddArg(v2) + v0.AddArg(v1) + v.AddArg(v0) + return true + } + goto end75dc7144497705c800e0c60dcd4a2828 + end75dc7144497705c800e0c60dcd4a2828: + ; + case OpRsh32x8: + // match: (Rsh32x8 x y) + // cond: + // result: (SARL x (ORB y (NOTL (SBBLcarrymask (CMPBconst [32] y))))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SARL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = t + v.AddArg(x) + v0 := v.Block.NewValue0(v.Line, OpAMD64ORB, TypeInvalid) + v0.Type = y.Type + v0.AddArg(y) + v1 := v.Block.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) + v1.Type = y.Type + v2 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v2.Type = y.Type + v3 := v.Block.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + v3.Type = TypeFlags + v3.AuxInt = 32 + v3.AddArg(y) + v2.AddArg(v3) + v1.AddArg(v2) + v0.AddArg(v1) + v.AddArg(v0) + return true + } + goto enda7b94b2fd5cbcd12bb2dcd576bdca481 + enda7b94b2fd5cbcd12bb2dcd576bdca481: + ; + case OpRsh64Ux16: + // match: (Rsh64Ux16 x y) + // cond: + // result: (ANDQ (SHRQ x y) (SBBQcarrymask (CMPWconst [64] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64SHRQ, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1.Type = t + v2 := v.Block.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v2.Type = TypeFlags + v2.AuxInt = 64 + v2.AddArg(y) + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto endc4bdfdc375a5c94978d936bd0db89cc5 + endc4bdfdc375a5c94978d936bd0db89cc5: + ; + case OpRsh64Ux32: + // match: (Rsh64Ux32 x y) + // cond: + // result: (ANDQ (SHRQ x y) (SBBQcarrymask (CMPLconst [64] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64SHRQ, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1.Type = t + v2 := v.Block.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v2.Type = TypeFlags + v2.AuxInt = 64 + v2.AddArg(y) + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto end217f32bca5f6744b9a7de052f4fae13e + end217f32bca5f6744b9a7de052f4fae13e: + ; + case OpRsh64Ux64: + // match: (Rsh64Ux64 x y) + // cond: + // result: (ANDQ (SHRQ x y) (SBBQcarrymask (CMPQconst [64] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64SHRQ, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1.Type = t + v2 := v.Block.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v2.Type = TypeFlags + v2.AuxInt = 64 + v2.AddArg(y) + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto end530dee0bcadf1cf5d092894b6210ffcd + end530dee0bcadf1cf5d092894b6210ffcd: + ; + case OpRsh64Ux8: + // match: (Rsh64Ux8 x y) + // cond: + // result: (ANDQ (SHRQ x y) (SBBQcarrymask (CMPBconst [64] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64SHRQ, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1.Type = t + v2 := v.Block.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + v2.Type = TypeFlags + v2.AuxInt = 64 + v2.AddArg(y) + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto endf09baf4e0005c5eb4905f71ce4c8b306 + endf09baf4e0005c5eb4905f71ce4c8b306: + ; + case OpRsh64x16: + // match: (Rsh64x16 x y) + // cond: + // result: (SARQ x (ORW y (NOTL (SBBLcarrymask (CMPWconst [64] y))))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SARQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = t + v.AddArg(x) + v0 := v.Block.NewValue0(v.Line, OpAMD64ORW, TypeInvalid) + v0.Type = y.Type + v0.AddArg(y) + v1 := v.Block.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) + v1.Type = y.Type + v2 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v2.Type = y.Type + v3 := v.Block.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v3.Type = TypeFlags + v3.AuxInt = 64 + v3.AddArg(y) + v2.AddArg(v3) + v1.AddArg(v2) + v0.AddArg(v1) + v.AddArg(v0) + return true + } + goto endb370ee74ca256a604138321ddca9d543 + endb370ee74ca256a604138321ddca9d543: + ; + case OpRsh64x32: + // match: (Rsh64x32 x y) + // cond: + // result: (SARQ x (ORL y (NOTL (SBBLcarrymask (CMPLconst [64] y))))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SARQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = t + v.AddArg(x) + v0 := v.Block.NewValue0(v.Line, OpAMD64ORL, TypeInvalid) + v0.Type = y.Type + v0.AddArg(y) + v1 := v.Block.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) + v1.Type = y.Type + v2 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v2.Type = y.Type + v3 := v.Block.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v3.Type = TypeFlags + v3.AuxInt = 64 + v3.AddArg(y) + v2.AddArg(v3) + v1.AddArg(v2) + v0.AddArg(v1) + v.AddArg(v0) + return true + } + goto end3cc6edf5b286a449332757ea12d2d601 + end3cc6edf5b286a449332757ea12d2d601: + ; + case OpRsh64x64: + // match: (Rsh64x64 x y) + // cond: + // result: (SARQ x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst [64] y))))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SARQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = t + v.AddArg(x) + v0 := v.Block.NewValue0(v.Line, OpAMD64ORQ, TypeInvalid) + v0.Type = y.Type + v0.AddArg(y) + v1 := v.Block.NewValue0(v.Line, OpAMD64NOTQ, TypeInvalid) + v1.Type = y.Type + v2 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v2.Type = y.Type + v3 := v.Block.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v3.Type = TypeFlags + v3.AuxInt = 64 + v3.AddArg(y) + v2.AddArg(v3) + v1.AddArg(v2) + v0.AddArg(v1) + v.AddArg(v0) + return true + } + goto end45de7b33396d9fd2ba377bd095f1d7a6 + end45de7b33396d9fd2ba377bd095f1d7a6: + ; + case OpRsh64x8: + // match: (Rsh64x8 x y) + // cond: + // result: (SARQ x (ORB y (NOTL (SBBLcarrymask (CMPBconst [64] y))))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SARQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = t + v.AddArg(x) + v0 := v.Block.NewValue0(v.Line, OpAMD64ORB, TypeInvalid) + v0.Type = y.Type + v0.AddArg(y) + v1 := v.Block.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) + v1.Type = y.Type + v2 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v2.Type = y.Type + v3 := v.Block.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + v3.Type = TypeFlags + v3.AuxInt = 64 + v3.AddArg(y) + v2.AddArg(v3) + v1.AddArg(v2) + v0.AddArg(v1) + v.AddArg(v0) + return true + } + goto ende03fa68104fd18bb9b2bb94370e0c8b3 + ende03fa68104fd18bb9b2bb94370e0c8b3: + ; + case OpRsh8Ux16: + // match: (Rsh8Ux16 x y) + // cond: + // result: (ANDB (SHRB x y) (SBBLcarrymask (CMPWconst [8] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64SHRB, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1.Type = t + v2 := v.Block.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v2.Type = TypeFlags + v2.AuxInt = 8 + v2.AddArg(y) + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto enda1adfc560334e10d5e83fbff27a8752f + enda1adfc560334e10d5e83fbff27a8752f: + ; + case OpRsh8Ux32: + // match: (Rsh8Ux32 x y) + // cond: + // result: (ANDB (SHRB x y) (SBBLcarrymask (CMPLconst [8] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64SHRB, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1.Type = t + v2 := v.Block.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v2.Type = TypeFlags + v2.AuxInt = 8 + v2.AddArg(y) + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto end17f63b4b712e715a33ac780193b59c2e + end17f63b4b712e715a33ac780193b59c2e: + ; + case OpRsh8Ux64: + // match: (Rsh8Ux64 x y) + // cond: + // result: (ANDB (SHRB x y) (SBBLcarrymask (CMPQconst [8] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64SHRB, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1.Type = t + v2 := v.Block.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v2.Type = TypeFlags + v2.AuxInt = 8 + v2.AddArg(y) + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto end77d5c3ef9982ebd27c135d3461b7430b + end77d5c3ef9982ebd27c135d3461b7430b: + ; + case OpRsh8Ux8: + // match: (Rsh8Ux8 x y) + // cond: + // result: (ANDB (SHRB x y) (SBBLcarrymask (CMPBconst [8] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := v.Block.NewValue0(v.Line, OpAMD64SHRB, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1.Type = t + v2 := v.Block.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + v2.Type = TypeFlags + v2.AuxInt = 8 + v2.AddArg(y) + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto end206712ffbda924142afbf384aeb8f09e + end206712ffbda924142afbf384aeb8f09e: ; - case OpOr64: - // match: (Or64 x y) + case OpRsh8x16: + // match: (Rsh8x16 x y) // cond: - // result: (ORQ x y) + // result: (SARB x (ORW y (NOTL (SBBLcarrymask (CMPWconst [8] y))))) { + t := v.Type x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ORQ + v.Op = OpAMD64SARB v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.Type = t v.AddArg(x) - v.AddArg(y) + v0 := v.Block.NewValue0(v.Line, OpAMD64ORW, TypeInvalid) + v0.Type = y.Type + v0.AddArg(y) + v1 := v.Block.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) + v1.Type = y.Type + v2 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v2.Type = y.Type + v3 := v.Block.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v3.Type = TypeFlags + v3.AuxInt = 8 + v3.AddArg(y) + v2.AddArg(v3) + v1.AddArg(v2) + v0.AddArg(v1) + v.AddArg(v0) return true } - goto end3a446becaf2461f4f1a41faeef313f41 - end3a446becaf2461f4f1a41faeef313f41: + goto endd303f390b49d9716dc783d5c4d57ddd1 + endd303f390b49d9716dc783d5c4d57ddd1: ; - case OpOr8: - // match: (Or8 x y) + case OpRsh8x32: + // match: (Rsh8x32 x y) // cond: - // result: (ORB x y) + // result: (SARB x (ORL y (NOTL (SBBLcarrymask (CMPLconst [8] y))))) { + t := v.Type x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ORB + v.Op = OpAMD64SARB v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.Type = t v.AddArg(x) - v.AddArg(y) + v0 := v.Block.NewValue0(v.Line, OpAMD64ORL, TypeInvalid) + v0.Type = y.Type + v0.AddArg(y) + v1 := v.Block.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) + v1.Type = y.Type + v2 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v2.Type = y.Type + v3 := v.Block.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v3.Type = TypeFlags + v3.AuxInt = 8 + v3.AddArg(y) + v2.AddArg(v3) + v1.AddArg(v2) + v0.AddArg(v1) + v.AddArg(v0) return true } - goto end6f8a8c559a167d1f0a5901d09a1fb248 - end6f8a8c559a167d1f0a5901d09a1fb248: + goto ende12a524a6fc68eb245140c6919034337 + ende12a524a6fc68eb245140c6919034337: ; - case OpRsh64: - // match: (Rsh64 x y) - // cond: y.Type.Size() == 8 - // result: (SARQ x (CMOVQCC (CMPQconst [64] y) (MOVQconst [63]) y)) + case OpRsh8x64: + // match: (Rsh8x64 x y) + // cond: + // result: (SARB x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst [8] y))))) { t := v.Type x := v.Args[0] y := v.Args[1] - if !(y.Type.Size() == 8) { - goto endd5f88a8c4f11e0e844b35fd8677bd940 - } - v.Op = OpAMD64SARQ + v.Op = OpAMD64SARB v.AuxInt = 0 v.Aux = nil v.resetArgs() v.Type = t v.AddArg(x) - v0 := v.Block.NewValue0(v.Line, OpAMD64CMOVQCC, TypeInvalid) - v0.Type = t - v1 := v.Block.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) - v1.Type = TypeFlags - v1.AuxInt = 64 - v1.AddArg(y) - v0.AddArg(v1) - v2 := v.Block.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) - v2.Type = t - v2.AuxInt = 63 - v0.AddArg(v2) + v0 := v.Block.NewValue0(v.Line, OpAMD64ORQ, TypeInvalid) + v0.Type = y.Type v0.AddArg(y) + v1 := v.Block.NewValue0(v.Line, OpAMD64NOTQ, TypeInvalid) + v1.Type = y.Type + v2 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v2.Type = y.Type + v3 := v.Block.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v3.Type = TypeFlags + v3.AuxInt = 8 + v3.AddArg(y) + v2.AddArg(v3) + v1.AddArg(v2) + v0.AddArg(v1) v.AddArg(v0) return true } - goto endd5f88a8c4f11e0e844b35fd8677bd940 - endd5f88a8c4f11e0e844b35fd8677bd940: + goto end6ee53459daa5458d163c86ea02dd2f31 + end6ee53459daa5458d163c86ea02dd2f31: ; - case OpRsh64U: - // match: (Rsh64U x y) - // cond: y.Type.Size() == 8 - // result: (ANDQ (SHRQ x y) (SBBQcarrymask (CMPQconst [64] y))) + case OpRsh8x8: + // match: (Rsh8x8 x y) + // cond: + // result: (SARB x (ORB y (NOTL (SBBLcarrymask (CMPBconst [8] y))))) { t := v.Type x := v.Args[0] y := v.Args[1] - if !(y.Type.Size() == 8) { - goto endfd6815c0dc9f8dff6c3ec6add7a23569 - } - v.Op = OpAMD64ANDQ + v.Op = OpAMD64SARB v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64SHRQ, TypeInvalid) - v0.Type = t - v0.AddArg(x) + v.Type = t + v.AddArg(x) + v0 := v.Block.NewValue0(v.Line, OpAMD64ORB, TypeInvalid) + v0.Type = y.Type v0.AddArg(y) - v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) - v1.Type = t - v2 := v.Block.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) - v2.Type = TypeFlags - v2.AuxInt = 64 - v2.AddArg(y) + v1 := v.Block.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) + v1.Type = y.Type + v2 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v2.Type = y.Type + v3 := v.Block.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + v3.Type = TypeFlags + v3.AuxInt = 8 + v3.AddArg(y) + v2.AddArg(v3) v1.AddArg(v2) - v.AddArg(v1) + v0.AddArg(v1) + v.AddArg(v0) return true } - goto endfd6815c0dc9f8dff6c3ec6add7a23569 - endfd6815c0dc9f8dff6c3ec6add7a23569: + goto end07f447a7e25b048c41d412c242330ec0 + end07f447a7e25b048c41d412c242330ec0: ; case OpAMD64SARB: // match: (SARB x (MOVBconst [c])) @@ -3889,6 +5450,156 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto enda7bfd1974bf83ca79653c560a718a86c enda7bfd1974bf83ca79653c560a718a86c: ; + // match: (SBBQcarrymask (CMPLconst [c] (MOVLconst [d]))) + // cond: inBounds(int64(int32(d)), int64(int32(c))) + // result: (MOVQconst [-1]) + { + if v.Args[0].Op != OpAMD64CMPLconst { + goto end8c6d39847239120fa0fe953007eb40ae + } + c := v.Args[0].AuxInt + if v.Args[0].Args[0].Op != OpAMD64MOVLconst { + goto end8c6d39847239120fa0fe953007eb40ae + } + d := v.Args[0].Args[0].AuxInt + if !(inBounds(int64(int32(d)), int64(int32(c)))) { + goto end8c6d39847239120fa0fe953007eb40ae + } + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = -1 + return true + } + goto end8c6d39847239120fa0fe953007eb40ae + end8c6d39847239120fa0fe953007eb40ae: + ; + // match: (SBBQcarrymask (CMPLconst [c] (MOVLconst [d]))) + // cond: !inBounds(int64(int32(d)), int64(int32(c))) + // result: (MOVQconst [0]) + { + if v.Args[0].Op != OpAMD64CMPLconst { + goto end20885e855545e16ca77af2b9a2b69ea9 + } + c := v.Args[0].AuxInt + if v.Args[0].Args[0].Op != OpAMD64MOVLconst { + goto end20885e855545e16ca77af2b9a2b69ea9 + } + d := v.Args[0].Args[0].AuxInt + if !(!inBounds(int64(int32(d)), int64(int32(c)))) { + goto end20885e855545e16ca77af2b9a2b69ea9 + } + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end20885e855545e16ca77af2b9a2b69ea9 + end20885e855545e16ca77af2b9a2b69ea9: + ; + // match: (SBBQcarrymask (CMPWconst [c] (MOVWconst [d]))) + // cond: inBounds(int64(int16(d)), int64(int16(c))) + // result: (MOVQconst [-1]) + { + if v.Args[0].Op != OpAMD64CMPWconst { + goto end16f61db69d07e67e9f408c2790a9de7c + } + c := v.Args[0].AuxInt + if v.Args[0].Args[0].Op != OpAMD64MOVWconst { + goto end16f61db69d07e67e9f408c2790a9de7c + } + d := v.Args[0].Args[0].AuxInt + if !(inBounds(int64(int16(d)), int64(int16(c)))) { + goto end16f61db69d07e67e9f408c2790a9de7c + } + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = -1 + return true + } + goto end16f61db69d07e67e9f408c2790a9de7c + end16f61db69d07e67e9f408c2790a9de7c: + ; + // match: (SBBQcarrymask (CMPWconst [c] (MOVWconst [d]))) + // cond: !inBounds(int64(int16(d)), int64(int16(c))) + // result: (MOVQconst [0]) + { + if v.Args[0].Op != OpAMD64CMPWconst { + goto end191ca427f7d5d2286bd290920c84a51d + } + c := v.Args[0].AuxInt + if v.Args[0].Args[0].Op != OpAMD64MOVWconst { + goto end191ca427f7d5d2286bd290920c84a51d + } + d := v.Args[0].Args[0].AuxInt + if !(!inBounds(int64(int16(d)), int64(int16(c)))) { + goto end191ca427f7d5d2286bd290920c84a51d + } + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end191ca427f7d5d2286bd290920c84a51d + end191ca427f7d5d2286bd290920c84a51d: + ; + // match: (SBBQcarrymask (CMPBconst [c] (MOVBconst [d]))) + // cond: inBounds(int64(int8(d)), int64(int8(c))) + // result: (MOVQconst [-1]) + { + if v.Args[0].Op != OpAMD64CMPBconst { + goto end3fd3f1e9660b9050c6a41b4fc948f793 + } + c := v.Args[0].AuxInt + if v.Args[0].Args[0].Op != OpAMD64MOVBconst { + goto end3fd3f1e9660b9050c6a41b4fc948f793 + } + d := v.Args[0].Args[0].AuxInt + if !(inBounds(int64(int8(d)), int64(int8(c)))) { + goto end3fd3f1e9660b9050c6a41b4fc948f793 + } + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = -1 + return true + } + goto end3fd3f1e9660b9050c6a41b4fc948f793 + end3fd3f1e9660b9050c6a41b4fc948f793: + ; + // match: (SBBQcarrymask (CMPBconst [c] (MOVBconst [d]))) + // cond: !inBounds(int64(int8(d)), int64(int8(c))) + // result: (MOVQconst [0]) + { + if v.Args[0].Op != OpAMD64CMPBconst { + goto ende0d6edd92ae98e6dc041f65029d8b243 + } + c := v.Args[0].AuxInt + if v.Args[0].Args[0].Op != OpAMD64MOVBconst { + goto ende0d6edd92ae98e6dc041f65029d8b243 + } + d := v.Args[0].Args[0].AuxInt + if !(!inBounds(int64(int8(d)), int64(int8(c)))) { + goto ende0d6edd92ae98e6dc041f65029d8b243 + } + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto ende0d6edd92ae98e6dc041f65029d8b243 + ende0d6edd92ae98e6dc041f65029d8b243: + ; case OpAMD64SETA: // match: (SETA (InvertFlags x)) // cond: @@ -4291,6 +6002,26 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endc288755d69b04d24a6aac32a73956411 endc288755d69b04d24a6aac32a73956411: ; + case OpAMD64SUBBconst: + // match: (SUBBconst [c] (MOVBconst [d])) + // cond: + // result: (MOVBconst [c-d]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVBconst { + goto end0e2d5c3e3c02001a20d5433daa9e8317 + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c - d + return true + } + goto end0e2d5c3e3c02001a20d5433daa9e8317 + end0e2d5c3e3c02001a20d5433daa9e8317: + ; case OpAMD64SUBL: // match: (SUBL x (MOVLconst [c])) // cond: @@ -4335,6 +6066,26 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endb0efe6e15ec20486b849534a00483ae2 endb0efe6e15ec20486b849534a00483ae2: ; + case OpAMD64SUBLconst: + // match: (SUBLconst [c] (MOVLconst [d])) + // cond: + // result: (MOVLconst [c-d]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVLconst { + goto endbe7466f3c09d9645544bdfc44c37c922 + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c - d + return true + } + goto endbe7466f3c09d9645544bdfc44c37c922 + endbe7466f3c09d9645544bdfc44c37c922: + ; case OpAMD64SUBQ: // match: (SUBQ x (MOVQconst [c])) // cond: is32Bit(c) @@ -4385,6 +6136,26 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end8beb96de3efee9206d1bd4b7d777d2cb end8beb96de3efee9206d1bd4b7d777d2cb: ; + case OpAMD64SUBQconst: + // match: (SUBQconst [c] (MOVQconst [d])) + // cond: + // result: (MOVQconst [c-d]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVQconst { + goto end96c09479fb3c043e875d89d3eb92f1d8 + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c - d + return true + } + goto end96c09479fb3c043e875d89d3eb92f1d8 + end96c09479fb3c043e875d89d3eb92f1d8: + ; case OpAMD64SUBW: // match: (SUBW x (MOVWconst [c])) // cond: @@ -4429,6 +6200,26 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end44d23f7e65a4b1c42d0e6463f8e493b6 end44d23f7e65a4b1c42d0e6463f8e493b6: ; + case OpAMD64SUBWconst: + // match: (SUBWconst [c] (MOVWconst [d])) + // cond: + // result: (MOVWconst [c-d]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVWconst { + goto end0e5079577fcf00f5925291dbd68306aa + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c - d + return true + } + goto end0e5079577fcf00f5925291dbd68306aa + end0e5079577fcf00f5925291dbd68306aa: + ; case OpSignExt16to32: // match: (SignExt16to32 x) // cond: @@ -4865,6 +6656,26 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endb02a07d9dc7b802c59f013116e952f3f endb02a07d9dc7b802c59f013116e952f3f: ; + case OpAMD64XORBconst: + // match: (XORBconst [c] (MOVBconst [d])) + // cond: + // result: (MOVBconst [c^d]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVBconst { + goto end6d8d1b612af9d253605c8bc69b822903 + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c ^ d + return true + } + goto end6d8d1b612af9d253605c8bc69b822903 + end6d8d1b612af9d253605c8bc69b822903: + ; case OpAMD64XORL: // match: (XORL x (MOVLconst [c])) // cond: @@ -4906,6 +6717,26 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end9c1a0af00eeadd8aa325e55f1f3fb89c end9c1a0af00eeadd8aa325e55f1f3fb89c: ; + case OpAMD64XORLconst: + // match: (XORLconst [c] (MOVLconst [d])) + // cond: + // result: (MOVLconst [c^d]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVLconst { + goto end71238075b10b68a226903cc453c4715c + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c ^ d + return true + } + goto end71238075b10b68a226903cc453c4715c + end71238075b10b68a226903cc453c4715c: + ; case OpAMD64XORQ: // match: (XORQ x (MOVQconst [c])) // cond: is32Bit(c) @@ -4953,6 +6784,26 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endd221a7e3daaaaa29ee385ad36e061b57 endd221a7e3daaaaa29ee385ad36e061b57: ; + case OpAMD64XORQconst: + // match: (XORQconst [c] (MOVQconst [d])) + // cond: + // result: (MOVQconst [c^d]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVQconst { + goto end3f404d4f07362319fbad2e1ba0827a9f + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c ^ d + return true + } + goto end3f404d4f07362319fbad2e1ba0827a9f + end3f404d4f07362319fbad2e1ba0827a9f: + ; case OpAMD64XORW: // match: (XORW x (MOVWconst [c])) // cond: @@ -4994,6 +6845,26 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end51ee62a06d4301e5a4aed7a6639b1d53 end51ee62a06d4301e5a4aed7a6639b1d53: ; + case OpAMD64XORWconst: + // match: (XORWconst [c] (MOVWconst [d])) + // cond: + // result: (MOVWconst [c^d]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVWconst { + goto ende24881ccdfa8486c4593fd9aa5df1ed6 + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c ^ d + return true + } + goto ende24881ccdfa8486c4593fd9aa5df1ed6 + ende24881ccdfa8486c4593fd9aa5df1ed6: + ; case OpXor16: // match: (Xor16 x y) // cond: diff --git a/src/cmd/compile/internal/ssa/shift_test.go b/src/cmd/compile/internal/ssa/shift_test.go index c32e48d93f..3bb26cda0b 100644 --- a/src/cmd/compile/internal/ssa/shift_test.go +++ b/src/cmd/compile/internal/ssa/shift_test.go @@ -10,17 +10,17 @@ import ( func TestShiftConstAMD64(t *testing.T) { c := NewConfig("amd64", DummyFrontend{t}) - fun := makeConstShiftFunc(c, 18, OpLsh64, TypeUInt64) + fun := makeConstShiftFunc(c, 18, OpLsh64x64, TypeUInt64) checkOpcodeCounts(t, fun.f, map[Op]int{OpAMD64SHLQconst: 1, OpAMD64CMPQconst: 0, OpAMD64ANDQconst: 0}) - fun = makeConstShiftFunc(c, 66, OpLsh64, TypeUInt64) + fun = makeConstShiftFunc(c, 66, OpLsh64x64, TypeUInt64) checkOpcodeCounts(t, fun.f, map[Op]int{OpAMD64SHLQconst: 0, OpAMD64CMPQconst: 0, OpAMD64ANDQconst: 0}) - fun = makeConstShiftFunc(c, 18, OpRsh64U, TypeUInt64) + fun = makeConstShiftFunc(c, 18, OpRsh64Ux64, TypeUInt64) checkOpcodeCounts(t, fun.f, map[Op]int{OpAMD64SHRQconst: 1, OpAMD64CMPQconst: 0, OpAMD64ANDQconst: 0}) - fun = makeConstShiftFunc(c, 66, OpRsh64U, TypeUInt64) + fun = makeConstShiftFunc(c, 66, OpRsh64Ux64, TypeUInt64) checkOpcodeCounts(t, fun.f, map[Op]int{OpAMD64SHRQconst: 0, OpAMD64CMPQconst: 0, OpAMD64ANDQconst: 0}) - fun = makeConstShiftFunc(c, 18, OpRsh64, TypeInt64) + fun = makeConstShiftFunc(c, 18, OpRsh64x64, TypeInt64) checkOpcodeCounts(t, fun.f, map[Op]int{OpAMD64SARQconst: 1, OpAMD64CMPQconst: 0}) - fun = makeConstShiftFunc(c, 66, OpRsh64, TypeInt64) + fun = makeConstShiftFunc(c, 66, OpRsh64x64, TypeInt64) checkOpcodeCounts(t, fun.f, map[Op]int{OpAMD64SARQconst: 1, OpAMD64CMPQconst: 0}) } -- cgit v1.3 From 9271ecc8c62930e4cac73f9dfe8ef0b1bb97cee6 Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Thu, 30 Jul 2015 13:57:43 -0400 Subject: [dev.ssa] cmd/compile: fix SUBQ generation error Fix code generation error that resulted in a multi-argument NEGQ doasm: notfound ft=13 tt=13 00134 NEGQ AX, AX 13 13 Change-Id: I8b712d21a5523eccbae1f33ccea417844c27073e Reviewed-on: https://go-review.googlesource.com/12869 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/gc/ssa.go | 2 -- src/cmd/compile/internal/gc/testdata/arith_ssa.go | 16 +++++++++++++++- 2 files changed, 15 insertions(+), 3 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 32844093d2..430adc31fd 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1765,8 +1765,6 @@ func genValue(v *ssa.Value) { p.From.Reg = y if neg { p := Prog(x86.ANEGQ) // TODO: use correct size? This is mostly a hack until regalloc does 2-address correctly - p.From.Type = obj.TYPE_REG - p.From.Reg = r p.To.Type = obj.TYPE_REG p.To.Reg = r } diff --git a/src/cmd/compile/internal/gc/testdata/arith_ssa.go b/src/cmd/compile/internal/gc/testdata/arith_ssa.go index 2731337dbf..3fd2fad457 100644 --- a/src/cmd/compile/internal/gc/testdata/arith_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/arith_ssa.go @@ -75,6 +75,20 @@ func testBitwiseOr_ssa(a, b uint32) uint32 { return a | b } +// testSubqToNegq ensures that the SUBQ -> NEGQ translation works correctly. +func testSubqToNegq(a, b, c, d, e, f, g, h, i, j, k int64) { + want := a + 8207351403619448057 - b - 1779494519303207690 + c*8810076340510052032*d - 4465874067674546219 - e*4361839741470334295 - f + 8688847565426072650*g*8065564729145417479 + if got := testSubqToNegq_ssa(a, b, c, d, e, f, g, h, i, j, k); want != got { + println("testSubqToNegq failed, wanted", want, "got", got) + failed = true + } +} +func testSubqToNegq_ssa(a, b, c, d, e, f, g, h, i, j, k int64) int64 { + switch { // prevent inlining + } + return a + 8207351403619448057 - b - 1779494519303207690 + c*8810076340510052032*d - 4465874067674546219 - e*4361839741470334295 - f + 8688847565426072650*g*8065564729145417479 +} + var failed = false func main() { @@ -82,7 +96,7 @@ func main() { test64BitConstMult(1, 2) test64BitConstAdd(1, 2) testRegallocCVSpill(1, 2, 3, 4) - + testSubqToNegq(1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2) if failed { panic("failed") } -- cgit v1.3 From 95aff4db54cd79461c85c7547860be7458e26ec3 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Tue, 28 Jul 2015 14:31:25 -0700 Subject: [dev.ssa] cmd/compile: use Copy instead of ConvNop The existing backend simply elides OCONVNOP. There's no reason for us to do any differently. Rather than insert ConvNops and then rewrite them away, stop creating them in the first place. Change-Id: I4bcbe2229fcebd189ae18df24f2c612feb6e215e Reviewed-on: https://go-review.googlesource.com/12810 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 59 +++++++++++++++++++++++++- src/cmd/compile/internal/ssa/gen/AMD64.rules | 4 -- src/cmd/compile/internal/ssa/gen/genericOps.go | 4 +- src/cmd/compile/internal/ssa/opGen.go | 5 --- src/cmd/compile/internal/ssa/regalloc.go | 2 +- src/cmd/compile/internal/ssa/rewriteAMD64.go | 39 ----------------- 6 files changed, 59 insertions(+), 54 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 430adc31fd..b9113b2733 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1005,8 +1005,51 @@ func (s *state) expr(n *Node) *ssa.Value { return nil } case OCONVNOP: + to := n.Type + from := n.Left.Type + if to.Etype == TFUNC { + s.Unimplementedf("CONVNOP closure %v -> %v", n.Type, n.Left.Type) + return nil + } + + // 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) - return s.newValue1(ssa.OpConvNop, n.Type, x) + v := s.newValue1(ssa.OpCopy, to, x) // ensure that v has the right type + + // 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(int(from.Etype), 0), to, Econv(int(to.Etype), 0)) + return nil + } + + if flag_race != 0 { + s.Unimplementedf("questionable CONVNOP from race detector %v -> %v\n", from, to) + return nil + } + + 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 @@ -1014,7 +1057,7 @@ func (s *state) expr(n *Node) *ssa.Value { if ft.IsInteger() && tt.IsInteger() { var op ssa.Op if tt.Size() == ft.Size() { - op = ssa.OpConvNop + op = ssa.OpCopy } else if tt.Size() < ft.Size() { // truncation switch 10*ft.Size() + tt.Size() { @@ -1310,6 +1353,18 @@ func (s *state) zeroVal(t *Type) *ssa.Value { return nil } +// 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 uint8) int8 { + switch e { + case TINT8, TINT16, TINT32, TINT64, TINT: + return -1 + case TUINT8, TUINT16, TUINT32, TUINT64, TUINT, TUINTPTR, TUNSAFEPTR: + return +1 + } + return 0 +} + // 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. func (s *state) addr(n *Node) *ssa.Value { diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 0aa9c73279..1630e13213 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -78,10 +78,6 @@ (Trunc64to16 x) -> (Copy x) (Trunc64to32 x) -> (Copy x) -(ConvNop x) && t == x.Type -> (Copy x) -(ConvNop x) && t.IsInteger() && x.Type.IsInteger() && t.Size() == x.Type.Size() -> (Copy x) -// TODO: other ConvNops are safe? Maybe all of them? - // Lowering shifts // Unsigned shifts need to return 0 if shift amount is >= width of shifted value. // result = (arg << shift) & (shift >= argbits ? 0 : 0xffffffffffffffff) diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index bc1fdc86a2..7536415216 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -203,7 +203,7 @@ var genericOps = []opData{ {name: "ClosureCall"}, // arg0=code pointer, arg1=context ptr, arg2=memory. Returns memory. {name: "StaticCall"}, // call function aux.(*gc.Sym), arg0=memory. Returns memory. - // Conversions: signed extensions, zero (unsigned) extensions, truncations, and no-op (type only) + // Conversions: signed extensions, zero (unsigned) extensions, truncations {name: "SignExt8to16"}, {name: "SignExt8to32"}, {name: "SignExt8to64"}, @@ -223,8 +223,6 @@ var genericOps = []opData{ {name: "Trunc64to16"}, {name: "Trunc64to32"}, - {name: "ConvNop"}, - // Automatically inserted safety checks {name: "IsNonNil"}, // arg0 != nil {name: "IsInBounds"}, // 0 <= arg0 < arg1 diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index f5f6e139f5..b0f86a9cbe 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -357,7 +357,6 @@ const ( OpTrunc64to8 OpTrunc64to16 OpTrunc64to32 - OpConvNop OpIsNonNil OpIsInBounds OpArrayIndex @@ -2722,10 +2721,6 @@ var opcodeTable = [...]opInfo{ name: "Trunc64to32", generic: true, }, - { - name: "ConvNop", - generic: true, - }, { name: "IsNonNil", generic: true, diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index a13b8b2a06..7e8f2ae354 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -167,7 +167,7 @@ func regalloc(f *Func) { // - definition of v. c will be identical to v but will live in // a register. v will be modified into a spill of c. regspec := opcodeTable[v.Op].reg - if v.Op == OpCopy || v.Op == OpConvNop { + if v.Op == OpCopy { // TODO: make this less of a hack regspec = opcodeTable[OpAMD64ADDQconst].reg } diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index eb1428e87e..f06227e749 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -1294,45 +1294,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endc395c0a53eeccf597e225a07b53047d1 endc395c0a53eeccf597e225a07b53047d1: ; - case OpConvNop: - // match: (ConvNop x) - // cond: t == x.Type - // result: (Copy x) - { - t := v.Type - x := v.Args[0] - if !(t == x.Type) { - goto end6c588ed8aedc7dca8c06b4ada77e3ddd - } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto end6c588ed8aedc7dca8c06b4ada77e3ddd - end6c588ed8aedc7dca8c06b4ada77e3ddd: - ; - // match: (ConvNop x) - // cond: t.IsInteger() && x.Type.IsInteger() && t.Size() == x.Type.Size() - // result: (Copy x) - { - t := v.Type - x := v.Args[0] - if !(t.IsInteger() && x.Type.IsInteger() && t.Size() == x.Type.Size()) { - goto endfb3563f9df3468ad8123dbaa962cdbf7 - } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto endfb3563f9df3468ad8123dbaa962cdbf7 - endfb3563f9df3468ad8123dbaa962cdbf7: - ; case OpEq16: // match: (Eq16 x y) // cond: -- cgit v1.3 From 6d9362a1f79a916a1a8de0a6bde8a3a94dc89944 Mon Sep 17 00:00:00 2001 From: Alexandru Moșoi Date: Thu, 30 Jul 2015 12:33:36 +0200 Subject: [dev.ssa] cmd/compile/internal/ssa/gen: implement OXOR. From compiling go there were 260 functions where XOR was needed. Much of the required changes for implementing XOR were already done in 12813. Change-Id: I5a68aa028f5ed597bc1d62cedbef3620753dfe82 Reviewed-on: https://go-review.googlesource.com/12901 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 11 ++++++++++- src/cmd/compile/internal/gc/testdata/arith_ssa.go | 17 ++++++++++++++++- 2 files changed, 26 insertions(+), 2 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index b9113b2733..c292e4e014 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -763,6 +763,15 @@ var opToSSA = map[opAndType]ssa.Op{ 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, @@ -1123,7 +1132,7 @@ func (s *state) expr(n *Node) *ssa.Value { a := s.expr(n.Left) b := s.expr(n.Right) return s.newValue2(s.ssaOp(n.Op, n.Left.Type), ssa.TypeBool, a, b) - case OADD, OSUB, OMUL, OAND, OOR: + case OADD, OAND, OMUL, OOR, OSUB, OXOR: a := s.expr(n.Left) b := s.expr(n.Right) return s.newValue2(s.ssaOp(n.Op, n.Type), a.Type, a, b) diff --git a/src/cmd/compile/internal/gc/testdata/arith_ssa.go b/src/cmd/compile/internal/gc/testdata/arith_ssa.go index 3fd2fad457..0a2290ef7b 100644 --- a/src/cmd/compile/internal/gc/testdata/arith_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/arith_ssa.go @@ -57,9 +57,15 @@ 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("testBitwiseAnd failed, wanted", want, "got", 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 } } @@ -75,6 +81,12 @@ func testBitwiseOr_ssa(a, b uint32) uint32 { return a | b } +func testBitwiseXor_ssa(a, b uint32) uint32 { + switch { // prevent inlining + } + return a ^ b +} + // testSubqToNegq ensures that the SUBQ -> NEGQ translation works correctly. func testSubqToNegq(a, b, c, d, e, f, g, h, i, j, k int64) { want := a + 8207351403619448057 - b - 1779494519303207690 + c*8810076340510052032*d - 4465874067674546219 - e*4361839741470334295 - f + 8688847565426072650*g*8065564729145417479 @@ -83,6 +95,7 @@ func testSubqToNegq(a, b, c, d, e, f, g, h, i, j, k int64) { failed = true } } + func testSubqToNegq_ssa(a, b, c, d, e, f, g, h, i, j, k int64) int64 { switch { // prevent inlining } @@ -97,6 +110,8 @@ func main() { test64BitConstAdd(1, 2) testRegallocCVSpill(1, 2, 3, 4) testSubqToNegq(1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2) + testBitwiseLogic() + if failed { panic("failed") } -- cgit v1.3 From 165c1c16d1e94ddd961e5b99eab6610d95af6fa6 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Thu, 30 Jul 2015 10:28:57 -0700 Subject: [dev.ssa] cmd/compile: provide stack trace for caught panics Change-Id: I9cbb6d53a8c2302222b13d2f33b081b704208b8a Reviewed-on: https://go-review.googlesource.com/12932 Reviewed-by: Keith Randall Reviewed-by: Todd Neal --- src/cmd/compile/internal/ssa/compile.go | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/compile.go b/src/cmd/compile/internal/ssa/compile.go index 7a7b9926ed..001530ae80 100644 --- a/src/cmd/compile/internal/ssa/compile.go +++ b/src/cmd/compile/internal/ssa/compile.go @@ -4,7 +4,10 @@ package ssa -import "log" +import ( + "log" + "runtime" +) // Compile is the main entry point for this package. // Compile modifies f so that on return: @@ -21,7 +24,11 @@ func Compile(f *Func) { phaseName := "init" defer func() { if phaseName != "" { - f.Fatalf("panic during %s while compiling %s\n", phaseName, f.Name) + 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) } }() -- cgit v1.3 From 85e0329fbc03df4165550611f3724d9ebcaa34a8 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Thu, 30 Jul 2015 11:03:05 -0700 Subject: [dev.ssa] cmd/compile: move most types outside SSA The only types that remain in the ssa package are special compiler-only types. Change-Id: If957abf128ec0778910d67666c297f97f183b7ee Reviewed-on: https://go-review.googlesource.com/12933 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 52 +++++++++----- src/cmd/compile/internal/ssa/config.go | 36 ++++++---- src/cmd/compile/internal/ssa/deadcode_test.go | 8 +-- src/cmd/compile/internal/ssa/deadstore_test.go | 6 +- src/cmd/compile/internal/ssa/dom_test.go | 16 ++--- src/cmd/compile/internal/ssa/export_test.go | 20 ++++++ src/cmd/compile/internal/ssa/func_test.go | 4 +- src/cmd/compile/internal/ssa/gen/AMD64.rules | 12 ++-- src/cmd/compile/internal/ssa/gen/generic.rules | 16 ++--- src/cmd/compile/internal/ssa/rewriteAMD64.go | 60 ++++++++-------- src/cmd/compile/internal/ssa/rewritegeneric.go | 98 +++++++++++++------------- src/cmd/compile/internal/ssa/schedule_test.go | 2 +- src/cmd/compile/internal/ssa/shift_test.go | 2 +- src/cmd/compile/internal/ssa/type.go | 67 ++++++------------ src/cmd/compile/internal/ssa/type_test.go | 55 +++++++++++++++ 15 files changed, 262 insertions(+), 192 deletions(-) create mode 100644 src/cmd/compile/internal/ssa/type_test.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index c292e4e014..4db33a84a7 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -67,8 +67,8 @@ func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { s.labels = map[string]*ssaLabel{} s.labeledNodes = map[*Node]*ssaLabel{} s.startmem = s.entryNewValue0(ssa.OpArg, ssa.TypeMem) - s.sp = s.entryNewValue0(ssa.OpSP, s.config.Uintptr) // TODO: use generic pointer type (unsafe.Pointer?) instead - s.sb = s.entryNewValue0(ssa.OpSB, s.config.Uintptr) + s.sp = s.entryNewValue0(ssa.OpSP, Types[TUINTPTR]) // TODO: use generic pointer type (unsafe.Pointer?) instead + s.sb = s.entryNewValue0(ssa.OpSB, Types[TUINTPTR]) // Generate addresses of local declarations s.decladdrs = map[*Node]*ssa.Value{} @@ -90,8 +90,8 @@ func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { } } // nodfp is a special argument which is the function's FP. - aux := &ssa.ArgSymbol{Typ: s.config.Uintptr, Offset: 0, Sym: nodfp.Sym} - s.decladdrs[nodfp] = s.entryNewValue1A(ssa.OpAddr, s.config.Uintptr, aux, s.sp) + aux := &ssa.ArgSymbol{Typ: Types[TUINTPTR], Offset: 0, Sym: nodfp.Sym} + s.decladdrs[nodfp] = s.entryNewValue1A(ssa.OpAddr, Types[TUINTPTR], aux, s.sp) // Convert the AST-based IR to the SSA-based IR s.startBlock(s.f.Entry) @@ -1131,7 +1131,7 @@ func (s *state) expr(n *Node) *ssa.Value { case OLT, OEQ, ONE, OLE, OGE, OGT: a := s.expr(n.Left) b := s.expr(n.Right) - return s.newValue2(s.ssaOp(n.Op, n.Left.Type), ssa.TypeBool, a, b) + return s.newValue2(s.ssaOp(n.Op, n.Left.Type), Types[TBOOL], a, b) case OADD, OAND, OMUL, OOR, OSUB, OXOR: a := s.expr(n.Left) b := s.expr(n.Right) @@ -1209,7 +1209,7 @@ func (s *state) expr(n *Node) *ssa.Value { case ODOTPTR: p := s.expr(n.Left) s.nilCheck(p) - p = s.newValue2(ssa.OpAddPtr, p.Type, p, s.constIntPtr(s.config.Uintptr, n.Xoffset)) + p = s.newValue2(ssa.OpAddPtr, p.Type, p, s.constIntPtr(Types[TUINTPTR], n.Xoffset)) return s.newValue2(ssa.OpLoad, n.Type, p, s.mem()) case OINDEX: @@ -1220,10 +1220,10 @@ func (s *state) expr(n *Node) *ssa.Value { var elemtype *Type var len *ssa.Value if n.Left.Type.IsString() { - len = s.newValue1(ssa.OpStringLen, s.config.Int, a) + len = s.newValue1(ssa.OpStringLen, Types[TINT], a) elemtype = Types[TUINT8] } else { - len = s.constInt(s.config.Int, n.Left.Type.Bound) + len = s.constInt(Types[TINT], n.Left.Type.Bound) elemtype = n.Left.Type.Type } s.boundsCheck(i, len) @@ -1240,11 +1240,11 @@ func (s *state) expr(n *Node) *ssa.Value { if n.Op == OCAP { op = ssa.OpSliceCap } - return s.newValue1(op, s.config.Int, s.expr(n.Left)) + 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, s.config.Int, s.expr(n.Left)) + return s.newValue1(ssa.OpStringLen, Types[TINT], s.expr(n.Left)) default: // array - return s.constInt(s.config.Int, n.Left.Type.Bound) + return s.constInt(Types[TINT], n.Left.Type.Bound) } case OCALLFUNC, OCALLMETH: @@ -1281,7 +1281,7 @@ func (s *state) expr(n *Node) *ssa.Value { if static { call = s.newValue1A(ssa.OpStaticCall, ssa.TypeMem, left.Sym, s.mem()) } else { - entry := s.newValue2(ssa.OpLoad, s.config.Uintptr, closure, s.mem()) + entry := s.newValue2(ssa.OpLoad, Types[TUINTPTR], closure, s.mem()) call = s.newValue3(ssa.OpClosureCall, ssa.TypeMem, entry, closure, s.mem()) } dowidth(left.Type) @@ -1418,7 +1418,7 @@ func (s *state) addr(n *Node) *ssa.Value { a := s.expr(n.Left) i := s.expr(n.Right) i = s.extendIndex(i) - len := s.newValue1(ssa.OpSliceLen, s.config.Uintptr, a) + len := s.newValue1(ssa.OpSliceLen, Types[TUINTPTR], a) s.boundsCheck(i, len) p := s.newValue1(ssa.OpSlicePtr, Ptrto(n.Left.Type.Type), a) return s.newValue2(ssa.OpPtrIndex, Ptrto(n.Left.Type.Type), p, i) @@ -1426,7 +1426,7 @@ func (s *state) addr(n *Node) *ssa.Value { a := s.addr(n.Left) i := s.expr(n.Right) i = s.extendIndex(i) - len := s.constInt(s.config.Int, n.Left.Type.Bound) + len := s.constInt(Types[TINT], n.Left.Type.Bound) s.boundsCheck(i, len) return s.newValue2(ssa.OpPtrIndex, Ptrto(n.Left.Type.Type), a, i) } @@ -1436,11 +1436,11 @@ func (s *state) addr(n *Node) *ssa.Value { return p case ODOT: p := s.addr(n.Left) - return s.newValue2(ssa.OpAddPtr, p.Type, p, s.constIntPtr(s.config.Uintptr, n.Xoffset)) + return s.newValue2(ssa.OpAddPtr, p.Type, p, s.constIntPtr(Types[TUINTPTR], n.Xoffset)) case ODOTPTR: p := s.expr(n.Left) s.nilCheck(p) - return s.newValue2(ssa.OpAddPtr, p.Type, p, s.constIntPtr(s.config.Uintptr, n.Xoffset)) + return s.newValue2(ssa.OpAddPtr, p.Type, p, s.constIntPtr(Types[TUINTPTR], n.Xoffset)) default: s.Unimplementedf("addr: bad op %v", Oconv(int(n.Op), 0)) return nil @@ -1477,7 +1477,7 @@ func canSSA(n *Node) bool { // Used only for automatically inserted nil checks, // not for user code like 'x != nil'. func (s *state) nilCheck(ptr *ssa.Value) { - c := s.newValue1(ssa.OpIsNonNil, ssa.TypeBool, ptr) + c := s.newValue1(ssa.OpIsNonNil, Types[TBOOL], ptr) b := s.endBlock() b.Kind = ssa.BlockIf b.Control = c @@ -1496,7 +1496,7 @@ func (s *state) boundsCheck(idx, len *ssa.Value) { // 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, ssa.TypeBool, idx, len) + cmp := s.newValue2(ssa.OpIsInBounds, Types[TBOOL], idx, len) b := s.endBlock() b.Kind = ssa.BlockIf b.Control = cmp @@ -2288,7 +2288,7 @@ func (s *state) extendIndex(v *ssa.Value) *ssa.Value { s.Fatalf("bad unsigned index extension %s", v.Type) } } - return s.newValue1(op, s.config.Uintptr, v) + return s.newValue1(op, Types[TUINTPTR], v) } // ssaRegToReg maps ssa register numbers to obj register numbers. @@ -2374,6 +2374,20 @@ type ssaExport struct { 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) 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{} { diff --git a/src/cmd/compile/internal/ssa/config.go b/src/cmd/compile/internal/ssa/config.go index cabf62e463..8aea59d13c 100644 --- a/src/cmd/compile/internal/ssa/config.go +++ b/src/cmd/compile/internal/ssa/config.go @@ -5,11 +5,9 @@ package ssa type Config struct { - arch string // "amd64", etc. - IntSize int64 // 4 or 8 - PtrSize int64 // 4 or 8 - Uintptr Type // pointer arithmetic type - Int Type + 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 @@ -17,7 +15,25 @@ type Config struct { // TODO: more stuff. Compiler flags of interest, ... } +type TypeSource interface { + TypeBool() Type + TypeInt8() Type + TypeInt16() Type + TypeInt32() Type + TypeInt64() Type + TypeUInt8() Type + TypeUInt16() Type + TypeUInt32() Type + TypeUInt64() Type + TypeInt() Type + TypeUintptr() Type + TypeString() Type + TypeBytePtr() Type // TODO: use unsafe.Pointer instead? +} + type Frontend interface { + TypeSource + // StringData returns a symbol pointing to the given string's contents. StringData(string) interface{} // returns *gc.Sym @@ -50,16 +66,6 @@ func NewConfig(arch string, fe Frontend) *Config { fe.Unimplementedf("arch %s not implemented", arch) } - // cache the frequently-used types in the config - c.Uintptr = TypeUInt32 - c.Int = TypeInt32 - if c.PtrSize == 8 { - c.Uintptr = TypeUInt64 - } - if c.IntSize == 8 { - c.Int = TypeInt64 - } - return c } diff --git a/src/cmd/compile/internal/ssa/deadcode_test.go b/src/cmd/compile/internal/ssa/deadcode_test.go index 9ec8959571..ef42d74f4d 100644 --- a/src/cmd/compile/internal/ssa/deadcode_test.go +++ b/src/cmd/compile/internal/ssa/deadcode_test.go @@ -7,7 +7,7 @@ package ssa import "testing" func TestDeadLoop(t *testing.T) { - c := NewConfig("amd64", DummyFrontend{t}) + c := testConfig(t) fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), @@ -37,7 +37,7 @@ func TestDeadLoop(t *testing.T) { } func TestDeadValue(t *testing.T) { - c := NewConfig("amd64", DummyFrontend{t}) + c := testConfig(t) fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), @@ -60,7 +60,7 @@ func TestDeadValue(t *testing.T) { } func TestNeverTaken(t *testing.T) { - c := NewConfig("amd64", DummyFrontend{t}) + c := testConfig(t) fun := Fun(c, "entry", Bloc("entry", Valu("cond", OpConstBool, TypeBool, 0, false), @@ -95,7 +95,7 @@ func TestNeverTaken(t *testing.T) { } func TestNestedDeadBlocks(t *testing.T) { - c := NewConfig("amd64", DummyFrontend{t}) + c := testConfig(t) fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), diff --git a/src/cmd/compile/internal/ssa/deadstore_test.go b/src/cmd/compile/internal/ssa/deadstore_test.go index 5b318eb2d2..8c0a875cad 100644 --- a/src/cmd/compile/internal/ssa/deadstore_test.go +++ b/src/cmd/compile/internal/ssa/deadstore_test.go @@ -9,7 +9,7 @@ import ( ) func TestDeadStore(t *testing.T) { - c := NewConfig("amd64", DummyFrontend{t}) + c := testConfig(t) ptrType := &TypeImpl{Size_: 8, Ptr: true, Name: "testptr"} // dummy for testing fun := Fun(c, "entry", Bloc("entry", @@ -36,7 +36,7 @@ func TestDeadStore(t *testing.T) { } func TestDeadStorePhi(t *testing.T) { // make sure we don't get into an infinite loop with phi values. - c := NewConfig("amd64", DummyFrontend{t}) + c := testConfig(t) ptrType := &TypeImpl{Size_: 8, Ptr: true, Name: "testptr"} // dummy for testing fun := Fun(c, "entry", Bloc("entry", @@ -62,7 +62,7 @@ func TestDeadStoreTypes(t *testing.T) { // 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 := NewConfig("amd64", DummyFrontend{t}) + c := testConfig(t) t1 := &TypeImpl{Size_: 8, Ptr: true, Name: "t1"} t2 := &TypeImpl{Size_: 4, Ptr: true, Name: "t2"} fun := Fun(c, "entry", diff --git a/src/cmd/compile/internal/ssa/dom_test.go b/src/cmd/compile/internal/ssa/dom_test.go index 1f3124167a..6cd2ff440c 100644 --- a/src/cmd/compile/internal/ssa/dom_test.go +++ b/src/cmd/compile/internal/ssa/dom_test.go @@ -220,7 +220,7 @@ func verifyDominators(t *testing.T, fut fun, domFn domFunc, doms map[string]stri } func TestDominatorsSingleBlock(t *testing.T) { - c := NewConfig("amd64", DummyFrontend{t}) + c := testConfig(t) fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), @@ -235,7 +235,7 @@ func TestDominatorsSingleBlock(t *testing.T) { } func TestDominatorsSimple(t *testing.T) { - c := NewConfig("amd64", DummyFrontend{t}) + c := testConfig(t) fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), @@ -263,7 +263,7 @@ func TestDominatorsSimple(t *testing.T) { } func TestDominatorsMultPredFwd(t *testing.T) { - c := NewConfig("amd64", DummyFrontend{t}) + c := testConfig(t) fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), @@ -291,7 +291,7 @@ func TestDominatorsMultPredFwd(t *testing.T) { } func TestDominatorsDeadCode(t *testing.T) { - c := NewConfig("amd64", DummyFrontend{t}) + c := testConfig(t) fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), @@ -314,7 +314,7 @@ func TestDominatorsDeadCode(t *testing.T) { } func TestDominatorsMultPredRev(t *testing.T) { - c := NewConfig("amd64", DummyFrontend{t}) + c := testConfig(t) fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), @@ -342,7 +342,7 @@ func TestDominatorsMultPredRev(t *testing.T) { } func TestDominatorsMultPred(t *testing.T) { - c := NewConfig("amd64", DummyFrontend{t}) + c := testConfig(t) fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), @@ -370,7 +370,7 @@ func TestDominatorsMultPred(t *testing.T) { } func TestPostDominators(t *testing.T) { - c := NewConfig("amd64", DummyFrontend{t}) + c := testConfig(t) fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), @@ -396,7 +396,7 @@ func TestPostDominators(t *testing.T) { } func TestInfiniteLoop(t *testing.T) { - c := NewConfig("amd64", DummyFrontend{t}) + c := testConfig(t) // note lack of an exit block fun := Fun(c, "entry", Bloc("entry", diff --git a/src/cmd/compile/internal/ssa/export_test.go b/src/cmd/compile/internal/ssa/export_test.go index d13729efbf..d2e8216b5d 100644 --- a/src/cmd/compile/internal/ssa/export_test.go +++ b/src/cmd/compile/internal/ssa/export_test.go @@ -11,6 +11,12 @@ var PrintFunc = printFunc var Opt = opt var Deadcode = deadcode +func testConfig(t *testing.T) *Config { + return NewConfig("amd64", DummyFrontend{t}) +} + +// DummyFrontend is a test-only frontend. +// It assumes 64 bit integers and pointers. type DummyFrontend struct { t testing.TB } @@ -22,3 +28,17 @@ func (DummyFrontend) StringData(s string) interface{} { func (d DummyFrontend) Logf(msg string, args ...interface{}) { d.t.Logf(msg, args...) } func (d DummyFrontend) Fatalf(msg string, args ...interface{}) { d.t.Fatalf(msg, args...) } func (d DummyFrontend) Unimplementedf(msg string, args ...interface{}) { d.t.Fatalf(msg, args...) } + +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) 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 } diff --git a/src/cmd/compile/internal/ssa/func_test.go b/src/cmd/compile/internal/ssa/func_test.go index dda96317fe..4bdc84bd4c 100644 --- a/src/cmd/compile/internal/ssa/func_test.go +++ b/src/cmd/compile/internal/ssa/func_test.go @@ -262,7 +262,7 @@ func addEdge(b, c *Block) { } func TestArgs(t *testing.T) { - c := NewConfig("amd64", DummyFrontend{t}) + c := testConfig(t) fun := Fun(c, "entry", Bloc("entry", Valu("a", OpConst64, TypeInt64, 14, nil), @@ -282,7 +282,7 @@ func TestArgs(t *testing.T) { } func TestEquiv(t *testing.T) { - c := NewConfig("amd64", DummyFrontend{t}) + c := testConfig(t) equivalentCases := []struct{ f, g fun }{ // simple case { diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 1630e13213..d0f5e5b073 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -211,7 +211,7 @@ (IsNonNil p) -> (SETNE (TESTQ p p)) (IsInBounds idx len) -> (SETB (CMPQ idx len)) -(Move [size] dst src mem) -> (REPMOVSB dst src (MOVQconst [size]) mem) +(Move [size] dst src mem) -> (REPMOVSB dst src (MOVQconst [size]) mem) (Not x) -> (XORBconst [1] x) @@ -391,15 +391,15 @@ // lower Zero instructions with word sizes (Zero [0] _ mem) -> (Copy mem) -(Zero [1] destptr mem) -> (MOVBstore destptr (MOVBconst [0]) mem) -(Zero [2] destptr mem) -> (MOVWstore destptr (MOVWconst [0]) mem) -(Zero [4] destptr mem) -> (MOVLstore destptr (MOVLconst [0]) mem) -(Zero [8] destptr mem) -> (MOVQstore destptr (MOVQconst [0]) mem) +(Zero [1] destptr mem) -> (MOVBstore destptr (MOVBconst [0]) mem) +(Zero [2] destptr mem) -> (MOVWstore destptr (MOVWconst [0]) mem) +(Zero [4] destptr mem) -> (MOVLstore destptr (MOVLconst [0]) mem) +(Zero [8] destptr mem) -> (MOVQstore destptr (MOVQconst [0]) mem) // rewrite anything less than 4 words into a series of MOV[BWLQ] $0, ptr(off) instructions (Zero [size] destptr mem) && size < 4*8 -> (MOVXzero [size] destptr mem) // Use STOSQ to zero memory. Rewrite this into storing the words with REPSTOSQ and then filling in the remainder with linear moves -(Zero [size] destptr mem) && size >= 4*8 -> (Zero [size%8] (OffPtr [size-(size%8)] destptr) (REPSTOSQ destptr (MOVQconst [size/8]) mem)) +(Zero [size] destptr mem) && size >= 4*8 -> (Zero [size%8] (OffPtr [size-(size%8)] destptr) (REPSTOSQ destptr (MOVQconst [size/8]) mem)) // Absorb InvertFlags into branches. (LT (InvertFlags cmp) yes no) -> (GT cmp yes no) diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index 49c70af4cc..6a8952d6cb 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -29,8 +29,8 @@ // tear apart slices // TODO: anything that generates a slice needs to go in here. (SlicePtr (Load ptr mem)) -> (Load ptr mem) -(SliceLen (Load ptr mem)) -> (Load (AddPtr ptr (ConstPtr [config.PtrSize])) mem) -(SliceCap (Load ptr mem)) -> (Load (AddPtr ptr (ConstPtr [config.PtrSize*2])) mem) +(SliceLen (Load ptr mem)) -> (Load (AddPtr ptr (ConstPtr [config.PtrSize])) mem) +(SliceCap (Load ptr mem)) -> (Load (AddPtr ptr (ConstPtr [config.PtrSize*2])) mem) // slice and interface comparisons // the frontend ensures that we can only compare against nil @@ -38,13 +38,13 @@ (EqFat x y) && x.Op == OpConstNil && y.Op != OpConstNil -> (EqFat y x) (NeqFat x y) && x.Op == OpConstNil && y.Op != OpConstNil -> (NeqFat y x) // it suffices to check the first word (backing array for slices, dynamic type for interfaces) -(EqFat (Load ptr mem) (ConstNil)) -> (EqPtr (Load ptr mem) (ConstPtr [0])) -(NeqFat (Load ptr mem) (ConstNil)) -> (NeqPtr (Load ptr mem) (ConstPtr [0])) +(EqFat (Load ptr mem) (ConstNil)) -> (EqPtr (Load ptr mem) (ConstPtr [0])) +(NeqFat (Load ptr mem) (ConstNil)) -> (NeqPtr (Load ptr mem) (ConstPtr [0])) // indexing operations // Note: bounds check has already been done (ArrayIndex (Load ptr mem) idx) -> (Load (PtrIndex ptr idx) mem) -(PtrIndex ptr idx) -> (AddPtr ptr (MulPtr idx (ConstPtr [t.Elem().Size()]))) +(PtrIndex ptr idx) -> (AddPtr ptr (MulPtr idx (ConstPtr [t.Elem().Size()]))) (StructSelect [idx] (Load ptr mem)) -> (Load (OffPtr [idx] ptr) mem) // big-object moves @@ -52,11 +52,11 @@ (Store dst (Load src mem) mem) && t.Size() > 8 -> (Move [t.Size()] dst src mem) // string ops -(ConstString {s}) -> (StringMake (Addr {config.fe.StringData(s.(string))} (SB )) (ConstPtr [int64(len(s.(string)))])) -(Load ptr mem) && t.IsString() -> (StringMake (Load ptr mem) (Load (OffPtr [config.PtrSize] ptr) mem)) +(ConstString {s}) -> (StringMake (Addr {config.fe.StringData(s.(string))} (SB )) (ConstPtr [int64(len(s.(string)))])) +(Load ptr mem) && t.IsString() -> (StringMake (Load ptr mem) (Load (OffPtr [config.PtrSize] ptr) mem)) (StringPtr (StringMake ptr _)) -> ptr (StringLen (StringMake _ len)) -> len -(Store dst str mem) && str.Type.IsString() -> (Store (OffPtr [config.PtrSize] dst) (StringLen str) (Store dst (StringPtr str) mem)) +(Store dst str mem) && str.Type.IsString() -> (Store (OffPtr [config.PtrSize] dst) (StringLen str) (Store dst (StringPtr str) mem)) (If (Not cond) yes no) -> (If cond no yes) (If (ConstBool {c}) yes no) && c.(bool) -> (Plain nil yes) diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index f06227e749..9e4f133f3b 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -3392,7 +3392,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { case OpMove: // match: (Move [size] dst src mem) // cond: - // result: (REPMOVSB dst src (MOVQconst [size]) mem) + // result: (REPMOVSB dst src (MOVQconst [size]) mem) { size := v.AuxInt dst := v.Args[0] @@ -3405,14 +3405,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(dst) v.AddArg(src) v0 := v.Block.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) - v0.Type = TypeUInt64 + v0.Type = config.Frontend().TypeUInt64() v0.AuxInt = size v.AddArg(v0) v.AddArg(mem) return true } - goto end2aab774aedae2c616ee88bfa87cdf30e - end2aab774aedae2c616ee88bfa87cdf30e: + goto end4dd156b33beb9981378c91e46f055a56 + end4dd156b33beb9981378c91e46f055a56: ; case OpMul16: // match: (Mul16 x y) @@ -6919,10 +6919,10 @@ func rewriteValueAMD64(v *Value, config *Config) bool { ; // match: (Zero [1] destptr mem) // cond: - // result: (MOVBstore destptr (MOVBconst [0]) mem) + // result: (MOVBstore destptr (MOVBconst [0]) mem) { if v.AuxInt != 1 { - goto end16839f51d2e9cf9548f216848406bd97 + goto end56bcaef03cce4d15c03efff669bb5585 } destptr := v.Args[0] mem := v.Args[1] @@ -6932,21 +6932,21 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(destptr) v0 := v.Block.NewValue0(v.Line, OpAMD64MOVBconst, TypeInvalid) - v0.Type = TypeInt8 + v0.Type = config.Frontend().TypeInt8() v0.AuxInt = 0 v.AddArg(v0) v.AddArg(mem) return true } - goto end16839f51d2e9cf9548f216848406bd97 - end16839f51d2e9cf9548f216848406bd97: + goto end56bcaef03cce4d15c03efff669bb5585 + end56bcaef03cce4d15c03efff669bb5585: ; // match: (Zero [2] destptr mem) // cond: - // result: (MOVWstore destptr (MOVWconst [0]) mem) + // result: (MOVWstore destptr (MOVWconst [0]) mem) { if v.AuxInt != 2 { - goto enddc4a090329efde9ca19983ad18174cbb + goto endf52f08f1f7b0ae220c4cfca6586a8586 } destptr := v.Args[0] mem := v.Args[1] @@ -6956,21 +6956,21 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(destptr) v0 := v.Block.NewValue0(v.Line, OpAMD64MOVWconst, TypeInvalid) - v0.Type = TypeInt16 + v0.Type = config.Frontend().TypeInt16() v0.AuxInt = 0 v.AddArg(v0) v.AddArg(mem) return true } - goto enddc4a090329efde9ca19983ad18174cbb - enddc4a090329efde9ca19983ad18174cbb: + goto endf52f08f1f7b0ae220c4cfca6586a8586 + endf52f08f1f7b0ae220c4cfca6586a8586: ; // match: (Zero [4] destptr mem) // cond: - // result: (MOVLstore destptr (MOVLconst [0]) mem) + // result: (MOVLstore destptr (MOVLconst [0]) mem) { if v.AuxInt != 4 { - goto end365a027b67399ad8d5d2d5eca847f7d8 + goto end41c91e0c7a23e233de77812b5264fd10 } destptr := v.Args[0] mem := v.Args[1] @@ -6980,21 +6980,21 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(destptr) v0 := v.Block.NewValue0(v.Line, OpAMD64MOVLconst, TypeInvalid) - v0.Type = TypeInt32 + v0.Type = config.Frontend().TypeInt32() v0.AuxInt = 0 v.AddArg(v0) v.AddArg(mem) return true } - goto end365a027b67399ad8d5d2d5eca847f7d8 - end365a027b67399ad8d5d2d5eca847f7d8: + goto end41c91e0c7a23e233de77812b5264fd10 + end41c91e0c7a23e233de77812b5264fd10: ; // match: (Zero [8] destptr mem) // cond: - // result: (MOVQstore destptr (MOVQconst [0]) mem) + // result: (MOVQstore destptr (MOVQconst [0]) mem) { if v.AuxInt != 8 { - goto end5808a5e9c68555a82c3514db39017e56 + goto end157ad586af643d8dac6cc84a776000ca } destptr := v.Args[0] mem := v.Args[1] @@ -7004,14 +7004,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(destptr) v0 := v.Block.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) - v0.Type = TypeInt64 + v0.Type = config.Frontend().TypeInt64() v0.AuxInt = 0 v.AddArg(v0) v.AddArg(mem) return true } - goto end5808a5e9c68555a82c3514db39017e56 - end5808a5e9c68555a82c3514db39017e56: + goto end157ad586af643d8dac6cc84a776000ca + end157ad586af643d8dac6cc84a776000ca: ; // match: (Zero [size] destptr mem) // cond: size < 4*8 @@ -7037,13 +7037,13 @@ func rewriteValueAMD64(v *Value, config *Config) bool { ; // match: (Zero [size] destptr mem) // cond: size >= 4*8 - // result: (Zero [size%8] (OffPtr [size-(size%8)] destptr) (REPSTOSQ destptr (MOVQconst [size/8]) mem)) + // result: (Zero [size%8] (OffPtr [size-(size%8)] destptr) (REPSTOSQ destptr (MOVQconst [size/8]) mem)) { size := v.AuxInt destptr := v.Args[0] mem := v.Args[1] if !(size >= 4*8) { - goto endb3058a90f909821d5689fb358519828b + goto end84c39fe2e8d40e0042a10741a0ef16bd } v.Op = OpZero v.AuxInt = 0 @@ -7051,7 +7051,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = size % 8 v0 := v.Block.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v0.Type = TypeUInt64 + v0.Type = config.Frontend().TypeUInt64() v0.AuxInt = size - (size % 8) v0.AddArg(destptr) v.AddArg(v0) @@ -7059,15 +7059,15 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1.Type = TypeMem v1.AddArg(destptr) v2 := v.Block.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) - v2.Type = TypeUInt64 + v2.Type = config.Frontend().TypeUInt64() v2.AuxInt = size / 8 v1.AddArg(v2) v1.AddArg(mem) v.AddArg(v1) return true } - goto endb3058a90f909821d5689fb358519828b - endb3058a90f909821d5689fb358519828b: + goto end84c39fe2e8d40e0042a10741a0ef16bd + end84c39fe2e8d40e0042a10741a0ef16bd: ; case OpZeroExt16to32: // match: (ZeroExt16to32 x) diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index 8fa3b6ded1..7d889b89f1 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -79,7 +79,7 @@ func rewriteValuegeneric(v *Value, config *Config) bool { case OpConstString: // match: (ConstString {s}) // cond: - // result: (StringMake (Addr {config.fe.StringData(s.(string))} (SB )) (ConstPtr [int64(len(s.(string)))])) + // result: (StringMake (Addr {config.fe.StringData(s.(string))} (SB )) (ConstPtr [int64(len(s.(string)))])) { s := v.Aux v.Op = OpStringMake @@ -87,20 +87,20 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := v.Block.NewValue0(v.Line, OpAddr, TypeInvalid) - v0.Type = TypeBytePtr + v0.Type = config.Frontend().TypeBytePtr() v0.Aux = config.fe.StringData(s.(string)) v1 := v.Block.NewValue0(v.Line, OpSB, TypeInvalid) - v1.Type = config.Uintptr + v1.Type = config.Frontend().TypeUintptr() v0.AddArg(v1) v.AddArg(v0) v2 := v.Block.NewValue0(v.Line, OpConstPtr, TypeInvalid) - v2.Type = config.Uintptr + v2.Type = config.Frontend().TypeUintptr() v2.AuxInt = int64(len(s.(string))) v.AddArg(v2) return true } - goto end1a01fc02fad8727f9a3b716cfdac3a44 - end1a01fc02fad8727f9a3b716cfdac3a44: + goto end68cc91679848c7c30bd8b0a8ed533843 + end68cc91679848c7c30bd8b0a8ed533843: ; case OpEqFat: // match: (EqFat x y) @@ -125,33 +125,33 @@ func rewriteValuegeneric(v *Value, config *Config) bool { ; // match: (EqFat (Load ptr mem) (ConstNil)) // cond: - // result: (EqPtr (Load ptr mem) (ConstPtr [0])) + // result: (EqPtr (Load ptr mem) (ConstPtr [0])) { if v.Args[0].Op != OpLoad { - goto end2597220d1792c84d362da7901d2065d2 + goto end540dc8dfbc66adcd3db2d7e819c534f6 } ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] if v.Args[1].Op != OpConstNil { - goto end2597220d1792c84d362da7901d2065d2 + goto end540dc8dfbc66adcd3db2d7e819c534f6 } v.Op = OpEqPtr v.AuxInt = 0 v.Aux = nil v.resetArgs() v0 := v.Block.NewValue0(v.Line, OpLoad, TypeInvalid) - v0.Type = config.Uintptr + v0.Type = config.Frontend().TypeUintptr() v0.AddArg(ptr) v0.AddArg(mem) v.AddArg(v0) v1 := v.Block.NewValue0(v.Line, OpConstPtr, TypeInvalid) - v1.Type = config.Uintptr + v1.Type = config.Frontend().TypeUintptr() v1.AuxInt = 0 v.AddArg(v1) return true } - goto end2597220d1792c84d362da7901d2065d2 - end2597220d1792c84d362da7901d2065d2: + goto end540dc8dfbc66adcd3db2d7e819c534f6 + end540dc8dfbc66adcd3db2d7e819c534f6: ; case OpIsInBounds: // match: (IsInBounds (ConstPtr [c]) (ConstPtr [d])) @@ -179,27 +179,27 @@ func rewriteValuegeneric(v *Value, config *Config) bool { case OpLoad: // match: (Load ptr mem) // cond: t.IsString() - // result: (StringMake (Load ptr mem) (Load (OffPtr [config.PtrSize] ptr) mem)) + // result: (StringMake (Load ptr mem) (Load (OffPtr [config.PtrSize] ptr) mem)) { t := v.Type ptr := v.Args[0] mem := v.Args[1] if !(t.IsString()) { - goto endce3ba169a57b8a9f6b12751d49b4e23a + goto end18afa4a6fdd6d0b92ed292840898c8f6 } v.Op = OpStringMake v.AuxInt = 0 v.Aux = nil v.resetArgs() v0 := v.Block.NewValue0(v.Line, OpLoad, TypeInvalid) - v0.Type = TypeBytePtr + v0.Type = config.Frontend().TypeBytePtr() v0.AddArg(ptr) v0.AddArg(mem) v.AddArg(v0) v1 := v.Block.NewValue0(v.Line, OpLoad, TypeInvalid) - v1.Type = config.Uintptr + v1.Type = config.Frontend().TypeUintptr() v2 := v.Block.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v2.Type = TypeBytePtr + v2.Type = config.Frontend().TypeBytePtr() v2.AuxInt = config.PtrSize v2.AddArg(ptr) v1.AddArg(v2) @@ -207,8 +207,8 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto endce3ba169a57b8a9f6b12751d49b4e23a - endce3ba169a57b8a9f6b12751d49b4e23a: + goto end18afa4a6fdd6d0b92ed292840898c8f6 + end18afa4a6fdd6d0b92ed292840898c8f6: ; case OpMul64: // match: (Mul64 (Const64 [c]) (Const64 [d])) @@ -279,38 +279,38 @@ func rewriteValuegeneric(v *Value, config *Config) bool { ; // match: (NeqFat (Load ptr mem) (ConstNil)) // cond: - // result: (NeqPtr (Load ptr mem) (ConstPtr [0])) + // result: (NeqPtr (Load ptr mem) (ConstPtr [0])) { if v.Args[0].Op != OpLoad { - goto end03a0fc8dde062c55439174f70c19e6ce + goto end67d723bb0f39a5c897816abcf411e5cf } ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] if v.Args[1].Op != OpConstNil { - goto end03a0fc8dde062c55439174f70c19e6ce + goto end67d723bb0f39a5c897816abcf411e5cf } v.Op = OpNeqPtr v.AuxInt = 0 v.Aux = nil v.resetArgs() v0 := v.Block.NewValue0(v.Line, OpLoad, TypeInvalid) - v0.Type = config.Uintptr + v0.Type = config.Frontend().TypeUintptr() v0.AddArg(ptr) v0.AddArg(mem) v.AddArg(v0) v1 := v.Block.NewValue0(v.Line, OpConstPtr, TypeInvalid) - v1.Type = config.Uintptr + v1.Type = config.Frontend().TypeUintptr() v1.AuxInt = 0 v.AddArg(v1) return true } - goto end03a0fc8dde062c55439174f70c19e6ce - end03a0fc8dde062c55439174f70c19e6ce: + goto end67d723bb0f39a5c897816abcf411e5cf + end67d723bb0f39a5c897816abcf411e5cf: ; case OpPtrIndex: // match: (PtrIndex ptr idx) // cond: - // result: (AddPtr ptr (MulPtr idx (ConstPtr [t.Elem().Size()]))) + // result: (AddPtr ptr (MulPtr idx (ConstPtr [t.Elem().Size()]))) { t := v.Type ptr := v.Args[0] @@ -321,25 +321,25 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.resetArgs() v.AddArg(ptr) v0 := v.Block.NewValue0(v.Line, OpMulPtr, TypeInvalid) - v0.Type = config.Uintptr + v0.Type = config.Frontend().TypeUintptr() v0.AddArg(idx) v1 := v.Block.NewValue0(v.Line, OpConstPtr, TypeInvalid) - v1.Type = config.Uintptr + v1.Type = config.Frontend().TypeUintptr() v1.AuxInt = t.Elem().Size() v0.AddArg(v1) v.AddArg(v0) return true } - goto endfb3e605edaa4c3c0684c4fa9c8f150ee - endfb3e605edaa4c3c0684c4fa9c8f150ee: + goto endf7546737f42c76a99699f241d41f491a + endf7546737f42c76a99699f241d41f491a: ; case OpSliceCap: // match: (SliceCap (Load ptr mem)) // cond: - // result: (Load (AddPtr ptr (ConstPtr [config.PtrSize*2])) mem) + // result: (Load (AddPtr ptr (ConstPtr [config.PtrSize*2])) mem) { if v.Args[0].Op != OpLoad { - goto end18c7acae3d96b30b9e5699194df4a687 + goto end6696811bf6bd45e505d24c1a15c68e70 } ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] @@ -351,23 +351,23 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v0.Type = ptr.Type v0.AddArg(ptr) v1 := v.Block.NewValue0(v.Line, OpConstPtr, TypeInvalid) - v1.Type = config.Uintptr + v1.Type = config.Frontend().TypeUintptr() v1.AuxInt = config.PtrSize * 2 v0.AddArg(v1) v.AddArg(v0) v.AddArg(mem) return true } - goto end18c7acae3d96b30b9e5699194df4a687 - end18c7acae3d96b30b9e5699194df4a687: + goto end6696811bf6bd45e505d24c1a15c68e70 + end6696811bf6bd45e505d24c1a15c68e70: ; case OpSliceLen: // match: (SliceLen (Load ptr mem)) // cond: - // result: (Load (AddPtr ptr (ConstPtr [config.PtrSize])) mem) + // result: (Load (AddPtr ptr (ConstPtr [config.PtrSize])) mem) { if v.Args[0].Op != OpLoad { - goto end2dc65aee31bb0d91847032be777777d2 + goto end9844ce3e290e81355493141e653e37d5 } ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] @@ -379,15 +379,15 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v0.Type = ptr.Type v0.AddArg(ptr) v1 := v.Block.NewValue0(v.Line, OpConstPtr, TypeInvalid) - v1.Type = config.Uintptr + v1.Type = config.Frontend().TypeUintptr() v1.AuxInt = config.PtrSize v0.AddArg(v1) v.AddArg(v0) v.AddArg(mem) return true } - goto end2dc65aee31bb0d91847032be777777d2 - end2dc65aee31bb0d91847032be777777d2: + goto end9844ce3e290e81355493141e653e37d5 + end9844ce3e290e81355493141e653e37d5: ; case OpSlicePtr: // match: (SlicePtr (Load ptr mem)) @@ -443,40 +443,40 @@ func rewriteValuegeneric(v *Value, config *Config) bool { ; // match: (Store dst str mem) // cond: str.Type.IsString() - // result: (Store (OffPtr [config.PtrSize] dst) (StringLen str) (Store dst (StringPtr str) mem)) + // result: (Store (OffPtr [config.PtrSize] dst) (StringLen str) (Store dst (StringPtr str) mem)) { dst := v.Args[0] str := v.Args[1] mem := v.Args[2] if !(str.Type.IsString()) { - goto endb47e037c1e5ac54c3a41d53163d8aef6 + goto enddf0c5a150f4b4bf6715fd2bd4bb4cc20 } v.Op = OpStore v.AuxInt = 0 v.Aux = nil v.resetArgs() v0 := v.Block.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v0.Type = TypeBytePtr + v0.Type = config.Frontend().TypeBytePtr() v0.AuxInt = config.PtrSize v0.AddArg(dst) v.AddArg(v0) v1 := v.Block.NewValue0(v.Line, OpStringLen, TypeInvalid) - v1.Type = config.Uintptr + v1.Type = config.Frontend().TypeUintptr() v1.AddArg(str) v.AddArg(v1) v2 := v.Block.NewValue0(v.Line, OpStore, TypeInvalid) v2.Type = TypeMem v2.AddArg(dst) v3 := v.Block.NewValue0(v.Line, OpStringPtr, TypeInvalid) - v3.Type = TypeBytePtr + v3.Type = config.Frontend().TypeBytePtr() v3.AddArg(str) v2.AddArg(v3) v2.AddArg(mem) v.AddArg(v2) return true } - goto endb47e037c1e5ac54c3a41d53163d8aef6 - endb47e037c1e5ac54c3a41d53163d8aef6: + goto enddf0c5a150f4b4bf6715fd2bd4bb4cc20 + enddf0c5a150f4b4bf6715fd2bd4bb4cc20: ; case OpStringLen: // match: (StringLen (StringMake _ len)) diff --git a/src/cmd/compile/internal/ssa/schedule_test.go b/src/cmd/compile/internal/ssa/schedule_test.go index e724871bd0..45f3dbcac5 100644 --- a/src/cmd/compile/internal/ssa/schedule_test.go +++ b/src/cmd/compile/internal/ssa/schedule_test.go @@ -7,7 +7,7 @@ package ssa import "testing" func TestSchedule(t *testing.T) { - c := NewConfig("amd64", DummyFrontend{t}) + c := testConfig(t) cases := []fun{ Fun(c, "entry", Bloc("entry", diff --git a/src/cmd/compile/internal/ssa/shift_test.go b/src/cmd/compile/internal/ssa/shift_test.go index 3bb26cda0b..fc26ab82ca 100644 --- a/src/cmd/compile/internal/ssa/shift_test.go +++ b/src/cmd/compile/internal/ssa/shift_test.go @@ -9,7 +9,7 @@ import ( ) func TestShiftConstAMD64(t *testing.T) { - c := NewConfig("amd64", DummyFrontend{t}) + c := testConfig(t) fun := makeConstShiftFunc(c, 18, OpLsh64x64, TypeUInt64) checkOpcodeCounts(t, fun.f, map[Op]int{OpAMD64SHLQconst: 1, OpAMD64CMPQconst: 0, OpAMD64ANDQconst: 0}) fun = makeConstShiftFunc(c, 66, OpLsh64x64, TypeUInt64) diff --git a/src/cmd/compile/internal/ssa/type.go b/src/cmd/compile/internal/ssa/type.go index 370137da71..d6e8384cf0 100644 --- a/src/cmd/compile/internal/ssa/type.go +++ b/src/cmd/compile/internal/ssa/type.go @@ -29,39 +29,29 @@ type Type interface { Equal(Type) bool } -// Stub implementation for now, until we are completely using ../gc:Type -type TypeImpl struct { - Size_ int64 - Align int64 - Boolean bool - Integer bool - Signed bool - Float bool - Ptr bool - string bool - +// Special compiler-only types. +type CompilerType struct { + Name string Memory bool Flags bool - - 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) IsPtr() bool { return t.Ptr } -func (t *TypeImpl) IsString() bool { return t.string } -func (t *TypeImpl) IsMemory() bool { return t.Memory } -func (t *TypeImpl) IsFlags() bool { return t.Flags } -func (t *TypeImpl) String() string { return t.Name } -func (t *TypeImpl) Elem() Type { panic("not implemented"); return nil } -func (t *TypeImpl) PtrTo() Type { panic("not implemented"); return nil } +func (t *CompilerType) Size() int64 { return 0 } +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) IsPtr() bool { return false } +func (t *CompilerType) IsString() bool { return false } +func (t *CompilerType) IsMemory() bool { return t.Memory } +func (t *CompilerType) IsFlags() bool { return t.Flags } +func (t *CompilerType) String() string { return t.Name } +func (t *CompilerType) Elem() Type { panic("not implemented") } +func (t *CompilerType) PtrTo() Type { panic("not implemented") } -func (t *TypeImpl) Equal(u Type) bool { - x, ok := u.(*TypeImpl) +func (t *CompilerType) Equal(u Type) bool { + x, ok := u.(*CompilerType) if !ok { return false } @@ -69,22 +59,7 @@ func (t *TypeImpl) Equal(u Type) bool { } 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"} - 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"} - //TypeString = types.Typ[types.String] - TypeBytePtr = &TypeImpl{Size_: 8, Align: 8, Ptr: true, Name: "*byte"} - - TypeInvalid = &TypeImpl{Name: "invalid"} - - // Additional compiler-only types go here. - TypeMem = &TypeImpl{Memory: true, Name: "mem"} - TypeFlags = &TypeImpl{Flags: true, Name: "flags"} + TypeInvalid = &CompilerType{Name: "invalid"} + TypeMem = &CompilerType{Name: "mem", Memory: true} + TypeFlags = &CompilerType{Name: "flags", Flags: 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 0000000000..6f8dd6d937 --- /dev/null +++ b/src/cmd/compile/internal/ssa/type_test.go @@ -0,0 +1,55 @@ +// 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 + Ptr bool + string bool + + 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) IsPtr() bool { return t.Ptr } +func (t *TypeImpl) IsString() bool { return t.string } +func (t *TypeImpl) IsMemory() bool { return false } +func (t *TypeImpl) IsFlags() bool { return false } +func (t *TypeImpl) String() string { return t.Name } +func (t *TypeImpl) Elem() Type { panic("not implemented") } +func (t *TypeImpl) PtrTo() Type { panic("not implemented") } + +func (t *TypeImpl) Equal(u Type) bool { + x, ok := u.(*TypeImpl) + if !ok { + return false + } + return x == t +} + +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"} + 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"} +) -- cgit v1.3 From 93c354b6cca23ba8ac5866c874493575e3e57510 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Thu, 30 Jul 2015 17:15:16 -0700 Subject: [dev.ssa] cmd/compile: handle non-in-place NEG and NOT This fixes the crypto/subtle tests. Change-Id: Ie6e721eec3481f67f13de1bfbd7988e227793148 Reviewed-on: https://go-review.googlesource.com/13000 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 4db33a84a7..9422970b98 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -2093,9 +2093,18 @@ func genValue(v *ssa.Value) { p.To.Reg = regnum(v.Args[0]) 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(regMoveAMD64(v.Type.Size())) + 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 = regnum(v.Args[0]) + p.To.Reg = r case ssa.OpSP, ssa.OpSB: // nothing to do case ssa.OpAMD64SETEQ, ssa.OpAMD64SETNE, -- cgit v1.3 From 9b25da732b62d294bc0762d45c77d1a0095d81fa Mon Sep 17 00:00:00 2001 From: Alexandru Moșoi Date: Fri, 31 Jul 2015 12:32:22 +0200 Subject: [dev.ssa] cmd/compile/internal/ssa/gen: add more simplifications rules This is a follow up on https://go-review.googlesource.com/#/c/12420/ with some rules moved to AMD64 closer to the existing rules. Change-Id: Id346bb0fc4459b3c49b826a59cc74308a590310e Reviewed-on: https://go-review.googlesource.com/12906 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/testdata/arith_ssa.go | 36 ++ src/cmd/compile/internal/ssa/gen/AMD64.rules | 35 ++ src/cmd/compile/internal/ssa/gen/generic.rules | 8 + src/cmd/compile/internal/ssa/gen/rulegen.go | 4 +- src/cmd/compile/internal/ssa/rewriteAMD64.go | 612 ++++++++++++++++++++++ src/cmd/compile/internal/ssa/rewritegeneric.go | 154 +++++- 6 files changed, 846 insertions(+), 3 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/testdata/arith_ssa.go b/src/cmd/compile/internal/gc/testdata/arith_ssa.go index 0a2290ef7b..1c8445fbda 100644 --- a/src/cmd/compile/internal/gc/testdata/arith_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/arith_ssa.go @@ -67,6 +67,30 @@ func testBitwiseLogic() { println("testBitwiseXor failed, wanted", want, "got", got) failed = true } + if want, got := int32(832), testBitwiseLsh_ssa(13, 4, 2); want != got { + println("testBitwiseXor 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(0), testBitwiseRsh_ssa(-13, 25, 15); want != got { + println("testBitwiseLsh failed, wanted", want, "got", got) + failed = true + } + if want, got := int32(0), testBitwiseRsh_ssa(13, 25, 15); want != got { + println("testBitwiseLsh failed, wanted", want, "got", got) + failed = true + } + if want, got := int32(-1), testBitwiseRsh_ssa(-13, 25, 15); want != got { + println("testBitwiseLsh failed, wanted", want, "got", got) + failed = true + } } func testBitwiseAnd_ssa(a, b uint32) uint32 { @@ -87,6 +111,18 @@ func testBitwiseXor_ssa(a, b uint32) uint32 { return a ^ b } +func testBitwiseLsh_ssa(a int32, b, c uint32) int32 { + switch { // prevent inlining + } + return a << b << c +} + +func testBitwiseRsh_ssa(a int32, b, c uint32) int32 { + switch { // prevent inlining + } + return a >> b >> c +} + // testSubqToNegq ensures that the SUBQ -> NEGQ translation works correctly. func testSubqToNegq(a, b, c, d, e, f, g, h, i, j, k int64) { want := a + 8207351403619448057 - b - 1779494519303207690 + c*8810076340510052032*d - 4465874067674546219 - e*4361839741470334295 - f + 8688847565426072650*g*8065564729145417479 diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index d0f5e5b073..dd34404b70 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -445,10 +445,22 @@ (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 [c-d]) (SUBLconst [c] (MOVLconst [d])) -> (MOVLconst [c-d]) (SUBWconst [c] (MOVWconst [d])) -> (MOVWconst [c-d]) (SUBBconst [c] (MOVBconst [d])) -> (MOVBconst [c-d]) +(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) +(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]) @@ -468,3 +480,26 @@ (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) -> (Copy x) +(ANDL x x) -> (Copy x) +(ANDW x x) -> (Copy x) +(ANDB x x) -> (Copy x) +(ORQ x x) -> (Copy x) +(ORL x x) -> (Copy x) +(ORW x x) -> (Copy x) +(ORB x x) -> (Copy x) +(XORQ x x) -> (MOVQconst [0]) +(XORL x x) -> (MOVLconst [0]) +(XORW x x) -> (MOVWconst [0]) +(XORB x x) -> (MOVBconst [0]) diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index 6a8952d6cb..9cc2f1b9ad 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -25,6 +25,14 @@ (Mul64 (Const64 [c]) (Const64 [d])) -> (Const64 [c*d]) (MulPtr (ConstPtr [c]) (ConstPtr [d])) -> (ConstPtr [c*d]) (IsInBounds (ConstPtr [c]) (ConstPtr [d])) -> (ConstPtr {inBounds(c,d)}) +(Eq64 x x) -> (ConstBool {true}) +(Eq32 x x) -> (ConstBool {true}) +(Eq16 x x) -> (ConstBool {true}) +(Eq8 x x) -> (ConstBool {true}) +(Neq64 x x) -> (ConstBool {false}) +(Neq32 x x) -> (ConstBool {false}) +(Neq16 x x) -> (ConstBool {false}) +(Neq8 x x) -> (ConstBool {false}) // tear apart slices // TODO: anything that generates a slice needs to go in here. diff --git a/src/cmd/compile/internal/ssa/gen/rulegen.go b/src/cmd/compile/internal/ssa/gen/rulegen.go index 03cbf7cd57..4b3775ca98 100644 --- a/src/cmd/compile/internal/ssa/gen/rulegen.go +++ b/src/cmd/compile/internal/ssa/gen/rulegen.go @@ -285,12 +285,12 @@ func genMatch(w io.Writer, arch arch, match, fail string) { func genMatch0(w io.Writer, arch arch, match, v, fail string, m map[string]string, top bool) { if match[0] != '(' { - if x, ok := m[match]; ok { + 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 %s", v, x, fail) + fmt.Fprintf(w, "if %s != %s %s", v, match, fail) return } // remember that this variable references the given value diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 9e4f133f3b..9157989035 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -45,6 +45,26 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end28aa1a4abe7e1abcdd64135e9967d39d end28aa1a4abe7e1abcdd64135e9967d39d: ; + // match: (ADDB x (NEGB y)) + // cond: + // result: (SUBB x y) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64NEGB { + goto end9464509b8874ffb00b43b843da01f0bc + } + y := v.Args[1].Args[0] + v.Op = OpAMD64SUBB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end9464509b8874ffb00b43b843da01f0bc + end9464509b8874ffb00b43b843da01f0bc: + ; case OpAMD64ADDBconst: // match: (ADDBconst [c] (MOVBconst [d])) // cond: @@ -65,6 +85,27 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto enda9b1e9e31ccdf0af5f4fe57bf4b1343f enda9b1e9e31ccdf0af5f4fe57bf4b1343f: ; + // match: (ADDBconst [c] (ADDBconst [d] x)) + // cond: + // result: (ADDBconst [c+d] x) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64ADDBconst { + goto end9b1e6890adbf9d9e447d591b4148cbd0 + } + d := v.Args[0].AuxInt + x := v.Args[0].Args[0] + v.Op = OpAMD64ADDBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + d + v.AddArg(x) + return true + } + goto end9b1e6890adbf9d9e447d591b4148cbd0 + end9b1e6890adbf9d9e447d591b4148cbd0: + ; case OpAMD64ADDL: // match: (ADDL x (MOVLconst [c])) // cond: @@ -106,6 +147,26 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end739561e08a561e26ce3634dc0d5ec733 end739561e08a561e26ce3634dc0d5ec733: ; + // match: (ADDL x (NEGL y)) + // cond: + // result: (SUBL x y) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64NEGL { + goto end9596df31f2685a49df67c6fb912a521d + } + y := v.Args[1].Args[0] + v.Op = OpAMD64SUBL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end9596df31f2685a49df67c6fb912a521d + end9596df31f2685a49df67c6fb912a521d: + ; case OpAMD64ADDLconst: // match: (ADDLconst [c] (MOVLconst [d])) // cond: @@ -126,6 +187,27 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto ende04850e987890abf1d66199042a19c23 ende04850e987890abf1d66199042a19c23: ; + // match: (ADDLconst [c] (ADDLconst [d] x)) + // cond: + // result: (ADDLconst [c+d] x) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64ADDLconst { + goto endf1dd8673b2fef4950aec87aa7523a236 + } + d := v.Args[0].AuxInt + x := v.Args[0].Args[0] + v.Op = OpAMD64ADDLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + d + v.AddArg(x) + return true + } + goto endf1dd8673b2fef4950aec87aa7523a236 + endf1dd8673b2fef4950aec87aa7523a236: + ; case OpAMD64ADDQ: // match: (ADDQ x (MOVQconst [c])) // cond: is32Bit(c) @@ -196,6 +278,26 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endc02313d35a0525d1d680cd58992e820d endc02313d35a0525d1d680cd58992e820d: ; + // match: (ADDQ x (NEGQ y)) + // cond: + // result: (SUBQ x y) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64NEGQ { + goto endec8f899c6e175a0147a90750f9bfe0a2 + } + y := v.Args[1].Args[0] + v.Op = OpAMD64SUBQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto endec8f899c6e175a0147a90750f9bfe0a2 + endec8f899c6e175a0147a90750f9bfe0a2: + ; case OpAMD64ADDQconst: // match: (ADDQconst [c] (LEAQ8 [d] x y)) // cond: @@ -257,6 +359,27 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end09dc54395b4e96e8332cf8e4e7481c52 end09dc54395b4e96e8332cf8e4e7481c52: ; + // match: (ADDQconst [c] (ADDQconst [d] x)) + // cond: + // result: (ADDQconst [c+d] x) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64ADDQconst { + goto endd4cb539641f0dc40bfd0cb7fbb9b0405 + } + d := v.Args[0].AuxInt + x := v.Args[0].Args[0] + v.Op = OpAMD64ADDQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + d + v.AddArg(x) + return true + } + goto endd4cb539641f0dc40bfd0cb7fbb9b0405 + endd4cb539641f0dc40bfd0cb7fbb9b0405: + ; case OpAMD64ADDW: // match: (ADDW x (MOVWconst [c])) // cond: @@ -298,6 +421,26 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto ende3aede99966f388afc624f9e86676fd2 ende3aede99966f388afc624f9e86676fd2: ; + // match: (ADDW x (NEGW y)) + // cond: + // result: (SUBW x y) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64NEGW { + goto end55cf2af0d75f3ec413528eeb799e94d5 + } + y := v.Args[1].Args[0] + v.Op = OpAMD64SUBW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end55cf2af0d75f3ec413528eeb799e94d5 + end55cf2af0d75f3ec413528eeb799e94d5: + ; case OpAMD64ADDWconst: // match: (ADDWconst [c] (MOVWconst [d])) // cond: @@ -318,6 +461,27 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end32541920f2f5a920dfae41d8ebbef00f end32541920f2f5a920dfae41d8ebbef00f: ; + // match: (ADDWconst [c] (ADDWconst [d] x)) + // cond: + // result: (ADDWconst [c+d] x) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64ADDWconst { + goto end73944f6ddda7e4c050f11d17484ff9a5 + } + d := v.Args[0].AuxInt + x := v.Args[0].Args[0] + v.Op = OpAMD64ADDWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + d + v.AddArg(x) + return true + } + goto end73944f6ddda7e4c050f11d17484ff9a5 + end73944f6ddda7e4c050f11d17484ff9a5: + ; case OpAMD64ANDB: // match: (ANDB x (MOVBconst [c])) // cond: @@ -359,6 +523,24 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end4068edac2ae0f354cf581db210288b98 end4068edac2ae0f354cf581db210288b98: ; + // match: (ANDB x x) + // cond: + // result: (Copy x) + { + x := v.Args[0] + if v.Args[1] != x { + goto end1c1e017efac06c84c72f2d09d6afadc0 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end1c1e017efac06c84c72f2d09d6afadc0 + end1c1e017efac06c84c72f2d09d6afadc0: + ; case OpAMD64ANDBconst: // match: (ANDBconst [c] _) // cond: int8(c)==0 @@ -457,6 +639,24 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end0529ba323d9b6f15c41add401ef67959 end0529ba323d9b6f15c41add401ef67959: ; + // match: (ANDL x x) + // cond: + // result: (Copy x) + { + x := v.Args[0] + if v.Args[1] != x { + goto end0ff7ad77f6811c422b0b588f48474ddc + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end0ff7ad77f6811c422b0b588f48474ddc + end0ff7ad77f6811c422b0b588f48474ddc: + ; case OpAMD64ANDLconst: // match: (ANDLconst [c] _) // cond: int32(c)==0 @@ -561,6 +761,24 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end3035a3bf650b708705fd27dd857ab0a4 end3035a3bf650b708705fd27dd857ab0a4: ; + // match: (ANDQ x x) + // cond: + // result: (Copy x) + { + x := v.Args[0] + if v.Args[1] != x { + goto endb54d87d7a12ba29a9d19b808319ab055 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto endb54d87d7a12ba29a9d19b808319ab055 + endb54d87d7a12ba29a9d19b808319ab055: + ; case OpAMD64ANDQconst: // match: (ANDQconst [0] _) // cond: @@ -657,6 +875,24 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endea2a25eb525a5dbf6d5132d84ea4e7a5 endea2a25eb525a5dbf6d5132d84ea4e7a5: ; + // match: (ANDW x x) + // cond: + // result: (Copy x) + { + x := v.Args[0] + if v.Args[1] != x { + goto end08c49eea4ac769acc212ebd833934be8 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end08c49eea4ac769acc212ebd833934be8 + end08c49eea4ac769acc212ebd833934be8: + ; case OpAMD64ANDWconst: // match: (ANDWconst [c] _) // cond: int16(c)==0 @@ -3504,6 +3740,82 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endbbedad106c011a93243e2062afdcc75f endbbedad106c011a93243e2062afdcc75f: ; + case OpAMD64NEGB: + // match: (NEGB (MOVBconst [c])) + // cond: + // result: (MOVBconst [-c]) + { + if v.Args[0].Op != OpAMD64MOVBconst { + goto end36d0300ba9eab8c9da86246ff653ca96 + } + c := v.Args[0].AuxInt + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = -c + return true + } + goto end36d0300ba9eab8c9da86246ff653ca96 + end36d0300ba9eab8c9da86246ff653ca96: + ; + case OpAMD64NEGL: + // match: (NEGL (MOVLconst [c])) + // cond: + // result: (MOVLconst [-c]) + { + if v.Args[0].Op != OpAMD64MOVLconst { + goto end7a245ec67e56bd51911e5ba2d0aa0a16 + } + c := v.Args[0].AuxInt + v.Op = OpAMD64MOVLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = -c + return true + } + goto end7a245ec67e56bd51911e5ba2d0aa0a16 + end7a245ec67e56bd51911e5ba2d0aa0a16: + ; + case OpAMD64NEGQ: + // match: (NEGQ (MOVQconst [c])) + // cond: + // result: (MOVQconst [-c]) + { + if v.Args[0].Op != OpAMD64MOVQconst { + goto end04ddd98bc6724ecb85c80c2a4e2bca5a + } + c := v.Args[0].AuxInt + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = -c + return true + } + goto end04ddd98bc6724ecb85c80c2a4e2bca5a + end04ddd98bc6724ecb85c80c2a4e2bca5a: + ; + case OpAMD64NEGW: + // match: (NEGW (MOVWconst [c])) + // cond: + // result: (MOVWconst [-c]) + { + if v.Args[0].Op != OpAMD64MOVWconst { + goto end1db6636f0a51848d8a34f6561ecfe7ae + } + c := v.Args[0].AuxInt + v.Op = OpAMD64MOVWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = -c + return true + } + goto end1db6636f0a51848d8a34f6561ecfe7ae + end1db6636f0a51848d8a34f6561ecfe7ae: + ; case OpAMD64NOTB: // match: (NOTB (MOVBconst [c])) // cond: @@ -3807,6 +4119,24 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end70b43d531e2097a4f6293f66256a642e end70b43d531e2097a4f6293f66256a642e: ; + // match: (ORB x x) + // cond: + // result: (Copy x) + { + x := v.Args[0] + if v.Args[1] != x { + goto endd53ede4886d67f4b4ae970316a2febb4 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto endd53ede4886d67f4b4ae970316a2febb4 + endd53ede4886d67f4b4ae970316a2febb4: + ; case OpAMD64ORBconst: // match: (ORBconst [c] x) // cond: int8(c)==0 @@ -3905,6 +4235,24 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto enda5bc49524a0cbd2241f792837d0a48a8 enda5bc49524a0cbd2241f792837d0a48a8: ; + // match: (ORL x x) + // cond: + // result: (Copy x) + { + x := v.Args[0] + if v.Args[1] != x { + goto end556b9151cacb9db2803373ce10829b2a + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end556b9151cacb9db2803373ce10829b2a + end556b9151cacb9db2803373ce10829b2a: + ; case OpAMD64ORLconst: // match: (ORLconst [c] x) // cond: int32(c)==0 @@ -4009,6 +4357,24 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end010afbebcd314e288509d79a16a6d5cc end010afbebcd314e288509d79a16a6d5cc: ; + // match: (ORQ x x) + // cond: + // result: (Copy x) + { + x := v.Args[0] + if v.Args[1] != x { + goto endcad306e115ea011a2a70f4e4e5440de4 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto endcad306e115ea011a2a70f4e4e5440de4 + endcad306e115ea011a2a70f4e4e5440de4: + ; case OpAMD64ORQconst: // match: (ORQconst [0] x) // cond: @@ -4105,6 +4471,24 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end96405942c9ceb5fcb0ddb85a8709d015 end96405942c9ceb5fcb0ddb85a8709d015: ; + // match: (ORW x x) + // cond: + // result: (Copy x) + { + x := v.Args[0] + if v.Args[1] != x { + goto end7c69794f4a3a6ada00bd868f743d86f8 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end7c69794f4a3a6ada00bd868f743d86f8 + end7c69794f4a3a6ada00bd868f743d86f8: + ; case OpAMD64ORWconst: // match: (ORWconst [c] x) // cond: int16(c)==0 @@ -5963,6 +6347,24 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endc288755d69b04d24a6aac32a73956411 endc288755d69b04d24a6aac32a73956411: ; + // match: (SUBB x x) + // cond: + // result: (MOVBconst [0]) + { + x := v.Args[0] + if v.Args[1] != x { + goto ende8904403d937d95b0d6133d3ec92bb45 + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto ende8904403d937d95b0d6133d3ec92bb45 + ende8904403d937d95b0d6133d3ec92bb45: + ; case OpAMD64SUBBconst: // match: (SUBBconst [c] (MOVBconst [d])) // cond: @@ -5983,6 +6385,27 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end0e2d5c3e3c02001a20d5433daa9e8317 end0e2d5c3e3c02001a20d5433daa9e8317: ; + // match: (SUBBconst [c] (SUBBconst [d] x)) + // cond: + // result: (ADDBconst [c-d] x) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64SUBBconst { + goto end48eccb421dfe0c678ea9c47113521d5a + } + d := v.Args[0].AuxInt + x := v.Args[0].Args[0] + v.Op = OpAMD64ADDBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c - d + v.AddArg(x) + return true + } + goto end48eccb421dfe0c678ea9c47113521d5a + end48eccb421dfe0c678ea9c47113521d5a: + ; case OpAMD64SUBL: // match: (SUBL x (MOVLconst [c])) // cond: @@ -6027,6 +6450,24 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endb0efe6e15ec20486b849534a00483ae2 endb0efe6e15ec20486b849534a00483ae2: ; + // match: (SUBL x x) + // cond: + // result: (MOVLconst [0]) + { + x := v.Args[0] + if v.Args[1] != x { + goto end332f1f641f875c69bea7289191e69133 + } + v.Op = OpAMD64MOVLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end332f1f641f875c69bea7289191e69133 + end332f1f641f875c69bea7289191e69133: + ; case OpAMD64SUBLconst: // match: (SUBLconst [c] (MOVLconst [d])) // cond: @@ -6047,6 +6488,27 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endbe7466f3c09d9645544bdfc44c37c922 endbe7466f3c09d9645544bdfc44c37c922: ; + // match: (SUBLconst [c] (SUBLconst [d] x)) + // cond: + // result: (ADDLconst [c-d] x) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64SUBLconst { + goto endb5106962a865bc4654b170c2e29a72c4 + } + d := v.Args[0].AuxInt + x := v.Args[0].Args[0] + v.Op = OpAMD64ADDLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c - d + v.AddArg(x) + return true + } + goto endb5106962a865bc4654b170c2e29a72c4 + endb5106962a865bc4654b170c2e29a72c4: + ; case OpAMD64SUBQ: // match: (SUBQ x (MOVQconst [c])) // cond: is32Bit(c) @@ -6097,6 +6559,24 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end8beb96de3efee9206d1bd4b7d777d2cb end8beb96de3efee9206d1bd4b7d777d2cb: ; + // match: (SUBQ x x) + // cond: + // result: (MOVQconst [0]) + { + x := v.Args[0] + if v.Args[1] != x { + goto endd87d1d839d2dc54d9c90fa4f73383480 + } + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto endd87d1d839d2dc54d9c90fa4f73383480 + endd87d1d839d2dc54d9c90fa4f73383480: + ; case OpAMD64SUBQconst: // match: (SUBQconst [c] (MOVQconst [d])) // cond: @@ -6117,6 +6597,27 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end96c09479fb3c043e875d89d3eb92f1d8 end96c09479fb3c043e875d89d3eb92f1d8: ; + // match: (SUBQconst [c] (SUBQconst [d] x)) + // cond: + // result: (ADDQconst [c-d] x) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64SUBQconst { + goto enddd9d61b404480adb40cfd7fedd7e5ec4 + } + d := v.Args[0].AuxInt + x := v.Args[0].Args[0] + v.Op = OpAMD64ADDQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c - d + v.AddArg(x) + return true + } + goto enddd9d61b404480adb40cfd7fedd7e5ec4 + enddd9d61b404480adb40cfd7fedd7e5ec4: + ; case OpAMD64SUBW: // match: (SUBW x (MOVWconst [c])) // cond: @@ -6161,6 +6662,24 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end44d23f7e65a4b1c42d0e6463f8e493b6 end44d23f7e65a4b1c42d0e6463f8e493b6: ; + // match: (SUBW x x) + // cond: + // result: (MOVWconst [0]) + { + x := v.Args[0] + if v.Args[1] != x { + goto endb970e7c318d04a1afe1dfe08a7ca0d9c + } + v.Op = OpAMD64MOVWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto endb970e7c318d04a1afe1dfe08a7ca0d9c + endb970e7c318d04a1afe1dfe08a7ca0d9c: + ; case OpAMD64SUBWconst: // match: (SUBWconst [c] (MOVWconst [d])) // cond: @@ -6181,6 +6700,27 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end0e5079577fcf00f5925291dbd68306aa end0e5079577fcf00f5925291dbd68306aa: ; + // match: (SUBWconst [c] (SUBWconst [d] x)) + // cond: + // result: (ADDWconst [c-d] x) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64SUBWconst { + goto endb628696cf5b329d03782b8093093269b + } + d := v.Args[0].AuxInt + x := v.Args[0].Args[0] + v.Op = OpAMD64ADDWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c - d + v.AddArg(x) + return true + } + goto endb628696cf5b329d03782b8093093269b + endb628696cf5b329d03782b8093093269b: + ; case OpSignExt16to32: // match: (SignExt16to32 x) // cond: @@ -6617,6 +7157,24 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endb02a07d9dc7b802c59f013116e952f3f endb02a07d9dc7b802c59f013116e952f3f: ; + // match: (XORB x x) + // cond: + // result: (MOVBconst [0]) + { + x := v.Args[0] + if v.Args[1] != x { + goto end2afddc39503d04d572a3a07878f6c9c9 + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end2afddc39503d04d572a3a07878f6c9c9 + end2afddc39503d04d572a3a07878f6c9c9: + ; case OpAMD64XORBconst: // match: (XORBconst [c] (MOVBconst [d])) // cond: @@ -6678,6 +7236,24 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end9c1a0af00eeadd8aa325e55f1f3fb89c end9c1a0af00eeadd8aa325e55f1f3fb89c: ; + // match: (XORL x x) + // cond: + // result: (MOVLconst [0]) + { + x := v.Args[0] + if v.Args[1] != x { + goto end7bcf9cfeb69a0d7647389124eb53ce2a + } + v.Op = OpAMD64MOVLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end7bcf9cfeb69a0d7647389124eb53ce2a + end7bcf9cfeb69a0d7647389124eb53ce2a: + ; case OpAMD64XORLconst: // match: (XORLconst [c] (MOVLconst [d])) // cond: @@ -6745,6 +7321,24 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endd221a7e3daaaaa29ee385ad36e061b57 endd221a7e3daaaaa29ee385ad36e061b57: ; + // match: (XORQ x x) + // cond: + // result: (MOVQconst [0]) + { + x := v.Args[0] + if v.Args[1] != x { + goto end10575a5d711cf14e6d4dffbb0e8dfaeb + } + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end10575a5d711cf14e6d4dffbb0e8dfaeb + end10575a5d711cf14e6d4dffbb0e8dfaeb: + ; case OpAMD64XORQconst: // match: (XORQconst [c] (MOVQconst [d])) // cond: @@ -6806,6 +7400,24 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end51ee62a06d4301e5a4aed7a6639b1d53 end51ee62a06d4301e5a4aed7a6639b1d53: ; + // match: (XORW x x) + // cond: + // result: (MOVWconst [0]) + { + x := v.Args[0] + if v.Args[1] != x { + goto end07f332e857be0c2707797ed480a2faf4 + } + v.Op = OpAMD64MOVWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end07f332e857be0c2707797ed480a2faf4 + end07f332e857be0c2707797ed480a2faf4: + ; case OpAMD64XORWconst: // match: (XORWconst [c] (MOVWconst [d])) // cond: diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index 7d889b89f1..17608d71c4 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -102,6 +102,82 @@ func rewriteValuegeneric(v *Value, config *Config) bool { goto end68cc91679848c7c30bd8b0a8ed533843 end68cc91679848c7c30bd8b0a8ed533843: ; + case OpEq16: + // match: (Eq16 x x) + // cond: + // result: (ConstBool {true}) + { + x := v.Args[0] + if v.Args[1] != x { + goto enda503589f9b617e708a5ad3ddb047809f + } + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Aux = true + return true + } + goto enda503589f9b617e708a5ad3ddb047809f + enda503589f9b617e708a5ad3ddb047809f: + ; + case OpEq32: + // match: (Eq32 x x) + // cond: + // result: (ConstBool {true}) + { + x := v.Args[0] + if v.Args[1] != x { + goto endc94ae3b97d0090257b02152e437b3e17 + } + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Aux = true + return true + } + goto endc94ae3b97d0090257b02152e437b3e17 + endc94ae3b97d0090257b02152e437b3e17: + ; + case OpEq64: + // match: (Eq64 x x) + // cond: + // result: (ConstBool {true}) + { + x := v.Args[0] + if v.Args[1] != x { + goto end4d21cead60174989467a9c8202dbb91d + } + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Aux = true + return true + } + goto end4d21cead60174989467a9c8202dbb91d + end4d21cead60174989467a9c8202dbb91d: + ; + case OpEq8: + // match: (Eq8 x x) + // cond: + // result: (ConstBool {true}) + { + x := v.Args[0] + if v.Args[1] != x { + goto end73dce8bba164e4f4a1dd701bf8cfb362 + } + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Aux = true + return true + } + goto end73dce8bba164e4f4a1dd701bf8cfb362 + end73dce8bba164e4f4a1dd701bf8cfb362: + ; case OpEqFat: // match: (EqFat x y) // cond: x.Op == OpConstNil && y.Op != OpConstNil @@ -256,6 +332,82 @@ func rewriteValuegeneric(v *Value, config *Config) bool { goto end808c190f346658bb1ad032bf37a1059f end808c190f346658bb1ad032bf37a1059f: ; + case OpNeq16: + // match: (Neq16 x x) + // cond: + // result: (ConstBool {false}) + { + x := v.Args[0] + if v.Args[1] != x { + goto end192755dd3c2be992e9d3deb53794a8d2 + } + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Aux = false + return true + } + goto end192755dd3c2be992e9d3deb53794a8d2 + end192755dd3c2be992e9d3deb53794a8d2: + ; + case OpNeq32: + // match: (Neq32 x x) + // cond: + // result: (ConstBool {false}) + { + x := v.Args[0] + if v.Args[1] != x { + goto endeb23619fc85950a8df7b31126252c4dd + } + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Aux = false + return true + } + goto endeb23619fc85950a8df7b31126252c4dd + endeb23619fc85950a8df7b31126252c4dd: + ; + case OpNeq64: + // match: (Neq64 x x) + // cond: + // result: (ConstBool {false}) + { + x := v.Args[0] + if v.Args[1] != x { + goto endfc6eea780fb4056afb9e4287076da60c + } + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Aux = false + return true + } + goto endfc6eea780fb4056afb9e4287076da60c + endfc6eea780fb4056afb9e4287076da60c: + ; + case OpNeq8: + // match: (Neq8 x x) + // cond: + // result: (ConstBool {false}) + { + x := v.Args[0] + if v.Args[1] != x { + goto endcccf700d93c6d57765b80f92f7b3fa81 + } + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Aux = false + return true + } + goto endcccf700d93c6d57765b80f92f7b3fa81 + endcccf700d93c6d57765b80f92f7b3fa81: + ; case OpNeqFat: // match: (NeqFat x y) // cond: x.Op == OpConstNil && y.Op != OpConstNil @@ -422,7 +574,7 @@ func rewriteValuegeneric(v *Value, config *Config) bool { t := v.Args[1].Type src := v.Args[1].Args[0] mem := v.Args[1].Args[1] - if v.Args[2] != v.Args[1].Args[1] { + if v.Args[2] != mem { goto end324ffb6d2771808da4267f62c854e9c8 } if !(t.Size() > 8) { -- cgit v1.3 From 4ac823eeb8aa08e8fbae01c70d185ec7501f55b7 Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Sun, 2 Aug 2015 20:28:31 -0500 Subject: [dev.ssa] cmd/compile/ssa: test against known values Modify tests to use a known value instead of comparing the backends directly. Change-Id: I32e804e12515885bd94c4f83644cbca03b018fea Reviewed-on: https://go-review.googlesource.com/13042 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/testdata/arith_ssa.go | 36 +++++++++++------------ 1 file changed, 18 insertions(+), 18 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/testdata/arith_ssa.go b/src/cmd/compile/internal/gc/testdata/arith_ssa.go index 1c8445fbda..032cc8e1cf 100644 --- a/src/cmd/compile/internal/gc/testdata/arith_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/arith_ssa.go @@ -10,9 +10,9 @@ package main // test64BitConstMulti tests that rewrite rules don't fold 64 bit constants // into multiply instructions. -func test64BitConstMult(a, b int64) { - want := 34359738369*a + b*34359738370 - if got := test64BitConstMult_ssa(a, b); want != got { +func test64BitConstMult() { + want := int64(103079215109) + if got := test64BitConstMult_ssa(1, 2); want != got { println("test64BitConstMult failed, wanted", want, "got", got) failed = true } @@ -25,30 +25,30 @@ func test64BitConstMult_ssa(a, b int64) int64 { // test64BitConstAdd tests that rewrite rules don't fold 64 bit constants // into add instructions. -func test64BitConstAdd(a, b int64) { - want := a + 575815584948629622 + b + 2991856197886747025 - if got := test64BitConstAdd_ssa(a, b); want != got { +func test64BitConstAdd() { + want := int64(3567671782835376650) + if got := test64BitConstAdd_ssa(1, 2); want != got { println("test64BitConstAdd failed, wanted", want, "got", got) failed = true } } func test64BitConstAdd_ssa(a, b int64) int64 { - switch { + switch { // prevent inlining } return a + 575815584948629622 + b + 2991856197886747025 } // testRegallocCVSpill tests that regalloc spills a value whose last use is the // current value. -func testRegallocCVSpill(a, b, c, d int8) { - want := a + -32 + b + 63*c*-87*d - if got := testRegallocCVSpill_ssa(a, b, c, d); want != got { +func testRegallocCVSpill() { + want := int8(-9) + if got := testRegallocCVSpill_ssa(1, 2, 3, 4); want != got { println("testRegallocCVSpill failed, wanted", want, "got", got) failed = true } } func testRegallocCVSpill_ssa(a, b, c, d int8) int8 { - switch { + switch { // prevent inlining } return a + -32 + b + 63*c*-87*d } @@ -124,9 +124,9 @@ func testBitwiseRsh_ssa(a int32, b, c uint32) int32 { } // testSubqToNegq ensures that the SUBQ -> NEGQ translation works correctly. -func testSubqToNegq(a, b, c, d, e, f, g, h, i, j, k int64) { - want := a + 8207351403619448057 - b - 1779494519303207690 + c*8810076340510052032*d - 4465874067674546219 - e*4361839741470334295 - f + 8688847565426072650*g*8065564729145417479 - if got := testSubqToNegq_ssa(a, b, c, d, e, f, g, h, i, j, k); want != got { +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 } @@ -142,10 +142,10 @@ var failed = false func main() { - test64BitConstMult(1, 2) - test64BitConstAdd(1, 2) - testRegallocCVSpill(1, 2, 3, 4) - testSubqToNegq(1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2) + test64BitConstMult() + test64BitConstAdd() + testRegallocCVSpill() + testSubqToNegq() testBitwiseLogic() if failed { -- cgit v1.3 From 4dcf8ea1a44cd1c566cb492560ee44b9e81a6d9e Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Tue, 14 Jul 2015 16:26:38 -0500 Subject: [dev.ssa] cmd/compile/ssa: speed up nilcheck Reworks nilcheck to be performed by a depth first traversal of the dominator tree, keeping an updated map of the values that have been nil-checked during the traversal. benchmark old ns/op new ns/op delta BenchmarkNilCheckDeep1-8 1242 1825 +46.94% BenchmarkNilCheckDeep10-8 2397 3942 +64.46% BenchmarkNilCheckDeep100-8 29105 24873 -14.54% BenchmarkNilCheckDeep1000-8 2742563 265760 -90.31% BenchmarkNilCheckDeep10000-8 335690119 3157995 -99.06% benchmark old MB/s new MB/s speedup BenchmarkNilCheckDeep1-8 0.81 0.55 0.68x BenchmarkNilCheckDeep10-8 4.17 2.54 0.61x BenchmarkNilCheckDeep100-8 3.44 4.02 1.17x BenchmarkNilCheckDeep1000-8 0.36 3.76 10.44x BenchmarkNilCheckDeep10000-8 0.03 3.17 105.67x benchmark old allocs new allocs delta BenchmarkNilCheckDeep1-8 9 14 +55.56% BenchmarkNilCheckDeep10-8 9 23 +155.56% BenchmarkNilCheckDeep100-8 9 113 +1155.56% BenchmarkNilCheckDeep1000-8 9 1015 +11177.78% BenchmarkNilCheckDeep10000-8 9 10024 +111277.78% benchmark old bytes new bytes delta BenchmarkNilCheckDeep1-8 432 608 +40.74% BenchmarkNilCheckDeep10-8 1008 1496 +48.41% BenchmarkNilCheckDeep100-8 8064 11656 +44.54% BenchmarkNilCheckDeep1000-8 73728 145240 +96.99% BenchmarkNilCheckDeep10000-8 737280 2144411 +190.85% Change-Id: I0f86010e9823aec04aac744fdb589b65ec8acefc Reviewed-on: https://go-review.googlesource.com/12332 Reviewed-by: David Chase --- src/cmd/compile/internal/ssa/nilcheck.go | 116 ++++++++++++-- src/cmd/compile/internal/ssa/nilcheck_test.go | 211 ++++++++++++++++++++++++++ 2 files changed, 316 insertions(+), 11 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/nilcheck.go b/src/cmd/compile/internal/ssa/nilcheck.go index d24340e630..b9964b2980 100644 --- a/src/cmd/compile/internal/ssa/nilcheck.go +++ b/src/cmd/compile/internal/ssa/nilcheck.go @@ -6,6 +6,111 @@ package ssa // 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, ptr: checkedptr(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()) + + // perform a depth first walk of the dominee tree + for len(work) > 0 { + node := work[len(work)-1] + work = work[:len(work)-1] + + var pushRecPtr bool + switch node.op { + case Work: + if node.ptr != nil { + // already have a nilcheck in the dominator path + if nonNilValues[node.ptr.ID] { + // Eliminate the nil check. + // The deadcode pass will remove vestigial values, + // and the fuse pass will join this block with its successor. + node.block.Kind = BlockPlain + node.block.Control = nil + f.removePredecessor(node.block, node.block.Succs[1]) + node.block.Succs = node.block.Succs[:1] + } else { + // 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: node.ptr}) + // and cause a new setPtr to be appended after the + // block's dominees + pushRecPtr = true + } + } + case RecPtr: + nonNilValues[node.ptr.ID] = true + continue + case ClearPtr: + nonNilValues[node.ptr.ID] = false + continue + } + + var nilBranch *Block + for _, w := range domTree[node.block.ID] { + // TODO: Since we handle the false side of OpIsNonNil + // correctly, look into rewriting user nil checks into + // OpIsNonNil so they can be eliminated also + + // we are about to traverse down the 'ptr is nil' side + // of a nilcheck block, so save it for later + if node.block.Kind == BlockIf && node.block.Control.Op == OpIsNonNil && + w == node.block.Succs[1] { + nilBranch = w + continue + } + work = append(work, bp{block: w, ptr: checkedptr(w)}) + } + + if nilBranch != nil { + // we pop from the back of the work slice, so this sets + // up the false branch to be operated on before the + // node.ptr is recorded + work = append(work, bp{op: RecPtr, ptr: node.ptr}) + work = append(work, bp{block: nilBranch, ptr: checkedptr(nilBranch)}) + } else if pushRecPtr { + work = append(work, bp{op: RecPtr, ptr: node.ptr}) + } + } +} + +// nilcheckelim0 is the original redundant nilcheck elimination algorithm. +func nilcheckelim0(f *Func) { // Exit early if there are no nil checks to eliminate. var found bool for _, b := range f.Blocks { @@ -50,17 +155,6 @@ func nilcheckelim(f *Func) { b.Succs = b.Succs[:1] } } - - // TODO: Eliminate more nil checks. - // For example, pointers to function arguments - // and pointers to static values cannot be nil. - // We could also track pointers constructed by - // taking the address of another value. - // We can also 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. } // checkedptr returns the Value, if any, diff --git a/src/cmd/compile/internal/ssa/nilcheck_test.go b/src/cmd/compile/internal/ssa/nilcheck_test.go index 272fd0c027..0ebf2bc801 100644 --- a/src/cmd/compile/internal/ssa/nilcheck_test.go +++ b/src/cmd/compile/internal/ssa/nilcheck_test.go @@ -46,6 +46,7 @@ func benchmarkNilCheckDeep(b *testing.B, depth int) { 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) @@ -55,3 +56,213 @@ func benchmarkNilCheckDeep(b *testing.B, depth int) { 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}) + fun := Fun(c, "entry", + Bloc("entry", + Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("sb", OpSB, TypeInvalid, 0, nil), + Goto("checkPtr")), + Bloc("checkPtr", + Valu("ptr1", OpConstPtr, ptrType, 0, nil, "sb"), + 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}) + fun := Fun(c, "entry", + Bloc("entry", + Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("sb", OpSB, TypeInvalid, 0, nil), + Goto("checkPtr")), + Bloc("checkPtr", + Valu("ptr1", OpConstPtr, ptrType, 0, nil, "sb"), + 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") + } + } +} + +//TODO: Disabled until we track OpAddr constructed values +// TestNilcheckAddr verifies that nilchecks of OpAddr constructed values are removed. +func DISABLETestNilcheckAddr(t *testing.T) { + ptrType := &TypeImpl{Size_: 8, Ptr: true, Name: "testptr"} // dummy for testing + c := NewConfig("amd64", DummyFrontend{t}) + fun := Fun(c, "entry", + Bloc("entry", + Valu("mem", OpArg, TypeMem, 0, ".mem"), + 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") + } + } +} + +// TestNilcheckKeepRemove verifies that dupliate 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}) + fun := Fun(c, "entry", + Bloc("entry", + Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("sb", OpSB, TypeInvalid, 0, nil), + Goto("checkPtr")), + Bloc("checkPtr", + Valu("ptr1", OpConstPtr, ptrType, 0, nil, "sb"), + Valu("bool1", OpIsNonNil, TypeBool, 0, nil, "ptr1"), + If("bool1", "differentCheck", "exit")), + Bloc("differentCheck", + Valu("ptr2", OpConstPtr, ptrType, 0, nil, "sb"), + 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}) + fun := Fun(c, "entry", + Bloc("entry", + Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("sb", OpSB, TypeInvalid, 0, nil), + Goto("checkPtr")), + Bloc("checkPtr", + Valu("ptr1", OpConstPtr, ptrType, 0, nil, "sb"), + 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]") + } +} -- cgit v1.3 From a678a5c7a59de585a09d7bde2505b8234cc4422e Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Mon, 3 Aug 2015 12:33:03 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: Fix scheduler The DFS scheduler doesn't do the right thing. If a Value x is used by more than one other Value, then x is put into the DFS queue when its first user (call it y) is visited. It is not removed and reinserted when the second user of x (call it z) is visited, so the dependency between x and z is not respected. There is no easy way to fix this with the DFS queue because we'd have to rip values out of the middle of the DFS queue. The new scheduler works from the end of the block backwards, scheduling instructions which have had all of their uses already scheduled. A simple priority scheme breaks ties between multiple instructions that are ready to schedule simultaneously. Keep track of whether we've scheduled or not, and make print() use the scheduled order if we have. Fix some shift tests that this change tickles. Add unsigned right shift tests. Change-Id: I44164c10bb92ae8ab8f76d7a5180cbafab826ea1 Reviewed-on: https://go-review.googlesource.com/13069 Reviewed-by: Todd Neal --- src/cmd/compile/internal/gc/testdata/arith_ssa.go | 28 +++- src/cmd/compile/internal/ssa/func.go | 2 + src/cmd/compile/internal/ssa/print.go | 12 +- src/cmd/compile/internal/ssa/schedule.go | 176 +++++++++++----------- 4 files changed, 122 insertions(+), 96 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/testdata/arith_ssa.go b/src/cmd/compile/internal/gc/testdata/arith_ssa.go index 032cc8e1cf..e69212e9ad 100644 --- a/src/cmd/compile/internal/gc/testdata/arith_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/arith_ssa.go @@ -68,7 +68,7 @@ func testBitwiseLogic() { failed = true } if want, got := int32(832), testBitwiseLsh_ssa(13, 4, 2); want != got { - println("testBitwiseXor failed, wanted", want, "got", got) + println("testBitwiseLsh failed, wanted", want, "got", got) failed = true } if want, got := int32(0), testBitwiseLsh_ssa(13, 25, 15); want != got { @@ -79,16 +79,28 @@ func testBitwiseLogic() { println("testBitwiseLsh failed, wanted", want, "got", got) failed = true } - if want, got := int32(0), testBitwiseRsh_ssa(-13, 25, 15); want != got { - println("testBitwiseLsh failed, wanted", want, "got", got) + 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("testBitwiseLsh failed, wanted", want, "got", got) + println("testBitwiseRsh failed, wanted", want, "got", got) failed = true } if want, got := int32(-1), testBitwiseRsh_ssa(-13, 25, 15); want != got { - println("testBitwiseLsh failed, wanted", want, "got", 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 } } @@ -123,6 +135,12 @@ func testBitwiseRsh_ssa(a int32, b, c uint32) int32 { return a >> b >> c } +func testBitwiseRshU_ssa(a uint32, b, c uint32) uint32 { + switch { // prevent inlining + } + return a >> b >> c +} + // testSubqToNegq ensures that the SUBQ -> NEGQ translation works correctly. func testSubqToNegq() { want := int64(-318294940372190156) diff --git a/src/cmd/compile/internal/ssa/func.go b/src/cmd/compile/internal/ssa/func.go index ce13075f19..9b6eb7f831 100644 --- a/src/cmd/compile/internal/ssa/func.go +++ b/src/cmd/compile/internal/ssa/func.go @@ -18,6 +18,8 @@ type Func struct { 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 // when stackalloc is done, the size of the stack frame diff --git a/src/cmd/compile/internal/ssa/print.go b/src/cmd/compile/internal/ssa/print.go index c8b90c6f93..54d6f542b3 100644 --- a/src/cmd/compile/internal/ssa/print.go +++ b/src/cmd/compile/internal/ssa/print.go @@ -34,9 +34,19 @@ func fprintFunc(w io.Writer, f *Func) { } } io.WriteString(w, "\n") - n := 0 + + if f.scheduled { + // Order of Values has been decided - print in that order. + for _, v := range b.Values { + fmt.Fprint(w, " ") + fmt.Fprintln(w, v.LongString()) + printed[v.ID] = true + } + continue + } // print phis first since all value cycles contain a phi + n := 0 for _, v := range b.Values { if v.Op != OpPhi { continue diff --git a/src/cmd/compile/internal/ssa/schedule.go b/src/cmd/compile/internal/ssa/schedule.go index 15e8ace391..d1596f25e8 100644 --- a/src/cmd/compile/internal/ssa/schedule.go +++ b/src/cmd/compile/internal/ssa/schedule.go @@ -6,121 +6,117 @@ package ssa // 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 an -// arbitrary valid schedule using a topological sort. TODO(khr): +// 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) { - const ( - unmarked = 0 - found = 1 - expanded = 2 - done = 3 - ) - state := make([]byte, f.NumValues()) - var queue []*Value //stack-like worklist. Contains found and expanded nodes. + // 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([]int, f.NumValues()) + + // scheduling order. We queue values in this list in reverse order. var order []*Value - nextMem := make([]*Value, f.NumValues()) // maps mem values to the next live value - additionalEdges := make([][]*Value, f.NumValues()) + // priority queue of legally schedulable (0 unscheduled uses) values + var priq [4][]*Value + for _, b := range f.Blocks { - // Set the nextMem values for this block. If the previous - // write is from a different block, then its nextMem entry - // might have already been set during processing of an earlier - // block. This loop resets the nextMem entries to be correct - // for this block. + // Compute uses. for _, v := range b.Values { - if v.Type.IsMemory() { + if v.Op != OpPhi { + // Note: if a value is used by a phi, it does not induce + // a scheduling edge because that use is from the + // previous iteration. for _, w := range v.Args { - if w.Type.IsMemory() { - nextMem[w.ID] = v + if w.Block == b { + uses[w.ID]++ } } } } - // Add a anti-dependency between each load v and the memory value n - // following the memory value that v loads from. - // This will enforce the single-live-mem restriction. + // Compute score. Larger numbers are scheduled closer to the end of the block. for _, v := range b.Values { - if v.Type.IsMemory() { - continue - } - for _, w := range v.Args { - if w.Type.IsMemory() && nextMem[w.ID] != nil { - // Filter for intra-block edges. - if n := nextMem[w.ID]; n.Block == b { - additionalEdges[n.ID] = append(additionalEdges[n.ID], v) - } - } + switch { + case v.Op == OpPhi: + // We want all the phis first. + score[v.ID] = 0 + case v.Type.IsMemory(): + // Schedule stores as late as possible. + // This makes sure that loads do not get scheduled + // after a following store (1-live-memory requirement). + score[v.ID] = 2 + 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] = 2 + default: + score[v.ID] = 1 } } + if b.Control != nil { + // Force the control value to be scheduled at the end. + score[b.Control.ID] = 3 + // TODO: some times control values are used by other values + // in the block. So the control value will not appear at + // the very end. Decide if this is a problem or not. + } - order = order[:0] - - // Schedule phis first + // Initialize priority queue with schedulable values. + for i := range priq { + priq[i] = priq[i][:0] + } for _, v := range b.Values { - if v.Op == OpPhi { - // TODO: what if a phi is also a control op? It happens for - // mem ops all the time, which shouldn't matter. But for - // regular ops we might be violating invariants about where - // control ops live. - if v == b.Control && !v.Type.IsMemory() { - f.Unimplementedf("phi is a control op %s %s", v, b) - } - order = append(order, v) + if uses[v.ID] == 0 { + s := score[v.ID] + priq[s] = append(priq[s], v) } } - // Topologically sort the non-phi values in b. - for _, v := range b.Values { - if v.Op == OpPhi { - continue + // 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 == b.Control { - continue + if v == nil { + break } - if state[v.ID] != unmarked { - if state[v.ID] != done { - panic("bad state") + + // Add it to the schedule. + order = append(order, v) + + // Update use counts of arguments. + for _, w := range v.Args { + if w.Block != b { + continue } - continue - } - state[v.ID] = found - queue = append(queue, v) - for len(queue) > 0 { - v = queue[len(queue)-1] - switch state[v.ID] { - case found: - state[v.ID] = expanded - // Note that v is not popped. We leave it in place - // until all its children have been explored. - for _, w := range v.Args { - if w.Block == b && w.Op != OpPhi && w != b.Control && state[w.ID] == unmarked { - state[w.ID] = found - queue = append(queue, w) - } - } - for _, w := range additionalEdges[v.ID] { - if w.Block == b && w.Op != OpPhi && w != b.Control && state[w.ID] == unmarked { - state[w.ID] = found - queue = append(queue, w) - } - } - case expanded: - queue = queue[:len(queue)-1] - state[v.ID] = done - order = append(order, v) - default: - panic("bad state") + 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 b.Control != nil { - order = append(order, b.Control) + 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] } - copy(b.Values, order) } - // TODO: only allow one live flags type (x86) - // This restriction will force and any flag uses to appear before - // the next flag update. This "anti-dependence" is not recorded - // explicitly in ssa form. + + f.scheduled = true } -- cgit v1.3 From faee392814f118d0d1c8103bb46965267e8619f7 Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Mon, 3 Aug 2015 19:28:48 -0500 Subject: [dev.ssa] cmd/compile/ssa : fix typo in error message Change-Id: Ibb5169aade15190773ff7dd11b303c1f1345a0c2 Reviewed-on: https://go-review.googlesource.com/13100 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/regalloc.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index 7e8f2ae354..46efa9859e 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -351,7 +351,7 @@ func regalloc(f *Func) { if b.Kind == BlockCall { call = b.Control if call != b.Values[len(b.Values)-1] { - b.Fatalf("call not at end of block %b %v", b, call) + b.Fatalf("call not at end of block %v %v", b, call) } b.Values = b.Values[:len(b.Values)-1] // TODO: do this for all control types? -- cgit v1.3 From 38ed6c10eb056419256beb03eefe289faa7d545b Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Thu, 30 Jul 2015 16:02:24 -0400 Subject: [dev.ssa] cmd/compile: simplify repeated OCOM Rewrite ^{n}x to be ^{n % 2}x. This will eventually resolve a fuzz issue that breaks v1.5. Updates #11352 Change-Id: I1b3f93872d06222f9ff5f6fd5580178ebaf4c003 Reviewed-on: https://go-review.googlesource.com/13110 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/testdata/arith_ssa.go | 16 +++++ src/cmd/compile/internal/ssa/gen/generic.rules | 5 ++ src/cmd/compile/internal/ssa/rewritegeneric.go | 76 +++++++++++++++++++++++ 3 files changed, 97 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/testdata/arith_ssa.go b/src/cmd/compile/internal/gc/testdata/arith_ssa.go index e69212e9ad..6341e9b90d 100644 --- a/src/cmd/compile/internal/gc/testdata/arith_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/arith_ssa.go @@ -156,6 +156,21 @@ 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 + } +} + +func testOcom_ssa(a, b int32) (int32, int32) { + switch { // prevent inlining + } + return ^^^^a, ^^^^^b +} + var failed = false func main() { @@ -165,6 +180,7 @@ func main() { testRegallocCVSpill() testSubqToNegq() testBitwiseLogic() + testOcom() if failed { panic("failed") diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index 9cc2f1b9ad..cb6a20014d 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -34,6 +34,11 @@ (Neq16 x x) -> (ConstBool {false}) (Neq8 x x) -> (ConstBool {false}) +(Com8 (Com8 x)) -> (Copy x) +(Com16 (Com16 x)) -> (Copy x) +(Com32 (Com32 x)) -> (Copy x) +(Com64 (Com64 x)) -> (Copy x) + // tear apart slices // TODO: anything that generates a slice needs to go in here. (SlicePtr (Load ptr mem)) -> (Load ptr mem) diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index 17608d71c4..bccf81b831 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -76,6 +76,82 @@ func rewriteValuegeneric(v *Value, config *Config) bool { goto end4894dd7b58383fee5f8a92be08437c33 end4894dd7b58383fee5f8a92be08437c33: ; + case OpCom16: + // match: (Com16 (Com16 x)) + // cond: + // result: (Copy x) + { + if v.Args[0].Op != OpCom16 { + goto end388d572e5a72fd87a07da5cab243ebdc + } + x := v.Args[0].Args[0] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end388d572e5a72fd87a07da5cab243ebdc + end388d572e5a72fd87a07da5cab243ebdc: + ; + case OpCom32: + // match: (Com32 (Com32 x)) + // cond: + // result: (Copy x) + { + if v.Args[0].Op != OpCom32 { + goto end5b2b3834acc7313649923604f685e7c5 + } + x := v.Args[0].Args[0] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end5b2b3834acc7313649923604f685e7c5 + end5b2b3834acc7313649923604f685e7c5: + ; + case OpCom64: + // match: (Com64 (Com64 x)) + // cond: + // result: (Copy x) + { + if v.Args[0].Op != OpCom64 { + goto end6d6312f25d06a327d92f028b1ce50566 + } + x := v.Args[0].Args[0] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end6d6312f25d06a327d92f028b1ce50566 + end6d6312f25d06a327d92f028b1ce50566: + ; + case OpCom8: + // match: (Com8 (Com8 x)) + // cond: + // result: (Copy x) + { + if v.Args[0].Op != OpCom8 { + goto end70cbd85c4b8e82c170dba7c23f8bc0f3 + } + x := v.Args[0].Args[0] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end70cbd85c4b8e82c170dba7c23f8bc0f3 + end70cbd85c4b8e82c170dba7c23f8bc0f3: + ; case OpConstString: // match: (ConstString {s}) // cond: -- cgit v1.3 From b8efee0d8ae06b3d2f0057d26d9927b86792a9a6 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Fri, 31 Jul 2015 14:37:15 -0700 Subject: [dev.ssa] cmd/compile: log progs during ssa codegen This is helpful when debugging generated code. Change-Id: I268efa3593a03bb2c4e9f07d9034c004cd40df41 Reviewed-on: https://go-review.googlesource.com/13099 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 36 ++++++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 9422970b98..46bcfab7e4 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1704,19 +1704,41 @@ func genssa(f *ssa.Func, ptxt *obj.Prog, gcargs, gclocals *Sym) { // and where they would like to go var branches []branch + 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 { bstart[b.ID] = Pc // Emit values in block for _, v := range b.Values { + x := Pc 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 { next = f.Blocks[i+1] } + x := Pc branches = genBlock(b, next, branches) + if logProgs { + for ; x != Pc; x = x.Link { + blockProgs[x] = b + } + } } // Resolve branches @@ -1726,6 +1748,20 @@ func genssa(f *ssa.Func, ptxt *obj.Prog, gcargs, gclocals *Sym) { Pc.As = obj.ARET // overwrite AEND + 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) + } + } + // Emit static data if f.StaticData != nil { for _, n := range f.StaticData.([]*Node) { -- cgit v1.3 From 683f5d7bdba38754caf0b45434f8081537799971 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Tue, 4 Aug 2015 12:24:23 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: put new values for block rewrites in rewritten block Don't put them in the control value's block. That may be many blocks up the dominator tree. Change-Id: Iab3ea36a890ffe0e355dadec7aeb676901c4f070 Reviewed-on: https://go-review.googlesource.com/13134 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/ssa/gen/rulegen.go | 5 +- src/cmd/compile/internal/ssa/rewriteAMD64.go | 443 +++++++++++++------------ src/cmd/compile/internal/ssa/rewritegeneric.go | 49 +-- 3 files changed, 250 insertions(+), 247 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/gen/rulegen.go b/src/cmd/compile/internal/ssa/gen/rulegen.go index 4b3775ca98..9edef83246 100644 --- a/src/cmd/compile/internal/ssa/gen/rulegen.go +++ b/src/cmd/compile/internal/ssa/gen/rulegen.go @@ -104,6 +104,7 @@ func genRules(arch arch) { fmt.Fprintln(w, "// generated with: cd gen; go run *.go") fmt.Fprintln(w, "package ssa") fmt.Fprintf(w, "func rewriteValue%s(v *Value, config *Config) bool {\n", arch.name) + fmt.Fprintln(w, "b := v.Block") // generate code for each rule fmt.Fprintf(w, "switch v.Op {\n") @@ -238,7 +239,7 @@ func genRules(arch arch) { // Modify predecessor lists for no-longer-reachable blocks for succ := range m { - fmt.Fprintf(w, "v.Block.Func.removePredecessor(b, %s)\n", succ) + fmt.Fprintf(w, "b.Func.removePredecessor(b, %s)\n", succ) } fmt.Fprintf(w, "b.Kind = %s\n", blockName(t[0], arch)) @@ -397,7 +398,7 @@ func genResult0(w io.Writer, arch arch, result string, alloc *int, top bool) str } else { v = fmt.Sprintf("v%d", *alloc) *alloc++ - fmt.Fprintf(w, "%s := v.Block.NewValue0(v.Line, %s, TypeInvalid)\n", v, opName(s[0], arch)) + fmt.Fprintf(w, "%s := b.NewValue0(v.Line, %s, TypeInvalid)\n", v, opName(s[0], arch)) } for _, a := range s[1:] { if a[0] == '<' { diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 9157989035..5a87169324 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -3,6 +3,7 @@ package ssa func rewriteValueAMD64(v *Value, config *Config) bool { + b := v.Block switch v.Op { case OpAMD64ADDB: // match: (ADDB x (MOVBconst [c])) @@ -1164,7 +1165,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AuxInt = c @@ -1208,7 +1209,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AuxInt = c @@ -1258,7 +1259,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AuxInt = c @@ -1302,7 +1303,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AuxInt = c @@ -1541,7 +1542,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) @@ -1562,7 +1563,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) @@ -1583,7 +1584,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) @@ -1604,7 +1605,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) @@ -1625,7 +1626,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) @@ -1646,7 +1647,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) @@ -1667,7 +1668,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) @@ -1688,7 +1689,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) @@ -1709,7 +1710,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) @@ -1730,7 +1731,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) @@ -1751,7 +1752,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) @@ -1772,7 +1773,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) @@ -1793,7 +1794,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) @@ -1814,7 +1815,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) @@ -1835,7 +1836,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) @@ -1856,7 +1857,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) @@ -1877,7 +1878,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) @@ -1898,7 +1899,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) @@ -1919,7 +1920,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) @@ -1940,7 +1941,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) @@ -1961,7 +1962,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) @@ -1982,7 +1983,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) v0.Type = TypeFlags v0.AddArg(idx) v0.AddArg(len) @@ -2002,7 +2003,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64TESTQ, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64TESTQ, TypeInvalid) v0.Type = TypeFlags v0.AddArg(p) v0.AddArg(p) @@ -2023,7 +2024,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) @@ -2044,7 +2045,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) @@ -2065,7 +2066,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) @@ -2086,7 +2087,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) @@ -2107,7 +2108,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) @@ -2128,7 +2129,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) @@ -2149,7 +2150,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) @@ -2170,7 +2171,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) @@ -2191,7 +2192,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) @@ -2212,7 +2213,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) @@ -2233,7 +2234,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) @@ -2254,7 +2255,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) @@ -2275,7 +2276,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) @@ -2296,7 +2297,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) @@ -2317,7 +2318,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) @@ -2338,7 +2339,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) @@ -2445,14 +2446,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64SHLW, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64SHLW, TypeInvalid) v0.Type = t v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t - v2 := v.Block.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) v2.Type = TypeFlags v2.AuxInt = 16 v2.AddArg(y) @@ -2475,14 +2476,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64SHLW, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64SHLW, TypeInvalid) v0.Type = t v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t - v2 := v.Block.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) v2.Type = TypeFlags v2.AuxInt = 16 v2.AddArg(y) @@ -2505,14 +2506,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64SHLW, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64SHLW, TypeInvalid) v0.Type = t v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t - v2 := v.Block.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) v2.Type = TypeFlags v2.AuxInt = 16 v2.AddArg(y) @@ -2535,14 +2536,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64SHLW, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64SHLW, TypeInvalid) v0.Type = t v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t - v2 := v.Block.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) v2.Type = TypeFlags v2.AuxInt = 16 v2.AddArg(y) @@ -2565,14 +2566,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64SHLL, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64SHLL, TypeInvalid) v0.Type = t v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t - v2 := v.Block.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) v2.Type = TypeFlags v2.AuxInt = 32 v2.AddArg(y) @@ -2595,14 +2596,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64SHLL, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64SHLL, TypeInvalid) v0.Type = t v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t - v2 := v.Block.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) v2.Type = TypeFlags v2.AuxInt = 32 v2.AddArg(y) @@ -2625,14 +2626,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64SHLL, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64SHLL, TypeInvalid) v0.Type = t v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t - v2 := v.Block.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) v2.Type = TypeFlags v2.AuxInt = 32 v2.AddArg(y) @@ -2655,14 +2656,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64SHLL, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64SHLL, TypeInvalid) v0.Type = t v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t - v2 := v.Block.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) v2.Type = TypeFlags v2.AuxInt = 32 v2.AddArg(y) @@ -2685,14 +2686,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64SHLQ, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64SHLQ, TypeInvalid) v0.Type = t v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) v1.Type = t - v2 := v.Block.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) v2.Type = TypeFlags v2.AuxInt = 64 v2.AddArg(y) @@ -2715,14 +2716,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64SHLQ, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64SHLQ, TypeInvalid) v0.Type = t v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) v1.Type = t - v2 := v.Block.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) v2.Type = TypeFlags v2.AuxInt = 64 v2.AddArg(y) @@ -2745,14 +2746,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64SHLQ, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64SHLQ, TypeInvalid) v0.Type = t v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) v1.Type = t - v2 := v.Block.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) v2.Type = TypeFlags v2.AuxInt = 64 v2.AddArg(y) @@ -2775,14 +2776,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64SHLQ, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64SHLQ, TypeInvalid) v0.Type = t v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) v1.Type = t - v2 := v.Block.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) v2.Type = TypeFlags v2.AuxInt = 64 v2.AddArg(y) @@ -2805,14 +2806,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64SHLB, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64SHLB, TypeInvalid) v0.Type = t v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t - v2 := v.Block.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) v2.Type = TypeFlags v2.AuxInt = 8 v2.AddArg(y) @@ -2835,14 +2836,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64SHLB, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64SHLB, TypeInvalid) v0.Type = t v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t - v2 := v.Block.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) v2.Type = TypeFlags v2.AuxInt = 8 v2.AddArg(y) @@ -2865,14 +2866,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64SHLB, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64SHLB, TypeInvalid) v0.Type = t v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t - v2 := v.Block.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) v2.Type = TypeFlags v2.AuxInt = 8 v2.AddArg(y) @@ -2895,14 +2896,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64SHLB, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64SHLB, TypeInvalid) v0.Type = t v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t - v2 := v.Block.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) v2.Type = TypeFlags v2.AuxInt = 8 v2.AddArg(y) @@ -3640,7 +3641,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(dst) v.AddArg(src) - v0 := v.Block.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) v0.Type = config.Frontend().TypeUInt64() v0.AuxInt = size v.AddArg(v0) @@ -3967,7 +3968,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) @@ -3988,7 +3989,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) @@ -4009,7 +4010,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) @@ -4030,7 +4031,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) @@ -4051,7 +4052,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) @@ -4648,14 +4649,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64SHRW, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64SHRW, TypeInvalid) v0.Type = t v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t - v2 := v.Block.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) v2.Type = TypeFlags v2.AuxInt = 16 v2.AddArg(y) @@ -4678,14 +4679,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64SHRW, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64SHRW, TypeInvalid) v0.Type = t v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t - v2 := v.Block.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) v2.Type = TypeFlags v2.AuxInt = 16 v2.AddArg(y) @@ -4708,14 +4709,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64SHRW, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64SHRW, TypeInvalid) v0.Type = t v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t - v2 := v.Block.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) v2.Type = TypeFlags v2.AuxInt = 16 v2.AddArg(y) @@ -4738,14 +4739,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64SHRW, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64SHRW, TypeInvalid) v0.Type = t v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t - v2 := v.Block.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) v2.Type = TypeFlags v2.AuxInt = 16 v2.AddArg(y) @@ -4770,14 +4771,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = t v.AddArg(x) - v0 := v.Block.NewValue0(v.Line, OpAMD64ORW, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64ORW, TypeInvalid) v0.Type = y.Type v0.AddArg(y) - v1 := v.Block.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) v1.Type = y.Type - v2 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v2.Type = y.Type - v3 := v.Block.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v3 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) v3.Type = TypeFlags v3.AuxInt = 16 v3.AddArg(y) @@ -4804,14 +4805,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = t v.AddArg(x) - v0 := v.Block.NewValue0(v.Line, OpAMD64ORL, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64ORL, TypeInvalid) v0.Type = y.Type v0.AddArg(y) - v1 := v.Block.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) v1.Type = y.Type - v2 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v2.Type = y.Type - v3 := v.Block.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v3 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) v3.Type = TypeFlags v3.AuxInt = 16 v3.AddArg(y) @@ -4838,14 +4839,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = t v.AddArg(x) - v0 := v.Block.NewValue0(v.Line, OpAMD64ORQ, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64ORQ, TypeInvalid) v0.Type = y.Type v0.AddArg(y) - v1 := v.Block.NewValue0(v.Line, OpAMD64NOTQ, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64NOTQ, TypeInvalid) v1.Type = y.Type - v2 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) v2.Type = y.Type - v3 := v.Block.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v3 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) v3.Type = TypeFlags v3.AuxInt = 16 v3.AddArg(y) @@ -4872,14 +4873,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = t v.AddArg(x) - v0 := v.Block.NewValue0(v.Line, OpAMD64ORB, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64ORB, TypeInvalid) v0.Type = y.Type v0.AddArg(y) - v1 := v.Block.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) v1.Type = y.Type - v2 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v2.Type = y.Type - v3 := v.Block.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + v3 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) v3.Type = TypeFlags v3.AuxInt = 16 v3.AddArg(y) @@ -4904,14 +4905,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64SHRL, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64SHRL, TypeInvalid) v0.Type = t v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t - v2 := v.Block.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) v2.Type = TypeFlags v2.AuxInt = 32 v2.AddArg(y) @@ -4934,14 +4935,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64SHRL, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64SHRL, TypeInvalid) v0.Type = t v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t - v2 := v.Block.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) v2.Type = TypeFlags v2.AuxInt = 32 v2.AddArg(y) @@ -4964,14 +4965,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64SHRL, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64SHRL, TypeInvalid) v0.Type = t v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t - v2 := v.Block.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) v2.Type = TypeFlags v2.AuxInt = 32 v2.AddArg(y) @@ -4994,14 +4995,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64SHRL, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64SHRL, TypeInvalid) v0.Type = t v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t - v2 := v.Block.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) v2.Type = TypeFlags v2.AuxInt = 32 v2.AddArg(y) @@ -5026,14 +5027,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = t v.AddArg(x) - v0 := v.Block.NewValue0(v.Line, OpAMD64ORW, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64ORW, TypeInvalid) v0.Type = y.Type v0.AddArg(y) - v1 := v.Block.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) v1.Type = y.Type - v2 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v2.Type = y.Type - v3 := v.Block.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v3 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) v3.Type = TypeFlags v3.AuxInt = 32 v3.AddArg(y) @@ -5060,14 +5061,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = t v.AddArg(x) - v0 := v.Block.NewValue0(v.Line, OpAMD64ORL, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64ORL, TypeInvalid) v0.Type = y.Type v0.AddArg(y) - v1 := v.Block.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) v1.Type = y.Type - v2 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v2.Type = y.Type - v3 := v.Block.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v3 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) v3.Type = TypeFlags v3.AuxInt = 32 v3.AddArg(y) @@ -5094,14 +5095,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = t v.AddArg(x) - v0 := v.Block.NewValue0(v.Line, OpAMD64ORQ, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64ORQ, TypeInvalid) v0.Type = y.Type v0.AddArg(y) - v1 := v.Block.NewValue0(v.Line, OpAMD64NOTQ, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64NOTQ, TypeInvalid) v1.Type = y.Type - v2 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) v2.Type = y.Type - v3 := v.Block.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v3 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) v3.Type = TypeFlags v3.AuxInt = 32 v3.AddArg(y) @@ -5128,14 +5129,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = t v.AddArg(x) - v0 := v.Block.NewValue0(v.Line, OpAMD64ORB, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64ORB, TypeInvalid) v0.Type = y.Type v0.AddArg(y) - v1 := v.Block.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) v1.Type = y.Type - v2 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v2.Type = y.Type - v3 := v.Block.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + v3 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) v3.Type = TypeFlags v3.AuxInt = 32 v3.AddArg(y) @@ -5160,14 +5161,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64SHRQ, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64SHRQ, TypeInvalid) v0.Type = t v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) v1.Type = t - v2 := v.Block.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) v2.Type = TypeFlags v2.AuxInt = 64 v2.AddArg(y) @@ -5190,14 +5191,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64SHRQ, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64SHRQ, TypeInvalid) v0.Type = t v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) v1.Type = t - v2 := v.Block.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) v2.Type = TypeFlags v2.AuxInt = 64 v2.AddArg(y) @@ -5220,14 +5221,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64SHRQ, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64SHRQ, TypeInvalid) v0.Type = t v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) v1.Type = t - v2 := v.Block.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) v2.Type = TypeFlags v2.AuxInt = 64 v2.AddArg(y) @@ -5250,14 +5251,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64SHRQ, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64SHRQ, TypeInvalid) v0.Type = t v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) v1.Type = t - v2 := v.Block.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) v2.Type = TypeFlags v2.AuxInt = 64 v2.AddArg(y) @@ -5282,14 +5283,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = t v.AddArg(x) - v0 := v.Block.NewValue0(v.Line, OpAMD64ORW, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64ORW, TypeInvalid) v0.Type = y.Type v0.AddArg(y) - v1 := v.Block.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) v1.Type = y.Type - v2 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v2.Type = y.Type - v3 := v.Block.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v3 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) v3.Type = TypeFlags v3.AuxInt = 64 v3.AddArg(y) @@ -5316,14 +5317,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = t v.AddArg(x) - v0 := v.Block.NewValue0(v.Line, OpAMD64ORL, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64ORL, TypeInvalid) v0.Type = y.Type v0.AddArg(y) - v1 := v.Block.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) v1.Type = y.Type - v2 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v2.Type = y.Type - v3 := v.Block.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v3 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) v3.Type = TypeFlags v3.AuxInt = 64 v3.AddArg(y) @@ -5350,14 +5351,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = t v.AddArg(x) - v0 := v.Block.NewValue0(v.Line, OpAMD64ORQ, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64ORQ, TypeInvalid) v0.Type = y.Type v0.AddArg(y) - v1 := v.Block.NewValue0(v.Line, OpAMD64NOTQ, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64NOTQ, TypeInvalid) v1.Type = y.Type - v2 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) v2.Type = y.Type - v3 := v.Block.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v3 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) v3.Type = TypeFlags v3.AuxInt = 64 v3.AddArg(y) @@ -5384,14 +5385,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = t v.AddArg(x) - v0 := v.Block.NewValue0(v.Line, OpAMD64ORB, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64ORB, TypeInvalid) v0.Type = y.Type v0.AddArg(y) - v1 := v.Block.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) v1.Type = y.Type - v2 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v2.Type = y.Type - v3 := v.Block.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + v3 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) v3.Type = TypeFlags v3.AuxInt = 64 v3.AddArg(y) @@ -5416,14 +5417,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64SHRB, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64SHRB, TypeInvalid) v0.Type = t v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t - v2 := v.Block.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) v2.Type = TypeFlags v2.AuxInt = 8 v2.AddArg(y) @@ -5446,14 +5447,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64SHRB, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64SHRB, TypeInvalid) v0.Type = t v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t - v2 := v.Block.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) v2.Type = TypeFlags v2.AuxInt = 8 v2.AddArg(y) @@ -5476,14 +5477,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64SHRB, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64SHRB, TypeInvalid) v0.Type = t v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t - v2 := v.Block.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) v2.Type = TypeFlags v2.AuxInt = 8 v2.AddArg(y) @@ -5506,14 +5507,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64SHRB, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64SHRB, TypeInvalid) v0.Type = t v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t - v2 := v.Block.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) v2.Type = TypeFlags v2.AuxInt = 8 v2.AddArg(y) @@ -5538,14 +5539,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = t v.AddArg(x) - v0 := v.Block.NewValue0(v.Line, OpAMD64ORW, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64ORW, TypeInvalid) v0.Type = y.Type v0.AddArg(y) - v1 := v.Block.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) v1.Type = y.Type - v2 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v2.Type = y.Type - v3 := v.Block.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v3 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) v3.Type = TypeFlags v3.AuxInt = 8 v3.AddArg(y) @@ -5572,14 +5573,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = t v.AddArg(x) - v0 := v.Block.NewValue0(v.Line, OpAMD64ORL, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64ORL, TypeInvalid) v0.Type = y.Type v0.AddArg(y) - v1 := v.Block.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) v1.Type = y.Type - v2 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v2.Type = y.Type - v3 := v.Block.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v3 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) v3.Type = TypeFlags v3.AuxInt = 8 v3.AddArg(y) @@ -5606,14 +5607,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = t v.AddArg(x) - v0 := v.Block.NewValue0(v.Line, OpAMD64ORQ, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64ORQ, TypeInvalid) v0.Type = y.Type v0.AddArg(y) - v1 := v.Block.NewValue0(v.Line, OpAMD64NOTQ, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64NOTQ, TypeInvalid) v1.Type = y.Type - v2 := v.Block.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) v2.Type = y.Type - v3 := v.Block.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v3 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) v3.Type = TypeFlags v3.AuxInt = 8 v3.AddArg(y) @@ -5640,14 +5641,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = t v.AddArg(x) - v0 := v.Block.NewValue0(v.Line, OpAMD64ORB, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64ORB, TypeInvalid) v0.Type = y.Type v0.AddArg(y) - v1 := v.Block.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) v1.Type = y.Type - v2 := v.Block.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v2.Type = y.Type - v3 := v.Block.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + v3 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) v3.Type = TypeFlags v3.AuxInt = 8 v3.AddArg(y) @@ -6337,7 +6338,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64SUBBconst, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64SUBBconst, TypeInvalid) v0.Type = v.Type v0.AddArg(x) v0.AuxInt = c @@ -6440,7 +6441,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64SUBLconst, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64SUBLconst, TypeInvalid) v0.Type = v.Type v0.AddArg(x) v0.AuxInt = c @@ -6549,7 +6550,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64SUBQconst, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64SUBQconst, TypeInvalid) v0.Type = v.Type v0.AddArg(x) v0.AuxInt = c @@ -6652,7 +6653,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAMD64SUBWconst, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64SUBWconst, TypeInvalid) v0.Type = v.Type v0.AddArg(x) v0.AuxInt = c @@ -7543,7 +7544,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(destptr) - v0 := v.Block.NewValue0(v.Line, OpAMD64MOVBconst, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64MOVBconst, TypeInvalid) v0.Type = config.Frontend().TypeInt8() v0.AuxInt = 0 v.AddArg(v0) @@ -7567,7 +7568,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(destptr) - v0 := v.Block.NewValue0(v.Line, OpAMD64MOVWconst, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64MOVWconst, TypeInvalid) v0.Type = config.Frontend().TypeInt16() v0.AuxInt = 0 v.AddArg(v0) @@ -7591,7 +7592,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(destptr) - v0 := v.Block.NewValue0(v.Line, OpAMD64MOVLconst, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64MOVLconst, TypeInvalid) v0.Type = config.Frontend().TypeInt32() v0.AuxInt = 0 v.AddArg(v0) @@ -7615,7 +7616,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(destptr) - v0 := v.Block.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) v0.Type = config.Frontend().TypeInt64() v0.AuxInt = 0 v.AddArg(v0) @@ -7662,15 +7663,15 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = size % 8 - v0 := v.Block.NewValue0(v.Line, OpOffPtr, TypeInvalid) + v0 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) v0.Type = config.Frontend().TypeUInt64() v0.AuxInt = size - (size % 8) v0.AddArg(destptr) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpAMD64REPSTOSQ, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64REPSTOSQ, TypeInvalid) v1.Type = TypeMem v1.AddArg(destptr) - v2 := v.Block.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) v2.Type = config.Frontend().TypeUInt64() v2.AuxInt = size / 8 v1.AddArg(v2) @@ -8057,7 +8058,7 @@ func rewriteBlockAMD64(b *Block) bool { goto end7e22019fb0effc80f85c05ea30bdb5d9 } b.Kind = BlockAMD64NE - v0 := v.Block.NewValue0(v.Line, OpAMD64TESTB, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64TESTB, TypeInvalid) v0.Type = TypeFlags v0.AddArg(cond) v0.AddArg(cond) diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index bccf81b831..d706fd7a2e 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -3,6 +3,7 @@ package ssa func rewriteValuegeneric(v *Value, config *Config) bool { + b := v.Block switch v.Op { case OpAdd64: // match: (Add64 (Const64 [c]) (Const64 [d])) @@ -65,7 +66,7 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpPtrIndex, TypeInvalid) + v0 := b.NewValue0(v.Line, OpPtrIndex, TypeInvalid) v0.Type = v.Type.PtrTo() v0.AddArg(ptr) v0.AddArg(idx) @@ -162,14 +163,14 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAddr, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAddr, TypeInvalid) v0.Type = config.Frontend().TypeBytePtr() v0.Aux = config.fe.StringData(s.(string)) - v1 := v.Block.NewValue0(v.Line, OpSB, TypeInvalid) + v1 := b.NewValue0(v.Line, OpSB, TypeInvalid) v1.Type = config.Frontend().TypeUintptr() v0.AddArg(v1) v.AddArg(v0) - v2 := v.Block.NewValue0(v.Line, OpConstPtr, TypeInvalid) + v2 := b.NewValue0(v.Line, OpConstPtr, TypeInvalid) v2.Type = config.Frontend().TypeUintptr() v2.AuxInt = int64(len(s.(string))) v.AddArg(v2) @@ -291,12 +292,12 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpLoad, TypeInvalid) + v0 := b.NewValue0(v.Line, OpLoad, TypeInvalid) v0.Type = config.Frontend().TypeUintptr() v0.AddArg(ptr) v0.AddArg(mem) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpConstPtr, TypeInvalid) + v1 := b.NewValue0(v.Line, OpConstPtr, TypeInvalid) v1.Type = config.Frontend().TypeUintptr() v1.AuxInt = 0 v.AddArg(v1) @@ -343,14 +344,14 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpLoad, TypeInvalid) + v0 := b.NewValue0(v.Line, OpLoad, TypeInvalid) v0.Type = config.Frontend().TypeBytePtr() v0.AddArg(ptr) v0.AddArg(mem) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpLoad, TypeInvalid) + v1 := b.NewValue0(v.Line, OpLoad, TypeInvalid) v1.Type = config.Frontend().TypeUintptr() - v2 := v.Block.NewValue0(v.Line, OpOffPtr, TypeInvalid) + v2 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) v2.Type = config.Frontend().TypeBytePtr() v2.AuxInt = config.PtrSize v2.AddArg(ptr) @@ -521,12 +522,12 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpLoad, TypeInvalid) + v0 := b.NewValue0(v.Line, OpLoad, TypeInvalid) v0.Type = config.Frontend().TypeUintptr() v0.AddArg(ptr) v0.AddArg(mem) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpConstPtr, TypeInvalid) + v1 := b.NewValue0(v.Line, OpConstPtr, TypeInvalid) v1.Type = config.Frontend().TypeUintptr() v1.AuxInt = 0 v.AddArg(v1) @@ -548,10 +549,10 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(ptr) - v0 := v.Block.NewValue0(v.Line, OpMulPtr, TypeInvalid) + v0 := b.NewValue0(v.Line, OpMulPtr, TypeInvalid) v0.Type = config.Frontend().TypeUintptr() v0.AddArg(idx) - v1 := v.Block.NewValue0(v.Line, OpConstPtr, TypeInvalid) + v1 := b.NewValue0(v.Line, OpConstPtr, TypeInvalid) v1.Type = config.Frontend().TypeUintptr() v1.AuxInt = t.Elem().Size() v0.AddArg(v1) @@ -575,10 +576,10 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAddPtr, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAddPtr, TypeInvalid) v0.Type = ptr.Type v0.AddArg(ptr) - v1 := v.Block.NewValue0(v.Line, OpConstPtr, TypeInvalid) + v1 := b.NewValue0(v.Line, OpConstPtr, TypeInvalid) v1.Type = config.Frontend().TypeUintptr() v1.AuxInt = config.PtrSize * 2 v0.AddArg(v1) @@ -603,10 +604,10 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpAddPtr, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAddPtr, TypeInvalid) v0.Type = ptr.Type v0.AddArg(ptr) - v1 := v.Block.NewValue0(v.Line, OpConstPtr, TypeInvalid) + v1 := b.NewValue0(v.Line, OpConstPtr, TypeInvalid) v1.Type = config.Frontend().TypeUintptr() v1.AuxInt = config.PtrSize v0.AddArg(v1) @@ -683,19 +684,19 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpOffPtr, TypeInvalid) + v0 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) v0.Type = config.Frontend().TypeBytePtr() v0.AuxInt = config.PtrSize v0.AddArg(dst) v.AddArg(v0) - v1 := v.Block.NewValue0(v.Line, OpStringLen, TypeInvalid) + v1 := b.NewValue0(v.Line, OpStringLen, TypeInvalid) v1.Type = config.Frontend().TypeUintptr() v1.AddArg(str) v.AddArg(v1) - v2 := v.Block.NewValue0(v.Line, OpStore, TypeInvalid) + v2 := b.NewValue0(v.Line, OpStore, TypeInvalid) v2.Type = TypeMem v2.AddArg(dst) - v3 := v.Block.NewValue0(v.Line, OpStringPtr, TypeInvalid) + v3 := b.NewValue0(v.Line, OpStringPtr, TypeInvalid) v3.Type = config.Frontend().TypeBytePtr() v3.AddArg(str) v2.AddArg(v3) @@ -759,7 +760,7 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := v.Block.NewValue0(v.Line, OpOffPtr, TypeInvalid) + v0 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) v0.Type = v.Type.PtrTo() v0.AuxInt = idx v0.AddArg(ptr) @@ -809,7 +810,7 @@ func rewriteBlockgeneric(b *Block) bool { if !(c.(bool)) { goto end9ff0273f9b1657f4afc287562ca889f0 } - v.Block.Func.removePredecessor(b, no) + b.Func.removePredecessor(b, no) b.Kind = BlockPlain b.Control = nil b.Succs = b.Succs[:1] @@ -833,7 +834,7 @@ func rewriteBlockgeneric(b *Block) bool { if !(!c.(bool)) { goto endf401a4553c3c7c6bed64801da7bba076 } - v.Block.Func.removePredecessor(b, yes) + b.Func.removePredecessor(b, yes) b.Kind = BlockPlain b.Control = nil b.Succs = b.Succs[:1] -- cgit v1.3 From 54dca047dd646cfd071fe24cafb57c91a6262992 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Tue, 4 Aug 2015 12:53:05 -0700 Subject: [dev.ssa] cmd/compile: always print block control values They were being omitted after scheduling. Change-Id: Ia20e2dcb61fde9ec854918b958c3897bafd282a6 Reviewed-on: https://go-review.googlesource.com/13140 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/print.go | 1 + 1 file changed, 1 insertion(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/print.go b/src/cmd/compile/internal/ssa/print.go index 54d6f542b3..2f9db4438f 100644 --- a/src/cmd/compile/internal/ssa/print.go +++ b/src/cmd/compile/internal/ssa/print.go @@ -42,6 +42,7 @@ func fprintFunc(w io.Writer, f *Func) { fmt.Fprintln(w, v.LongString()) printed[v.ID] = true } + fmt.Fprintln(w, " "+b.LongString()) continue } -- cgit v1.3 From 573c791e81f4356698e604bb2fdba13518edc736 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Tue, 4 Aug 2015 14:22:29 -0700 Subject: [dev.ssa] cmd/compile: treat control ops as live at end of block Failure to treat control ops as live can lead to them being eliminated when they live in other blocks. Change-Id: I604a1977a3d3884b1f4516bea4e15885ce38272d Reviewed-on: https://go-review.googlesource.com/13138 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/check.go | 7 ++++++ src/cmd/compile/internal/ssa/regalloc.go | 5 ++++- src/cmd/compile/internal/ssa/regalloc_test.go | 32 +++++++++++++++++++++++++++ 3 files changed, 43 insertions(+), 1 deletion(-) create mode 100644 src/cmd/compile/internal/ssa/regalloc_test.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/check.go b/src/cmd/compile/internal/ssa/check.go index 4fe59e08d1..1f6ffc0129 100644 --- a/src/cmd/compile/internal/ssa/check.go +++ b/src/cmd/compile/internal/ssa/check.go @@ -137,6 +137,13 @@ func checkFunc(f *Func) { } } + for _, b := range f.Blocks { + if b.Control != nil { + if !valueMark[b.Control.ID] { + f.Fatalf("control value for %s is missing: %v", b, b.Control) + } + } + } for _, id := range f.bid.free { if blockMark[id] { f.Fatalf("used block b%d in free list", id) diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index 46efa9859e..dac107dd18 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -440,6 +440,9 @@ func live(f *Func) [][]ID { // Start with known live values at the end of the block s.clear() s.addAll(live[b.ID]) + if b.Control != nil { + s.add(b.Control.ID) + } // Propagate backwards to the start of the block // Assumes Values have been scheduled. @@ -456,7 +459,7 @@ func live(f *Func) [][]ID { } // for each predecessor of b, expand its list of live-at-end values - // inv: s contains the values live at the start of b (excluding phi inputs) + // invariant: s contains the values live at the start of b (excluding phi inputs) for i, p := range b.Preds { t.clear() t.addAll(live[p.ID]) 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 0000000000..dcd253ea14 --- /dev/null +++ b/src/cmd/compile/internal/ssa/regalloc_test.go @@ -0,0 +1,32 @@ +// 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", OpArg, TypeMem, 0, ".mem"), + Valu("x", OpAMD64MOVBconst, TypeInt8, 0, 1), + Valu("y", OpAMD64MOVBconst, TypeInt8, 0, 2), + Valu("a", OpAMD64TESTB, TypeBool, 0, nil, "x", "y"), + Valu("b", OpAMD64TESTB, TypeBool, 0, nil, "y", "x"), + If("a", "if", "exit"), + ), + Bloc("if", + If("b", "plain", "exit"), + ), + Bloc("plain", + Goto("exit"), + ), + Bloc("exit", + Exit("mem"), + ), + ) + regalloc(f.f) + checkFunc(f.f) +} -- cgit v1.3 From 9495e45c8077fe2f562a57da8e3593b1779b2d2f Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Tue, 4 Aug 2015 11:13:56 -0700 Subject: [dev.ssa] cmd/compile: make GOSSAFUNC trigger logging I find myself always adding this in temporarily. Make it permanent. Change-Id: I1646b3930a07d0ea01840736ccd449b7fd24f06e Reviewed-on: https://go-review.googlesource.com/13141 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 46bcfab7e4..247eacbee4 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -20,7 +20,7 @@ import ( // it will never return nil, and the bool can be removed. func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { name := fn.Func.Nname.Sym.Name - usessa = strings.HasSuffix(name, "_ssa") + usessa = strings.HasSuffix(name, "_ssa") || name == os.Getenv("GOSSAFUNC") if usessa { fmt.Println("generating SSA for", name) @@ -150,7 +150,7 @@ func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { // TODO: enable codegen more broadly once the codegen stabilizes // and runtime support is in (gc maps, write barriers, etc.) - return s.f, usessa || name == os.Getenv("GOSSAFUNC") || localpkg.Name == os.Getenv("GOSSAPKG") + return s.f, usessa || localpkg.Name == os.Getenv("GOSSAPKG") } type state struct { -- cgit v1.3 From d1c15a0e3ed1ba9c846a35d637c92525f07258a8 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Tue, 4 Aug 2015 15:47:22 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: implement ITAB Implement ITAB, selecting the itable field of an interface. Soften the lowering check to allow lowerings that leave generic but dead ops behind. (The ITAB lowering does this.) Change-Id: Icc84961dd4060d143602f001311aa1d8be0d7fc0 Reviewed-on: https://go-review.googlesource.com/13144 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/gc/ssa.go | 4 ++++ src/cmd/compile/internal/ssa/compile.go | 4 ++++ src/cmd/compile/internal/ssa/gen/AMD64.rules | 2 ++ src/cmd/compile/internal/ssa/gen/genericOps.go | 3 +++ src/cmd/compile/internal/ssa/lower.go | 7 ++++++- src/cmd/compile/internal/ssa/opGen.go | 5 +++++ src/cmd/compile/internal/ssa/rewriteAMD64.go | 21 +++++++++++++++++++++ 7 files changed, 45 insertions(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 247eacbee4..b63b662126 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1247,6 +1247,10 @@ func (s *state) expr(n *Node) *ssa.Value { return s.constInt(Types[TINT], n.Left.Type.Bound) } + case OITAB: + a := s.expr(n.Left) + return s.newValue1(ssa.OpITab, n.Type, a) + case OCALLFUNC, OCALLMETH: left := n.Left static := left.Op == ONAME && left.Class == PFUNC diff --git a/src/cmd/compile/internal/ssa/compile.go b/src/cmd/compile/internal/ssa/compile.go index 001530ae80..9111254a32 100644 --- a/src/cmd/compile/internal/ssa/compile.go +++ b/src/cmd/compile/internal/ssa/compile.go @@ -68,6 +68,7 @@ var passes = [...]pass{ {"lower", lower}, {"lowered cse", cse}, {"lowered deadcode", deadcode}, + {"checkLower", checkLower}, {"critical", critical}, // remove critical edges {"layout", layout}, // schedule blocks {"schedule", schedule}, // schedule values @@ -101,6 +102,9 @@ var passOrder = [...]constraint{ {"schedule", "regalloc"}, // stack allocation requires register allocation {"regalloc", "stackalloc"}, + // checkLower must run after lowering & subsequent dead code elim + {"lower", "checkLower"}, + {"lowered deadcode", "checkLower"}, } func init() { diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index dd34404b70..e7c712eb17 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -228,6 +228,8 @@ (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) diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 7536415216..657973e333 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -244,6 +244,9 @@ var genericOps = []opData{ {name: "StringPtr"}, // ptr(arg0) {name: "StringLen"}, // len(arg0) + // Interfaces + {name: "ITab"}, // arg0=interface, returns itable 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 diff --git a/src/cmd/compile/internal/ssa/lower.go b/src/cmd/compile/internal/ssa/lower.go index 6499dc8565..6f6b885062 100644 --- a/src/cmd/compile/internal/ssa/lower.go +++ b/src/cmd/compile/internal/ssa/lower.go @@ -8,8 +8,13 @@ package ssa func lower(f *Func) { // repeat rewrites until we find no more rewrites applyRewrite(f, f.Config.lowerBlock, f.Config.lowerValue) +} - // Check for unlowered opcodes, fail if we find one. +// 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 && v.Op != OpSP && v.Op != OpSB && v.Op != OpArg && v.Op != OpCopy && v.Op != OpPhi { diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index b0f86a9cbe..e77df40ebd 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -370,6 +370,7 @@ const ( OpStringMake OpStringPtr OpStringLen + OpITab OpStoreReg OpLoadReg OpFwdRef @@ -2773,6 +2774,10 @@ var opcodeTable = [...]opInfo{ name: "StringLen", generic: true, }, + { + name: "ITab", + generic: true, + }, { name: "StoreReg", generic: true, diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 5a87169324..1e7d957f92 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -1972,6 +1972,27 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end22eaafbcfe70447f79d9b3e6cc395bbd end22eaafbcfe70447f79d9b3e6cc395bbd: ; + case OpITab: + // match: (ITab (Load ptr mem)) + // cond: + // result: (MOVQload ptr mem) + { + if v.Args[0].Op != OpLoad { + goto enda49fcae3630a097c78aa58189c90a97a + } + ptr := v.Args[0].Args[0] + mem := v.Args[0].Args[1] + v.Op = OpAMD64MOVQload + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto enda49fcae3630a097c78aa58189c90a97a + enda49fcae3630a097c78aa58189c90a97a: + ; case OpIsInBounds: // match: (IsInBounds idx len) // cond: -- cgit v1.3 From f91ff1a509c41ba0d14c3018f486fb64b3b54425 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Tue, 4 Aug 2015 14:55:35 -0700 Subject: [dev.ssa] cmd/compile: add SSA pass to move values closer to uses MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Even this very simple, restricted initial implementation helps. While running make.bash, it moves 84437 values to new, closer homes. As a concrete example: func f_ssa(i, j int, b bool) int { if !b { return 0 } return i + j } It cuts off one stack slot and two instructions: Before: "".f_ssa t=1 size=96 value=0 args=0x20 locals=0x18 0x0000 00000 (x.go:3) TEXT "".f_ssa(SB), $24-32 0x0000 00000 (x.go:3) SUBQ $24, SP 0x0004 00004 (x.go:3) FUNCDATA $0, "".gcargs·0(SB) 0x0004 00004 (x.go:3) FUNCDATA $1, "".gclocals·1(SB) 0x0004 00004 (x.go:5) MOVQ $0, AX 0x0006 00006 (x.go:3) MOVQ 32(SP), CX 0x000b 00011 (x.go:3) MOVQ 40(SP), DX 0x0010 00016 (x.go:3) LEAQ 48(SP), BX 0x0015 00021 (x.go:3) MOVB (BX), BPB 0x0018 00024 (x.go:3) MOVQ $0, SI 0x001a 00026 (x.go:3) MOVQ SI, 56(SP) 0x001f 00031 (x.go:3) TESTB BPB, BPB 0x0022 00034 (x.go:5) MOVQ AX, (SP) 0x0026 00038 (x.go:3) MOVQ CX, 8(SP) 0x002b 00043 (x.go:3) MOVQ DX, 16(SP) 0x0030 00048 (x.go:4) JEQ 74 0x0032 00050 (x.go:3) MOVQ 8(SP), AX 0x0037 00055 (x.go:3) MOVQ 16(SP), CX 0x003c 00060 (x.go:7) LEAQ (AX)(CX*1), DX 0x0040 00064 (x.go:7) MOVQ DX, 56(SP) 0x0045 00069 (x.go:3) ADDQ $24, SP 0x0049 00073 (x.go:3) RET 0x004a 00074 (x.go:5) MOVQ (SP), AX 0x004e 00078 (x.go:5) MOVQ AX, 56(SP) 0x0053 00083 (x.go:3) JMP 69 After: "".f_ssa t=1 size=80 value=0 args=0x20 locals=0x10 0x0000 00000 (x.go:3) TEXT "".f_ssa(SB), $16-32 0x0000 00000 (x.go:3) SUBQ $16, SP 0x0004 00004 (x.go:3) FUNCDATA $0, "".gcargs·0(SB) 0x0004 00004 (x.go:3) FUNCDATA $1, "".gclocals·1(SB) 0x0004 00004 (x.go:3) MOVQ 32(SP), AX 0x0009 00009 (x.go:3) MOVQ 24(SP), CX 0x000e 00014 (x.go:3) LEAQ 40(SP), DX 0x0013 00019 (x.go:3) MOVB (DX), BL 0x0015 00021 (x.go:3) MOVQ $0, BP 0x0017 00023 (x.go:3) MOVQ BP, 48(SP) 0x001c 00028 (x.go:3) TESTB BL, BL 0x001e 00030 (x.go:3) MOVQ AX, (SP) 0x0022 00034 (x.go:3) MOVQ CX, 8(SP) 0x0027 00039 (x.go:4) JEQ 64 0x0029 00041 (x.go:3) MOVQ 8(SP), AX 0x002e 00046 (x.go:3) MOVQ (SP), CX 0x0032 00050 (x.go:7) LEAQ (AX)(CX*1), DX 0x0036 00054 (x.go:7) MOVQ DX, 48(SP) 0x003b 00059 (x.go:3) ADDQ $16, SP 0x003f 00063 (x.go:3) RET 0x0040 00064 (x.go:5) MOVQ $0, AX 0x0042 00066 (x.go:5) MOVQ AX, 48(SP) 0x0047 00071 (x.go:3) JMP 59 Of course, the old backend is still well ahead: "".f_ssa t=1 size=48 value=0 args=0x20 locals=0x0 0x0000 00000 (x.go:3) TEXT "".f_ssa(SB), $0-32 0x0000 00000 (x.go:3) NOP 0x0000 00000 (x.go:3) NOP 0x0000 00000 (x.go:3) FUNCDATA $0, gclocals·a8eabfc4a4514ed6b3b0c61e9680e440(SB) 0x0000 00000 (x.go:3) FUNCDATA $1, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB) 0x0000 00000 (x.go:4) CMPB "".b+24(FP), $0 0x0005 00005 (x.go:4) JNE 17 0x0007 00007 (x.go:5) MOVQ $0, "".~r3+32(FP) 0x0010 00016 (x.go:5) RET 0x0011 00017 (x.go:7) MOVQ "".i+8(FP), BX 0x0016 00022 (x.go:7) MOVQ "".j+16(FP), BP 0x001b 00027 (x.go:7) ADDQ BP, BX 0x001e 00030 (x.go:7) MOVQ BX, "".~r3+32(FP) 0x0023 00035 (x.go:7) RET Some regalloc improvements should help considerably. Change-Id: I95bb5dd83e56afd70ae4e983f1d32dffd0c3d46a Reviewed-on: https://go-review.googlesource.com/13142 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/compile.go | 6 +++ src/cmd/compile/internal/ssa/tighten.go | 70 +++++++++++++++++++++++++++++++++ 2 files changed, 76 insertions(+) create mode 100644 src/cmd/compile/internal/ssa/tighten.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/compile.go b/src/cmd/compile/internal/ssa/compile.go index 9111254a32..7ab8ddf3dc 100644 --- a/src/cmd/compile/internal/ssa/compile.go +++ b/src/cmd/compile/internal/ssa/compile.go @@ -65,6 +65,7 @@ var passes = [...]pass{ {"generic deadcode", deadcode}, {"dse", dse}, {"fuse", fuse}, + {"tighten", tighten}, // move values closer to their uses {"lower", lower}, {"lowered cse", cse}, {"lowered deadcode", deadcode}, @@ -94,6 +95,11 @@ var passOrder = [...]constraint{ {"nilcheckelim", "generic deadcode"}, // nilcheckelim generates sequences of plain basic blocks {"nilcheckelim", "fuse"}, + // 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 layout blocks until critical edges have been removed {"critical", "layout"}, // regalloc requires the removal of all critical edges diff --git a/src/cmd/compile/internal/ssa/tighten.go b/src/cmd/compile/internal/ssa/tighten.go new file mode 100644 index 0000000000..9cf9a44590 --- /dev/null +++ b/src/cmd/compile/internal/ssa/tighten.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. + +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. +// 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([]int, 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 + + for _, b := range f.Blocks { + for _, v := range b.Values { + for _, w := range v.Args { + 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 { + continue + } + if uses[v.ID] == 1 && 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 + } + } + } + } +} -- cgit v1.3 From e5fe33e546589d57616cf9603781299a3c5751dc Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Wed, 5 Aug 2015 15:51:05 -0700 Subject: [dev.ssa] cmd/compile: respect phi values in tighten Given (say) b1: <- b2 b3 v1 = Phi v2 v3 b2: v2 = ... b3: ... tighten will move v2 to b1, since it is only used in b1. This is wrong; v2 needs to be evaluated before entering b1. Fix it. Change-Id: I2cc3b30e3ffd221cf594e36cec534dfd9cf3c6a7 Reviewed-on: https://go-review.googlesource.com/13264 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/tighten.go | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/tighten.go b/src/cmd/compile/internal/ssa/tighten.go index 9cf9a44590..a43218095e 100644 --- a/src/cmd/compile/internal/ssa/tighten.go +++ b/src/cmd/compile/internal/ssa/tighten.go @@ -8,7 +8,8 @@ package ssa // 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. +// 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. @@ -17,6 +18,9 @@ func tighten(f *Func) { // For each value, the number of blocks in which it is used. uses := make([]int, 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()) @@ -28,11 +32,15 @@ func tighten(f *Func) { for i := range uses { uses[i] = 0 } - // No need to reset home; any relevant values will be written anew anyway + // 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 } @@ -49,7 +57,7 @@ func tighten(f *Func) { if v.Op == OpPhi { continue } - if uses[v.ID] == 1 && home[v.ID] != b && len(v.Args) < 2 { + 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 -- cgit v1.3 From e13954981e6f6575f6813f00a2119550c682d1b5 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Wed, 5 Aug 2015 16:06:39 -0700 Subject: [dev.ssa] cmd/compile: provide better errors for regnum and localOffset failures Change-Id: I2667b0923e17df7cbf08e34ebec1b69a0f2f02b2 Reviewed-on: https://go-review.googlesource.com/13265 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index b63b662126..5c56b370bd 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -2398,8 +2398,14 @@ func regMoveAMD64(width int64) int { // 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 { - return ssaRegToReg[v.Block.Func.RegAlloc[v.ID].(*ssa.Register).Num] + 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] } // localOffset returns the offset below the frame pointer where @@ -2410,7 +2416,7 @@ func localOffset(v *ssa.Value) int64 { reg := v.Block.Func.RegAlloc[v.ID] slot, ok := reg.(*ssa.LocalSlot) if !ok { - v.Unimplementedf("localOffset of non-LocalSlot value: %s", v.LongString()) + v.Unimplementedf("localOffset of non-LocalSlot value: %s\n%s\n", v.LongString(), v.Block.Func) return 0 } return slot.Idx -- cgit v1.3 From 6548b63d6b5151a5063c92d4cffc7d861dfa0ed9 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Wed, 5 Aug 2015 16:11:57 -0700 Subject: [dev.ssa] cmd/compile: don't move OpSP and OpSB values regalloc expects to find all OpSP and OpSB values in the entry block. There is no value to moving them; don't. Change-Id: I775198f03ce7420348721ffc5e7d2bab065465b1 Reviewed-on: https://go-review.googlesource.com/13266 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/regalloc.go | 3 ++- src/cmd/compile/internal/ssa/tighten.go | 7 +++++++ 2 files changed, 9 insertions(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index dac107dd18..9056531634 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -101,7 +101,8 @@ func regalloc(f *Func) { var oldSched []*Value - // Hack to find sp and sb Values and assign them a register. (TODO: make not so hacky) + // Hack to find sp and sb Values and assign them a register. + // TODO: make not so hacky; update the tighten pass when this is done var sp, sb *Value for _, v := range f.Entry.Values { switch v.Op { diff --git a/src/cmd/compile/internal/ssa/tighten.go b/src/cmd/compile/internal/ssa/tighten.go index a43218095e..02b1f701f5 100644 --- a/src/cmd/compile/internal/ssa/tighten.go +++ b/src/cmd/compile/internal/ssa/tighten.go @@ -57,6 +57,13 @@ func tighten(f *Func) { if v.Op == OpPhi { continue } + if v.Op == OpSB || v.Op == OpSP { + // regalloc expects OpSP and OpSB values to be in the entry block, + // so don't move them. + // TODO: Handle this more gracefully in regalloc and + // remove this restriction. + 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, -- cgit v1.3 From 5584523224dba203aab2e984ef6343db56bae249 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Wed, 5 Aug 2015 16:43:49 -0700 Subject: [dev.ssa] cmd/compile: improve error message for phi location mismatch Change-Id: I402841743fcdc287631646039eb149f5cfdf886c Reviewed-on: https://go-review.googlesource.com/13269 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 5c56b370bd..041e321717 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -2111,8 +2111,8 @@ func genValue(v *ssa.Value) { f := v.Block.Func loc := f.RegAlloc[v.ID] for _, a := range v.Args { - if f.RegAlloc[a.ID] != loc { // TODO: .Equal() instead? - v.Fatalf("phi arg at different location than phi %v %v %v %v", v, loc, a, f.RegAlloc[a.ID]) + 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.OpConst8, ssa.OpConst16, ssa.OpConst32, ssa.OpConst64, ssa.OpConstString, ssa.OpConstNil, ssa.OpConstBool: -- cgit v1.3 From cd0cb0a9d6e7c5594e2870239290ff5704de0ef3 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Thu, 6 Aug 2015 09:34:54 -0700 Subject: [dev.ssa] cmd/compile: tidy up register setup No functional changes. The intent is just to make this easier to read and maintain. Change-Id: Iec207546482cd62bcb22eaae8efe5be6c4f15378 Reviewed-on: https://go-review.googlesource.com/13284 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 57 ++++++++++++++++++---------- 1 file changed, 36 insertions(+), 21 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 626e2175a9..0c306cbbcb 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -70,25 +70,40 @@ func init() { return m } - gp := buildReg("AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15") - gpsp := gp | buildReg("SP") - gpspsb := gpsp | buildReg("SB") - flags := buildReg("FLAGS") - gp01 := regInfo{[]regMask{}, 0, []regMask{gp}} - gp11 := regInfo{[]regMask{gpsp}, 0, []regMask{gp}} - gp11sb := regInfo{[]regMask{gpspsb}, 0, []regMask{gp}} - gp21 := regInfo{[]regMask{gpsp, gpsp}, 0, []regMask{gp}} - gp21sb := regInfo{[]regMask{gpspsb, gpsp}, 0, []regMask{gp}} - gp21shift := regInfo{[]regMask{gpsp, buildReg("CX")}, 0, []regMask{gp}} - gp2flags := regInfo{[]regMask{gpsp, gpsp}, 0, []regMask{flags}} - gp1flags := regInfo{[]regMask{gpsp}, 0, []regMask{flags}} - flagsgp1 := regInfo{[]regMask{flags}, 0, []regMask{gp}} - gpload := regInfo{[]regMask{gpspsb, 0}, 0, []regMask{gp}} - gploadidx := regInfo{[]regMask{gpspsb, gpsp, 0}, 0, []regMask{gp}} - gpstore := regInfo{[]regMask{gpspsb, gpsp, 0}, 0, nil} - gpstoreconst := regInfo{[]regMask{gpspsb, 0}, 0, nil} - gpstoreidx := regInfo{[]regMask{gpspsb, gpsp, gpsp, 0}, 0, nil} - flagsgp := regInfo{[]regMask{flags}, 0, []regMask{gp}} + // Common individual register masks + var ( + gp = buildReg("AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15") + gpsp = gp | buildReg("SP") + gpspsb = gpsp | buildReg("SB") + flags = buildReg("FLAGS") + ) + + // Common slices of register masks + var ( + gponly = []regMask{gp} + flagsonly = []regMask{flags} + ) + + // Common regInfo + var ( + gp01 = regInfo{inputs: []regMask{}, outputs: gponly} + gp11 = regInfo{inputs: []regMask{gpsp}, outputs: gponly} + gp11sb = regInfo{inputs: []regMask{gpspsb}, outputs: gponly} + gp21 = regInfo{inputs: []regMask{gpsp, gpsp}, outputs: gponly} + gp21sb = regInfo{inputs: []regMask{gpspsb, gpsp}, outputs: gponly} + gp21shift = regInfo{inputs: []regMask{gpsp, buildReg("CX")}, outputs: gponly} + + gp2flags = regInfo{inputs: []regMask{gpsp, gpsp}, outputs: flagsonly} + gp1flags = regInfo{inputs: []regMask{gpsp}, outputs: flagsonly} + flagsgp = regInfo{inputs: flagsonly, outputs: gponly} + + 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}} + ) // Suffixes encode the bit width of various instructions. // Q = 64 bit, L = 32 bit, W = 16 bit, B = 8 bit @@ -205,8 +220,8 @@ func init() { {name: "NOTW", reg: gp11, asm: "NOTW"}, // ^arg0 {name: "NOTB", reg: gp11, asm: "NOTB"}, // ^arg0 - {name: "SBBQcarrymask", reg: flagsgp1, asm: "SBBQ"}, // (int64)(-1) if carry is set, 0 if carry is clear. - {name: "SBBLcarrymask", reg: flagsgp1, asm: "SBBL"}, // (int32)(-1) if carry is set, 0 if carry is clear. + {name: "SBBQcarrymask", reg: flagsgp, asm: "SBBQ"}, // (int64)(-1) if carry is set, 0 if carry is clear. + {name: "SBBLcarrymask", 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", reg: flagsgp, asm: "SETEQ"}, // extract == condition from arg0 -- cgit v1.3 From f1401f1a1084327c4f24a4403dbc7003867ee009 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Wed, 5 Aug 2015 16:07:13 -0700 Subject: [dev.ssa] cmd/compile: schedule phi control values first Change-Id: I684440dc316625d5572cc12179adbc206e306429 Reviewed-on: https://go-review.googlesource.com/13263 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/schedule.go | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/schedule.go b/src/cmd/compile/internal/ssa/schedule.go index d1596f25e8..9c8e9a1156 100644 --- a/src/cmd/compile/internal/ssa/schedule.go +++ b/src/cmd/compile/internal/ssa/schedule.go @@ -15,7 +15,7 @@ func schedule(f *Func) { uses := make([]int, f.NumValues()) // "priority" for a value - score := make([]int, f.NumValues()) + score := make([]uint8, f.NumValues()) // scheduling order. We queue values in this list in reverse order. var order []*Value @@ -57,8 +57,9 @@ func schedule(f *Func) { score[v.ID] = 1 } } - if b.Control != nil { - // Force the control value to be scheduled at the end. + 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] = 3 // TODO: some times control values are used by other values // in the block. So the control value will not appear at -- cgit v1.3 From ddeee0eed33a675faa4eee289aabfdb25055cbef Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Wed, 5 Aug 2015 11:01:59 -0700 Subject: [dev.ssa] cmd/compile: enforce that all phis are first during regalloc Change-Id: I035708f5d0659b3deef00808d35e1cc8a80215e0 Reviewed-on: https://go-review.googlesource.com/13243 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/regalloc.go | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index 9056531634..b8a2f24c33 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -394,11 +394,16 @@ func regalloc(f *Func) { // immediately preceding the phi's block. func addPhiCopies(f *Func) { for _, b := range f.Blocks { + phis := true // all phis should appear first; confirm that as we go for _, v := range b.Values { - if v.Op != OpPhi { - break // all phis should appear first - } - if v.Type.IsMemory() { // TODO: only "regallocable" types + switch { + case v.Op == OpPhi && !phis: + f.Fatalf("phi var %v not at beginning of block %v:\n%s\n", v, v.Block, f) + break + case v.Op != OpPhi: + phis = false + continue + case v.Type.IsMemory(): // TODO: only "regallocable" types continue } for i, w := range v.Args { -- cgit v1.3 From cfd8dfaa10ab387c6b9c9e620aadab5852a4c76e Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Tue, 4 Aug 2015 21:59:15 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: more checks on ssa structure Make sure all referenced Blocks and Values are really there. Fix deadcode to generate SSA graphs that pass this new test. Change-Id: Ib002ce20e33490eb8c919bd189d209f769d61517 Reviewed-on: https://go-review.googlesource.com/13147 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/ssa/check.go | 29 ++++++++++++++++++++++++++--- src/cmd/compile/internal/ssa/deadcode.go | 16 ++++++++++++++-- 2 files changed, 40 insertions(+), 5 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/check.go b/src/cmd/compile/internal/ssa/check.go index 1f6ffc0129..668828fcd1 100644 --- a/src/cmd/compile/internal/ssa/check.go +++ b/src/cmd/compile/internal/ssa/check.go @@ -137,13 +137,36 @@ func checkFunc(f *Func) { } } + // 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 { - if b.Control != nil { - if !valueMark[b.Control.ID] { - f.Fatalf("control value for %s is missing: %v", b, b.Control) + 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) } } } + + // 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 _, id := range f.bid.free { if blockMark[id] { f.Fatalf("used block b%d in free list", id) diff --git a/src/cmd/compile/internal/ssa/deadcode.go b/src/cmd/compile/internal/ssa/deadcode.go index 04e5b71ceb..426e6865c0 100644 --- a/src/cmd/compile/internal/ssa/deadcode.go +++ b/src/cmd/compile/internal/ssa/deadcode.go @@ -6,7 +6,6 @@ package ssa // deadcode removes dead code from f. func deadcode(f *Func) { - // Find all reachable basic blocks. reachable := make([]bool, f.NumBlocks()) reachable[f.Entry.ID] = true @@ -85,6 +84,11 @@ func deadcode(f *Func) { if len(b.Values) > 0 { b.Fatalf("live values in unreachable block %v: %v", b, b.Values) } + s := b.Succs + b.Succs = nil + for _, c := range s { + f.removePredecessor(b, c) + } f.bid.put(b.ID) } } @@ -108,14 +112,22 @@ func (f *Func) removePredecessor(b, c *Block) { b, c := work[0][0], work[0][1] work = work[1:] - // find index of b in c's predecessor list + // Find index of b in c's predecessor list + // TODO: This could conceivably cause O(n^2) work. Imagine a very + // wide phi in (for example) the return block. If we determine that + // lots of panics won't happen, we remove each edge at a cost of O(n) each. var i int + found := false for j, p := range c.Preds { if p == b { i = j + found = true break } } + if !found { + f.Fatalf("can't find predecessor %v of %v\n", b, c) + } n := len(c.Preds) - 1 c.Preds[i] = c.Preds[n] -- cgit v1.3 From ca088cf4e59a1e9ef97dbbf16f035a152a8ddda8 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Wed, 5 Aug 2015 15:56:31 -0700 Subject: [dev.ssa] cmd/compile: handle phi control values Tests courtesy of Todd Neal. Change-Id: If657c7c7d3cd1ce01e9d9ad79eb6b2110230c0f9 Reviewed-on: https://go-review.googlesource.com/13267 Reviewed-by: Todd Neal Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/testdata/ctl_ssa.go | 53 +++++++++++++++++++++++++ src/cmd/compile/internal/ssa/gen/AMD64.rules | 2 +- src/cmd/compile/internal/ssa/rewriteAMD64.go | 9 ++--- 3 files changed, 57 insertions(+), 7 deletions(-) create mode 100644 src/cmd/compile/internal/gc/testdata/ctl_ssa.go (limited to 'src/cmd') 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 0000000000..7377c9aee8 --- /dev/null +++ b/src/cmd/compile/internal/gc/testdata/ctl_ssa.go @@ -0,0 +1,53 @@ +// 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 + } + } +} + +var failed = false + +func main() { + testPhiControl() + if failed { + panic("failed") + } +} diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index e7c712eb17..ea2311cae0 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -241,7 +241,7 @@ (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) -(If cond yes no) && cond.Op == OpAMD64MOVBload -> (NE (TESTB cond cond) yes no) +(If cond yes no) -> (NE (TESTB cond cond) yes no) (StaticCall [argwid] {target} mem) -> (CALLstatic [argwid] {target} mem) (ClosureCall [argwid] entry closure mem) -> (CALLclosure [argwid] entry closure mem) diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 1e7d957f92..4fa95a4726 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -8068,16 +8068,13 @@ func rewriteBlockAMD64(b *Block) bool { end9bea9963c3c5dfb97249a5feb8287f94: ; // match: (If cond yes no) - // cond: cond.Op == OpAMD64MOVBload + // cond: // result: (NE (TESTB cond cond) yes no) { v := b.Control cond := v yes := b.Succs[0] no := b.Succs[1] - if !(cond.Op == OpAMD64MOVBload) { - goto end7e22019fb0effc80f85c05ea30bdb5d9 - } b.Kind = BlockAMD64NE v0 := b.NewValue0(v.Line, OpAMD64TESTB, TypeInvalid) v0.Type = TypeFlags @@ -8088,8 +8085,8 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end7e22019fb0effc80f85c05ea30bdb5d9 - end7e22019fb0effc80f85c05ea30bdb5d9: + goto end012351592edfc708bd3181d7e53f3993 + end012351592edfc708bd3181d7e53f3993: ; case BlockAMD64LE: // match: (LE (InvertFlags cmp) yes no) -- cgit v1.3 From d2150c83284c06ef3d7e106ca52160a8d1caeca2 Mon Sep 17 00:00:00 2001 From: Alexandru Moșoi Date: Thu, 6 Aug 2015 18:33:49 +0200 Subject: [dev.ssa] cmd/compile/internal/ssa/gen: generate better code when right-shifting with a constant. The lowering rules were missing the non-64 bit case. SBBLcarrymask can be folded to a int32 integer whose type has a smaller bit size. Without the new AND rules the following would be generated: v19 = MOVLconst [-1] : SI v20 = ANDB v18 v19 : DI which is obviously a NOP. Fixes #12022 Change-Id: I5f4209f78edc0f118e5b9b2908739f09cefebca4 Reviewed-on: https://go-review.googlesource.com/13301 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/gen/AMD64.rules | 12 ++ src/cmd/compile/internal/ssa/rewriteAMD64.go | 281 +++++++++++++++++++++++++++ 2 files changed, 293 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index ea2311cae0..2a54bb075a 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -279,8 +279,12 @@ (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) @@ -424,6 +428,14 @@ (SBBQcarrymask (CMPWconst [c] (MOVWconst [d]))) && !inBounds(int64(int16(d)), int64(int16(c))) -> (MOVQconst [0]) (SBBQcarrymask (CMPBconst [c] (MOVBconst [d]))) && inBounds(int64(int8(d)), int64(int8(c))) -> (MOVQconst [-1]) (SBBQcarrymask (CMPBconst [c] (MOVBconst [d]))) && !inBounds(int64(int8(d)), int64(int8(c))) -> (MOVQconst [0]) +(SBBLcarrymask (CMPQconst [c] (MOVQconst [d]))) && inBounds(d, c) -> (MOVLconst [-1]) +(SBBLcarrymask (CMPQconst [c] (MOVQconst [d]))) && !inBounds(d, c) -> (MOVLconst [0]) +(SBBLcarrymask (CMPLconst [c] (MOVLconst [d]))) && inBounds(int64(int32(d)), int64(int32(c))) -> (MOVLconst [-1]) +(SBBLcarrymask (CMPLconst [c] (MOVLconst [d]))) && !inBounds(int64(int32(d)), int64(int32(c))) -> (MOVLconst [0]) +(SBBLcarrymask (CMPWconst [c] (MOVWconst [d]))) && inBounds(int64(int16(d)), int64(int16(c))) -> (MOVLconst [-1]) +(SBBLcarrymask (CMPWconst [c] (MOVWconst [d]))) && !inBounds(int64(int16(d)), int64(int16(c))) -> (MOVLconst [0]) +(SBBLcarrymask (CMPBconst [c] (MOVBconst [d]))) && inBounds(int64(int8(d)), int64(int8(c))) -> (MOVLconst [-1]) +(SBBLcarrymask (CMPBconst [c] (MOVBconst [d]))) && !inBounds(int64(int8(d)), int64(int8(c))) -> (MOVLconst [0]) (ANDQconst [0] _) -> (MOVQconst [0]) (ANDLconst [c] _) && int32(c)==0 -> (MOVLconst [0]) (ANDWconst [c] _) && int16(c)==0 -> (MOVWconst [0]) diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 4fa95a4726..bdcb99174e 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -484,6 +484,46 @@ func rewriteValueAMD64(v *Value, config *Config) bool { end73944f6ddda7e4c050f11d17484ff9a5: ; case OpAMD64ANDB: + // match: (ANDB x (MOVLconst [c])) + // cond: + // result: (ANDBconst [c] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVLconst { + goto end01100cd255396e29bfdb130f4fbc9bbc + } + c := v.Args[1].AuxInt + v.Op = OpAMD64ANDBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end01100cd255396e29bfdb130f4fbc9bbc + end01100cd255396e29bfdb130f4fbc9bbc: + ; + // match: (ANDB (MOVLconst [c]) x) + // cond: + // result: (ANDBconst [c] x) + { + if v.Args[0].Op != OpAMD64MOVLconst { + goto end70830ce2834dc5f8d786fa6789460926 + } + c := v.Args[0].AuxInt + x := v.Args[1] + v.Op = OpAMD64ANDBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end70830ce2834dc5f8d786fa6789460926 + end70830ce2834dc5f8d786fa6789460926: + ; // match: (ANDB x (MOVBconst [c])) // cond: // result: (ANDBconst [c] x) @@ -836,6 +876,46 @@ func rewriteValueAMD64(v *Value, config *Config) bool { end67ca66494705b0345a5f22c710225292: ; case OpAMD64ANDW: + // match: (ANDW x (MOVLconst [c])) + // cond: + // result: (ANDWconst [c] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVLconst { + goto endce6f557823ee2fdd7a8f47b6f925fc7c + } + c := v.Args[1].AuxInt + v.Op = OpAMD64ANDWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto endce6f557823ee2fdd7a8f47b6f925fc7c + endce6f557823ee2fdd7a8f47b6f925fc7c: + ; + // match: (ANDW (MOVLconst [c]) x) + // cond: + // result: (ANDWconst [c] x) + { + if v.Args[0].Op != OpAMD64MOVLconst { + goto endc46af0d9265c08b09f1f1fba24feda80 + } + c := v.Args[0].AuxInt + x := v.Args[1] + v.Op = OpAMD64ANDWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto endc46af0d9265c08b09f1f1fba24feda80 + endc46af0d9265c08b09f1f1fba24feda80: + ; // match: (ANDW x (MOVWconst [c])) // cond: // result: (ANDWconst [c] x) @@ -5766,6 +5846,207 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endc46e3f211f94238f9a0aec3c498af490 endc46e3f211f94238f9a0aec3c498af490: ; + case OpAMD64SBBLcarrymask: + // match: (SBBLcarrymask (CMPQconst [c] (MOVQconst [d]))) + // cond: inBounds(d, c) + // result: (MOVLconst [-1]) + { + if v.Args[0].Op != OpAMD64CMPQconst { + goto enda9e02a887246381d02b3259b9df4050c + } + c := v.Args[0].AuxInt + if v.Args[0].Args[0].Op != OpAMD64MOVQconst { + goto enda9e02a887246381d02b3259b9df4050c + } + d := v.Args[0].Args[0].AuxInt + if !(inBounds(d, c)) { + goto enda9e02a887246381d02b3259b9df4050c + } + v.Op = OpAMD64MOVLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = -1 + return true + } + goto enda9e02a887246381d02b3259b9df4050c + enda9e02a887246381d02b3259b9df4050c: + ; + // match: (SBBLcarrymask (CMPQconst [c] (MOVQconst [d]))) + // cond: !inBounds(d, c) + // result: (MOVLconst [0]) + { + if v.Args[0].Op != OpAMD64CMPQconst { + goto end3f8220527278b72a64148fcf9dc58bfe + } + c := v.Args[0].AuxInt + if v.Args[0].Args[0].Op != OpAMD64MOVQconst { + goto end3f8220527278b72a64148fcf9dc58bfe + } + d := v.Args[0].Args[0].AuxInt + if !(!inBounds(d, c)) { + goto end3f8220527278b72a64148fcf9dc58bfe + } + v.Op = OpAMD64MOVLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end3f8220527278b72a64148fcf9dc58bfe + end3f8220527278b72a64148fcf9dc58bfe: + ; + // match: (SBBLcarrymask (CMPLconst [c] (MOVLconst [d]))) + // cond: inBounds(int64(int32(d)), int64(int32(c))) + // result: (MOVLconst [-1]) + { + if v.Args[0].Op != OpAMD64CMPLconst { + goto end880a2b9a12ed4f551bbd46473b9439bc + } + c := v.Args[0].AuxInt + if v.Args[0].Args[0].Op != OpAMD64MOVLconst { + goto end880a2b9a12ed4f551bbd46473b9439bc + } + d := v.Args[0].Args[0].AuxInt + if !(inBounds(int64(int32(d)), int64(int32(c)))) { + goto end880a2b9a12ed4f551bbd46473b9439bc + } + v.Op = OpAMD64MOVLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = -1 + return true + } + goto end880a2b9a12ed4f551bbd46473b9439bc + end880a2b9a12ed4f551bbd46473b9439bc: + ; + // match: (SBBLcarrymask (CMPLconst [c] (MOVLconst [d]))) + // cond: !inBounds(int64(int32(d)), int64(int32(c))) + // result: (MOVLconst [0]) + { + if v.Args[0].Op != OpAMD64CMPLconst { + goto end3f08080e0f55d51afca2a131ed0c672e + } + c := v.Args[0].AuxInt + if v.Args[0].Args[0].Op != OpAMD64MOVLconst { + goto end3f08080e0f55d51afca2a131ed0c672e + } + d := v.Args[0].Args[0].AuxInt + if !(!inBounds(int64(int32(d)), int64(int32(c)))) { + goto end3f08080e0f55d51afca2a131ed0c672e + } + v.Op = OpAMD64MOVLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end3f08080e0f55d51afca2a131ed0c672e + end3f08080e0f55d51afca2a131ed0c672e: + ; + // match: (SBBLcarrymask (CMPWconst [c] (MOVWconst [d]))) + // cond: inBounds(int64(int16(d)), int64(int16(c))) + // result: (MOVLconst [-1]) + { + if v.Args[0].Op != OpAMD64CMPWconst { + goto end91ed02166e0c0d696730e1704d0a682e + } + c := v.Args[0].AuxInt + if v.Args[0].Args[0].Op != OpAMD64MOVWconst { + goto end91ed02166e0c0d696730e1704d0a682e + } + d := v.Args[0].Args[0].AuxInt + if !(inBounds(int64(int16(d)), int64(int16(c)))) { + goto end91ed02166e0c0d696730e1704d0a682e + } + v.Op = OpAMD64MOVLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = -1 + return true + } + goto end91ed02166e0c0d696730e1704d0a682e + end91ed02166e0c0d696730e1704d0a682e: + ; + // match: (SBBLcarrymask (CMPWconst [c] (MOVWconst [d]))) + // cond: !inBounds(int64(int16(d)), int64(int16(c))) + // result: (MOVLconst [0]) + { + if v.Args[0].Op != OpAMD64CMPWconst { + goto endc7edc3a13ec73ec4e6e87e7ab421a71a + } + c := v.Args[0].AuxInt + if v.Args[0].Args[0].Op != OpAMD64MOVWconst { + goto endc7edc3a13ec73ec4e6e87e7ab421a71a + } + d := v.Args[0].Args[0].AuxInt + if !(!inBounds(int64(int16(d)), int64(int16(c)))) { + goto endc7edc3a13ec73ec4e6e87e7ab421a71a + } + v.Op = OpAMD64MOVLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto endc7edc3a13ec73ec4e6e87e7ab421a71a + endc7edc3a13ec73ec4e6e87e7ab421a71a: + ; + // match: (SBBLcarrymask (CMPBconst [c] (MOVBconst [d]))) + // cond: inBounds(int64(int8(d)), int64(int8(c))) + // result: (MOVLconst [-1]) + { + if v.Args[0].Op != OpAMD64CMPBconst { + goto end0fe2997fc76ce00b1d496f7289ab345a + } + c := v.Args[0].AuxInt + if v.Args[0].Args[0].Op != OpAMD64MOVBconst { + goto end0fe2997fc76ce00b1d496f7289ab345a + } + d := v.Args[0].Args[0].AuxInt + if !(inBounds(int64(int8(d)), int64(int8(c)))) { + goto end0fe2997fc76ce00b1d496f7289ab345a + } + v.Op = OpAMD64MOVLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = -1 + return true + } + goto end0fe2997fc76ce00b1d496f7289ab345a + end0fe2997fc76ce00b1d496f7289ab345a: + ; + // match: (SBBLcarrymask (CMPBconst [c] (MOVBconst [d]))) + // cond: !inBounds(int64(int8(d)), int64(int8(c))) + // result: (MOVLconst [0]) + { + if v.Args[0].Op != OpAMD64CMPBconst { + goto end3a07121fcc82f1a19da4226b07a757ce + } + c := v.Args[0].AuxInt + if v.Args[0].Args[0].Op != OpAMD64MOVBconst { + goto end3a07121fcc82f1a19da4226b07a757ce + } + d := v.Args[0].Args[0].AuxInt + if !(!inBounds(int64(int8(d)), int64(int8(c)))) { + goto end3a07121fcc82f1a19da4226b07a757ce + } + v.Op = OpAMD64MOVLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end3a07121fcc82f1a19da4226b07a757ce + end3a07121fcc82f1a19da4226b07a757ce: + ; case OpAMD64SBBQcarrymask: // match: (SBBQcarrymask (CMPQconst [c] (MOVQconst [d]))) // cond: inBounds(d, c) -- cgit v1.3 From 0fb818a424889a1f12c386fa5fb29814957678cd Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Wed, 5 Aug 2015 10:33:09 -0700 Subject: [dev.ssa] cmd/compile: copy values during rewrites Rather than require an explicit Copy on the RHS of rewrite rules, use rulegen magic to add it. The advantages to handling this in rulegen are: * simpler rules * harder to accidentally miss a Copy Change-Id: I46853bade83bdf517eee9495bf5a553175277b53 Reviewed-on: https://go-review.googlesource.com/13242 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/gen/AMD64.rules | 50 +++--- src/cmd/compile/internal/ssa/gen/generic.rules | 8 +- src/cmd/compile/internal/ssa/gen/rulegen.go | 12 +- src/cmd/compile/internal/ssa/rewriteAMD64.go | 213 ++++++++++++++----------- src/cmd/compile/internal/ssa/rewritegeneric.go | 54 ++++--- 5 files changed, 186 insertions(+), 151 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 2a54bb075a..1e9f615805 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -71,12 +71,12 @@ (ZeroExt32to64 x) -> (MOVLQZX x) // Because we ignore high parts of registers, truncates are just copies. -(Trunc16to8 x) -> (Copy x) -(Trunc32to8 x) -> (Copy x) -(Trunc32to16 x) -> (Copy x) -(Trunc64to8 x) -> (Copy x) -(Trunc64to16 x) -> (Copy x) -(Trunc64to32 x) -> (Copy x) +(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. @@ -338,7 +338,7 @@ // strength reduction (MULQconst [-1] x) -> (NEGQ x) (MULQconst [0] _) -> (MOVQconst [0]) -(MULQconst [1] x) -> (Copy x) +(MULQconst [1] x) -> x (MULQconst [3] x) -> (LEAQ2 x x) (MULQconst [5] x) -> (LEAQ4 x x) (MULQconst [9] x) -> (LEAQ8 x x) @@ -393,10 +393,10 @@ (MOVQloadidx8 [off1] (ADDQconst [off2] ptr) idx mem) -> (MOVQloadidx8 [addOff(off1, off2)] ptr idx mem) (MOVQstoreidx8 [off1] (ADDQconst [off2] ptr) idx val mem) -> (MOVQstoreidx8 [addOff(off1, off2)] ptr idx val mem) -(ADDQconst [0] x) -> (Copy x) +(ADDQconst [0] x) -> x // lower Zero instructions with word sizes -(Zero [0] _ mem) -> (Copy mem) +(Zero [0] _ mem) -> mem (Zero [1] destptr mem) -> (MOVBstore destptr (MOVBconst [0]) mem) (Zero [2] destptr mem) -> (MOVWstore destptr (MOVWconst [0]) mem) (Zero [4] destptr mem) -> (MOVLstore destptr (MOVLconst [0]) mem) @@ -440,14 +440,14 @@ (ANDLconst [c] _) && int32(c)==0 -> (MOVLconst [0]) (ANDWconst [c] _) && int16(c)==0 -> (MOVWconst [0]) (ANDBconst [c] _) && int8(c)==0 -> (MOVBconst [0]) -(ANDQconst [-1] x) -> (Copy x) -(ANDLconst [c] x) && int32(c)==-1 -> (Copy x) -(ANDWconst [c] x) && int16(c)==-1 -> (Copy x) -(ANDBconst [c] x) && int8(c)==-1 -> (Copy x) -(ORQconst [0] x) -> (Copy x) -(ORLconst [c] x) && int32(c)==0 -> (Copy x) -(ORWconst [c] x) && int16(c)==0 -> (Copy x) -(ORBconst [c] x) && int8(c)==0 -> (Copy x) +(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]) @@ -505,14 +505,14 @@ (SUBL x x) -> (MOVLconst [0]) (SUBW x x) -> (MOVWconst [0]) (SUBB x x) -> (MOVBconst [0]) -(ANDQ x x) -> (Copy x) -(ANDL x x) -> (Copy x) -(ANDW x x) -> (Copy x) -(ANDB x x) -> (Copy x) -(ORQ x x) -> (Copy x) -(ORL x x) -> (Copy x) -(ORW x x) -> (Copy x) -(ORB x x) -> (Copy x) +(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]) diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index cb6a20014d..8656b7cc4f 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -34,10 +34,10 @@ (Neq16 x x) -> (ConstBool {false}) (Neq8 x x) -> (ConstBool {false}) -(Com8 (Com8 x)) -> (Copy x) -(Com16 (Com16 x)) -> (Copy x) -(Com32 (Com32 x)) -> (Copy x) -(Com64 (Com64 x)) -> (Copy x) +(Com8 (Com8 x)) -> x +(Com16 (Com16 x)) -> x +(Com32 (Com32 x)) -> x +(Com64 (Com64 x)) -> x // tear apart slices // TODO: anything that generates a slice needs to go in here. diff --git a/src/cmd/compile/internal/ssa/gen/rulegen.go b/src/cmd/compile/internal/ssa/gen/rulegen.go index 9edef83246..6ee22c1345 100644 --- a/src/cmd/compile/internal/ssa/gen/rulegen.go +++ b/src/cmd/compile/internal/ssa/gen/rulegen.go @@ -376,11 +376,15 @@ func genResult0(w io.Writer, arch arch, result string, alloc *int, top bool) str if result[0] != '(' { // variable if top { - fmt.Fprintf(w, "v.Op = %s.Op\n", result) - fmt.Fprintf(w, "v.AuxInt = %s.AuxInt\n", result) - fmt.Fprintf(w, "v.Aux = %s.Aux\n", result) + // 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.Op = OpCopy\n") + fmt.Fprintf(w, "v.AuxInt = 0\n") + fmt.Fprintf(w, "v.Aux = nil\n") fmt.Fprintf(w, "v.resetArgs()\n") - fmt.Fprintf(w, "v.AddArgs(%s.Args...)\n", result) + fmt.Fprintf(w, "v.Type = %s.Type\n", result) + fmt.Fprintf(w, "v.AddArg(%s)\n", result) } return result } diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index bdcb99174e..327f322592 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -325,21 +325,22 @@ func rewriteValueAMD64(v *Value, config *Config) bool { ; // match: (ADDQconst [0] x) // cond: - // result: (Copy x) + // result: x { if v.AuxInt != 0 { - goto end288952f259d4a1842f1e8d5c389b3f28 + goto end03d9f5a3e153048b0afa781401e2a849 } x := v.Args[0] v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.Type = x.Type v.AddArg(x) return true } - goto end288952f259d4a1842f1e8d5c389b3f28 - end288952f259d4a1842f1e8d5c389b3f28: + goto end03d9f5a3e153048b0afa781401e2a849 + end03d9f5a3e153048b0afa781401e2a849: ; // match: (ADDQconst [c] (MOVQconst [d])) // cond: @@ -566,21 +567,22 @@ func rewriteValueAMD64(v *Value, config *Config) bool { ; // match: (ANDB x x) // cond: - // result: (Copy x) + // result: x { x := v.Args[0] if v.Args[1] != x { - goto end1c1e017efac06c84c72f2d09d6afadc0 + goto endb8ff272a1456513da708603abe37541c } v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.Type = x.Type v.AddArg(x) return true } - goto end1c1e017efac06c84c72f2d09d6afadc0 - end1c1e017efac06c84c72f2d09d6afadc0: + goto endb8ff272a1456513da708603abe37541c + endb8ff272a1456513da708603abe37541c: ; case OpAMD64ANDBconst: // match: (ANDBconst [c] _) @@ -603,22 +605,23 @@ func rewriteValueAMD64(v *Value, config *Config) bool { ; // match: (ANDBconst [c] x) // cond: int8(c)==-1 - // result: (Copy x) + // result: x { c := v.AuxInt x := v.Args[0] if !(int8(c) == -1) { - goto ende983ac58fd9834f2c8503e92e45d83db + goto enda0b78503c204c8225de1433949a71fe4 } v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.Type = x.Type v.AddArg(x) return true } - goto ende983ac58fd9834f2c8503e92e45d83db - ende983ac58fd9834f2c8503e92e45d83db: + goto enda0b78503c204c8225de1433949a71fe4 + enda0b78503c204c8225de1433949a71fe4: ; // match: (ANDBconst [c] (MOVBconst [d])) // cond: @@ -682,21 +685,22 @@ func rewriteValueAMD64(v *Value, config *Config) bool { ; // match: (ANDL x x) // cond: - // result: (Copy x) + // result: x { x := v.Args[0] if v.Args[1] != x { - goto end0ff7ad77f6811c422b0b588f48474ddc + goto enddfb08a0d0c262854db3905cb323388c7 } v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.Type = x.Type v.AddArg(x) return true } - goto end0ff7ad77f6811c422b0b588f48474ddc - end0ff7ad77f6811c422b0b588f48474ddc: + goto enddfb08a0d0c262854db3905cb323388c7 + enddfb08a0d0c262854db3905cb323388c7: ; case OpAMD64ANDLconst: // match: (ANDLconst [c] _) @@ -719,22 +723,23 @@ func rewriteValueAMD64(v *Value, config *Config) bool { ; // match: (ANDLconst [c] x) // cond: int32(c)==-1 - // result: (Copy x) + // result: x { c := v.AuxInt x := v.Args[0] if !(int32(c) == -1) { - goto enda670b6e074269a5e1fcbdaec05596a28 + goto end0e852ae30bb8289d6ffee0c9267e3e0c } v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.Type = x.Type v.AddArg(x) return true } - goto enda670b6e074269a5e1fcbdaec05596a28 - enda670b6e074269a5e1fcbdaec05596a28: + goto end0e852ae30bb8289d6ffee0c9267e3e0c + end0e852ae30bb8289d6ffee0c9267e3e0c: ; // match: (ANDLconst [c] (MOVLconst [d])) // cond: @@ -804,21 +809,22 @@ func rewriteValueAMD64(v *Value, config *Config) bool { ; // match: (ANDQ x x) // cond: - // result: (Copy x) + // result: x { x := v.Args[0] if v.Args[1] != x { - goto endb54d87d7a12ba29a9d19b808319ab055 + goto end06b5ec19efdd4e79f03a5e4a2c3c3427 } v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.Type = x.Type v.AddArg(x) return true } - goto endb54d87d7a12ba29a9d19b808319ab055 - endb54d87d7a12ba29a9d19b808319ab055: + goto end06b5ec19efdd4e79f03a5e4a2c3c3427 + end06b5ec19efdd4e79f03a5e4a2c3c3427: ; case OpAMD64ANDQconst: // match: (ANDQconst [0] _) @@ -840,21 +846,22 @@ func rewriteValueAMD64(v *Value, config *Config) bool { ; // match: (ANDQconst [-1] x) // cond: - // result: (Copy x) + // result: x { if v.AuxInt != -1 { - goto end993d44ced14a02748f2d0e77230e8991 + goto endb542c4b42ab94a7bedb32dec8f610d67 } x := v.Args[0] v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.Type = x.Type v.AddArg(x) return true } - goto end993d44ced14a02748f2d0e77230e8991 - end993d44ced14a02748f2d0e77230e8991: + goto endb542c4b42ab94a7bedb32dec8f610d67 + endb542c4b42ab94a7bedb32dec8f610d67: ; // match: (ANDQconst [c] (MOVQconst [d])) // cond: @@ -958,21 +965,22 @@ func rewriteValueAMD64(v *Value, config *Config) bool { ; // match: (ANDW x x) // cond: - // result: (Copy x) + // result: x { x := v.Args[0] if v.Args[1] != x { - goto end08c49eea4ac769acc212ebd833934be8 + goto end3a26cf52dd1b77f07cc9e005760dbb11 } v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.Type = x.Type v.AddArg(x) return true } - goto end08c49eea4ac769acc212ebd833934be8 - end08c49eea4ac769acc212ebd833934be8: + goto end3a26cf52dd1b77f07cc9e005760dbb11 + end3a26cf52dd1b77f07cc9e005760dbb11: ; case OpAMD64ANDWconst: // match: (ANDWconst [c] _) @@ -995,22 +1003,23 @@ func rewriteValueAMD64(v *Value, config *Config) bool { ; // match: (ANDWconst [c] x) // cond: int16(c)==-1 - // result: (Copy x) + // result: x { c := v.AuxInt x := v.Args[0] if !(int16(c) == -1) { - goto ende01402832ff041ac3e12fc077684125f + goto endfb111c3afa8c5c4040fa6000fadee810 } v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.Type = x.Type v.AddArg(x) return true } - goto ende01402832ff041ac3e12fc077684125f - ende01402832ff041ac3e12fc077684125f: + goto endfb111c3afa8c5c4040fa6000fadee810 + endfb111c3afa8c5c4040fa6000fadee810: ; // match: (ANDWconst [c] (MOVWconst [d])) // cond: @@ -3554,21 +3563,22 @@ func rewriteValueAMD64(v *Value, config *Config) bool { ; // match: (MULQconst [1] x) // cond: - // result: (Copy x) + // result: x { if v.AuxInt != 1 { - goto endd7217a7c6311fc7a3e0736a1b0b5be73 + goto end0b527e71db2b288b2841a1f757aa580d } x := v.Args[0] v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.Type = x.Type v.AddArg(x) return true } - goto endd7217a7c6311fc7a3e0736a1b0b5be73 - endd7217a7c6311fc7a3e0736a1b0b5be73: + goto end0b527e71db2b288b2841a1f757aa580d + end0b527e71db2b288b2841a1f757aa580d: ; // match: (MULQconst [3] x) // cond: @@ -4223,41 +4233,43 @@ func rewriteValueAMD64(v *Value, config *Config) bool { ; // match: (ORB x x) // cond: - // result: (Copy x) + // result: x { x := v.Args[0] if v.Args[1] != x { - goto endd53ede4886d67f4b4ae970316a2febb4 + goto enddca5ce800a9eca157f243cb2fdb1408a } v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.Type = x.Type v.AddArg(x) return true } - goto endd53ede4886d67f4b4ae970316a2febb4 - endd53ede4886d67f4b4ae970316a2febb4: + goto enddca5ce800a9eca157f243cb2fdb1408a + enddca5ce800a9eca157f243cb2fdb1408a: ; case OpAMD64ORBconst: // match: (ORBconst [c] x) // cond: int8(c)==0 - // result: (Copy x) + // result: x { c := v.AuxInt x := v.Args[0] if !(int8(c) == 0) { - goto end3b9f6d1a1a523595d101f89410f453a1 + goto end565f78e3a843dc73943b59227b39a1b3 } v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.Type = x.Type v.AddArg(x) return true } - goto end3b9f6d1a1a523595d101f89410f453a1 - end3b9f6d1a1a523595d101f89410f453a1: + goto end565f78e3a843dc73943b59227b39a1b3 + end565f78e3a843dc73943b59227b39a1b3: ; // match: (ORBconst [c] _) // cond: int8(c)==-1 @@ -4339,41 +4351,43 @@ func rewriteValueAMD64(v *Value, config *Config) bool { ; // match: (ORL x x) // cond: - // result: (Copy x) + // result: x { x := v.Args[0] if v.Args[1] != x { - goto end556b9151cacb9db2803373ce10829b2a + goto end2dd719b68f4938777ef0d820aab93659 } v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.Type = x.Type v.AddArg(x) return true } - goto end556b9151cacb9db2803373ce10829b2a - end556b9151cacb9db2803373ce10829b2a: + goto end2dd719b68f4938777ef0d820aab93659 + end2dd719b68f4938777ef0d820aab93659: ; case OpAMD64ORLconst: // match: (ORLconst [c] x) // cond: int32(c)==0 - // result: (Copy x) + // result: x { c := v.AuxInt x := v.Args[0] if !(int32(c) == 0) { - goto end800adaf85f4201ebf7a0e38dc1768c86 + goto end5b52623a724e8a7167c71289fb7192f1 } v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.Type = x.Type v.AddArg(x) return true } - goto end800adaf85f4201ebf7a0e38dc1768c86 - end800adaf85f4201ebf7a0e38dc1768c86: + goto end5b52623a724e8a7167c71289fb7192f1 + end5b52623a724e8a7167c71289fb7192f1: ; // match: (ORLconst [c] _) // cond: int32(c)==-1 @@ -4461,40 +4475,42 @@ func rewriteValueAMD64(v *Value, config *Config) bool { ; // match: (ORQ x x) // cond: - // result: (Copy x) + // result: x { x := v.Args[0] if v.Args[1] != x { - goto endcad306e115ea011a2a70f4e4e5440de4 + goto end47a27d30b82db576978c5a3a57b520fb } v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.Type = x.Type v.AddArg(x) return true } - goto endcad306e115ea011a2a70f4e4e5440de4 - endcad306e115ea011a2a70f4e4e5440de4: + goto end47a27d30b82db576978c5a3a57b520fb + end47a27d30b82db576978c5a3a57b520fb: ; case OpAMD64ORQconst: // match: (ORQconst [0] x) // cond: - // result: (Copy x) + // result: x { if v.AuxInt != 0 { - goto end98a286fc50bc6cf8ca9f5af523e2b5cd + goto end44534da6b9ce98d33fad7e20f0be1fbd } x := v.Args[0] v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.Type = x.Type v.AddArg(x) return true } - goto end98a286fc50bc6cf8ca9f5af523e2b5cd - end98a286fc50bc6cf8ca9f5af523e2b5cd: + goto end44534da6b9ce98d33fad7e20f0be1fbd + end44534da6b9ce98d33fad7e20f0be1fbd: ; // match: (ORQconst [-1] _) // cond: @@ -4575,41 +4591,43 @@ func rewriteValueAMD64(v *Value, config *Config) bool { ; // match: (ORW x x) // cond: - // result: (Copy x) + // result: x { x := v.Args[0] if v.Args[1] != x { - goto end7c69794f4a3a6ada00bd868f743d86f8 + goto endc6a23b64e541dc9cfc6a90fd7028e8c1 } v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.Type = x.Type v.AddArg(x) return true } - goto end7c69794f4a3a6ada00bd868f743d86f8 - end7c69794f4a3a6ada00bd868f743d86f8: + goto endc6a23b64e541dc9cfc6a90fd7028e8c1 + endc6a23b64e541dc9cfc6a90fd7028e8c1: ; case OpAMD64ORWconst: // match: (ORWconst [c] x) // cond: int16(c)==0 - // result: (Copy x) + // result: x { c := v.AuxInt x := v.Args[0] if !(int16(c) == 0) { - goto end61a4fd5308425b3eafd158f13aaf8f13 + goto endbbbdec9091c8b4c58e587eac8a43402d } v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.Type = x.Type v.AddArg(x) return true } - goto end61a4fd5308425b3eafd158f13aaf8f13 - end61a4fd5308425b3eafd158f13aaf8f13: + goto endbbbdec9091c8b4c58e587eac8a43402d + endbbbdec9091c8b4c58e587eac8a43402d: ; // match: (ORWconst [c] _) // cond: int16(c)==-1 @@ -7326,98 +7344,104 @@ func rewriteValueAMD64(v *Value, config *Config) bool { case OpTrunc16to8: // match: (Trunc16to8 x) // cond: - // result: (Copy x) + // result: x { x := v.Args[0] v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.Type = x.Type v.AddArg(x) return true } - goto end18a19bd8418f9079595720df0874e90a - end18a19bd8418f9079595720df0874e90a: + goto end8e2f5e0a6e3a06423c077747de6c2bdd + end8e2f5e0a6e3a06423c077747de6c2bdd: ; case OpTrunc32to16: // match: (Trunc32to16 x) // cond: - // result: (Copy x) + // result: x { x := v.Args[0] v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.Type = x.Type v.AddArg(x) return true } - goto end217b00780a8b1139d068680ed9d61cb0 - end217b00780a8b1139d068680ed9d61cb0: + goto end5bed0e3a3c1c6374d86beb5a4397708c + end5bed0e3a3c1c6374d86beb5a4397708c: ; case OpTrunc32to8: // match: (Trunc32to8 x) // cond: - // result: (Copy x) + // result: x { x := v.Args[0] v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.Type = x.Type v.AddArg(x) return true } - goto end05d10e0a1c707d66b11b2d342634efd0 - end05d10e0a1c707d66b11b2d342634efd0: + goto endef0b8032ce91979ce6cd0004260c04ee + endef0b8032ce91979ce6cd0004260c04ee: ; case OpTrunc64to16: // match: (Trunc64to16 x) // cond: - // result: (Copy x) + // result: x { x := v.Args[0] v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.Type = x.Type v.AddArg(x) return true } - goto end4623ae65eb76feca3936354f22d45fa7 - end4623ae65eb76feca3936354f22d45fa7: + goto endd32fd6e0ce970c212835e6f71c3dcbfd + endd32fd6e0ce970c212835e6f71c3dcbfd: ; case OpTrunc64to32: // match: (Trunc64to32 x) // cond: - // result: (Copy x) + // result: x { x := v.Args[0] v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.Type = x.Type v.AddArg(x) return true } - goto end93e0b16b58a717a3e4f5c2ca67b6be87 - end93e0b16b58a717a3e4f5c2ca67b6be87: + goto end1212c4e84153210aff7fd630fb3e1883 + end1212c4e84153210aff7fd630fb3e1883: ; case OpTrunc64to8: // match: (Trunc64to8 x) // cond: - // result: (Copy x) + // result: x { x := v.Args[0] v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.Type = x.Type v.AddArg(x) return true } - goto endc4c1a1b86edd0f082339d17eb5096ad0 - endc4c1a1b86edd0f082339d17eb5096ad0: + goto end734f017d4b2810ca2288f7037365824c + end734f017d4b2810ca2288f7037365824c: ; case OpAMD64XORB: // match: (XORB x (MOVBconst [c])) @@ -7816,21 +7840,22 @@ func rewriteValueAMD64(v *Value, config *Config) bool { case OpZero: // match: (Zero [0] _ mem) // cond: - // result: (Copy mem) + // result: mem { if v.AuxInt != 0 { - goto endb85a34a7d102b0e0d801454f437db5bf + goto endc9a38a60f0322f93682daa824611272c } mem := v.Args[1] v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.Type = mem.Type v.AddArg(mem) return true } - goto endb85a34a7d102b0e0d801454f437db5bf - endb85a34a7d102b0e0d801454f437db5bf: + goto endc9a38a60f0322f93682daa824611272c + endc9a38a60f0322f93682daa824611272c: ; // match: (Zero [1] destptr mem) // cond: diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index d706fd7a2e..9753bde45d 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -80,78 +80,82 @@ func rewriteValuegeneric(v *Value, config *Config) bool { case OpCom16: // match: (Com16 (Com16 x)) // cond: - // result: (Copy x) + // result: x { if v.Args[0].Op != OpCom16 { - goto end388d572e5a72fd87a07da5cab243ebdc + goto end1ea17710dd4dd7ba4e710e0e4c7b5a56 } x := v.Args[0].Args[0] v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.Type = x.Type v.AddArg(x) return true } - goto end388d572e5a72fd87a07da5cab243ebdc - end388d572e5a72fd87a07da5cab243ebdc: + goto end1ea17710dd4dd7ba4e710e0e4c7b5a56 + end1ea17710dd4dd7ba4e710e0e4c7b5a56: ; case OpCom32: // match: (Com32 (Com32 x)) // cond: - // result: (Copy x) + // result: x { if v.Args[0].Op != OpCom32 { - goto end5b2b3834acc7313649923604f685e7c5 + goto end9a04ed536496e292c27bef4414128cbf } x := v.Args[0].Args[0] v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.Type = x.Type v.AddArg(x) return true } - goto end5b2b3834acc7313649923604f685e7c5 - end5b2b3834acc7313649923604f685e7c5: + goto end9a04ed536496e292c27bef4414128cbf + end9a04ed536496e292c27bef4414128cbf: ; case OpCom64: // match: (Com64 (Com64 x)) // cond: - // result: (Copy x) + // result: x { if v.Args[0].Op != OpCom64 { - goto end6d6312f25d06a327d92f028b1ce50566 + goto ended44e29d5968f0f7b86972b7bf417ab3 } x := v.Args[0].Args[0] v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.Type = x.Type v.AddArg(x) return true } - goto end6d6312f25d06a327d92f028b1ce50566 - end6d6312f25d06a327d92f028b1ce50566: + goto ended44e29d5968f0f7b86972b7bf417ab3 + ended44e29d5968f0f7b86972b7bf417ab3: ; case OpCom8: // match: (Com8 (Com8 x)) // cond: - // result: (Copy x) + // result: x { if v.Args[0].Op != OpCom8 { - goto end70cbd85c4b8e82c170dba7c23f8bc0f3 + goto end4d92ff3ba567d9afd38fc9ca113602ad } x := v.Args[0].Args[0] v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.Type = x.Type v.AddArg(x) return true } - goto end70cbd85c4b8e82c170dba7c23f8bc0f3 - end70cbd85c4b8e82c170dba7c23f8bc0f3: + goto end4d92ff3ba567d9afd38fc9ca113602ad + end4d92ff3ba567d9afd38fc9ca113602ad: ; case OpConstString: // match: (ConstString {s}) @@ -716,11 +720,12 @@ func rewriteValuegeneric(v *Value, config *Config) bool { goto end0d922460b7e5ca88324034f4bd6c027c } len := v.Args[0].Args[1] - v.Op = len.Op - v.AuxInt = len.AuxInt - v.Aux = len.Aux + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil v.resetArgs() - v.AddArgs(len.Args...) + v.Type = len.Type + v.AddArg(len) return true } goto end0d922460b7e5ca88324034f4bd6c027c @@ -735,11 +740,12 @@ func rewriteValuegeneric(v *Value, config *Config) bool { goto end061edc5d85c73ad909089af2556d9380 } ptr := v.Args[0].Args[0] - v.Op = ptr.Op - v.AuxInt = ptr.AuxInt - v.Aux = ptr.Aux + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil v.resetArgs() - v.AddArgs(ptr.Args...) + v.Type = ptr.Type + v.AddArg(ptr) return true } goto end061edc5d85c73ad909089af2556d9380 -- cgit v1.3 From b14b8d6bc7d55fdde87aa5de74d7c906ca53bfd0 Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Mon, 3 Aug 2015 18:08:22 -0500 Subject: [dev.ssa] cmd/compile/ssa: don't perform nilcheck on OpAddr/OpAddPtr values Don't nilcheck values that were constructed as a result of OpAddr or OpAddPtr. Change-Id: I38053e905d1b76a2a64e77f84e444d38a5217108 Reviewed-on: https://go-review.googlesource.com/13256 Reviewed-by: David Chase --- src/cmd/compile/internal/ssa/nilcheck.go | 13 ++++++++++ src/cmd/compile/internal/ssa/nilcheck_test.go | 36 +++++++++++++++++++++++++-- 2 files changed, 47 insertions(+), 2 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/nilcheck.go b/src/cmd/compile/internal/ssa/nilcheck.go index b9964b2980..ac7af5c60d 100644 --- a/src/cmd/compile/internal/ssa/nilcheck.go +++ b/src/cmd/compile/internal/ssa/nilcheck.go @@ -53,6 +53,19 @@ func nilcheckelim(f *Func) { var pushRecPtr bool switch node.op { case Work: + // 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 node.block.Values { + if v.Op == OpAddr || v.Op == OpAddPtr { + // set this immediately instead of + // using SetPtr so we can potentially + // remove an OpIsNonNil check in the + // current work block + nonNilValues[v.ID] = true + } + } + if node.ptr != nil { // already have a nilcheck in the dominator path if nonNilValues[node.ptr.ID] { diff --git a/src/cmd/compile/internal/ssa/nilcheck_test.go b/src/cmd/compile/internal/ssa/nilcheck_test.go index 0ebf2bc801..e542df25c4 100644 --- a/src/cmd/compile/internal/ssa/nilcheck_test.go +++ b/src/cmd/compile/internal/ssa/nilcheck_test.go @@ -134,9 +134,8 @@ func TestNilcheckDomOrder(t *testing.T) { } } -//TODO: Disabled until we track OpAddr constructed values // TestNilcheckAddr verifies that nilchecks of OpAddr constructed values are removed. -func DISABLETestNilcheckAddr(t *testing.T) { +func TestNilcheckAddr(t *testing.T) { ptrType := &TypeImpl{Size_: 8, Ptr: true, Name: "testptr"} // dummy for testing c := NewConfig("amd64", DummyFrontend{t}) fun := Fun(c, "entry", @@ -168,6 +167,39 @@ func DISABLETestNilcheckAddr(t *testing.T) { } } +// 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}) + fun := Fun(c, "entry", + Bloc("entry", + Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("sb", OpSB, TypeInvalid, 0, nil), + Goto("checkPtr")), + Bloc("checkPtr", + Valu("ptr1", OpAddPtr, 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") + } + } +} + // TestNilcheckKeepRemove verifies that dupliate checks of the same pointer // are removed, but checks of different pointers are not. func TestNilcheckKeepRemove(t *testing.T) { -- cgit v1.3 From 0d91018082bb078f6c84388327375f40f231a8d4 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Fri, 7 Aug 2015 10:24:57 -0700 Subject: [dev.ssa] cmd/compile: add simplifying block rewrite rules Change-Id: Ia946c259628f84dc7031171456563975d2ad5ea9 Reviewed-on: https://go-review.googlesource.com/13381 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/gen/AMD64.rules | 28 ++- src/cmd/compile/internal/ssa/rewriteAMD64.go | 298 ++++++++++++++++++++++++--- 2 files changed, 284 insertions(+), 42 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 1e9f615805..f4a26c8c64 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -231,18 +231,30 @@ (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 (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 (SETA cmp) yes no) -> (UGT cmp yes no) (If (SETAE cmp) yes no) -> (UGE 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) + (StaticCall [argwid] {target} mem) -> (CALLstatic [argwid] {target} mem) (ClosureCall [argwid] entry closure mem) -> (CALLclosure [argwid] entry closure mem) diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 327f322592..867d62b1bc 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -8173,13 +8173,13 @@ func rewriteBlockAMD64(b *Block) bool { endf60c0660b6a8aa9565c97fc87f04eb34: ; case BlockIf: - // match: (If (SETL cmp) yes no) + // match: (If (SETL cmp) yes no) // cond: - // result: (LT cmp yes no) + // result: (LT cmp yes no) { v := b.Control if v.Op != OpAMD64SETL { - goto ende4d36879bb8e1bd8facaa8c91ba99dcc + goto end94277282f4b83f0c035b23711a075801 } cmp := v.Args[0] yes := b.Succs[0] @@ -8190,16 +8190,16 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto ende4d36879bb8e1bd8facaa8c91ba99dcc - ende4d36879bb8e1bd8facaa8c91ba99dcc: + goto end94277282f4b83f0c035b23711a075801 + end94277282f4b83f0c035b23711a075801: ; // match: (If (SETLE cmp) yes no) // cond: - // result: (LE cmp yes no) + // result: (LE cmp yes no) { v := b.Control if v.Op != OpAMD64SETLE { - goto end40df18679690e8f9005d8642fab44654 + goto enda84798dd797927b54a9a2987421b2ba2 } cmp := v.Args[0] yes := b.Succs[0] @@ -8210,16 +8210,16 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end40df18679690e8f9005d8642fab44654 - end40df18679690e8f9005d8642fab44654: + goto enda84798dd797927b54a9a2987421b2ba2 + enda84798dd797927b54a9a2987421b2ba2: ; - // match: (If (SETG cmp) yes no) + // match: (If (SETG cmp) yes no) // cond: - // result: (GT cmp yes no) + // result: (GT cmp yes no) { v := b.Control if v.Op != OpAMD64SETG { - goto endb1faff07a84ae08a4b05a4a7e71eb740 + goto end3434ef985979cbf394455ab5b559567c } cmp := v.Args[0] yes := b.Succs[0] @@ -8230,16 +8230,16 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto endb1faff07a84ae08a4b05a4a7e71eb740 - endb1faff07a84ae08a4b05a4a7e71eb740: + goto end3434ef985979cbf394455ab5b559567c + end3434ef985979cbf394455ab5b559567c: ; // match: (If (SETGE cmp) yes no) // cond: - // result: (GE cmp yes no) + // result: (GE cmp yes no) { v := b.Control if v.Op != OpAMD64SETGE { - goto enda9211ccfa5b0ab8eafc0017630c542b6 + goto endee147d81d8620a5e23cb92bd9f13cf8d } cmp := v.Args[0] yes := b.Succs[0] @@ -8250,16 +8250,16 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto enda9211ccfa5b0ab8eafc0017630c542b6 - enda9211ccfa5b0ab8eafc0017630c542b6: + goto endee147d81d8620a5e23cb92bd9f13cf8d + endee147d81d8620a5e23cb92bd9f13cf8d: ; // match: (If (SETEQ cmp) yes no) // cond: - // result: (EQ cmp yes no) + // result: (EQ cmp yes no) { v := b.Control if v.Op != OpAMD64SETEQ { - goto endf113deb06abc88613840e6282942921a + goto ende7d85ccc850fc3963c50a91df096de17 } cmp := v.Args[0] yes := b.Succs[0] @@ -8270,16 +8270,16 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto endf113deb06abc88613840e6282942921a - endf113deb06abc88613840e6282942921a: + goto ende7d85ccc850fc3963c50a91df096de17 + ende7d85ccc850fc3963c50a91df096de17: ; // match: (If (SETNE cmp) yes no) // cond: - // result: (NE cmp yes no) + // result: (NE cmp yes no) { v := b.Control if v.Op != OpAMD64SETNE { - goto end5ff1403aaf7b543bc454177ab584e4f5 + goto endba4b54260ecda1b5731b129c0eb493d0 } cmp := v.Args[0] yes := b.Succs[0] @@ -8290,16 +8290,16 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end5ff1403aaf7b543bc454177ab584e4f5 - end5ff1403aaf7b543bc454177ab584e4f5: + goto endba4b54260ecda1b5731b129c0eb493d0 + endba4b54260ecda1b5731b129c0eb493d0: ; - // match: (If (SETB cmp) yes no) + // match: (If (SETB cmp) yes no) // cond: // result: (ULT cmp yes no) { v := b.Control if v.Op != OpAMD64SETB { - goto end04935012db9defeafceef8175f803ea2 + goto endf84eedfcd3f18f5c9c3f3d1045a24330 } cmp := v.Args[0] yes := b.Succs[0] @@ -8310,8 +8310,8 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end04935012db9defeafceef8175f803ea2 - end04935012db9defeafceef8175f803ea2: + goto endf84eedfcd3f18f5c9c3f3d1045a24330 + endf84eedfcd3f18f5c9c3f3d1045a24330: ; // match: (If (SETBE cmp) yes no) // cond: @@ -8333,13 +8333,13 @@ func rewriteBlockAMD64(b *Block) bool { goto endfe0178f6f4406945ca8966817d04be60 endfe0178f6f4406945ca8966817d04be60: ; - // match: (If (SETA cmp) yes no) + // match: (If (SETA cmp) yes no) // cond: // result: (UGT cmp yes no) { v := b.Control if v.Op != OpAMD64SETA { - goto endbd22a7d56a98d85e4e132ff952dae262 + goto end2b5a2d7756bdba01a732bf54d9acdb73 } cmp := v.Args[0] yes := b.Succs[0] @@ -8350,8 +8350,8 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto endbd22a7d56a98d85e4e132ff952dae262 - endbd22a7d56a98d85e4e132ff952dae262: + goto end2b5a2d7756bdba01a732bf54d9acdb73 + end2b5a2d7756bdba01a732bf54d9acdb73: ; // match: (If (SETAE cmp) yes no) // cond: @@ -8437,6 +8437,236 @@ func rewriteBlockAMD64(b *Block) bool { end6a408cde0fee0ae7b7da0443c8d902bf: ; case BlockAMD64NE: + // match: (NE (TESTB (SETL cmp)) yes no) + // cond: + // result: (LT cmp yes no) + { + v := b.Control + if v.Op != OpAMD64TESTB { + goto end0b9ca165d6b395de676eebef94bc62f7 + } + if v.Args[0].Op != OpAMD64SETL { + goto end0b9ca165d6b395de676eebef94bc62f7 + } + 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 + } + goto end0b9ca165d6b395de676eebef94bc62f7 + end0b9ca165d6b395de676eebef94bc62f7: + ; + // match: (NE (TESTB (SETLE cmp)) yes no) + // cond: + // result: (LE cmp yes no) + { + v := b.Control + if v.Op != OpAMD64TESTB { + goto endaaba0ee4d0ff8c66a1c3107d2a14c4bc + } + if v.Args[0].Op != OpAMD64SETLE { + goto endaaba0ee4d0ff8c66a1c3107d2a14c4bc + } + 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 + } + goto endaaba0ee4d0ff8c66a1c3107d2a14c4bc + endaaba0ee4d0ff8c66a1c3107d2a14c4bc: + ; + // match: (NE (TESTB (SETG cmp)) yes no) + // cond: + // result: (GT cmp yes no) + { + v := b.Control + if v.Op != OpAMD64TESTB { + goto end1b689463137526b36ba9ceed1e76e512 + } + if v.Args[0].Op != OpAMD64SETG { + goto end1b689463137526b36ba9ceed1e76e512 + } + 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 + } + goto end1b689463137526b36ba9ceed1e76e512 + end1b689463137526b36ba9ceed1e76e512: + ; + // match: (NE (TESTB (SETGE cmp)) yes no) + // cond: + // result: (GE cmp yes no) + { + v := b.Control + if v.Op != OpAMD64TESTB { + goto end99eefee595c658b997f41577ed853c2e + } + if v.Args[0].Op != OpAMD64SETGE { + goto end99eefee595c658b997f41577ed853c2e + } + 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 + } + goto end99eefee595c658b997f41577ed853c2e + end99eefee595c658b997f41577ed853c2e: + ; + // match: (NE (TESTB (SETEQ cmp)) yes no) + // cond: + // result: (EQ cmp yes no) + { + v := b.Control + if v.Op != OpAMD64TESTB { + goto end371b67d3d63e9b92d848b09c3324e8b9 + } + if v.Args[0].Op != OpAMD64SETEQ { + goto end371b67d3d63e9b92d848b09c3324e8b9 + } + 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 + } + goto end371b67d3d63e9b92d848b09c3324e8b9 + end371b67d3d63e9b92d848b09c3324e8b9: + ; + // match: (NE (TESTB (SETNE cmp)) yes no) + // cond: + // result: (NE cmp yes no) + { + v := b.Control + if v.Op != OpAMD64TESTB { + goto endd245f2aac2191d32e57cd2e321daa453 + } + if v.Args[0].Op != OpAMD64SETNE { + goto endd245f2aac2191d32e57cd2e321daa453 + } + 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 + } + goto endd245f2aac2191d32e57cd2e321daa453 + endd245f2aac2191d32e57cd2e321daa453: + ; + // match: (NE (TESTB (SETB cmp)) yes no) + // cond: + // result: (ULT cmp yes no) + { + v := b.Control + if v.Op != OpAMD64TESTB { + goto end90c4bec851e734d37457d611b1a5ff28 + } + if v.Args[0].Op != OpAMD64SETB { + goto end90c4bec851e734d37457d611b1a5ff28 + } + 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 + } + goto end90c4bec851e734d37457d611b1a5ff28 + end90c4bec851e734d37457d611b1a5ff28: + ; + // match: (NE (TESTB (SETBE cmp)) yes no) + // cond: + // result: (ULE cmp yes no) + { + v := b.Control + if v.Op != OpAMD64TESTB { + goto end3a68a28114e9b89ee0708823386bc1ee + } + if v.Args[0].Op != OpAMD64SETBE { + goto end3a68a28114e9b89ee0708823386bc1ee + } + 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 + } + goto end3a68a28114e9b89ee0708823386bc1ee + end3a68a28114e9b89ee0708823386bc1ee: + ; + // match: (NE (TESTB (SETA cmp)) yes no) + // cond: + // result: (UGT cmp yes no) + { + v := b.Control + if v.Op != OpAMD64TESTB { + goto end16496f57185756e960d536b057c776c0 + } + if v.Args[0].Op != OpAMD64SETA { + goto end16496f57185756e960d536b057c776c0 + } + 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 + } + goto end16496f57185756e960d536b057c776c0 + end16496f57185756e960d536b057c776c0: + ; + // match: (NE (TESTB (SETAE cmp)) yes no) + // cond: + // result: (UGE cmp yes no) + { + v := b.Control + if v.Op != OpAMD64TESTB { + goto endbd122fd599aeb9e60881a0fa735e2fde + } + if v.Args[0].Op != OpAMD64SETAE { + goto endbd122fd599aeb9e60881a0fa735e2fde + } + 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 + } + goto endbd122fd599aeb9e60881a0fa735e2fde + endbd122fd599aeb9e60881a0fa735e2fde: + ; // match: (NE (InvertFlags cmp) yes no) // cond: // result: (NE cmp yes no) -- cgit v1.3 From e98edc88c9d8453a22bfe3753d0f49510de0cf83 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Mon, 10 Aug 2015 11:10:53 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: enforce load-store ordering in scheduler We must make sure that all loads that use a store are scheduled before the next store. Add additional dependency edges to the value graph to enforce this constraint. Change-Id: Iab83644f68bc4c30637085b82ca7467b9d5513a5 Reviewed-on: https://go-review.googlesource.com/13470 Reviewed-by: Josh Bleecher Snyder --- .../compile/internal/gc/testdata/loadstore_ssa.go | 39 ++++++++++++++ src/cmd/compile/internal/ssa/schedule.go | 62 +++++++++++++++++----- 2 files changed, 87 insertions(+), 14 deletions(-) create mode 100644 src/cmd/compile/internal/gc/testdata/loadstore_ssa.go (limited to 'src/cmd') 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 0000000000..abca2a4bf8 --- /dev/null +++ b/src/cmd/compile/internal/gc/testdata/loadstore_ssa.go @@ -0,0 +1,39 @@ +// 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 + +// 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 +} + +var failed = false + +func main() { + + testLoadStoreOrder() + + if failed { + panic("failed") + } +} diff --git a/src/cmd/compile/internal/ssa/schedule.go b/src/cmd/compile/internal/ssa/schedule.go index 9c8e9a1156..8388695fa8 100644 --- a/src/cmd/compile/internal/ssa/schedule.go +++ b/src/cmd/compile/internal/ssa/schedule.go @@ -21,20 +21,47 @@ func schedule(f *Func) { var order []*Value // priority queue of legally schedulable (0 unscheduled uses) values - var priq [4][]*Value + var priq [5][]*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. + 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 { - // Note: if a value is used by a phi, it does not induce + 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. - for _, w := range v.Args { - if w.Block == b { - uses[w.ID]++ - } + 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. @@ -44,23 +71,22 @@ func schedule(f *Func) { // We want all the phis first. score[v.ID] = 0 case v.Type.IsMemory(): - // Schedule stores as late as possible. - // This makes sure that loads do not get scheduled - // after a following store (1-live-memory requirement). - score[v.ID] = 2 + // Schedule stores as early as possible. This tends to + // reduce register pressure. + score[v.ID] = 1 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] = 2 + score[v.ID] = 3 default: - score[v.ID] = 1 + score[v.ID] = 2 } } 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] = 3 + score[b.Control.ID] = 4 // TODO: some times control values are used by other values // in the block. So the control value will not appear at // the very end. Decide if this is a problem or not. @@ -110,6 +136,14 @@ func schedule(f *Func) { 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") -- cgit v1.3 From baf2c3ec4ade20b3a56022983d20373ea9ea49b7 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Mon, 10 Aug 2015 14:01:04 -0700 Subject: [dev.ssa] cmd/compile: detect rewrite loops of length > 1 Use a version of Floyd's cycle finding algorithm, but advance by 1 and 1/2 steps per cycle rather than by 1 and 2. It is simpler and should be cheaper in the normal, acyclic case. This should fix the 386 and arm builds, which are currently hung. Change-Id: If8bd443011b28a5ecb004a549239991d3dfc862b Reviewed-on: https://go-review.googlesource.com/13473 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/rewrite.go | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go index a02f1d50b2..39fc48df4a 100644 --- a/src/cmd/compile/internal/ssa/rewrite.go +++ b/src/cmd/compile/internal/ssa/rewrite.go @@ -44,9 +44,18 @@ func applyRewrite(f *Func, rb func(*Block) bool, rv func(*Value, *Config) bool) } // Rewriting can generate OpCopy loops. // They are harmless (see removePredecessor), - // but take care not to loop forever. - for a.Op == OpCopy && a != a.Args[0] { + // 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 = a + } + advance = !advance } v.Args[i] = a } -- cgit v1.3 From 9787ba43eeaebe2d61c701f27a5b50d095533b9b Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Mon, 10 Aug 2015 13:40:28 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: Update TODO list Change-Id: Ibcd4c6984c8728fd9ab76e0c7df555984deaf281 Reviewed-on: https://go-review.googlesource.com/13471 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/ssa/TODO | 129 +++++++++++++++---------------- src/cmd/compile/internal/ssa/schedule.go | 2 + 2 files changed, 66 insertions(+), 65 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/TODO b/src/cmd/compile/internal/ssa/TODO index f77c5ad8f3..9f8225852c 100644 --- a/src/cmd/compile/internal/ssa/TODO +++ b/src/cmd/compile/internal/ssa/TODO @@ -1,71 +1,70 @@ -This is a list of things that need to be worked on. It is by no means complete. +This is a list of things that need to be worked on. It will hopefully +be complete soon. -Allocation -- Allocation of decls in stackalloc. Decls survive if they are - addrtaken or are too large for registerization. +Coverage +-------- +- Floating point numbers +- Complex numbers +- Integer division +- Fat objects (strings/slices/interfaces) vs. Phi +- Defer? +- Closure args +- PHEAP vars -Scheduling - - Make sure loads are scheduled correctly with respect to stores. - Same for flag type values. We can't have more than one value of - mem or flag types live at once. - - Reduce register pressure. Schedule instructions which kill - variables first. +Correctness +----------- +- GC maps +- Write barriers +- Debugging info +- Handle flags register correctly (clobber/spill/restore) +- Proper panic edges from checks & calls (+deferreturn) +- Can/should we move control values out of their basic block? +- Anything to do for the race detector? +- Slicing details (avoid ptr to next object) -Values - - Store *Type instead of Type? Keep an array of used Types in Func - and reference by id? Unify with the type ../gc so we just use a - pointer instead of an interface? - - Recycle dead values instead of using GC to do that. - - A lot of Aux fields are just int64. Add a separate AuxInt field? - If not that, then cache the interfaces that wrap int64s. - - OpStore uses 3 args. Increase the size of argstorage to 3? +Optimizations (better compiled code) +------------------------------------ +- Reduce register pressure in scheduler +- More strength reduction: multiply -> shift/add combos (Worth doing?) +- Strength reduction: constant divides -> multiply +- Expand current optimizations to all bit widths +- Nil/bounds check removal +- Combining nil checks with subsequent load +- Implement memory zeroing with REPSTOSQ and DuffZero +- Implement memory copying with REPMOVSQ and DuffCopy +- Make deadstore work with zeroing +- Branch prediction: Respect hints from the frontend, add our own +- Add a value range propagation pass (for bounds elim & bitwidth reduction) +- Stackalloc: group pointer-containing variables & spill slots together +- Stackalloc: organize values to allow good packing +- Regalloc: use arg slots as the home for arguments (don't copy args to locals) +- Reuse stack slots for noninterfering & compatible values (but see issue 8740) +- (x86) Combine loads into other ops +- (x86) More combining address arithmetic into loads/stores -Regalloc - - Make less arch-dependent - - Don't spill everything at every basic block boundary. - - Allow args and return values to be ssa-able. - - Handle 2-address instructions. - - Floating point registers - - Make calls clobber all registers - - Make liveness analysis non-quadratic. - - Handle in-place instructions (like XORQconst) directly: - Use XORQ AX, 1 rather than MOVQ AX, BX; XORQ BX, 1. - -StackAlloc: - - Sort variables so all ptr-containing ones are first (so stack - maps are smaller) - - Reuse stack slots for noninterfering and type-compatible variables - (both AUTOs and spilled Values). But see issue 8740 for what - "type-compatible variables" mean and what DWARF information provides. +Optimizations (better compiler) +------------------------------- +- Smaller Value.Type (int32 or ptr)? Get rid of types altogether? +- Recycle dead Values (and Blocks) explicitly instead of using GC +- OpStore uses 3 args. Increase the size of Value.argstorage to 3? +- Constant cache +- Reuseable slices (e.g. []int of size NumValues()) cached in Func -Rewrites - - Strength reduction (both arch-indep and arch-dependent?) - - Start another architecture (arm?) - - 64-bit ops on 32-bit machines - - (MOVLstore x m) - to get rid of most of the MOVLQSX. - - Determine which nil checks can be done implicitly (by faulting) - and which need code generated, and do the code generation. - -Common-Subexpression Elimination - - Make better decision about which value in an equivalence class we should - choose to replace other values in that class. - - Can we move control values out of their basic block? - This would break nilcheckelim as currently implemented, - but it could be replaced by a similar CFG simplication pass. - - 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? +Regalloc +-------- +- Make less arch-dependent +- Don't spill everything at every basic block boundary +- Allow args and return values to be ssa-able +- Handle 2-address instructions +- Make calls clobber all registers +- Make liveness analysis non-quadratic +- Materialization of constants -Other - - Write barriers - - For testing, do something more sophisticated than - checkOpcodeCounts. Michael Matloob suggests using a similar - pattern matcher to the rewrite engine to check for certain - expression subtrees in the output. - - Implement memory zeroing with REPSTOSQ and DuffZero - - make deadstore work with zeroing. - - Add a value range propagation optimization pass. - Use it for bounds check elimination and bitwidth reduction. - - Branch prediction: Respect hints from the frontend, add our own. +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/schedule.go b/src/cmd/compile/internal/ssa/schedule.go index 8388695fa8..de0b4acbf4 100644 --- a/src/cmd/compile/internal/ssa/schedule.go +++ b/src/cmd/compile/internal/ssa/schedule.go @@ -30,6 +30,8 @@ func schedule(f *Func) { 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 { -- cgit v1.3 From e0e556620aaf9861c422191fc1efb8020c2f1507 Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Thu, 6 Aug 2015 20:13:27 -0500 Subject: [dev.ssa] cmd/compile/ssa: don't nil check phis with non-nil arguments Move the known-non-nil scan outside the work loop to resolve an issue with values that were declared outside the block being operated on. Also consider phis whose arguments are all non-nil, as non-nil. Change-Id: I4d5b840042de9eb181f2cb918f36913fb5d517a2 Reviewed-on: https://go-review.googlesource.com/13441 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/nilcheck.go | 37 +++++++++++++-------- src/cmd/compile/internal/ssa/nilcheck_test.go | 46 ++++++++++++++++++++++++++- 2 files changed, 69 insertions(+), 14 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/nilcheck.go b/src/cmd/compile/internal/ssa/nilcheck.go index ac7af5c60d..4833ac472d 100644 --- a/src/cmd/compile/internal/ssa/nilcheck.go +++ b/src/cmd/compile/internal/ssa/nilcheck.go @@ -45,6 +45,30 @@ func nilcheckelim(f *Func) { // 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] @@ -53,19 +77,6 @@ func nilcheckelim(f *Func) { var pushRecPtr bool switch node.op { case Work: - // 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 node.block.Values { - if v.Op == OpAddr || v.Op == OpAddPtr { - // set this immediately instead of - // using SetPtr so we can potentially - // remove an OpIsNonNil check in the - // current work block - nonNilValues[v.ID] = true - } - } - if node.ptr != nil { // already have a nilcheck in the dominator path if nonNilValues[node.ptr.ID] { diff --git a/src/cmd/compile/internal/ssa/nilcheck_test.go b/src/cmd/compile/internal/ssa/nilcheck_test.go index e542df25c4..c54f86a7b4 100644 --- a/src/cmd/compile/internal/ssa/nilcheck_test.go +++ b/src/cmd/compile/internal/ssa/nilcheck_test.go @@ -200,7 +200,51 @@ func TestNilcheckAddPtr(t *testing.T) { } } -// TestNilcheckKeepRemove verifies that dupliate checks of the same pointer +// 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}) + fun := Fun(c, "entry", + Bloc("entry", + Valu("mem", OpArg, TypeMem, 0, ".mem"), + 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 -- cgit v1.3 From 40aba8c4e7ac5babf9901d1948ff56c117e3bcf9 Mon Sep 17 00:00:00 2001 From: David Chase Date: Wed, 5 Aug 2015 22:11:14 -0400 Subject: [dev.ssa] cmd/compile: add support for LROT, and tests Hardcoded the limit on constants only allowed. Change-Id: Idb9b07b4871db7a752a79e492671e9b41207b956 Reviewed-on: https://go-review.googlesource.com/13257 Reviewed-by: Keith Randall Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/gc/ssa.go | 24 ++++++- src/cmd/compile/internal/gc/testdata/arith_ssa.go | 52 +++++++++++++++ src/cmd/compile/internal/ssa/gen/AMD64.rules | 5 ++ src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 5 ++ src/cmd/compile/internal/ssa/gen/genericOps.go | 25 +++++++ src/cmd/compile/internal/ssa/opGen.go | 72 ++++++++++++++++++++ src/cmd/compile/internal/ssa/rewriteAMD64.go | 80 +++++++++++++++++++++++ 7 files changed, 262 insertions(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 041e321717..13a6d6c009 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -843,6 +843,11 @@ var opToSSA = map[opAndType]ssa.Op{ opAndType{OGE, TUINT32}: ssa.OpGeq32U, opAndType{OGE, TINT64}: ssa.OpGeq64, opAndType{OGE, TUINT64}: ssa.OpGeq64U, + + opAndType{OLROT, TUINT8}: ssa.OpLrot8, + opAndType{OLROT, TUINT16}: ssa.OpLrot16, + opAndType{OLROT, TUINT32}: ssa.OpLrot32, + opAndType{OLROT, TUINT64}: ssa.OpLrot64, } func (s *state) concreteEtype(t *Type) uint8 { @@ -967,6 +972,15 @@ func (s *state) ssaShiftOp(op uint8, t *Type, u *Type) ssa.Op { return x } +func (s *state) ssaRotateOp(op uint8, 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(int(etype1), 0)) + } + 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) @@ -1140,6 +1154,13 @@ func (s *state) expr(n *Node) *ssa.Value { 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 @@ -1936,7 +1957,8 @@ func genValue(v *ssa.Value) { ssa.OpAMD64SUBQconst, ssa.OpAMD64SUBLconst, ssa.OpAMD64SUBWconst, 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.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]) diff --git a/src/cmd/compile/internal/gc/testdata/arith_ssa.go b/src/cmd/compile/internal/gc/testdata/arith_ssa.go index 6341e9b90d..0dbf9451ab 100644 --- a/src/cmd/compile/internal/gc/testdata/arith_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/arith_ssa.go @@ -171,6 +171,57 @@ 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 +} + +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. + switch { // prevents inlining + } + return (w << n) | (w >> (32 - n)) +} + +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. + switch { // prevents inlining + } + 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 + } + +} + var failed = false func main() { @@ -181,6 +232,7 @@ func main() { testSubqToNegq() testBitwiseLogic() testOcom() + testLrot() if failed { panic("failed") diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index f4a26c8c64..42b3cf2777 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -102,6 +102,11 @@ (Lsh8x16 x y) -> (ANDB (SHLB x y) (SBBLcarrymask (CMPWconst [8] y))) (Lsh8x8 x y) -> (ANDB (SHLB x y) (SBBLcarrymask (CMPBconst [8] y))) +(Lrot64 x [c]) -> (ROLQconst [c&63] x) +(Lrot32 x [c]) -> (ROLLconst [c&31] x) +(Lrot16 x [c]) -> (ROLWconst [c&15] x) +(Lrot8 x [c]) -> (ROLBconst [c&7] x) + (Rsh64Ux64 x y) -> (ANDQ (SHRQ x y) (SBBQcarrymask (CMPQconst [64] y))) (Rsh64Ux32 x y) -> (ANDQ (SHRQ x y) (SBBQcarrymask (CMPLconst [64] y))) (Rsh64Ux16 x y) -> (ANDQ (SHRQ x y) (SBBQcarrymask (CMPWconst [64] y))) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 0c306cbbcb..65fc5c60e1 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -209,6 +209,11 @@ func init() { {name: "SARWconst", reg: gp11, asm: "SARW"}, // signed arg0 >> auxint, shift amount 0-31 {name: "SARBconst", reg: gp11, asm: "SARB"}, // signed arg0 >> auxint, shift amount 0-31 + {name: "ROLQconst", reg: gp11, asm: "ROLQ"}, // arg0 rotate left auxint, rotate amount 0-63 + {name: "ROLLconst", reg: gp11, asm: "ROLL"}, // arg0 rotate left auxint, rotate amount 0-31 + {name: "ROLWconst", reg: gp11, asm: "ROLW"}, // arg0 rotate left auxint, rotate amount 0-15 + {name: "ROLBconst", reg: gp11, asm: "ROLB"}, // arg0 rotate left auxint, rotate amount 0-7 + // unary ops {name: "NEGQ", reg: gp11, asm: "NEGQ"}, // -arg0 {name: "NEGL", reg: gp11, asm: "NEGL"}, // -arg0 diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 657973e333..4aa6af5c9e 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -94,6 +94,31 @@ var genericOps = []opData{ {name: "Rsh64Ux32"}, {name: "Rsh64Ux64"}, + // (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"}, + {name: "Lrot16"}, + {name: "Lrot32"}, + {name: "Lrot64"}, + // 2-input comparisons {name: "Eq8"}, // arg0 == arg1 {name: "Eq16"}, diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index e77df40ebd..427fb33f57 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -137,6 +137,10 @@ const ( OpAMD64SARLconst OpAMD64SARWconst OpAMD64SARBconst + OpAMD64ROLQconst + OpAMD64ROLLconst + OpAMD64ROLWconst + OpAMD64ROLBconst OpAMD64NEGQ OpAMD64NEGL OpAMD64NEGW @@ -265,6 +269,10 @@ const ( OpRsh64Ux16 OpRsh64Ux32 OpRsh64Ux64 + OpLrot8 + OpLrot16 + OpLrot32 + OpLrot64 OpEq8 OpEq16 OpEq32 @@ -1454,6 +1462,54 @@ var opcodeTable = [...]opInfo{ }, }, }, + { + name: "ROLQconst", + asm: x86.AROLQ, + reg: regInfo{ + inputs: []regMask{ + 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: "ROLLconst", + asm: x86.AROLL, + reg: regInfo{ + inputs: []regMask{ + 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: "ROLWconst", + asm: x86.AROLW, + reg: regInfo{ + inputs: []regMask{ + 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: "ROLBconst", + asm: x86.AROLB, + reg: regInfo{ + inputs: []regMask{ + 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: "NEGQ", asm: x86.ANEGQ, @@ -2354,6 +2410,22 @@ var opcodeTable = [...]opInfo{ name: "Rsh64Ux64", generic: true, }, + { + name: "Lrot8", + generic: true, + }, + { + name: "Lrot16", + generic: true, + }, + { + name: "Lrot32", + generic: true, + }, + { + name: "Lrot64", + generic: true, + }, { name: "Eq8", generic: true, diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 867d62b1bc..4a9fa71bdb 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -2544,6 +2544,86 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end8f83bf72293670e75b22d6627bd13f0b end8f83bf72293670e75b22d6627bd13f0b: ; + case OpLrot16: + // match: (Lrot16 x [c]) + // cond: + // result: (ROLWconst [c&15] x) + { + t := v.Type + x := v.Args[0] + c := v.AuxInt + v.Op = OpAMD64ROLWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = t + v.AuxInt = c & 15 + v.AddArg(x) + return true + } + goto endb23dfa24c619d0068f925899d53ee7fd + endb23dfa24c619d0068f925899d53ee7fd: + ; + case OpLrot32: + // match: (Lrot32 x [c]) + // cond: + // result: (ROLLconst [c&31] x) + { + t := v.Type + x := v.Args[0] + c := v.AuxInt + v.Op = OpAMD64ROLLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = t + v.AuxInt = c & 31 + v.AddArg(x) + return true + } + goto end38b2215c011896c36845f72ecb72b1b0 + end38b2215c011896c36845f72ecb72b1b0: + ; + case OpLrot64: + // match: (Lrot64 x [c]) + // cond: + // result: (ROLQconst [c&63] x) + { + t := v.Type + x := v.Args[0] + c := v.AuxInt + v.Op = OpAMD64ROLQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = t + v.AuxInt = c & 63 + v.AddArg(x) + return true + } + goto end5cb355e4f3ca387f252ef4f6a55f9f68 + end5cb355e4f3ca387f252ef4f6a55f9f68: + ; + case OpLrot8: + // match: (Lrot8 x [c]) + // cond: + // result: (ROLBconst [c&7] x) + { + t := v.Type + x := v.Args[0] + c := v.AuxInt + v.Op = OpAMD64ROLBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = t + v.AuxInt = c & 7 + v.AddArg(x) + return true + } + goto end26bfb3dd5b537cf13ac9f2978d94ed71 + end26bfb3dd5b537cf13ac9f2978d94ed71: + ; case OpLsh16x16: // match: (Lsh16x16 x y) // cond: -- cgit v1.3 From 2af06480140dd48a4dc54257c2da46a73ca3ebb5 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Tue, 11 Aug 2015 14:23:08 -0700 Subject: [dev.ssa] cmd/compile: fix function call memory accounting We were not recording function calls as changing the state of memory. As a result, the scheduler was not aware that storing values to the stack in order to make a function call must happen *after* retrieving results from the stack from a just-completed function call. This fixes the container/ring tests. This was my first experience debugging an issue using the HTML output. I'm feeling quite pleased with it. Change-Id: I9e8276846be9fd7a60422911b11816c5175e3d0a Reviewed-on: https://go-review.googlesource.com/13560 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 1 + 1 file changed, 1 insertion(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 13a6d6c009..dcc7de8d04 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1319,6 +1319,7 @@ func (s *state) expr(n *Node) *ssa.Value { // read result from stack at the start of the fallthrough block s.startBlock(bNext) + s.vars[&memvar] = call var titer Iter fp := Structfirst(&titer, Getoutarg(left.Type)) if fp == nil { -- cgit v1.3 From 463858e6ff8cacd3bf2dafebe56272f8a863d959 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Tue, 11 Aug 2015 09:47:45 -0700 Subject: [dev.ssa] cmd/compile: make failed nil checks panic Introduce pseudo-ops PanicMem and LoweredPanicMem. PanicMem could be rewritten directly into MOVL during lowering, but then we couldn't log nil checks. With this change, runnable nil check tests pass: GOSSAPKG=main go run run.go -- nil*.go Compiler output nil check tests fail: GOSSAPKG=p go run run.go -- nil*.go This is due to several factors: * SSA has improved elimination of unnecessary nil checks. * SSA is missing elimination of implicit nil checks. * SSA is missing extra logging about why nil checks were removed. I'm not sure how best to resolve these failures, particularly in a world in which the two backends will live side by side for some time. For now, punt on the problem. Change-Id: Ib2ca6824551671f92e0e1800b036f5ca0905e2a3 Reviewed-on: https://go-review.googlesource.com/13474 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 36 ++++++++++++++++++++++---- src/cmd/compile/internal/ssa/gen/AMD64.rules | 2 ++ src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 3 +++ src/cmd/compile/internal/ssa/gen/genericOps.go | 2 ++ src/cmd/compile/internal/ssa/lower.go | 9 +++++-- src/cmd/compile/internal/ssa/opGen.go | 10 +++++++ src/cmd/compile/internal/ssa/rewriteAMD64.go | 18 +++++++++++++ 7 files changed, 73 insertions(+), 7 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index dcc7de8d04..75e12ee8f2 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1499,20 +1499,27 @@ func canSSA(n *Node) bool { } // nilCheck generates nil pointer checking code. -// Starts a new block on return. +// 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 + } c := s.newValue1(ssa.OpIsNonNil, Types[TBOOL], ptr) b := s.endBlock() - b.Kind = ssa.BlockIf + b.Kind = ssa.BlockIf // TODO: likeliness hint b.Control = c bNext := s.f.NewBlock(ssa.BlockPlain) + bPanic := s.f.NewBlock(ssa.BlockPlain) addEdge(b, bNext) - addEdge(b, s.exit) - s.startBlock(bNext) - // TODO(khr): Don't go directly to exit. Go to a stub that calls panicmem first. + addEdge(b, bPanic) + addEdge(bPanic, s.exit) + s.startBlock(bPanic) // TODO: implicit nil checks somehow? + s.vars[&memvar] = s.newValue2(ssa.OpPanicNilCheck, ssa.TypeMem, ptr, s.mem()) + s.endBlock() + s.startBlock(bNext) } // boundsCheck generates bounds checking code. Checks if 0 <= idx < len, branches to exit if not. @@ -2145,6 +2152,25 @@ func genValue(v *ssa.Value) { case ssa.OpArg: // memory arg needs no code // TODO: check that only mem arg goes here. + case ssa.OpAMD64LoweredPanicNilCheck: + if Debug_checknil != 0 && v.Line > 1 { // v.Line==1 in generated wrappers + Warnl(int(v.Line), "generated nil check") + } + // Write to memory address 0. It doesn't matter what we write; use AX. + // XORL AX, AX; MOVL AX, (AX) is shorter than MOVL AX, 0. + // TODO: If we had the pointer (v.Args[0]) in a register r, + // we could use MOVL AX, (r) instead of having to zero AX. + // But it isn't worth loading r just to accomplish that. + p := Prog(x86.AXORL) + p.From.Type = obj.TYPE_REG + p.From.Reg = x86.REG_AX + p.To.Type = obj.TYPE_REG + p.To.Reg = x86.REG_AX + q := Prog(x86.AMOVL) + q.From.Type = obj.TYPE_REG + q.From.Reg = x86.REG_AX + q.To.Type = obj.TYPE_MEM + q.To.Reg = x86.REG_AX case ssa.OpAMD64CALLstatic: p := Prog(obj.ACALL) p.To.Type = obj.TYPE_MEM diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 42b3cf2777..29f60d9a6b 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -216,6 +216,8 @@ (IsNonNil p) -> (SETNE (TESTQ p p)) (IsInBounds idx len) -> (SETB (CMPQ idx len)) +(PanicNilCheck ptr mem) -> (LoweredPanicNilCheck ptr mem) + (Move [size] dst src mem) -> (REPMOVSB dst src (MOVQconst [size]) mem) (Not x) -> (XORBconst [1] x) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 65fc5c60e1..9808745e35 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -287,6 +287,9 @@ func init() { // Rewrites will convert this to (SETG (CMPQ b a)). // InvertFlags is a pseudo-op which can't appear in assembly output. {name: "InvertFlags"}, // reverse direction of arg0 + + // LoweredPanicNilCheck is a pseudo-op. + {name: "LoweredPanicNilCheck"}, } var AMD64blocks = []blockData{ diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 4aa6af5c9e..6ff5d1ea1a 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -252,6 +252,8 @@ var genericOps = []opData{ {name: "IsNonNil"}, // arg0 != nil {name: "IsInBounds"}, // 0 <= arg0 < arg1 + {name: "PanicNilCheck"}, // trigger a dereference fault; arg0=nil ptr, arg1=mem + // Indexing operations {name: "ArrayIndex"}, // arg0=array, arg1=index. Returns a[i] {name: "PtrIndex"}, // arg0=ptr, arg1=index. Computes ptr+sizeof(*v.type)*index, where index is extended to ptrwidth type diff --git a/src/cmd/compile/internal/ssa/lower.go b/src/cmd/compile/internal/ssa/lower.go index 6f6b885062..56ee062b92 100644 --- a/src/cmd/compile/internal/ssa/lower.go +++ b/src/cmd/compile/internal/ssa/lower.go @@ -17,9 +17,14 @@ func checkLower(f *Func) { // rules may leave dead generic ops behind). for _, b := range f.Blocks { for _, v := range b.Values { - if opcodeTable[v.Op].generic && v.Op != OpSP && v.Op != OpSB && v.Op != OpArg && v.Op != OpCopy && v.Op != OpPhi { - f.Unimplementedf("%s not lowered", v.LongString()) + if !opcodeTable[v.Op].generic { + continue // lowered } + switch v.Op { + case OpSP, OpSB, OpArg, OpCopy, OpPhi: + continue // ok not to lower + } + f.Unimplementedf("%s not lowered", v.LongString()) } } } diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 427fb33f57..d56a8ba81b 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -194,6 +194,7 @@ const ( OpAMD64CALLclosure OpAMD64REPMOVSB OpAMD64InvertFlags + OpAMD64LoweredPanicNilCheck OpAdd8 OpAdd16 @@ -367,6 +368,7 @@ const ( OpTrunc64to32 OpIsNonNil OpIsInBounds + OpPanicNilCheck OpArrayIndex OpPtrIndex OpOffPtr @@ -2113,6 +2115,10 @@ var opcodeTable = [...]opInfo{ name: "InvertFlags", reg: regInfo{}, }, + { + name: "LoweredPanicNilCheck", + reg: regInfo{}, + }, { name: "Add8", @@ -2802,6 +2808,10 @@ var opcodeTable = [...]opInfo{ name: "IsInBounds", generic: true, }, + { + name: "PanicNilCheck", + generic: true, + }, { name: "ArrayIndex", generic: true, diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 4a9fa71bdb..2668d570d1 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -4836,6 +4836,24 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end6f8a8c559a167d1f0a5901d09a1fb248 end6f8a8c559a167d1f0a5901d09a1fb248: ; + case OpPanicNilCheck: + // match: (PanicNilCheck ptr mem) + // cond: + // result: (LoweredPanicNilCheck ptr mem) + { + ptr := v.Args[0] + mem := v.Args[1] + v.Op = OpAMD64LoweredPanicNilCheck + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto enda02b1ad5a6f929b782190145f2c8628b + enda02b1ad5a6f929b782190145f2c8628b: + ; case OpRsh16Ux16: // match: (Rsh16Ux16 x y) // cond: -- cgit v1.3 From dee1f2750b544dc2dd109231d5f8347beb142b8d Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Mon, 10 Aug 2015 21:05:35 -0500 Subject: [dev.ssa] cmd/compile/ssa: eliminate Zero with dse Consider OpZero to be a store so it can be eliminated by dse. Change-Id: Idebb6a190657b76966f0c5b20f2ec9f52fe47499 Reviewed-on: https://go-review.googlesource.com/13447 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/deadstore.go | 20 ++++++++++++++++---- src/cmd/compile/internal/ssa/deadstore_test.go | 18 ++++++++++++------ 2 files changed, 28 insertions(+), 10 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/deadstore.go b/src/cmd/compile/internal/ssa/deadstore.go index db3808639a..982bd7fa70 100644 --- a/src/cmd/compile/internal/ssa/deadstore.go +++ b/src/cmd/compile/internal/ssa/deadstore.go @@ -30,7 +30,7 @@ func dse(f *Func) { for _, a := range v.Args { if a.Block == b && a.Type.IsMemory() { storeUse.add(a.ID) - if v.Op != OpStore { + if v.Op != OpStore && v.Op != OpZero { // CALL, DUFFCOPY, etc. are both // reads and writes. loadUse.add(a.ID) @@ -77,12 +77,24 @@ func dse(f *Func) { // Clear all shadowed addresses. shadowed.clear() } - if v.Op == OpStore { + if v.Op == OpStore || v.Op == OpZero { if shadowed.contains(v.Args[0].ID) { // Modify store into a copy - v.Op = OpCopy + 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.SetArgs1(v.Args[2]) + v.AuxInt = 0 + v.Op = OpCopy } else { shadowed.add(v.Args[0].ID) } diff --git a/src/cmd/compile/internal/ssa/deadstore_test.go b/src/cmd/compile/internal/ssa/deadstore_test.go index 8c0a875cad..8d9b4b1298 100644 --- a/src/cmd/compile/internal/ssa/deadstore_test.go +++ b/src/cmd/compile/internal/ssa/deadstore_test.go @@ -4,9 +4,7 @@ package ssa -import ( - "testing" -) +import "testing" func TestDeadStore(t *testing.T) { c := testConfig(t) @@ -18,9 +16,12 @@ func TestDeadStore(t *testing.T) { Valu("v", OpConstBool, TypeBool, 0, true), Valu("addr1", OpAddr, ptrType, 0, nil, "sb"), Valu("addr2", OpAddr, ptrType, 0, nil, "sb"), - Valu("store1", OpStore, TypeMem, 0, nil, "addr1", "v", "start"), + Valu("addr3", OpAddr, ptrType, 0, nil, "sb"), + Valu("zero1", OpZero, TypeMem, 8, nil, "addr3", "start"), + Valu("store1", OpStore, TypeMem, 0, nil, "addr1", "v", "zero1"), Valu("store2", OpStore, TypeMem, 0, nil, "addr2", "v", "store1"), Valu("store3", OpStore, TypeMem, 0, nil, "addr1", "v", "store2"), + Valu("store4", OpStore, TypeMem, 0, nil, "addr3", "v", "store3"), Goto("exit")), Bloc("exit", Exit("store3"))) @@ -29,10 +30,15 @@ func TestDeadStore(t *testing.T) { dse(fun.f) CheckFunc(fun.f) - v := fun.values["store1"] - if v.Op != OpCopy { + 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. -- cgit v1.3 From ce9778891400e0c6b9ad245e1e9b4bca2a08a3c9 Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Tue, 11 Aug 2015 19:31:53 -0500 Subject: [dev.ssa] cmd/compile/ssa: fix test for dse Fix the test broken with dee1f2 by implementing Elem() Change-Id: I7a4a487885267c24fdc52d79fb7d450231328812 Reviewed-on: https://go-review.googlesource.com/13551 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/deadstore_test.go | 3 ++- src/cmd/compile/internal/ssa/type_test.go | 3 ++- 2 files changed, 4 insertions(+), 2 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/deadstore_test.go b/src/cmd/compile/internal/ssa/deadstore_test.go index 8d9b4b1298..634192f25b 100644 --- a/src/cmd/compile/internal/ssa/deadstore_test.go +++ b/src/cmd/compile/internal/ssa/deadstore_test.go @@ -8,7 +8,8 @@ import "testing" func TestDeadStore(t *testing.T) { c := testConfig(t) - ptrType := &TypeImpl{Size_: 8, Ptr: true, Name: "testptr"} // dummy for testing + 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", OpArg, TypeMem, 0, ".mem"), diff --git a/src/cmd/compile/internal/ssa/type_test.go b/src/cmd/compile/internal/ssa/type_test.go index 6f8dd6d937..29bd5cd131 100644 --- a/src/cmd/compile/internal/ssa/type_test.go +++ b/src/cmd/compile/internal/ssa/type_test.go @@ -14,6 +14,7 @@ type TypeImpl struct { Float bool Ptr bool string bool + Elem_ Type Name string } @@ -29,7 +30,7 @@ func (t *TypeImpl) IsString() bool { return t.string } func (t *TypeImpl) IsMemory() bool { return false } func (t *TypeImpl) IsFlags() bool { return false } func (t *TypeImpl) String() string { return t.Name } -func (t *TypeImpl) Elem() Type { panic("not implemented") } +func (t *TypeImpl) Elem() Type { return t.Elem_ } func (t *TypeImpl) PtrTo() Type { panic("not implemented") } func (t *TypeImpl) Equal(u Type) bool { -- cgit v1.3 From d56d2fa20611bd30fce294c2523b859600b8dc18 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Wed, 12 Aug 2015 12:54:47 -0700 Subject: [dev.ssa] cmd/compile: fix function call memory We need to move the memory variable update back to before endBlock so that all successors use the right memory value. See https://go-review.googlesource.com/13560 Change-Id: Id72e5526c56e5e070b933d3b28dc503a5a2978dc Reviewed-on: https://go-review.googlesource.com/13586 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/gc/ssa.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 75e12ee8f2..81f9c8f6ce 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1311,6 +1311,7 @@ func (s *state) expr(n *Node) *ssa.Value { } dowidth(left.Type) call.AuxInt = left.Type.Argwid // call operations carry the argsize of the callee along with them + s.vars[&memvar] = call b := s.endBlock() b.Kind = ssa.BlockCall b.Control = call @@ -1319,7 +1320,6 @@ func (s *state) expr(n *Node) *ssa.Value { // read result from stack at the start of the fallthrough block s.startBlock(bNext) - s.vars[&memvar] = call var titer Iter fp := Structfirst(&titer, Getoutarg(left.Type)) if fp == nil { -- cgit v1.3 From a2d1580fdb3fcac97391ba6574452b4dbe3f13f9 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Wed, 12 Aug 2015 10:12:14 -0700 Subject: [dev.ssa] cmd/compile: implement OSPTR Change-Id: Iaa40f14a1e3e4393af3c446953ffc315e79a3762 Reviewed-on: https://go-review.googlesource.com/13581 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 8 ++++++++ 1 file changed, 8 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 81f9c8f6ce..2a1c184803 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1268,6 +1268,14 @@ func (s *state) expr(n *Node) *ssa.Value { 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) -- cgit v1.3 From 212a1763fc7d0cf17ae9e27680dcb3e346d1c71b Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Wed, 12 Aug 2015 10:21:41 -0700 Subject: [dev.ssa] cmd/compile: update opnames This claims to be autogenerated from go tool dist, but I don't see where. In any case, the update is trivial. Change-Id: I58daaba755f3d34a0396005046b89411a02ada7e Reviewed-on: https://go-review.googlesource.com/13584 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/opnames.go | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/opnames.go b/src/cmd/compile/internal/gc/opnames.go index 9134bd4332..d5183234b9 100644 --- a/src/cmd/compile/internal/gc/opnames.go +++ b/src/cmd/compile/internal/gc/opnames.go @@ -159,5 +159,9 @@ var opnames = []string{ OLROT: "LROT", ORROTC: "RROTC", ORETJMP: "RETJMP", + OPS: "OPS", + OPC: "OPC", + OSQRT: "OSQRT", + OGETG: "OGETG", OEND: "END", } -- cgit v1.3 From bbf8c5ce2ffc7085bc63e2edf0117adaccada53e Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Tue, 11 Aug 2015 17:28:56 -0700 Subject: [dev.ssa] cmd/compile: initial implementation of likely direction Change-Id: Id8457b18c07bf717d13c9423d8f314f253eee64f Reviewed-on: https://go-review.googlesource.com/13580 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 34 +++++++++++++++++++++----- src/cmd/compile/internal/ssa/TODO | 2 +- src/cmd/compile/internal/ssa/block.go | 21 ++++++++++++++++ src/cmd/compile/internal/ssa/check.go | 3 +++ src/cmd/compile/internal/ssa/gen/rulegen.go | 13 ++++++++++ src/cmd/compile/internal/ssa/layout.go | 16 +++++++++++- src/cmd/compile/internal/ssa/rewritegeneric.go | 3 +++ 7 files changed, 84 insertions(+), 8 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 2a1c184803..0086feceab 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -504,7 +504,7 @@ func (s *state) stmt(n *Node) { b := s.endBlock() b.Kind = ssa.BlockIf b.Control = cond - // TODO(khr): likely direction + b.Likely = ssa.BranchPrediction(n.Likely) // gc and ssa both use -1/0/+1 for likeliness bThen := s.f.NewBlock(ssa.BlockPlain) bEnd := s.f.NewBlock(ssa.BlockPlain) @@ -613,7 +613,7 @@ func (s *state) stmt(n *Node) { b = s.endBlock() b.Kind = ssa.BlockIf b.Control = cond - // TODO(khr): likely direction + b.Likely = ssa.BranchLikely addEdge(b, bBody) addEdge(b, bEnd) @@ -1181,6 +1181,10 @@ func (s *state) expr(n *Node) *ssa.Value { 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) @@ -1516,8 +1520,9 @@ func (s *state) nilCheck(ptr *ssa.Value) { } c := s.newValue1(ssa.OpIsNonNil, Types[TBOOL], ptr) b := s.endBlock() - b.Kind = ssa.BlockIf // TODO: likeliness hint + b.Kind = ssa.BlockIf b.Control = c + b.Likely = ssa.BranchLikely bNext := s.f.NewBlock(ssa.BlockPlain) bPanic := s.f.NewBlock(ssa.BlockPlain) addEdge(b, bNext) @@ -1541,6 +1546,7 @@ func (s *state) boundsCheck(idx, len *ssa.Value) { b := s.endBlock() b.Kind = ssa.BlockIf b.Control = cmp + b.Likely = ssa.BranchLikely bNext := s.f.NewBlock(ssa.BlockPlain) addEdge(b, bNext) addEdge(b, s.exit) @@ -2295,17 +2301,20 @@ func genBlock(b, next *ssa.Block, branches []branch) []branch { 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) + p = Prog(jmp.invasm) + likely *= -1 p.To.Type = obj.TYPE_BRANCH branches = append(branches, branch{p, b.Succs[1]}) case b.Succs[1]: - p := Prog(jmp.asm) + p = Prog(jmp.asm) p.To.Type = obj.TYPE_BRANCH branches = append(branches, branch{p, b.Succs[0]}) default: - p := Prog(jmp.asm) + p = Prog(jmp.asm) p.To.Type = obj.TYPE_BRANCH branches = append(branches, branch{p, b.Succs[0]}) q := Prog(obj.AJMP) @@ -2313,6 +2322,19 @@ func genBlock(b, next *ssa.Block, branches []branch) []branch { branches = append(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()) } diff --git a/src/cmd/compile/internal/ssa/TODO b/src/cmd/compile/internal/ssa/TODO index 9f8225852c..d049bea872 100644 --- a/src/cmd/compile/internal/ssa/TODO +++ b/src/cmd/compile/internal/ssa/TODO @@ -33,7 +33,7 @@ Optimizations (better compiled code) - Implement memory zeroing with REPSTOSQ and DuffZero - Implement memory copying with REPMOVSQ and DuffCopy - Make deadstore work with zeroing -- Branch prediction: Respect hints from the frontend, add our own +- Add branch predictions - Add a value range propagation pass (for bounds elim & bitwidth reduction) - Stackalloc: group pointer-containing variables & spill slots together - Stackalloc: organize values to allow good packing diff --git a/src/cmd/compile/internal/ssa/block.go b/src/cmd/compile/internal/ssa/block.go index b788031fce..a67cdb5ac6 100644 --- a/src/cmd/compile/internal/ssa/block.go +++ b/src/cmd/compile/internal/ssa/block.go @@ -40,6 +40,13 @@ type Block struct { // 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 } // kind control successors @@ -67,9 +74,23 @@ func (b *Block) LongString() string { s += " " + c.String() } } + switch b.Likely { + case BranchUnlikely: + s += " (unlikely)" + case BranchLikely: + s += " (likely)" + } return s } func (b *Block) Logf(msg string, args ...interface{}) { b.Func.Logf(msg, args...) } 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 index 668828fcd1..dfb33dbd07 100644 --- a/src/cmd/compile/internal/ssa/check.go +++ b/src/cmd/compile/internal/ssa/check.go @@ -103,6 +103,9 @@ func checkFunc(f *Func) { f.Fatalf("exception edge from call block %s does not go to exit but %s", b, b.Succs[1]) } } + 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 { for _, arg := range v.Args { diff --git a/src/cmd/compile/internal/ssa/gen/rulegen.go b/src/cmd/compile/internal/ssa/gen/rulegen.go index 6ee22c1345..571389bb4c 100644 --- a/src/cmd/compile/internal/ssa/gen/rulegen.go +++ b/src/cmd/compile/internal/ssa/gen/rulegen.go @@ -254,6 +254,19 @@ func genRules(arch arch) { 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") + } fmt.Fprintf(w, "return true\n") diff --git a/src/cmd/compile/internal/ssa/layout.go b/src/cmd/compile/internal/ssa/layout.go index c2d72267b1..7e865f948e 100644 --- a/src/cmd/compile/internal/ssa/layout.go +++ b/src/cmd/compile/internal/ssa/layout.go @@ -47,7 +47,21 @@ blockloop: // Pick the next block to schedule // Pick among the successor blocks that have not been scheduled yet. - // Just use degree for now. TODO(khr): use likely direction hints. + + // 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 { diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index 9753bde45d..6371ac2b38 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -797,6 +797,7 @@ func rewriteBlockgeneric(b *Block) bool { b.Control = cond b.Succs[0] = no b.Succs[1] = yes + b.Likely *= -1 return true } goto endebe19c1c3c3bec068cdb2dd29ef57f96 @@ -821,6 +822,7 @@ func rewriteBlockgeneric(b *Block) bool { b.Control = nil b.Succs = b.Succs[:1] b.Succs[0] = yes + b.Likely = BranchUnknown return true } goto end9ff0273f9b1657f4afc287562ca889f0 @@ -845,6 +847,7 @@ func rewriteBlockgeneric(b *Block) bool { b.Control = nil b.Succs = b.Succs[:1] b.Succs[0] = no + b.Likely = BranchUnknown return true } goto endf401a4553c3c7c6bed64801da7bba076 -- cgit v1.3 From 3d23afb9133c151404635f2476bf895028b972bc Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Wed, 12 Aug 2015 11:22:16 -0700 Subject: [dev.ssa] cmd/compile: implement OGETG Change-Id: I7ecf62cf399c710b4a617803c43e83fce09b8a7d Reviewed-on: https://go-review.googlesource.com/13585 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 31 ++++++++++++++++++++++++++ src/cmd/compile/internal/ssa/gen/AMD64.rules | 1 + src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 3 ++- src/cmd/compile/internal/ssa/gen/generic.rules | 2 ++ src/cmd/compile/internal/ssa/gen/genericOps.go | 2 ++ src/cmd/compile/internal/ssa/opGen.go | 10 +++++++++ src/cmd/compile/internal/ssa/rewriteAMD64.go | 14 ++++++++++++ src/cmd/compile/internal/ssa/rewritegeneric.go | 24 ++++++++++++++++++++ src/cmd/internal/obj/x86/obj6.go | 4 ++-- 9 files changed, 88 insertions(+), 3 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 0086feceab..c8ec01f5b6 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1340,6 +1340,10 @@ func (s *state) expr(n *Node) *ssa.Value { } a := s.entryNewValue1I(ssa.OpOffPtr, Ptrto(fp.Type), fp.Width, s.sp) return s.newValue2(ssa.OpLoad, fp.Type, a, call) + + case OGETG: + return s.newValue0(ssa.OpGetG, n.Type) + default: s.Unimplementedf("unhandled expr %s", opnames[n.Op]) return nil @@ -2185,6 +2189,33 @@ func genValue(v *ssa.Value) { q.From.Reg = x86.REG_AX q.To.Type = obj.TYPE_MEM q.To.Reg = x86.REG_AX + 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 diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 29f60d9a6b..ab8e44a444 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -217,6 +217,7 @@ (IsInBounds idx len) -> (SETB (CMPQ idx len)) (PanicNilCheck ptr mem) -> (LoweredPanicNilCheck ptr mem) +(GetG) -> (LoweredGetG) (Move [size] dst src mem) -> (REPMOVSB dst src (MOVQconst [size]) mem) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 9808745e35..903eea3057 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -288,8 +288,9 @@ func init() { // InvertFlags is a pseudo-op which can't appear in assembly output. {name: "InvertFlags"}, // reverse direction of arg0 - // LoweredPanicNilCheck is a pseudo-op. + // Pseudo-ops {name: "LoweredPanicNilCheck"}, + {name: "LoweredGetG"}, } var AMD64blocks = []blockData{ diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index 8656b7cc4f..f4f49acb86 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -71,6 +71,8 @@ (StringLen (StringMake _ len)) -> len (Store dst str mem) && str.Type.IsString() -> (Store (OffPtr [config.PtrSize] dst) (StringLen str) (Store dst (StringPtr str) mem)) +(If (IsNonNil (GetG)) yes no) -> (Plain nil yes) + (If (Not cond) yes no) -> (If cond no yes) (If (ConstBool {c}) yes no) && c.(bool) -> (Plain nil yes) (If (ConstBool {c}) yes no) && !c.(bool) -> (Plain nil no) diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 6ff5d1ea1a..ec4f038f43 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -252,7 +252,9 @@ var genericOps = []opData{ {name: "IsNonNil"}, // arg0 != nil {name: "IsInBounds"}, // 0 <= arg0 < arg1 + // Pseudo-ops {name: "PanicNilCheck"}, // trigger a dereference fault; arg0=nil ptr, arg1=mem + {name: "GetG"}, // runtime.getg() (read g pointer) // Indexing operations {name: "ArrayIndex"}, // arg0=array, arg1=index. Returns a[i] diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index d56a8ba81b..425c7e468c 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -195,6 +195,7 @@ const ( OpAMD64REPMOVSB OpAMD64InvertFlags OpAMD64LoweredPanicNilCheck + OpAMD64LoweredGetG OpAdd8 OpAdd16 @@ -369,6 +370,7 @@ const ( OpIsNonNil OpIsInBounds OpPanicNilCheck + OpGetG OpArrayIndex OpPtrIndex OpOffPtr @@ -2119,6 +2121,10 @@ var opcodeTable = [...]opInfo{ name: "LoweredPanicNilCheck", reg: regInfo{}, }, + { + name: "LoweredGetG", + reg: regInfo{}, + }, { name: "Add8", @@ -2812,6 +2818,10 @@ var opcodeTable = [...]opInfo{ name: "PanicNilCheck", generic: true, }, + { + name: "GetG", + generic: true, + }, { name: "ArrayIndex", generic: true, diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 2668d570d1..a18097f91e 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -1893,6 +1893,20 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endd30ee67afc0284c419cef70261f61452 endd30ee67afc0284c419cef70261f61452: ; + case OpGetG: + // match: (GetG) + // cond: + // result: (LoweredGetG) + { + v.Op = OpAMD64LoweredGetG + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + return true + } + goto endb17140e71dd641aa4d89e14479160260 + endb17140e71dd641aa4d89e14479160260: + ; case OpGreater16: // match: (Greater16 x y) // cond: diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index 6371ac2b38..e39305461d 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -782,6 +782,30 @@ func rewriteValuegeneric(v *Value, config *Config) bool { func rewriteBlockgeneric(b *Block) bool { switch b.Kind { case BlockIf: + // match: (If (IsNonNil (GetG)) yes no) + // cond: + // result: (Plain nil yes) + { + v := b.Control + if v.Op != OpIsNonNil { + goto end0f2bb0111a86be0436b44210dbd83a90 + } + if v.Args[0].Op != OpGetG { + goto end0f2bb0111a86be0436b44210dbd83a90 + } + yes := b.Succs[0] + no := b.Succs[1] + b.Func.removePredecessor(b, no) + b.Kind = BlockPlain + b.Control = nil + b.Succs = b.Succs[:1] + b.Succs[0] = yes + b.Likely = BranchUnknown + return true + } + goto end0f2bb0111a86be0436b44210dbd83a90 + end0f2bb0111a86be0436b44210dbd83a90: + ; // match: (If (Not cond) yes no) // cond: // result: (If cond no yes) diff --git a/src/cmd/internal/obj/x86/obj6.go b/src/cmd/internal/obj/x86/obj6.go index fa9c474adb..5249ca9581 100644 --- a/src/cmd/internal/obj/x86/obj6.go +++ b/src/cmd/internal/obj/x86/obj6.go @@ -38,7 +38,7 @@ import ( "math" ) -func canuse1insntls(ctxt *obj.Link) bool { +func CanUse1InsnTLS(ctxt *obj.Link) bool { if ctxt.Arch.Regsize == 4 { switch ctxt.Headtype { case obj.Hlinux, @@ -120,7 +120,7 @@ func progedit(ctxt *obj.Link, p *obj.Prog) { // 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 -- cgit v1.3 From 514ab7c385116564d005c592e7473ba46c3fac87 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Wed, 12 Aug 2015 13:54:04 -0700 Subject: [dev.ssa] cmd/compile: log line numbers in generated rewrite rules This makes it easier to investigate and understand rewrite behavior. Change-Id: I790e8964922caf98362ce8a6d6972f52d83eefa8 Reviewed-on: https://go-review.googlesource.com/13588 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/gen/rulegen.go | 92 +- src/cmd/compile/internal/ssa/rewrite.go | 5 + src/cmd/compile/internal/ssa/rewriteAMD64.go | 1229 ++++++++++++++++++++++++ src/cmd/compile/internal/ssa/rewritegeneric.go | 113 +++ 4 files changed, 1398 insertions(+), 41 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/gen/rulegen.go b/src/cmd/compile/internal/ssa/gen/rulegen.go index 571389bb4c..ea7cf081e5 100644 --- a/src/cmd/compile/internal/ssa/gen/rulegen.go +++ b/src/cmd/compile/internal/ssa/gen/rulegen.go @@ -45,6 +45,35 @@ import ( // If multiple rules match, the first one in file order is selected. +type Rule struct { + rule string + lineno int +} + +func (r Rule) String() string { + return fmt.Sprintf("rule %q at line %d", r.rule, r.lineno) +} + +func (r Rule) hash() string { + return fmt.Sprintf("%02x", md5.Sum([]byte(r.rule))) +} + +// 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") @@ -53,13 +82,15 @@ func genRules(arch arch) { } // oprules contains a list of rules for each block and opcode - blockrules := map[string][]string{} - oprules := map[string][]string{} + 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 @@ -85,24 +116,25 @@ func genRules(arch arch) { op = op[:len(op)-1] // rule has only opcode, e.g. (ConstNil) -> ... } if isBlock(op, arch) { - blockrules[op] = append(blockrules[op], rule) + blockrules[op] = append(blockrules[op], Rule{rule: rule, lineno: lineno}) } else { - oprules[op] = append(oprules[op], rule) + oprules[op] = append(oprules[op], Rule{rule: rule, lineno: lineno}) } rule = "" } - if unbalanced(rule) { - log.Fatalf("unbalanced rule: %v\n", 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) + } // 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, "package ssa") + fmt.Fprintln(w, "import \"fmt\"") fmt.Fprintf(w, "func rewriteValue%s(v *Value, config *Config) bool {\n", arch.name) fmt.Fprintln(w, "b := v.Block") @@ -120,24 +152,9 @@ func genRules(arch arch) { // identity is invariant to adding/removing rules elsewhere // in the rules file. This is useful to squash spurious // diffs that would occur if we used rule index. - rulehash := fmt.Sprintf("%02x", md5.Sum([]byte(rule))) - - // split at -> - s := strings.Split(rule, "->") - if len(s) != 2 { - log.Fatalf("rule must contain exactly one arrow: %s", rule) - } - lhs := strings.TrimSpace(s[0]) - result := strings.TrimSpace(s[1]) - - // split match into matching part and additional condition - match := lhs - cond := "" - if i := strings.Index(match, "&&"); i >= 0 { - cond = strings.TrimSpace(match[i+2:]) - match = strings.TrimSpace(match[:i]) - } + rulehash := rule.hash() + 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) @@ -152,6 +169,9 @@ func genRules(arch arch) { } genResult(w, arch, result) + fmt.Fprintf(w, "if logRewriteRules {\n") + fmt.Fprintf(w, " fmt.Println(\"rewrite %s.rules:%d\")", arch.name, rule.lineno) + fmt.Fprintf(w, "}\n") fmt.Fprintf(w, "return true\n") fmt.Fprintf(w, "}\n") @@ -174,23 +194,9 @@ func genRules(arch arch) { for _, op := range ops { fmt.Fprintf(w, "case %s:\n", blockName(op, arch)) for _, rule := range blockrules[op] { - rulehash := fmt.Sprintf("%02x", md5.Sum([]byte(rule))) - // split at -> - s := strings.Split(rule, "->") - if len(s) != 2 { - log.Fatalf("no arrow in rule %s", rule) - } - lhs := strings.TrimSpace(s[0]) - result := strings.TrimSpace(s[1]) - - // split match into matching part and additional condition - match := lhs - cond := "" - if i := strings.Index(match, "&&"); i >= 0 { - cond = strings.TrimSpace(match[i+2:]) - match = strings.TrimSpace(match[:i]) - } + rulehash := rule.hash() + 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) @@ -198,7 +204,8 @@ func genRules(arch arch) { fail := fmt.Sprintf("{\ngoto end%s\n}\n", rulehash) fmt.Fprintf(w, "{\n") - s = split(match[1 : len(match)-1]) // remove parens, then split + + s := split(match[1 : len(match)-1]) // remove parens, then split // check match of control value if s[1] != "nil" { @@ -268,6 +275,9 @@ func genRules(arch arch) { fmt.Fprintln(w, "b.Likely = BranchUnknown") } + fmt.Fprintf(w, "if logRewriteRules {\n") + fmt.Fprintf(w, " fmt.Println(\"rewrite %s.rules:%d\")", arch.name, rule.lineno) + fmt.Fprintf(w, "}\n") fmt.Fprintf(w, "return true\n") fmt.Fprintf(w, "}\n") diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go index 39fc48df4a..ae3b889c39 100644 --- a/src/cmd/compile/internal/ssa/rewrite.go +++ b/src/cmd/compile/internal/ssa/rewrite.go @@ -6,6 +6,11 @@ package ssa import "fmt" +// Set to true to log all rewrite rules as they occur. +// This is useful for figuring out whether a rule is triggering +// and which rules are most heavily used. +const logRewriteRules = false + func applyRewrite(f *Func, rb func(*Block) bool, rv func(*Value, *Config) bool) { // repeat rewrites until we find no more rewrites var curb *Block diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index a18097f91e..d133b8db38 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -2,6 +2,8 @@ // generated with: cd gen; go run *.go package ssa +import "fmt" + func rewriteValueAMD64(v *Value, config *Config) bool { b := v.Block switch v.Op { @@ -21,6 +23,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:279") + } return true } goto endab690db69bfd8192eea57a2f9f76bf84 @@ -41,6 +46,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:280") + } return true } goto end28aa1a4abe7e1abcdd64135e9967d39d @@ -61,6 +69,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:523") + } return true } goto end9464509b8874ffb00b43b843da01f0bc @@ -81,6 +92,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c + d + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:481") + } return true } goto enda9b1e9e31ccdf0af5f4fe57bf4b1343f @@ -102,6 +116,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c + d v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:485") + } return true } goto end9b1e6890adbf9d9e447d591b4148cbd0 @@ -123,6 +140,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:275") + } return true } goto end8d6d3b99a7be8da6b7a254b7e709cc95 @@ -143,6 +163,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:276") + } return true } goto end739561e08a561e26ce3634dc0d5ec733 @@ -163,6 +186,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:521") + } return true } goto end9596df31f2685a49df67c6fb912a521d @@ -183,6 +209,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c + d + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:479") + } return true } goto ende04850e987890abf1d66199042a19c23 @@ -204,6 +233,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c + d v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:483") + } return true } goto endf1dd8673b2fef4950aec87aa7523a236 @@ -228,6 +260,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:273") + } return true } goto end1de8aeb1d043e0dadcffd169a99ce5c0 @@ -251,6 +286,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:274") + } return true } goto endca635e3bdecd9e3aeb892f841021dfaa @@ -274,6 +312,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:368") + } return true } goto endc02313d35a0525d1d680cd58992e820d @@ -294,6 +335,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:520") + } return true } goto endec8f899c6e175a0147a90750f9bfe0a2 @@ -318,6 +362,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = addOff(c, d) v.AddArg(x) v.AddArg(y) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:369") + } return true } goto ende2cc681c9abf9913288803fb1b39e639 @@ -337,6 +384,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:416") + } return true } goto end03d9f5a3e153048b0afa781401e2a849 @@ -356,6 +406,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c + d + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:478") + } return true } goto end09dc54395b4e96e8332cf8e4e7481c52 @@ -377,6 +430,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c + d v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:482") + } return true } goto endd4cb539641f0dc40bfd0cb7fbb9b0405 @@ -398,6 +454,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:277") + } return true } goto end1aabd2317de77c7dfc4876fd7e4c5011 @@ -418,6 +477,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:278") + } return true } goto ende3aede99966f388afc624f9e86676fd2 @@ -438,6 +500,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:522") + } return true } goto end55cf2af0d75f3ec413528eeb799e94d5 @@ -458,6 +523,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c + d + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:480") + } return true } goto end32541920f2f5a920dfae41d8ebbef00f @@ -479,6 +547,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c + d v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:484") + } return true } goto end73944f6ddda7e4c050f11d17484ff9a5 @@ -500,6 +571,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:306") + } return true } goto end01100cd255396e29bfdb130f4fbc9bbc @@ -520,6 +594,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:307") + } return true } goto end70830ce2834dc5f8d786fa6789460926 @@ -540,6 +617,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:308") + } return true } goto endd275ec2e73768cb3d201478fc934e06c @@ -560,6 +640,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:309") + } return true } goto end4068edac2ae0f354cf581db210288b98 @@ -579,6 +662,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:531") + } return true } goto endb8ff272a1456513da708603abe37541c @@ -598,6 +684,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 0 + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:462") + } return true } goto end2106d410c949da14d7c00041f40eca76 @@ -618,6 +707,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:466") + } return true } goto enda0b78503c204c8225de1433949a71fe4 @@ -637,6 +729,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c & d + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:504") + } return true } goto end946312b1f216933da86febe293eb956f @@ -658,6 +753,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:300") + } return true } goto end0a4c49d9a26759c0fd21369dafcd7abb @@ -678,6 +776,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:301") + } return true } goto end0529ba323d9b6f15c41add401ef67959 @@ -697,6 +798,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:529") + } return true } goto enddfb08a0d0c262854db3905cb323388c7 @@ -716,6 +820,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 0 + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:460") + } return true } goto end5efb241208aef28c950b7bcf8d85d5de @@ -736,6 +843,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:464") + } return true } goto end0e852ae30bb8289d6ffee0c9267e3e0c @@ -755,6 +865,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c & d + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:502") + } return true } goto end7bfd24059369753eadd235f07e2dd7b8 @@ -779,6 +892,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:298") + } return true } goto end048fadc69e81103480015b84b9cafff7 @@ -802,6 +918,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:299") + } return true } goto end3035a3bf650b708705fd27dd857ab0a4 @@ -821,6 +940,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:528") + } return true } goto end06b5ec19efdd4e79f03a5e4a2c3c3427 @@ -839,6 +961,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 0 + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:459") + } return true } goto end57018c1d0f54fd721521095b4832bab2 @@ -858,6 +983,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:463") + } return true } goto endb542c4b42ab94a7bedb32dec8f610d67 @@ -877,6 +1005,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c & d + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:501") + } return true } goto end67ca66494705b0345a5f22c710225292 @@ -898,6 +1029,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:302") + } return true } goto endce6f557823ee2fdd7a8f47b6f925fc7c @@ -918,6 +1052,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:303") + } return true } goto endc46af0d9265c08b09f1f1fba24feda80 @@ -938,6 +1075,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:304") + } return true } goto enda77a39f65a5eb3436a5842eab69a3103 @@ -958,6 +1098,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:305") + } return true } goto endea2a25eb525a5dbf6d5132d84ea4e7a5 @@ -977,6 +1120,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:530") + } return true } goto end3a26cf52dd1b77f07cc9e005760dbb11 @@ -996,6 +1142,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 0 + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:461") + } return true } goto end336ece33b4f0fb44dfe1f24981df7b74 @@ -1016,6 +1165,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:465") + } return true } goto endfb111c3afa8c5c4040fa6000fadee810 @@ -1035,6 +1187,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c & d + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:503") + } return true } goto end250eb27fcac10bf6c0d96ce66a21726e @@ -1053,6 +1208,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:16") + } return true } goto ende604481c6de9fe4574cb2954ba2ddc67 @@ -1071,6 +1229,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:15") + } return true } goto endc445ea2a65385445676cd684ae9a42b5 @@ -1089,6 +1250,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:13") + } return true } goto endd88f18b3f39e3ccc201477a616f0abc0 @@ -1107,6 +1271,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:17") + } return true } goto end6117c84a6b75c1b816b3fb095bc5f656 @@ -1125,6 +1292,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:14") + } return true } goto enda1d5640788c7157996f9d4af602dec1c @@ -1143,6 +1313,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Aux = sym v.AddArg(base) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:237") + } return true } goto end53cad0c3c9daa5575680e77c14e05e72 @@ -1161,6 +1334,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:35") + } return true } goto end1c01f04a173d86ce1a6d1ef59e753014 @@ -1179,6 +1355,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:34") + } return true } goto end6b9eb9375b3a859028a6ba6bf6b8ec88 @@ -1197,6 +1376,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:33") + } return true } goto enda0bde5853819d05fa2b7d3b723629552 @@ -1215,6 +1397,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:36") + } return true } goto end0f53bee6291f1229b43aa1b5f977b4f2 @@ -1236,6 +1421,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AuxInt = c + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:355") + } return true } goto end52190c0b8759133aa6c540944965c4c0 @@ -1259,6 +1447,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AuxInt = c v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:356") + } return true } goto end6798593f4f9a27e90de089b3248187fd @@ -1280,6 +1471,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AuxInt = c + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:351") + } return true } goto end49ff4559c4bdecb2aef0c905e2d9a6cf @@ -1303,6 +1497,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AuxInt = c v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:352") + } return true } goto end3c04e861f07a442be9e2f5e0e0d07cce @@ -1327,6 +1524,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AuxInt = c + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:349") + } return true } goto end3bbb2c6caa57853a7561738ce3c0c630 @@ -1353,6 +1553,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AuxInt = c v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:350") + } return true } goto end5edbe48a495a51ecabd3b2c0ed44a3d3 @@ -1374,6 +1577,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AuxInt = c + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:353") + } return true } goto end310a9ba58ac35c97587e08c63fe8a46c @@ -1397,6 +1603,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AuxInt = c v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:354") + } return true } goto end1ce191aaab0f4dd3b98dafdfbfac13ce @@ -1419,6 +1628,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(entry) v.AddArg(closure) v.AddArg(mem) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:267") + } return true } goto endfd75d26316012d86cb71d0dd1214259b @@ -1435,6 +1647,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:55") + } return true } goto end1b14ba8d7d7aa585ec0a211827f280ae @@ -1451,6 +1666,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:54") + } return true } goto end6eb124ba3bdb3fd6031414370852feb6 @@ -1467,6 +1685,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:53") + } return true } goto endf5f3b355a87779c347e305719dddda05 @@ -1483,6 +1704,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:56") + } return true } goto end1c7c5c055d663ccf1f05fbc4883030c6 @@ -1499,6 +1723,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = val + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:229") + } return true } goto end2c6c92f297873b8ac12bd035d56d001e @@ -1515,6 +1742,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = val + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:230") + } return true } goto enddae5807662af67143a3ac3ad9c63bae5 @@ -1531,6 +1761,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = val + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:231") + } return true } goto endc630434ae7f143ab69d5f482a9b52b5f @@ -1547,6 +1780,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = val + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:228") + } return true } goto end200524c722ed14ca935ba47f8f30327d @@ -1566,6 +1802,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 0 + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:234") + } return true } goto end876159ea073d2dcefcc251667c1a7780 @@ -1584,6 +1823,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 1 + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:235") + } return true } goto end0dacad3f7cad53905aad5303391447f6 @@ -1599,6 +1841,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 0 + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:233") + } return true } goto endea557d921056c25b945a49649e4b9b91 @@ -1615,6 +1860,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = val + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:232") + } return true } goto endc395c0a53eeccf597e225a07b53047d1 @@ -1636,6 +1884,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:195") + } return true } goto end66a03470b5b3e8457ba205ccfcaccea6 @@ -1657,6 +1908,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:194") + } return true } goto end4d77d0b016f93817fd6e5f60fa0e7ef2 @@ -1678,6 +1932,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:193") + } return true } goto endae6c62e4e20b4f62694b6ee40dbd9211 @@ -1699,6 +1956,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:196") + } return true } goto end84a692e769900e3adbfe00718d2169e0 @@ -1720,6 +1980,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:197") + } return true } goto end6de1d39c9d151e5e503d643bd835356e @@ -1741,6 +2004,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:185") + } return true } goto end26084bf821f9e418934fee812632b774 @@ -1762,6 +2028,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:190") + } return true } goto end20b00f850ca834cb2013414645c19ad9 @@ -1783,6 +2052,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:184") + } return true } goto end713c3dfa0f7247dcc232bcfc916fb044 @@ -1804,6 +2076,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:189") + } return true } goto endac2cde17ec6ab0107eabbda6407d1004 @@ -1825,6 +2100,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:183") + } return true } goto end63f44e3fec8d92723b5bde42d6d7eea0 @@ -1846,6 +2124,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:188") + } return true } goto endd8d2d9faa19457f6a7b0635a756d234f @@ -1867,6 +2148,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:186") + } return true } goto endb5f40ee158007e675b2113c3ce962382 @@ -1888,6 +2172,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:191") + } return true } goto endd30ee67afc0284c419cef70261f61452 @@ -1902,6 +2189,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:220") + } return true } goto endb17140e71dd641aa4d89e14479160260 @@ -1923,6 +2213,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:175") + } return true } goto end5bc9fdb7e563a6b949e42d721903cb58 @@ -1944,6 +2237,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:180") + } return true } goto endd5b646f04fd839d11082a9ff6adb4a3f @@ -1965,6 +2261,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:174") + } return true } goto endbf0b2b1368aadff48969a7386eee5795 @@ -1986,6 +2285,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:179") + } return true } goto end033c944272dc0af6fafe33f667cf7485 @@ -2007,6 +2309,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:173") + } return true } goto endaef0cfa5e27e23cf5e527061cf251069 @@ -2028,6 +2333,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:178") + } return true } goto end2afc16a19fe1073dfa86770a78eba2b4 @@ -2049,6 +2357,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:176") + } return true } goto endbdb1e5f6b760cf02e0fc2f474622e6be @@ -2070,6 +2381,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:181") + } return true } goto end22eaafbcfe70447f79d9b3e6cc395bbd @@ -2091,6 +2405,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(ptr) v.AddArg(mem) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:239") + } return true } goto enda49fcae3630a097c78aa58189c90a97a @@ -2112,6 +2429,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(idx) v0.AddArg(len) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:217") + } return true } goto endb51d371171154c0f1613b687757e0576 @@ -2132,6 +2452,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(p) v0.AddArg(p) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:216") + } return true } goto endff508c3726edfb573abc6128c177e76c @@ -2153,6 +2476,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:165") + } return true } goto endc1916dfcb3eae58ab237e40a57e1ff16 @@ -2174,6 +2500,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:170") + } return true } goto end627e261aea217b5d17177b52711b8c82 @@ -2195,6 +2524,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:164") + } return true } goto endf422ecc8da0033e22242de9c67112537 @@ -2216,6 +2548,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:169") + } return true } goto end1b39c9661896abdff8a29de509311b96 @@ -2237,6 +2572,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:163") + } return true } goto endf03da5e28dccdb4797671f39e824fb10 @@ -2258,6 +2596,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:168") + } return true } goto end37302777dd91a5d0c6f410a5444ccb38 @@ -2279,6 +2620,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:166") + } return true } goto end03be536eea60fdd98d48b17681acaf5a @@ -2300,6 +2644,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:171") + } return true } goto end661377f6745450bb1fa7fd0608ef0a86 @@ -2321,6 +2668,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:155") + } return true } goto endeb09704ef62ba2695a967b6fcb42e562 @@ -2342,6 +2692,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:160") + } return true } goto end2209a57bd887f68ad732aa7da2bc7286 @@ -2363,6 +2716,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:154") + } return true } goto end8da8d2030c0a323a84503c1240c566ae @@ -2384,6 +2740,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:159") + } return true } goto enddcfbbb482eb194146f4f7c8f12029a7a @@ -2405,6 +2764,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:153") + } return true } goto endf8e7a24c25692045bbcfd2c9356d1a8c @@ -2426,6 +2788,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:158") + } return true } goto end2fac0a2c2e972b5e04b5062d5786b87d @@ -2447,6 +2812,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:156") + } return true } goto end445ad05f8d23dfecf246ce083f1ea167 @@ -2468,6 +2836,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:161") + } return true } goto end816d1dff858c45836dfa337262e04649 @@ -2490,6 +2861,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(ptr) v.AddArg(mem) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:205") + } return true } goto end7c4c53acf57ebc5f03273652ba1d5934 @@ -2511,6 +2885,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(ptr) v.AddArg(mem) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:206") + } return true } goto ende1cfcb15bfbcfd448ce303d0882a4057 @@ -2532,6 +2909,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(ptr) v.AddArg(mem) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:207") + } return true } goto end2d0a1304501ed9f4e9e2d288505a9c7c @@ -2553,6 +2933,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(ptr) v.AddArg(mem) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:208") + } return true } goto end8f83bf72293670e75b22d6627bd13f0b @@ -2573,6 +2956,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Type = t v.AuxInt = c & 15 v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:107") + } return true } goto endb23dfa24c619d0068f925899d53ee7fd @@ -2593,6 +2979,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Type = t v.AuxInt = c & 31 v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:106") + } return true } goto end38b2215c011896c36845f72ecb72b1b0 @@ -2613,6 +3002,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Type = t v.AuxInt = c & 63 v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:105") + } return true } goto end5cb355e4f3ca387f252ef4f6a55f9f68 @@ -2633,6 +3025,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Type = t v.AuxInt = c & 7 v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:108") + } return true } goto end26bfb3dd5b537cf13ac9f2978d94ed71 @@ -2663,6 +3058,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:97") + } return true } goto end5b63495f0e75ac68c4ce9d4afa1472d4 @@ -2693,6 +3091,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:96") + } return true } goto end6384dd9bdcec3046732d7347250d49f6 @@ -2723,6 +3124,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:95") + } return true } goto end0975ca28988350db0ad556c925d8af07 @@ -2753,6 +3157,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:98") + } return true } goto endd17c913707f29d59cfcb5d57d5f5c6ff @@ -2783,6 +3190,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:92") + } return true } goto end027b6f888054cc1dd8911fe16a6315a1 @@ -2813,6 +3223,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:91") + } return true } goto endbcc31e2bd8800d5ddb27c09d37f867b9 @@ -2843,6 +3256,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:90") + } return true } goto end6797e3a3bbb0fe7eda819fe19a4d4b49 @@ -2873,6 +3289,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:93") + } return true } goto end7dd2c717933f46750e8a0871aab6fc63 @@ -2903,6 +3322,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:87") + } return true } goto end3a2fda1dddb29e49f46ccde6f5397222 @@ -2933,6 +3355,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:86") + } return true } goto end147322aba732027ac2290fd8173d806a @@ -2963,6 +3388,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:85") + } return true } goto endeb8e78c9c960fa12e29ea07a8519649b @@ -2993,6 +3421,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:88") + } return true } goto end42cdc11c34c81bbd5e8b4ad19ceec1ef @@ -3023,6 +3454,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:102") + } return true } goto end60bf962bf5256e20b547e18e3c886aa5 @@ -3053,6 +3487,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:101") + } return true } goto end8ed3445f6dbba1a87c80b140371445ce @@ -3083,6 +3520,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:100") + } return true } goto end0a03c9cc48ef1bfd74973de5f5fb02b0 @@ -3113,6 +3553,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:103") + } return true } goto end781e3a47b186cf99fcb7137afd3432b9 @@ -3134,6 +3577,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(ptr) v.AddArg(mem) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:384") + } return true } goto enda3a5eeb5767e31f42b0b6c1db8311ebb @@ -3155,6 +3601,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(ptr) v.AddArg(mem) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:385") + } return true } goto end9510a482da21d9945d53c4233b19e825 @@ -3178,6 +3627,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(ptr) v.AddArg(x) v.AddArg(mem) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:391") + } return true } goto endc356ef104095b9217b36b594f85171c6 @@ -3200,6 +3652,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(ptr) v.AddArg(x) v.AddArg(mem) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:394") + } return true } goto end25841a70cce7ac32c6d5e561b992d3df @@ -3223,6 +3678,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(ptr) v.AddArg(x) v.AddArg(mem) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:389") + } return true } goto endf79c699f70cb356abb52dc28f4abf46b @@ -3245,6 +3703,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(ptr) v.AddArg(x) v.AddArg(mem) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:392") + } return true } goto end67d1549d16d373e4ad6a89298866d1bc @@ -3269,6 +3730,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = addOff(off1, off2) v.AddArg(ptr) v.AddArg(mem) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:401") + } return true } goto end843d29b538c4483b432b632e5666d6e3 @@ -3298,6 +3762,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = mergeSym(sym1, sym2) v.AddArg(base) v.AddArg(mem) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:405") + } return true } goto end227426af95e74caddcf59fdcd30ca8bc @@ -3323,6 +3790,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(ptr) v.AddArg(idx) v.AddArg(mem) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:410") + } return true } goto end02f5ad148292c46463e7c20d3b821735 @@ -3349,6 +3819,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(ptr) v.AddArg(idx) v.AddArg(mem) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:413") + } return true } goto ende81e44bcfb11f90916ccb440c590121f @@ -3375,6 +3848,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(ptr) v.AddArg(val) v.AddArg(mem) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:402") + } return true } goto end2108c693a43c79aed10b9246c39c80aa @@ -3406,6 +3882,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(base) v.AddArg(val) v.AddArg(mem) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:407") + } return true } goto end5061f48193268a5eb1e1740bdd23c43d @@ -3433,6 +3912,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(idx) v.AddArg(val) v.AddArg(mem) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:411") + } return true } goto endce1db8c8d37c8397c500a2068a65c215 @@ -3461,6 +3943,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(idx) v.AddArg(val) v.AddArg(mem) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:414") + } return true } goto end01c970657b0fdefeab82458c15022163 @@ -3484,6 +3969,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(ptr) v.AddArg(x) v.AddArg(mem) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:390") + } return true } goto endcc13af07a951a61fcfec3299342f7e1f @@ -3506,6 +3994,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(ptr) v.AddArg(x) v.AddArg(mem) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:393") + } return true } goto end4e7df15ee55bdd73d8ecd61b759134d4 @@ -3527,6 +4018,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:293") + } return true } goto end893477a261bcad6c2821b77c83075c6c @@ -3547,6 +4041,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:294") + } return true } goto end8a0f957c528a54eecb0dbfc5d96e017a @@ -3567,6 +4064,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c * d + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:499") + } return true } goto endd5732835ed1276ef8b728bcfc1289f73 @@ -3591,6 +4091,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:291") + } return true } goto endb38c6e3e0ddfa25ba0ef9684ac1528c0 @@ -3614,6 +4117,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:292") + } return true } goto end9cb4f29b0bd7141639416735dcbb3b87 @@ -3633,6 +4139,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:359") + } return true } goto end82501cca6b5fb121a7f8b197e55f2fec @@ -3650,6 +4159,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 0 + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:360") + } return true } goto endcb9faa068e3558ff44daaf1d47d091b5 @@ -3669,6 +4181,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:361") + } return true } goto end0b527e71db2b288b2841a1f757aa580d @@ -3688,6 +4203,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:362") + } return true } goto end34a86f261671b5852bec6c57155fe0da @@ -3707,6 +4225,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:363") + } return true } goto end534601906c45a9171a9fec3e4b82b189 @@ -3726,6 +4247,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:364") + } return true } goto end48a2280b6459821289c56073b8354997 @@ -3746,6 +4270,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = log2(c) v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:365") + } return true } goto end75076953dbfe022526a153eda99b39b2 @@ -3765,6 +4292,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c * d + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:498") + } return true } goto end55c38c5c405101e610d7ba7fc702ddc0 @@ -3786,6 +4316,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:295") + } return true } goto end542112cc08217d4bdffc1a645d290ffb @@ -3806,6 +4339,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:296") + } return true } goto endd97b4245ced2b3d27d8c555b06281de4 @@ -3826,6 +4362,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c * d + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:500") + } return true } goto end61dbc9d9e93dd6946a20a1f475b3f74b @@ -3851,6 +4390,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AuxInt = size v.AddArg(v0) v.AddArg(mem) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:222") + } return true } goto end4dd156b33beb9981378c91e46f055a56 @@ -3869,6 +4411,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:27") + } return true } goto end1addf5ea2c885aa1729b8f944859d00c @@ -3887,6 +4432,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:26") + } return true } goto ende144381f85808e5144782804768e2859 @@ -3905,6 +4453,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:24") + } return true } goto end38da21e77ac329eb643b20e7d97d5853 @@ -3923,6 +4474,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:31") + } return true } goto end861428e804347e8489a6424f2e6ce71c @@ -3941,6 +4495,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:25") + } return true } goto endbbedad106c011a93243e2062afdcc75f @@ -3960,6 +4517,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = -c + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:497") + } return true } goto end36d0300ba9eab8c9da86246ff653ca96 @@ -3979,6 +4539,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = -c + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:495") + } return true } goto end7a245ec67e56bd51911e5ba2d0aa0a16 @@ -3998,6 +4561,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = -c + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:494") + } return true } goto end04ddd98bc6724ecb85c80c2a4e2bca5a @@ -4017,6 +4583,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = -c + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:496") + } return true } goto end1db6636f0a51848d8a34f6561ecfe7ae @@ -4036,6 +4605,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = ^c + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:516") + } return true } goto end9e383a9ceb29a9e2bf890ec6a67212a8 @@ -4055,6 +4627,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = ^c + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:514") + } return true } goto endcc73972c088d5e652a1370a96e56502d @@ -4074,6 +4649,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = ^c + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:513") + } return true } goto endb39ddb6bf7339d46f74114baad4333b6 @@ -4093,6 +4671,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = ^c + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:515") + } return true } goto end35848095ebcf894c6957ad3be5f82c43 @@ -4109,6 +4690,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:50") + } return true } goto end7a8c652f4ffeb49656119af69512edb2 @@ -4125,6 +4709,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:49") + } return true } goto endce1f7e17fc193f6c076e47d5e401e126 @@ -4141,6 +4728,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:48") + } return true } goto enda06c5b1718f2b96aba10bf5a5c437c6c @@ -4157,6 +4747,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:51") + } return true } goto end1e5f495a2ac6cdea47b1ae5ba62aa95d @@ -4178,6 +4771,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:201") + } return true } goto endf177c3b3868606824e43e11da7804572 @@ -4199,6 +4795,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:200") + } return true } goto end39c4bf6d063f8a0b6f0064c96ce25173 @@ -4220,6 +4819,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:199") + } return true } goto end8ab0bcb910c0d3213dd8726fbcc4848e @@ -4241,6 +4843,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:202") + } return true } goto end4aaff28af59a65b3684f4f1897299932 @@ -4262,6 +4867,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:203") + } return true } goto end6e180ffd9583cd55361ed3e465158a4c @@ -4279,6 +4887,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = 1 v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:224") + } return true } goto end73973101aad60079c62fa64624e21db1 @@ -4300,6 +4911,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:317") + } return true } goto end7b63870decde2515cb77ec4f8f76817c @@ -4320,6 +4934,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:318") + } return true } goto end70b43d531e2097a4f6293f66256a642e @@ -4339,6 +4956,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:535") + } return true } goto enddca5ce800a9eca157f243cb2fdb1408a @@ -4360,6 +4980,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:470") + } return true } goto end565f78e3a843dc73943b59227b39a1b3 @@ -4378,6 +5001,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = -1 + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:474") + } return true } goto end6033c7910d8cd536b31446e179e4610d @@ -4397,6 +5023,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c | d + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:508") + } return true } goto endbe5263f022dc10a5cf53c118937d79dd @@ -4418,6 +5047,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:313") + } return true } goto end1b883e30d860b6fac14ae98462c4f61a @@ -4438,6 +5070,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:314") + } return true } goto enda5bc49524a0cbd2241f792837d0a48a8 @@ -4457,6 +5092,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:533") + } return true } goto end2dd719b68f4938777ef0d820aab93659 @@ -4478,6 +5116,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:468") + } return true } goto end5b52623a724e8a7167c71289fb7192f1 @@ -4496,6 +5137,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = -1 + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:472") + } return true } goto end345a8ea439ef2ef54bd84fc8a0f73e97 @@ -4515,6 +5159,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c | d + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:506") + } return true } goto ende9ca05024248f782c88084715f81d727 @@ -4539,6 +5186,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:311") + } return true } goto end601f2bb3ccda102e484ff60adeaf6d26 @@ -4562,6 +5212,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:312") + } return true } goto end010afbebcd314e288509d79a16a6d5cc @@ -4581,6 +5234,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:532") + } return true } goto end47a27d30b82db576978c5a3a57b520fb @@ -4601,6 +5257,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:467") + } return true } goto end44534da6b9ce98d33fad7e20f0be1fbd @@ -4618,6 +5277,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = -1 + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:471") + } return true } goto endcde9b9d7c4527eaa5d50b252f50b43c1 @@ -4637,6 +5299,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c | d + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:505") + } return true } goto enda2488509b71db9abcb06a5115c4ddc2c @@ -4658,6 +5323,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:315") + } return true } goto end9f98df10892dbf170b49aace86ee0d7f @@ -4678,6 +5346,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:316") + } return true } goto end96405942c9ceb5fcb0ddb85a8709d015 @@ -4697,6 +5368,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:534") + } return true } goto endc6a23b64e541dc9cfc6a90fd7028e8c1 @@ -4718,6 +5392,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:469") + } return true } goto endbbbdec9091c8b4c58e587eac8a43402d @@ -4736,6 +5413,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = -1 + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:473") + } return true } goto ended87a5775f5e04b2d2a117a63d82dd9b @@ -4755,6 +5435,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c | d + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:507") + } return true } goto endba9221a8462b5c62e8d7c686f64c2778 @@ -4773,6 +5456,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = off v.AddArg(ptr) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:226") + } return true } goto end0429f947ee7ac49ff45a243e461a5290 @@ -4791,6 +5477,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:40") + } return true } goto end8fedf2c79d5607b7056b0ff015199cbd @@ -4809,6 +5498,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:39") + } return true } goto endea45bed9ca97d2995b68b53e6012d384 @@ -4827,6 +5519,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:38") + } return true } goto end3a446becaf2461f4f1a41faeef313f41 @@ -4845,6 +5540,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:41") + } return true } goto end6f8a8c559a167d1f0a5901d09a1fb248 @@ -4863,6 +5561,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(ptr) v.AddArg(mem) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:219") + } return true } goto enda02b1ad5a6f929b782190145f2c8628b @@ -4893,6 +5594,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:122") + } return true } goto end73239750a306668023d2c49875ac442f @@ -4923,6 +5627,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:121") + } return true } goto end9951e3b2e92c892256feece722b32219 @@ -4953,6 +5660,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:120") + } return true } goto end610d56d808c204abfa40d653447b2c17 @@ -4983,6 +5693,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:123") + } return true } goto end45e76a8d2b004e6802d53cf12b4757b3 @@ -5017,6 +5730,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:145") + } return true } goto endbcd8fd69ada08517f6f94f35da91e1c3 @@ -5051,6 +5767,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:144") + } return true } goto endec3994083e7f82857ecec05906c29aa6 @@ -5085,6 +5804,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:143") + } return true } goto end19da3883e21ffa3a45d7fc648ef38b66 @@ -5119,6 +5841,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:146") + } return true } goto end3c989f6931d059ea04e4ba93601b6c51 @@ -5149,6 +5874,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:117") + } return true } goto end056ede9885a9fc2f32615a2a03b35388 @@ -5179,6 +5907,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:116") + } return true } goto end30439bdc3517479ea25ae7f54408ba7f @@ -5209,6 +5940,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:115") + } return true } goto end49b47fd18b54461d8eea51f6e5889cd2 @@ -5239,6 +5973,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:118") + } return true } goto end46e045970a8b1afb9035605fc0e50c69 @@ -5273,6 +6010,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:140") + } return true } goto end5d1b8d7e1d1e53e621d13bb0eafc9102 @@ -5307,6 +6047,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:139") + } return true } goto end9c27383961c2161a9955012fce808cab @@ -5341,6 +6084,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:138") + } return true } goto end75dc7144497705c800e0c60dcd4a2828 @@ -5375,6 +6121,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:141") + } return true } goto enda7b94b2fd5cbcd12bb2dcd576bdca481 @@ -5405,6 +6154,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:112") + } return true } goto endc4bdfdc375a5c94978d936bd0db89cc5 @@ -5435,6 +6187,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:111") + } return true } goto end217f32bca5f6744b9a7de052f4fae13e @@ -5465,6 +6220,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:110") + } return true } goto end530dee0bcadf1cf5d092894b6210ffcd @@ -5495,6 +6253,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:113") + } return true } goto endf09baf4e0005c5eb4905f71ce4c8b306 @@ -5529,6 +6290,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:135") + } return true } goto endb370ee74ca256a604138321ddca9d543 @@ -5563,6 +6327,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:134") + } return true } goto end3cc6edf5b286a449332757ea12d2d601 @@ -5597,6 +6364,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:133") + } return true } goto end45de7b33396d9fd2ba377bd095f1d7a6 @@ -5631,6 +6401,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:136") + } return true } goto ende03fa68104fd18bb9b2bb94370e0c8b3 @@ -5661,6 +6434,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:127") + } return true } goto enda1adfc560334e10d5e83fbff27a8752f @@ -5691,6 +6467,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:126") + } return true } goto end17f63b4b712e715a33ac780193b59c2e @@ -5721,6 +6500,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:125") + } return true } goto end77d5c3ef9982ebd27c135d3461b7430b @@ -5751,6 +6533,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:128") + } return true } goto end206712ffbda924142afbf384aeb8f09e @@ -5785,6 +6570,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:150") + } return true } goto endd303f390b49d9716dc783d5c4d57ddd1 @@ -5819,6 +6607,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:149") + } return true } goto ende12a524a6fc68eb245140c6919034337 @@ -5853,6 +6644,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:148") + } return true } goto end6ee53459daa5458d163c86ea02dd2f31 @@ -5887,6 +6681,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:151") + } return true } goto end07f447a7e25b048c41d412c242330ec0 @@ -5908,6 +6705,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c & 31 v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:342") + } return true } goto end3bf3d17717aa6c04462e56d1c87902ce @@ -5929,6 +6729,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c & 31 v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:340") + } return true } goto ende586a72c1b232ee0b63e37c71eeb8470 @@ -5950,6 +6753,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c & 63 v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:339") + } return true } goto end25e720ab203be2745dded5550e6d8a7c @@ -5971,6 +6777,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c & 31 v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:341") + } return true } goto endc46e3f211f94238f9a0aec3c498af490 @@ -5997,6 +6806,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = -1 + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:451") + } return true } goto enda9e02a887246381d02b3259b9df4050c @@ -6022,6 +6834,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 0 + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:452") + } return true } goto end3f8220527278b72a64148fcf9dc58bfe @@ -6047,6 +6862,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = -1 + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:453") + } return true } goto end880a2b9a12ed4f551bbd46473b9439bc @@ -6072,6 +6890,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 0 + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:454") + } return true } goto end3f08080e0f55d51afca2a131ed0c672e @@ -6097,6 +6918,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = -1 + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:455") + } return true } goto end91ed02166e0c0d696730e1704d0a682e @@ -6122,6 +6946,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 0 + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:456") + } return true } goto endc7edc3a13ec73ec4e6e87e7ab421a71a @@ -6147,6 +6974,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = -1 + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:457") + } return true } goto end0fe2997fc76ce00b1d496f7289ab345a @@ -6172,6 +7002,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 0 + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:458") + } return true } goto end3a07121fcc82f1a19da4226b07a757ce @@ -6198,6 +7031,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = -1 + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:443") + } return true } goto end378de7e659770f877c08b6b269073069 @@ -6223,6 +7059,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 0 + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:444") + } return true } goto enda7bfd1974bf83ca79653c560a718a86c @@ -6248,6 +7087,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = -1 + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:445") + } return true } goto end8c6d39847239120fa0fe953007eb40ae @@ -6273,6 +7115,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 0 + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:446") + } return true } goto end20885e855545e16ca77af2b9a2b69ea9 @@ -6298,6 +7143,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = -1 + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:447") + } return true } goto end16f61db69d07e67e9f408c2790a9de7c @@ -6323,6 +7171,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 0 + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:448") + } return true } goto end191ca427f7d5d2286bd290920c84a51d @@ -6348,6 +7199,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = -1 + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:449") + } return true } goto end3fd3f1e9660b9050c6a41b4fc948f793 @@ -6373,6 +7227,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 0 + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:450") + } return true } goto ende0d6edd92ae98e6dc041f65029d8b243 @@ -6392,6 +7249,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:375") + } return true } goto enda4ac36e94fc279d762b5a6c7c6cc665d @@ -6411,6 +7271,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:379") + } return true } goto end0468f5be6caf682fdea6b91d6648991e @@ -6430,6 +7293,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:374") + } return true } goto endc9eba7aa1e54a228570d2f5cc96f3565 @@ -6449,6 +7315,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:378") + } return true } goto end9d9031643469798b14b8cad1f5a7a1ba @@ -6468,6 +7337,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:380") + } return true } goto end5d2039c9368d8c0cfba23b5a85b459e1 @@ -6487,6 +7359,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:373") + } return true } goto endf7586738694c9cd0b74ae28bbadb649f @@ -6506,6 +7381,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:377") + } return true } goto end82c11eff6f842159f564f2dad3d2eedc @@ -6525,6 +7403,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:372") + } return true } goto ende33160cd86b9d4d3b77e02fb4658d5d3 @@ -6544,6 +7425,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:376") + } return true } goto end9307d96753efbeb888d1c98a6aba7a29 @@ -6563,6 +7447,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:381") + } return true } goto endbc71811b789475308014550f638026eb @@ -6584,6 +7471,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c & 31 v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:332") + } return true } goto end2d0d0111d831d8a575b5627284a6337a @@ -6605,6 +7495,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c & 31 v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:330") + } return true } goto end633f9ddcfbb63374c895a5f78da75d25 @@ -6626,6 +7519,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c & 63 v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:329") + } return true } goto end4d7e3a945cacdd6b6c8c0de6f465d4ae @@ -6647,6 +7543,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c & 31 v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:331") + } return true } goto endba96a52aa58d28b3357828051e0e695c @@ -6668,6 +7567,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c & 31 v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:337") + } return true } goto enddb1cd5aaa826d43fa4f6d1b2b8795e58 @@ -6689,6 +7591,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c & 31 v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:335") + } return true } goto end344b8b9202e1925e8d0561f1c21412fc @@ -6710,6 +7615,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c & 63 v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:334") + } return true } goto end699d35e2d5cfa08b8a3b1c8a183ddcf3 @@ -6731,6 +7639,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c & 31 v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:336") + } return true } goto endd75ff1f9b3e9ec9c942a39b6179da1b3 @@ -6752,6 +7663,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AuxInt = c + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:288") + } return true } goto end9ca5d2a70e2df1a5a3ed6786bce1f7b2 @@ -6775,6 +7689,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AuxInt = c v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:289") + } return true } goto endc288755d69b04d24a6aac32a73956411 @@ -6793,6 +7710,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 0 + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:527") + } return true } goto ende8904403d937d95b0d6133d3ec92bb45 @@ -6813,6 +7733,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c - d + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:489") + } return true } goto end0e2d5c3e3c02001a20d5433daa9e8317 @@ -6834,6 +7757,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c - d v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:493") + } return true } goto end48eccb421dfe0c678ea9c47113521d5a @@ -6855,6 +7781,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AuxInt = c + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:284") + } return true } goto end178c1d6c86f9c16f6497586c2f7d8625 @@ -6878,6 +7807,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AuxInt = c v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:285") + } return true } goto endb0efe6e15ec20486b849534a00483ae2 @@ -6896,6 +7828,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 0 + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:525") + } return true } goto end332f1f641f875c69bea7289191e69133 @@ -6916,6 +7851,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c - d + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:487") + } return true } goto endbe7466f3c09d9645544bdfc44c37c922 @@ -6937,6 +7875,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c - d v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:491") + } return true } goto endb5106962a865bc4654b170c2e29a72c4 @@ -6961,6 +7902,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AuxInt = c + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:282") + } return true } goto end9bbb7b20824a498752c605942fad89c2 @@ -6987,6 +7931,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AuxInt = c v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:283") + } return true } goto end8beb96de3efee9206d1bd4b7d777d2cb @@ -7005,6 +7952,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 0 + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:524") + } return true } goto endd87d1d839d2dc54d9c90fa4f73383480 @@ -7025,6 +7975,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c - d + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:486") + } return true } goto end96c09479fb3c043e875d89d3eb92f1d8 @@ -7046,6 +7999,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c - d v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:490") + } return true } goto enddd9d61b404480adb40cfd7fedd7e5ec4 @@ -7067,6 +8023,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AuxInt = c + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:286") + } return true } goto end135aa9100b2f61d58b37cede37b63731 @@ -7090,6 +8049,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AuxInt = c v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:287") + } return true } goto end44d23f7e65a4b1c42d0e6463f8e493b6 @@ -7108,6 +8070,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 0 + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:526") + } return true } goto endb970e7c318d04a1afe1dfe08a7ca0d9c @@ -7128,6 +8093,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c - d + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:488") + } return true } goto end0e5079577fcf00f5925291dbd68306aa @@ -7149,6 +8117,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c - d v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:492") + } return true } goto endb628696cf5b329d03782b8093093269b @@ -7165,6 +8136,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:62") + } return true } goto end21e4271c2b48a5aa3561ccfa8fa67cd9 @@ -7181,6 +8155,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:63") + } return true } goto endc6d242ee3a3e195ef0f9e8dae47ada75 @@ -7197,6 +8174,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:64") + } return true } goto endb9f1a8b2d01eee44964a71a01bca165c @@ -7213,6 +8193,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:59") + } return true } goto end372869f08e147404b80634e5f83fd506 @@ -7229,6 +8212,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:60") + } return true } goto end913e3575e5b4cf7f60585c108db40464 @@ -7245,6 +8231,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:61") + } return true } goto endcef6d6001d3f25cf5dacee11a46e5c8c @@ -7265,6 +8254,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = argwid v.Aux = target v.AddArg(mem) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:266") + } return true } goto end32c5cbec813d1c2ae94fc9b1090e4b2a @@ -7288,6 +8280,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(ptr) v.AddArg(val) v.AddArg(mem) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:209") + } return true } goto endbaeb60123806948cd2433605820d5af1 @@ -7310,6 +8305,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(ptr) v.AddArg(val) v.AddArg(mem) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:210") + } return true } goto end582e895008657c728c141c6b95070de7 @@ -7332,6 +8330,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(ptr) v.AddArg(val) v.AddArg(mem) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:211") + } return true } goto enda3f6a985b6ebb277665f80ad30b178df @@ -7354,6 +8355,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(ptr) v.AddArg(val) v.AddArg(mem) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:212") + } return true } goto ende2dee0bc82f631e3c6b0031bf8d224c1 @@ -7376,6 +8380,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(ptr) v.AddArg(val) v.AddArg(mem) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:213") + } return true } goto end6f343b676bf49740054e459f972b24f5 @@ -7394,6 +8401,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:21") + } return true } goto end54adc5de883c0460ca71c6ee464d4244 @@ -7412,6 +8422,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:20") + } return true } goto enddc3a2a488bda8c5856f93343e5ffe5f8 @@ -7430,6 +8443,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:19") + } return true } goto endd88d5646309fd9174584888ecc8aca2c @@ -7448,6 +8464,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:22") + } return true } goto end7d33bf9bdfa505f96b930563eca7955f @@ -7465,6 +8484,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:74") + } return true } goto end8e2f5e0a6e3a06423c077747de6c2bdd @@ -7482,6 +8504,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:76") + } return true } goto end5bed0e3a3c1c6374d86beb5a4397708c @@ -7499,6 +8524,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:75") + } return true } goto endef0b8032ce91979ce6cd0004260c04ee @@ -7516,6 +8544,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:78") + } return true } goto endd32fd6e0ce970c212835e6f71c3dcbfd @@ -7533,6 +8564,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:79") + } return true } goto end1212c4e84153210aff7fd630fb3e1883 @@ -7550,6 +8584,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:77") + } return true } goto end734f017d4b2810ca2288f7037365824c @@ -7571,6 +8608,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:326") + } return true } goto enda9ed9fdd115ffdffa8127c007c34d7b7 @@ -7591,6 +8631,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:327") + } return true } goto endb02a07d9dc7b802c59f013116e952f3f @@ -7609,6 +8652,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 0 + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:539") + } return true } goto end2afddc39503d04d572a3a07878f6c9c9 @@ -7629,6 +8675,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c ^ d + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:512") + } return true } goto end6d8d1b612af9d253605c8bc69b822903 @@ -7650,6 +8699,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:322") + } return true } goto enda9459d509d3416da67d13a22dd074a9c @@ -7670,6 +8722,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:323") + } return true } goto end9c1a0af00eeadd8aa325e55f1f3fb89c @@ -7688,6 +8743,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 0 + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:537") + } return true } goto end7bcf9cfeb69a0d7647389124eb53ce2a @@ -7708,6 +8766,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c ^ d + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:510") + } return true } goto end71238075b10b68a226903cc453c4715c @@ -7732,6 +8793,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:320") + } return true } goto end452341f950062e0483f16438fb9ec500 @@ -7755,6 +8819,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:321") + } return true } goto endd221a7e3daaaaa29ee385ad36e061b57 @@ -7773,6 +8840,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 0 + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:536") + } return true } goto end10575a5d711cf14e6d4dffbb0e8dfaeb @@ -7793,6 +8863,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c ^ d + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:509") + } return true } goto end3f404d4f07362319fbad2e1ba0827a9f @@ -7814,6 +8887,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:324") + } return true } goto end2ca109efd66c221a5691a4da95ec6c67 @@ -7834,6 +8910,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:325") + } return true } goto end51ee62a06d4301e5a4aed7a6639b1d53 @@ -7852,6 +8931,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 0 + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:538") + } return true } goto end07f332e857be0c2707797ed480a2faf4 @@ -7872,6 +8954,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c ^ d + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:511") + } return true } goto ende24881ccdfa8486c4593fd9aa5df1ed6 @@ -7890,6 +8975,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:45") + } return true } goto end20efdd5dfd5130abf818de5546a991a0 @@ -7908,6 +8996,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:44") + } return true } goto end9da6bce98b437e2609488346116a75d8 @@ -7926,6 +9017,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:43") + } return true } goto endc88cd189c2a6f07ecff324ed94809f8f @@ -7944,6 +9038,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:46") + } return true } goto end50f4434ef96916d3e65ad3cc236d1723 @@ -7964,6 +9061,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = mem.Type v.AddArg(mem) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:419") + } return true } goto endc9a38a60f0322f93682daa824611272c @@ -7988,6 +9088,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AuxInt = 0 v.AddArg(v0) v.AddArg(mem) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:420") + } return true } goto end56bcaef03cce4d15c03efff669bb5585 @@ -8012,6 +9115,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AuxInt = 0 v.AddArg(v0) v.AddArg(mem) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:421") + } return true } goto endf52f08f1f7b0ae220c4cfca6586a8586 @@ -8036,6 +9142,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AuxInt = 0 v.AddArg(v0) v.AddArg(mem) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:422") + } return true } goto end41c91e0c7a23e233de77812b5264fd10 @@ -8060,6 +9169,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AuxInt = 0 v.AddArg(v0) v.AddArg(mem) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:423") + } return true } goto end157ad586af643d8dac6cc84a776000ca @@ -8082,6 +9194,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = size v.AddArg(destptr) v.AddArg(mem) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:426") + } return true } goto endf0a22f1506977610ac0a310eee152075 @@ -8116,6 +9231,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1.AddArg(v2) v1.AddArg(mem) v.AddArg(v1) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:428") + } return true } goto end84c39fe2e8d40e0042a10741a0ef16bd @@ -8132,6 +9250,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:69") + } return true } goto endbfff79412a2cc96095069c66812844b4 @@ -8148,6 +9269,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:70") + } return true } goto end7a40262c5c856101058d2bd518ed0910 @@ -8164,6 +9288,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:71") + } return true } goto enddf83bdc8cc6c5673a9ef7aca7affe45a @@ -8180,6 +9307,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:66") + } return true } goto endd03d53d2a585727e4107ae1a3cc55479 @@ -8196,6 +9326,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:67") + } return true } goto endcbd33e965b3dab14fced5ae93d8949de @@ -8212,6 +9345,9 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:68") + } return true } goto end63ae7cc15db9d15189b2f1342604b2cb @@ -8237,6 +9373,9 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:439") + } return true } goto end6b8e9afc73b1c4d528f31a60d2575fae @@ -8258,6 +9397,9 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:434") + } return true } goto end0610f000a6988ee8310307ec2ea138f8 @@ -8279,6 +9421,9 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:432") + } return true } goto endf60c0660b6a8aa9565c97fc87f04eb34 @@ -8300,6 +9445,9 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:242") + } return true } goto end94277282f4b83f0c035b23711a075801 @@ -8320,6 +9468,9 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:243") + } return true } goto enda84798dd797927b54a9a2987421b2ba2 @@ -8340,6 +9491,9 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:244") + } return true } goto end3434ef985979cbf394455ab5b559567c @@ -8360,6 +9514,9 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:245") + } return true } goto endee147d81d8620a5e23cb92bd9f13cf8d @@ -8380,6 +9537,9 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:246") + } return true } goto ende7d85ccc850fc3963c50a91df096de17 @@ -8400,6 +9560,9 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:247") + } return true } goto endba4b54260ecda1b5731b129c0eb493d0 @@ -8420,6 +9583,9 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:248") + } return true } goto endf84eedfcd3f18f5c9c3f3d1045a24330 @@ -8440,6 +9606,9 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:249") + } return true } goto endfe0178f6f4406945ca8966817d04be60 @@ -8460,6 +9629,9 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:250") + } return true } goto end2b5a2d7756bdba01a732bf54d9acdb73 @@ -8480,6 +9652,9 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:251") + } return true } goto end9bea9963c3c5dfb97249a5feb8287f94 @@ -8501,6 +9676,9 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = v0 b.Succs[0] = yes b.Succs[1] = no + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:253") + } return true } goto end012351592edfc708bd3181d7e53f3993 @@ -8522,6 +9700,9 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:433") + } return true } goto end0d49d7d087fe7578e8015cf13dae37e3 @@ -8543,6 +9724,9 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:431") + } return true } goto end6a408cde0fee0ae7b7da0443c8d902bf @@ -8567,6 +9751,9 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:255") + } return true } goto end0b9ca165d6b395de676eebef94bc62f7 @@ -8590,6 +9777,9 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:256") + } return true } goto endaaba0ee4d0ff8c66a1c3107d2a14c4bc @@ -8613,6 +9803,9 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:257") + } return true } goto end1b689463137526b36ba9ceed1e76e512 @@ -8636,6 +9829,9 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:258") + } return true } goto end99eefee595c658b997f41577ed853c2e @@ -8659,6 +9855,9 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:259") + } return true } goto end371b67d3d63e9b92d848b09c3324e8b9 @@ -8682,6 +9881,9 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:260") + } return true } goto endd245f2aac2191d32e57cd2e321daa453 @@ -8705,6 +9907,9 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:261") + } return true } goto end90c4bec851e734d37457d611b1a5ff28 @@ -8728,6 +9933,9 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:262") + } return true } goto end3a68a28114e9b89ee0708823386bc1ee @@ -8751,6 +9959,9 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:263") + } return true } goto end16496f57185756e960d536b057c776c0 @@ -8774,6 +9985,9 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:264") + } return true } goto endbd122fd599aeb9e60881a0fa735e2fde @@ -8794,6 +10008,9 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:440") + } return true } goto end713001aba794e50b582fbff930e110af @@ -8815,6 +10032,9 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:438") + } return true } goto ende3e4ddc183ca1a46598b11c2d0d13966 @@ -8836,6 +10056,9 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:436") + } return true } goto end49818853af2e5251175d06c62768cae7 @@ -8857,6 +10080,9 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:437") + } return true } goto endd6698aac0d67261293b558c95ea17b4f @@ -8878,6 +10104,9 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no + if logRewriteRules { + fmt.Println("rewrite AMD64.rules:435") + } return true } goto end35105dbc9646f02577167e45ae2f2fd2 diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index e39305461d..7f787fc57e 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -2,6 +2,8 @@ // generated with: cd gen; go run *.go package ssa +import "fmt" + func rewriteValuegeneric(v *Value, config *Config) bool { b := v.Block switch v.Op { @@ -23,6 +25,9 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c + d + if logRewriteRules { + fmt.Println("rewrite generic.rules:23") + } return true } goto end8c46df6f85a11cb1d594076b0e467908 @@ -46,6 +51,9 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c + d + if logRewriteRules { + fmt.Println("rewrite generic.rules:24") + } return true } goto end145c1aec793b2befff34bc8983b48a38 @@ -72,6 +80,9 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v0.AddArg(idx) v.AddArg(v0) v.AddArg(mem) + if logRewriteRules { + fmt.Println("rewrite generic.rules:59") + } return true } goto end4894dd7b58383fee5f8a92be08437c33 @@ -92,6 +103,9 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite generic.rules:38") + } return true } goto end1ea17710dd4dd7ba4e710e0e4c7b5a56 @@ -112,6 +126,9 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite generic.rules:39") + } return true } goto end9a04ed536496e292c27bef4414128cbf @@ -132,6 +149,9 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite generic.rules:40") + } return true } goto ended44e29d5968f0f7b86972b7bf417ab3 @@ -152,6 +172,9 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite generic.rules:37") + } return true } goto end4d92ff3ba567d9afd38fc9ca113602ad @@ -178,6 +201,9 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v2.Type = config.Frontend().TypeUintptr() v2.AuxInt = int64(len(s.(string))) v.AddArg(v2) + if logRewriteRules { + fmt.Println("rewrite generic.rules:68") + } return true } goto end68cc91679848c7c30bd8b0a8ed533843 @@ -197,6 +223,9 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.Aux = true + if logRewriteRules { + fmt.Println("rewrite generic.rules:30") + } return true } goto enda503589f9b617e708a5ad3ddb047809f @@ -216,6 +245,9 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.Aux = true + if logRewriteRules { + fmt.Println("rewrite generic.rules:29") + } return true } goto endc94ae3b97d0090257b02152e437b3e17 @@ -235,6 +267,9 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.Aux = true + if logRewriteRules { + fmt.Println("rewrite generic.rules:28") + } return true } goto end4d21cead60174989467a9c8202dbb91d @@ -254,6 +289,9 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.Aux = true + if logRewriteRules { + fmt.Println("rewrite generic.rules:31") + } return true } goto end73dce8bba164e4f4a1dd701bf8cfb362 @@ -275,6 +313,9 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.resetArgs() v.AddArg(y) v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite generic.rules:51") + } return true } goto endcea7f7399afcff860c54d82230a9a934 @@ -305,6 +346,9 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v1.Type = config.Frontend().TypeUintptr() v1.AuxInt = 0 v.AddArg(v1) + if logRewriteRules { + fmt.Println("rewrite generic.rules:54") + } return true } goto end540dc8dfbc66adcd3db2d7e819c534f6 @@ -328,6 +372,9 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.Aux = inBounds(c, d) + if logRewriteRules { + fmt.Println("rewrite generic.rules:27") + } return true } goto enddfd340bc7103ca323354aec96b113c23 @@ -362,6 +409,9 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v1.AddArg(v2) v1.AddArg(mem) v.AddArg(v1) + if logRewriteRules { + fmt.Println("rewrite generic.rules:69") + } return true } goto end18afa4a6fdd6d0b92ed292840898c8f6 @@ -385,6 +435,9 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c * d + if logRewriteRules { + fmt.Println("rewrite generic.rules:25") + } return true } goto end7aea1048b5d1230974b97f17238380ae @@ -408,6 +461,9 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c * d + if logRewriteRules { + fmt.Println("rewrite generic.rules:26") + } return true } goto end808c190f346658bb1ad032bf37a1059f @@ -427,6 +483,9 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.Aux = false + if logRewriteRules { + fmt.Println("rewrite generic.rules:34") + } return true } goto end192755dd3c2be992e9d3deb53794a8d2 @@ -446,6 +505,9 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.Aux = false + if logRewriteRules { + fmt.Println("rewrite generic.rules:33") + } return true } goto endeb23619fc85950a8df7b31126252c4dd @@ -465,6 +527,9 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.Aux = false + if logRewriteRules { + fmt.Println("rewrite generic.rules:32") + } return true } goto endfc6eea780fb4056afb9e4287076da60c @@ -484,6 +549,9 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.Aux = false + if logRewriteRules { + fmt.Println("rewrite generic.rules:35") + } return true } goto endcccf700d93c6d57765b80f92f7b3fa81 @@ -505,6 +573,9 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.resetArgs() v.AddArg(y) v.AddArg(x) + if logRewriteRules { + fmt.Println("rewrite generic.rules:52") + } return true } goto end94c68f7dc30c66ed42e507e01c4e5dc7 @@ -535,6 +606,9 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v1.Type = config.Frontend().TypeUintptr() v1.AuxInt = 0 v.AddArg(v1) + if logRewriteRules { + fmt.Println("rewrite generic.rules:55") + } return true } goto end67d723bb0f39a5c897816abcf411e5cf @@ -561,6 +635,9 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v1.AuxInt = t.Elem().Size() v0.AddArg(v1) v.AddArg(v0) + if logRewriteRules { + fmt.Println("rewrite generic.rules:60") + } return true } goto endf7546737f42c76a99699f241d41f491a @@ -589,6 +666,9 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v0.AddArg(v1) v.AddArg(v0) v.AddArg(mem) + if logRewriteRules { + fmt.Println("rewrite generic.rules:46") + } return true } goto end6696811bf6bd45e505d24c1a15c68e70 @@ -617,6 +697,9 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v0.AddArg(v1) v.AddArg(v0) v.AddArg(mem) + if logRewriteRules { + fmt.Println("rewrite generic.rules:45") + } return true } goto end9844ce3e290e81355493141e653e37d5 @@ -638,6 +721,9 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.resetArgs() v.AddArg(ptr) v.AddArg(mem) + if logRewriteRules { + fmt.Println("rewrite generic.rules:44") + } return true } goto end459613b83f95b65729d45c2ed663a153 @@ -669,6 +755,9 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.AddArg(dst) v.AddArg(src) v.AddArg(mem) + if logRewriteRules { + fmt.Println("rewrite generic.rules:65") + } return true } goto end324ffb6d2771808da4267f62c854e9c8 @@ -706,6 +795,9 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v2.AddArg(v3) v2.AddArg(mem) v.AddArg(v2) + if logRewriteRules { + fmt.Println("rewrite generic.rules:72") + } return true } goto enddf0c5a150f4b4bf6715fd2bd4bb4cc20 @@ -726,6 +818,9 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.resetArgs() v.Type = len.Type v.AddArg(len) + if logRewriteRules { + fmt.Println("rewrite generic.rules:71") + } return true } goto end0d922460b7e5ca88324034f4bd6c027c @@ -746,6 +841,9 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.resetArgs() v.Type = ptr.Type v.AddArg(ptr) + if logRewriteRules { + fmt.Println("rewrite generic.rules:70") + } return true } goto end061edc5d85c73ad909089af2556d9380 @@ -772,6 +870,9 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v0.AddArg(ptr) v.AddArg(v0) v.AddArg(mem) + if logRewriteRules { + fmt.Println("rewrite generic.rules:61") + } return true } goto end16fdb45e1dd08feb36e3cc3fb5ed8935 @@ -801,6 +902,9 @@ func rewriteBlockgeneric(b *Block) bool { b.Succs = b.Succs[:1] b.Succs[0] = yes b.Likely = BranchUnknown + if logRewriteRules { + fmt.Println("rewrite generic.rules:74") + } return true } goto end0f2bb0111a86be0436b44210dbd83a90 @@ -822,6 +926,9 @@ func rewriteBlockgeneric(b *Block) bool { b.Succs[0] = no b.Succs[1] = yes b.Likely *= -1 + if logRewriteRules { + fmt.Println("rewrite generic.rules:76") + } return true } goto endebe19c1c3c3bec068cdb2dd29ef57f96 @@ -847,6 +954,9 @@ func rewriteBlockgeneric(b *Block) bool { b.Succs = b.Succs[:1] b.Succs[0] = yes b.Likely = BranchUnknown + if logRewriteRules { + fmt.Println("rewrite generic.rules:77") + } return true } goto end9ff0273f9b1657f4afc287562ca889f0 @@ -872,6 +982,9 @@ func rewriteBlockgeneric(b *Block) bool { b.Succs = b.Succs[:1] b.Succs[0] = no b.Likely = BranchUnknown + if logRewriteRules { + fmt.Println("rewrite generic.rules:78") + } return true } goto endf401a4553c3c7c6bed64801da7bba076 -- cgit v1.3 From 867662da6ae5d8e29180c951b0184b241b780502 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Wed, 12 Aug 2015 14:51:24 -0700 Subject: [dev.ssa] cmd/compile: make sure entry block has no predecessors Fix one test that build a violating CFG. Change-Id: Ie0296ced602984d914a70461c76559c507ce2510 Reviewed-on: https://go-review.googlesource.com/13621 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/ssa/check.go | 4 ++++ src/cmd/compile/internal/ssa/dom_test.go | 13 ++++++++----- 2 files changed, 12 insertions(+), 5 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/check.go b/src/cmd/compile/internal/ssa/check.go index dfb33dbd07..2631401130 100644 --- a/src/cmd/compile/internal/ssa/check.go +++ b/src/cmd/compile/internal/ssa/check.go @@ -157,6 +157,10 @@ func checkFunc(f *Func) { } } + 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 { diff --git a/src/cmd/compile/internal/ssa/dom_test.go b/src/cmd/compile/internal/ssa/dom_test.go index 6cd2ff440c..e125907929 100644 --- a/src/cmd/compile/internal/ssa/dom_test.go +++ b/src/cmd/compile/internal/ssa/dom_test.go @@ -317,11 +317,13 @@ func TestDominatorsMultPredRev(t *testing.T) { c := testConfig(t) fun := Fun(c, "entry", Bloc("entry", + Goto("first")), + Bloc("first", Valu("mem", OpArg, TypeMem, 0, ".mem"), Valu("p", OpConstBool, TypeBool, 0, true), Goto("a")), Bloc("a", - If("p", "b", "entry")), + If("p", "b", "first")), Bloc("b", Goto("c")), Bloc("c", @@ -330,10 +332,11 @@ func TestDominatorsMultPredRev(t *testing.T) { Exit("mem"))) doms := map[string]string{ - "a": "entry", - "b": "a", - "c": "b", - "exit": "c", + "first": "entry", + "a": "first", + "b": "a", + "c": "b", + "exit": "c", } CheckFunc(fun.f) -- cgit v1.3 From f85faefa67cb33a053d281a2c3f0907629d1c581 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Wed, 12 Aug 2015 15:39:16 -0700 Subject: [dev.ssa] cmd/compile: move rewrite logging behind codegen flag Generating logging code every time causes large diffs for small changes. Since the intent is to use this for debugging only, generate logging code only when requested. Committed generated code will be logging free. Change-Id: I9ef9e29c88b76c2557bad4c6b424b9db1255ec8b Reviewed-on: https://go-review.googlesource.com/13623 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/gen/main.go | 2 + src/cmd/compile/internal/ssa/gen/rulegen.go | 26 +- src/cmd/compile/internal/ssa/rewrite.go | 5 - src/cmd/compile/internal/ssa/rewriteAMD64.go | 1229 ------------------------ src/cmd/compile/internal/ssa/rewritegeneric.go | 113 --- 5 files changed, 19 insertions(+), 1356 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/gen/main.go b/src/cmd/compile/internal/ssa/gen/main.go index ddc2c6df96..97ac802cbd 100644 --- a/src/cmd/compile/internal/ssa/gen/main.go +++ b/src/cmd/compile/internal/ssa/gen/main.go @@ -9,6 +9,7 @@ package main import ( "bytes" + "flag" "fmt" "go/format" "io/ioutil" @@ -59,6 +60,7 @@ func (a arch) regMaskComment(r regMask) string { var archs []arch func main() { + flag.Parse() genOp() genLower() } diff --git a/src/cmd/compile/internal/ssa/gen/rulegen.go b/src/cmd/compile/internal/ssa/gen/rulegen.go index ea7cf081e5..57305413f9 100644 --- a/src/cmd/compile/internal/ssa/gen/rulegen.go +++ b/src/cmd/compile/internal/ssa/gen/rulegen.go @@ -13,6 +13,7 @@ import ( "bufio" "bytes" "crypto/md5" + "flag" "fmt" "go/format" "io" @@ -45,6 +46,10 @@ import ( // 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 @@ -134,7 +139,9 @@ func genRules(arch arch) { 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, "package ssa") - fmt.Fprintln(w, "import \"fmt\"") + if *genLog { + fmt.Fprintln(w, "import \"fmt\"") + } fmt.Fprintf(w, "func rewriteValue%s(v *Value, config *Config) bool {\n", arch.name) fmt.Fprintln(w, "b := v.Block") @@ -169,9 +176,9 @@ func genRules(arch arch) { } genResult(w, arch, result) - fmt.Fprintf(w, "if logRewriteRules {\n") - fmt.Fprintf(w, " fmt.Println(\"rewrite %s.rules:%d\")", arch.name, rule.lineno) - fmt.Fprintf(w, "}\n") + 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") @@ -275,9 +282,9 @@ func genRules(arch arch) { fmt.Fprintln(w, "b.Likely = BranchUnknown") } - fmt.Fprintf(w, "if logRewriteRules {\n") - fmt.Fprintf(w, " fmt.Println(\"rewrite %s.rules:%d\")", arch.name, rule.lineno) - fmt.Fprintf(w, "}\n") + 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") @@ -291,13 +298,14 @@ func genRules(arch arch) { // gofmt result b := w.Bytes() - b, err = format.Source(b) + 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", b, 0666) + err = ioutil.WriteFile("../rewrite"+arch.name+".go", src, 0666) if err != nil { log.Fatalf("can't write output: %v\n", err) } diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go index ae3b889c39..39fc48df4a 100644 --- a/src/cmd/compile/internal/ssa/rewrite.go +++ b/src/cmd/compile/internal/ssa/rewrite.go @@ -6,11 +6,6 @@ package ssa import "fmt" -// Set to true to log all rewrite rules as they occur. -// This is useful for figuring out whether a rule is triggering -// and which rules are most heavily used. -const logRewriteRules = false - func applyRewrite(f *Func, rb func(*Block) bool, rv func(*Value, *Config) bool) { // repeat rewrites until we find no more rewrites var curb *Block diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index d133b8db38..a18097f91e 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -2,8 +2,6 @@ // generated with: cd gen; go run *.go package ssa -import "fmt" - func rewriteValueAMD64(v *Value, config *Config) bool { b := v.Block switch v.Op { @@ -23,9 +21,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:279") - } return true } goto endab690db69bfd8192eea57a2f9f76bf84 @@ -46,9 +41,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:280") - } return true } goto end28aa1a4abe7e1abcdd64135e9967d39d @@ -69,9 +61,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:523") - } return true } goto end9464509b8874ffb00b43b843da01f0bc @@ -92,9 +81,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c + d - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:481") - } return true } goto enda9b1e9e31ccdf0af5f4fe57bf4b1343f @@ -116,9 +102,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c + d v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:485") - } return true } goto end9b1e6890adbf9d9e447d591b4148cbd0 @@ -140,9 +123,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:275") - } return true } goto end8d6d3b99a7be8da6b7a254b7e709cc95 @@ -163,9 +143,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:276") - } return true } goto end739561e08a561e26ce3634dc0d5ec733 @@ -186,9 +163,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:521") - } return true } goto end9596df31f2685a49df67c6fb912a521d @@ -209,9 +183,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c + d - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:479") - } return true } goto ende04850e987890abf1d66199042a19c23 @@ -233,9 +204,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c + d v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:483") - } return true } goto endf1dd8673b2fef4950aec87aa7523a236 @@ -260,9 +228,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:273") - } return true } goto end1de8aeb1d043e0dadcffd169a99ce5c0 @@ -286,9 +251,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:274") - } return true } goto endca635e3bdecd9e3aeb892f841021dfaa @@ -312,9 +274,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:368") - } return true } goto endc02313d35a0525d1d680cd58992e820d @@ -335,9 +294,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:520") - } return true } goto endec8f899c6e175a0147a90750f9bfe0a2 @@ -362,9 +318,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = addOff(c, d) v.AddArg(x) v.AddArg(y) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:369") - } return true } goto ende2cc681c9abf9913288803fb1b39e639 @@ -384,9 +337,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:416") - } return true } goto end03d9f5a3e153048b0afa781401e2a849 @@ -406,9 +356,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c + d - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:478") - } return true } goto end09dc54395b4e96e8332cf8e4e7481c52 @@ -430,9 +377,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c + d v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:482") - } return true } goto endd4cb539641f0dc40bfd0cb7fbb9b0405 @@ -454,9 +398,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:277") - } return true } goto end1aabd2317de77c7dfc4876fd7e4c5011 @@ -477,9 +418,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:278") - } return true } goto ende3aede99966f388afc624f9e86676fd2 @@ -500,9 +438,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:522") - } return true } goto end55cf2af0d75f3ec413528eeb799e94d5 @@ -523,9 +458,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c + d - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:480") - } return true } goto end32541920f2f5a920dfae41d8ebbef00f @@ -547,9 +479,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c + d v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:484") - } return true } goto end73944f6ddda7e4c050f11d17484ff9a5 @@ -571,9 +500,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:306") - } return true } goto end01100cd255396e29bfdb130f4fbc9bbc @@ -594,9 +520,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:307") - } return true } goto end70830ce2834dc5f8d786fa6789460926 @@ -617,9 +540,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:308") - } return true } goto endd275ec2e73768cb3d201478fc934e06c @@ -640,9 +560,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:309") - } return true } goto end4068edac2ae0f354cf581db210288b98 @@ -662,9 +579,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:531") - } return true } goto endb8ff272a1456513da708603abe37541c @@ -684,9 +598,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 0 - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:462") - } return true } goto end2106d410c949da14d7c00041f40eca76 @@ -707,9 +618,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:466") - } return true } goto enda0b78503c204c8225de1433949a71fe4 @@ -729,9 +637,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c & d - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:504") - } return true } goto end946312b1f216933da86febe293eb956f @@ -753,9 +658,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:300") - } return true } goto end0a4c49d9a26759c0fd21369dafcd7abb @@ -776,9 +678,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:301") - } return true } goto end0529ba323d9b6f15c41add401ef67959 @@ -798,9 +697,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:529") - } return true } goto enddfb08a0d0c262854db3905cb323388c7 @@ -820,9 +716,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 0 - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:460") - } return true } goto end5efb241208aef28c950b7bcf8d85d5de @@ -843,9 +736,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:464") - } return true } goto end0e852ae30bb8289d6ffee0c9267e3e0c @@ -865,9 +755,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c & d - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:502") - } return true } goto end7bfd24059369753eadd235f07e2dd7b8 @@ -892,9 +779,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:298") - } return true } goto end048fadc69e81103480015b84b9cafff7 @@ -918,9 +802,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:299") - } return true } goto end3035a3bf650b708705fd27dd857ab0a4 @@ -940,9 +821,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:528") - } return true } goto end06b5ec19efdd4e79f03a5e4a2c3c3427 @@ -961,9 +839,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 0 - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:459") - } return true } goto end57018c1d0f54fd721521095b4832bab2 @@ -983,9 +858,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:463") - } return true } goto endb542c4b42ab94a7bedb32dec8f610d67 @@ -1005,9 +877,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c & d - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:501") - } return true } goto end67ca66494705b0345a5f22c710225292 @@ -1029,9 +898,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:302") - } return true } goto endce6f557823ee2fdd7a8f47b6f925fc7c @@ -1052,9 +918,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:303") - } return true } goto endc46af0d9265c08b09f1f1fba24feda80 @@ -1075,9 +938,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:304") - } return true } goto enda77a39f65a5eb3436a5842eab69a3103 @@ -1098,9 +958,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:305") - } return true } goto endea2a25eb525a5dbf6d5132d84ea4e7a5 @@ -1120,9 +977,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:530") - } return true } goto end3a26cf52dd1b77f07cc9e005760dbb11 @@ -1142,9 +996,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 0 - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:461") - } return true } goto end336ece33b4f0fb44dfe1f24981df7b74 @@ -1165,9 +1016,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:465") - } return true } goto endfb111c3afa8c5c4040fa6000fadee810 @@ -1187,9 +1035,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c & d - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:503") - } return true } goto end250eb27fcac10bf6c0d96ce66a21726e @@ -1208,9 +1053,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:16") - } return true } goto ende604481c6de9fe4574cb2954ba2ddc67 @@ -1229,9 +1071,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:15") - } return true } goto endc445ea2a65385445676cd684ae9a42b5 @@ -1250,9 +1089,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:13") - } return true } goto endd88f18b3f39e3ccc201477a616f0abc0 @@ -1271,9 +1107,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:17") - } return true } goto end6117c84a6b75c1b816b3fb095bc5f656 @@ -1292,9 +1125,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:14") - } return true } goto enda1d5640788c7157996f9d4af602dec1c @@ -1313,9 +1143,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Aux = sym v.AddArg(base) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:237") - } return true } goto end53cad0c3c9daa5575680e77c14e05e72 @@ -1334,9 +1161,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:35") - } return true } goto end1c01f04a173d86ce1a6d1ef59e753014 @@ -1355,9 +1179,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:34") - } return true } goto end6b9eb9375b3a859028a6ba6bf6b8ec88 @@ -1376,9 +1197,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:33") - } return true } goto enda0bde5853819d05fa2b7d3b723629552 @@ -1397,9 +1215,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:36") - } return true } goto end0f53bee6291f1229b43aa1b5f977b4f2 @@ -1421,9 +1236,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AuxInt = c - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:355") - } return true } goto end52190c0b8759133aa6c540944965c4c0 @@ -1447,9 +1259,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AuxInt = c v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:356") - } return true } goto end6798593f4f9a27e90de089b3248187fd @@ -1471,9 +1280,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AuxInt = c - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:351") - } return true } goto end49ff4559c4bdecb2aef0c905e2d9a6cf @@ -1497,9 +1303,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AuxInt = c v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:352") - } return true } goto end3c04e861f07a442be9e2f5e0e0d07cce @@ -1524,9 +1327,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AuxInt = c - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:349") - } return true } goto end3bbb2c6caa57853a7561738ce3c0c630 @@ -1553,9 +1353,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AuxInt = c v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:350") - } return true } goto end5edbe48a495a51ecabd3b2c0ed44a3d3 @@ -1577,9 +1374,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AuxInt = c - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:353") - } return true } goto end310a9ba58ac35c97587e08c63fe8a46c @@ -1603,9 +1397,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AuxInt = c v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:354") - } return true } goto end1ce191aaab0f4dd3b98dafdfbfac13ce @@ -1628,9 +1419,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(entry) v.AddArg(closure) v.AddArg(mem) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:267") - } return true } goto endfd75d26316012d86cb71d0dd1214259b @@ -1647,9 +1435,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:55") - } return true } goto end1b14ba8d7d7aa585ec0a211827f280ae @@ -1666,9 +1451,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:54") - } return true } goto end6eb124ba3bdb3fd6031414370852feb6 @@ -1685,9 +1467,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:53") - } return true } goto endf5f3b355a87779c347e305719dddda05 @@ -1704,9 +1483,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:56") - } return true } goto end1c7c5c055d663ccf1f05fbc4883030c6 @@ -1723,9 +1499,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = val - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:229") - } return true } goto end2c6c92f297873b8ac12bd035d56d001e @@ -1742,9 +1515,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = val - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:230") - } return true } goto enddae5807662af67143a3ac3ad9c63bae5 @@ -1761,9 +1531,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = val - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:231") - } return true } goto endc630434ae7f143ab69d5f482a9b52b5f @@ -1780,9 +1547,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = val - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:228") - } return true } goto end200524c722ed14ca935ba47f8f30327d @@ -1802,9 +1566,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 0 - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:234") - } return true } goto end876159ea073d2dcefcc251667c1a7780 @@ -1823,9 +1584,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 1 - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:235") - } return true } goto end0dacad3f7cad53905aad5303391447f6 @@ -1841,9 +1599,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 0 - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:233") - } return true } goto endea557d921056c25b945a49649e4b9b91 @@ -1860,9 +1615,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = val - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:232") - } return true } goto endc395c0a53eeccf597e225a07b53047d1 @@ -1884,9 +1636,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:195") - } return true } goto end66a03470b5b3e8457ba205ccfcaccea6 @@ -1908,9 +1657,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:194") - } return true } goto end4d77d0b016f93817fd6e5f60fa0e7ef2 @@ -1932,9 +1678,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:193") - } return true } goto endae6c62e4e20b4f62694b6ee40dbd9211 @@ -1956,9 +1699,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:196") - } return true } goto end84a692e769900e3adbfe00718d2169e0 @@ -1980,9 +1720,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:197") - } return true } goto end6de1d39c9d151e5e503d643bd835356e @@ -2004,9 +1741,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:185") - } return true } goto end26084bf821f9e418934fee812632b774 @@ -2028,9 +1762,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:190") - } return true } goto end20b00f850ca834cb2013414645c19ad9 @@ -2052,9 +1783,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:184") - } return true } goto end713c3dfa0f7247dcc232bcfc916fb044 @@ -2076,9 +1804,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:189") - } return true } goto endac2cde17ec6ab0107eabbda6407d1004 @@ -2100,9 +1825,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:183") - } return true } goto end63f44e3fec8d92723b5bde42d6d7eea0 @@ -2124,9 +1846,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:188") - } return true } goto endd8d2d9faa19457f6a7b0635a756d234f @@ -2148,9 +1867,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:186") - } return true } goto endb5f40ee158007e675b2113c3ce962382 @@ -2172,9 +1888,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:191") - } return true } goto endd30ee67afc0284c419cef70261f61452 @@ -2189,9 +1902,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:220") - } return true } goto endb17140e71dd641aa4d89e14479160260 @@ -2213,9 +1923,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:175") - } return true } goto end5bc9fdb7e563a6b949e42d721903cb58 @@ -2237,9 +1944,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:180") - } return true } goto endd5b646f04fd839d11082a9ff6adb4a3f @@ -2261,9 +1965,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:174") - } return true } goto endbf0b2b1368aadff48969a7386eee5795 @@ -2285,9 +1986,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:179") - } return true } goto end033c944272dc0af6fafe33f667cf7485 @@ -2309,9 +2007,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:173") - } return true } goto endaef0cfa5e27e23cf5e527061cf251069 @@ -2333,9 +2028,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:178") - } return true } goto end2afc16a19fe1073dfa86770a78eba2b4 @@ -2357,9 +2049,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:176") - } return true } goto endbdb1e5f6b760cf02e0fc2f474622e6be @@ -2381,9 +2070,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:181") - } return true } goto end22eaafbcfe70447f79d9b3e6cc395bbd @@ -2405,9 +2091,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(ptr) v.AddArg(mem) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:239") - } return true } goto enda49fcae3630a097c78aa58189c90a97a @@ -2429,9 +2112,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(idx) v0.AddArg(len) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:217") - } return true } goto endb51d371171154c0f1613b687757e0576 @@ -2452,9 +2132,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(p) v0.AddArg(p) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:216") - } return true } goto endff508c3726edfb573abc6128c177e76c @@ -2476,9 +2153,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:165") - } return true } goto endc1916dfcb3eae58ab237e40a57e1ff16 @@ -2500,9 +2174,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:170") - } return true } goto end627e261aea217b5d17177b52711b8c82 @@ -2524,9 +2195,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:164") - } return true } goto endf422ecc8da0033e22242de9c67112537 @@ -2548,9 +2216,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:169") - } return true } goto end1b39c9661896abdff8a29de509311b96 @@ -2572,9 +2237,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:163") - } return true } goto endf03da5e28dccdb4797671f39e824fb10 @@ -2596,9 +2258,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:168") - } return true } goto end37302777dd91a5d0c6f410a5444ccb38 @@ -2620,9 +2279,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:166") - } return true } goto end03be536eea60fdd98d48b17681acaf5a @@ -2644,9 +2300,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:171") - } return true } goto end661377f6745450bb1fa7fd0608ef0a86 @@ -2668,9 +2321,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:155") - } return true } goto endeb09704ef62ba2695a967b6fcb42e562 @@ -2692,9 +2342,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:160") - } return true } goto end2209a57bd887f68ad732aa7da2bc7286 @@ -2716,9 +2363,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:154") - } return true } goto end8da8d2030c0a323a84503c1240c566ae @@ -2740,9 +2384,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:159") - } return true } goto enddcfbbb482eb194146f4f7c8f12029a7a @@ -2764,9 +2405,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:153") - } return true } goto endf8e7a24c25692045bbcfd2c9356d1a8c @@ -2788,9 +2426,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:158") - } return true } goto end2fac0a2c2e972b5e04b5062d5786b87d @@ -2812,9 +2447,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:156") - } return true } goto end445ad05f8d23dfecf246ce083f1ea167 @@ -2836,9 +2468,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:161") - } return true } goto end816d1dff858c45836dfa337262e04649 @@ -2861,9 +2490,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(ptr) v.AddArg(mem) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:205") - } return true } goto end7c4c53acf57ebc5f03273652ba1d5934 @@ -2885,9 +2511,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(ptr) v.AddArg(mem) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:206") - } return true } goto ende1cfcb15bfbcfd448ce303d0882a4057 @@ -2909,9 +2532,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(ptr) v.AddArg(mem) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:207") - } return true } goto end2d0a1304501ed9f4e9e2d288505a9c7c @@ -2933,9 +2553,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(ptr) v.AddArg(mem) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:208") - } return true } goto end8f83bf72293670e75b22d6627bd13f0b @@ -2956,9 +2573,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Type = t v.AuxInt = c & 15 v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:107") - } return true } goto endb23dfa24c619d0068f925899d53ee7fd @@ -2979,9 +2593,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Type = t v.AuxInt = c & 31 v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:106") - } return true } goto end38b2215c011896c36845f72ecb72b1b0 @@ -3002,9 +2613,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Type = t v.AuxInt = c & 63 v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:105") - } return true } goto end5cb355e4f3ca387f252ef4f6a55f9f68 @@ -3025,9 +2633,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Type = t v.AuxInt = c & 7 v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:108") - } return true } goto end26bfb3dd5b537cf13ac9f2978d94ed71 @@ -3058,9 +2663,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:97") - } return true } goto end5b63495f0e75ac68c4ce9d4afa1472d4 @@ -3091,9 +2693,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:96") - } return true } goto end6384dd9bdcec3046732d7347250d49f6 @@ -3124,9 +2723,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:95") - } return true } goto end0975ca28988350db0ad556c925d8af07 @@ -3157,9 +2753,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:98") - } return true } goto endd17c913707f29d59cfcb5d57d5f5c6ff @@ -3190,9 +2783,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:92") - } return true } goto end027b6f888054cc1dd8911fe16a6315a1 @@ -3223,9 +2813,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:91") - } return true } goto endbcc31e2bd8800d5ddb27c09d37f867b9 @@ -3256,9 +2843,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:90") - } return true } goto end6797e3a3bbb0fe7eda819fe19a4d4b49 @@ -3289,9 +2873,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:93") - } return true } goto end7dd2c717933f46750e8a0871aab6fc63 @@ -3322,9 +2903,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:87") - } return true } goto end3a2fda1dddb29e49f46ccde6f5397222 @@ -3355,9 +2933,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:86") - } return true } goto end147322aba732027ac2290fd8173d806a @@ -3388,9 +2963,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:85") - } return true } goto endeb8e78c9c960fa12e29ea07a8519649b @@ -3421,9 +2993,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:88") - } return true } goto end42cdc11c34c81bbd5e8b4ad19ceec1ef @@ -3454,9 +3023,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:102") - } return true } goto end60bf962bf5256e20b547e18e3c886aa5 @@ -3487,9 +3053,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:101") - } return true } goto end8ed3445f6dbba1a87c80b140371445ce @@ -3520,9 +3083,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:100") - } return true } goto end0a03c9cc48ef1bfd74973de5f5fb02b0 @@ -3553,9 +3113,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:103") - } return true } goto end781e3a47b186cf99fcb7137afd3432b9 @@ -3577,9 +3134,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(ptr) v.AddArg(mem) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:384") - } return true } goto enda3a5eeb5767e31f42b0b6c1db8311ebb @@ -3601,9 +3155,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(ptr) v.AddArg(mem) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:385") - } return true } goto end9510a482da21d9945d53c4233b19e825 @@ -3627,9 +3178,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(ptr) v.AddArg(x) v.AddArg(mem) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:391") - } return true } goto endc356ef104095b9217b36b594f85171c6 @@ -3652,9 +3200,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(ptr) v.AddArg(x) v.AddArg(mem) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:394") - } return true } goto end25841a70cce7ac32c6d5e561b992d3df @@ -3678,9 +3223,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(ptr) v.AddArg(x) v.AddArg(mem) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:389") - } return true } goto endf79c699f70cb356abb52dc28f4abf46b @@ -3703,9 +3245,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(ptr) v.AddArg(x) v.AddArg(mem) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:392") - } return true } goto end67d1549d16d373e4ad6a89298866d1bc @@ -3730,9 +3269,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = addOff(off1, off2) v.AddArg(ptr) v.AddArg(mem) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:401") - } return true } goto end843d29b538c4483b432b632e5666d6e3 @@ -3762,9 +3298,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = mergeSym(sym1, sym2) v.AddArg(base) v.AddArg(mem) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:405") - } return true } goto end227426af95e74caddcf59fdcd30ca8bc @@ -3790,9 +3323,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(ptr) v.AddArg(idx) v.AddArg(mem) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:410") - } return true } goto end02f5ad148292c46463e7c20d3b821735 @@ -3819,9 +3349,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(ptr) v.AddArg(idx) v.AddArg(mem) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:413") - } return true } goto ende81e44bcfb11f90916ccb440c590121f @@ -3848,9 +3375,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(ptr) v.AddArg(val) v.AddArg(mem) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:402") - } return true } goto end2108c693a43c79aed10b9246c39c80aa @@ -3882,9 +3406,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(base) v.AddArg(val) v.AddArg(mem) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:407") - } return true } goto end5061f48193268a5eb1e1740bdd23c43d @@ -3912,9 +3433,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(idx) v.AddArg(val) v.AddArg(mem) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:411") - } return true } goto endce1db8c8d37c8397c500a2068a65c215 @@ -3943,9 +3461,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(idx) v.AddArg(val) v.AddArg(mem) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:414") - } return true } goto end01c970657b0fdefeab82458c15022163 @@ -3969,9 +3484,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(ptr) v.AddArg(x) v.AddArg(mem) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:390") - } return true } goto endcc13af07a951a61fcfec3299342f7e1f @@ -3994,9 +3506,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(ptr) v.AddArg(x) v.AddArg(mem) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:393") - } return true } goto end4e7df15ee55bdd73d8ecd61b759134d4 @@ -4018,9 +3527,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:293") - } return true } goto end893477a261bcad6c2821b77c83075c6c @@ -4041,9 +3547,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:294") - } return true } goto end8a0f957c528a54eecb0dbfc5d96e017a @@ -4064,9 +3567,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c * d - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:499") - } return true } goto endd5732835ed1276ef8b728bcfc1289f73 @@ -4091,9 +3591,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:291") - } return true } goto endb38c6e3e0ddfa25ba0ef9684ac1528c0 @@ -4117,9 +3614,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:292") - } return true } goto end9cb4f29b0bd7141639416735dcbb3b87 @@ -4139,9 +3633,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:359") - } return true } goto end82501cca6b5fb121a7f8b197e55f2fec @@ -4159,9 +3650,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 0 - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:360") - } return true } goto endcb9faa068e3558ff44daaf1d47d091b5 @@ -4181,9 +3669,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:361") - } return true } goto end0b527e71db2b288b2841a1f757aa580d @@ -4203,9 +3688,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:362") - } return true } goto end34a86f261671b5852bec6c57155fe0da @@ -4225,9 +3707,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:363") - } return true } goto end534601906c45a9171a9fec3e4b82b189 @@ -4247,9 +3726,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:364") - } return true } goto end48a2280b6459821289c56073b8354997 @@ -4270,9 +3746,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = log2(c) v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:365") - } return true } goto end75076953dbfe022526a153eda99b39b2 @@ -4292,9 +3765,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c * d - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:498") - } return true } goto end55c38c5c405101e610d7ba7fc702ddc0 @@ -4316,9 +3786,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:295") - } return true } goto end542112cc08217d4bdffc1a645d290ffb @@ -4339,9 +3806,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:296") - } return true } goto endd97b4245ced2b3d27d8c555b06281de4 @@ -4362,9 +3826,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c * d - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:500") - } return true } goto end61dbc9d9e93dd6946a20a1f475b3f74b @@ -4390,9 +3851,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AuxInt = size v.AddArg(v0) v.AddArg(mem) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:222") - } return true } goto end4dd156b33beb9981378c91e46f055a56 @@ -4411,9 +3869,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:27") - } return true } goto end1addf5ea2c885aa1729b8f944859d00c @@ -4432,9 +3887,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:26") - } return true } goto ende144381f85808e5144782804768e2859 @@ -4453,9 +3905,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:24") - } return true } goto end38da21e77ac329eb643b20e7d97d5853 @@ -4474,9 +3923,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:31") - } return true } goto end861428e804347e8489a6424f2e6ce71c @@ -4495,9 +3941,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:25") - } return true } goto endbbedad106c011a93243e2062afdcc75f @@ -4517,9 +3960,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = -c - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:497") - } return true } goto end36d0300ba9eab8c9da86246ff653ca96 @@ -4539,9 +3979,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = -c - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:495") - } return true } goto end7a245ec67e56bd51911e5ba2d0aa0a16 @@ -4561,9 +3998,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = -c - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:494") - } return true } goto end04ddd98bc6724ecb85c80c2a4e2bca5a @@ -4583,9 +4017,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = -c - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:496") - } return true } goto end1db6636f0a51848d8a34f6561ecfe7ae @@ -4605,9 +4036,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = ^c - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:516") - } return true } goto end9e383a9ceb29a9e2bf890ec6a67212a8 @@ -4627,9 +4055,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = ^c - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:514") - } return true } goto endcc73972c088d5e652a1370a96e56502d @@ -4649,9 +4074,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = ^c - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:513") - } return true } goto endb39ddb6bf7339d46f74114baad4333b6 @@ -4671,9 +4093,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = ^c - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:515") - } return true } goto end35848095ebcf894c6957ad3be5f82c43 @@ -4690,9 +4109,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:50") - } return true } goto end7a8c652f4ffeb49656119af69512edb2 @@ -4709,9 +4125,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:49") - } return true } goto endce1f7e17fc193f6c076e47d5e401e126 @@ -4728,9 +4141,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:48") - } return true } goto enda06c5b1718f2b96aba10bf5a5c437c6c @@ -4747,9 +4157,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:51") - } return true } goto end1e5f495a2ac6cdea47b1ae5ba62aa95d @@ -4771,9 +4178,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:201") - } return true } goto endf177c3b3868606824e43e11da7804572 @@ -4795,9 +4199,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:200") - } return true } goto end39c4bf6d063f8a0b6f0064c96ce25173 @@ -4819,9 +4220,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:199") - } return true } goto end8ab0bcb910c0d3213dd8726fbcc4848e @@ -4843,9 +4241,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:202") - } return true } goto end4aaff28af59a65b3684f4f1897299932 @@ -4867,9 +4262,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:203") - } return true } goto end6e180ffd9583cd55361ed3e465158a4c @@ -4887,9 +4279,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = 1 v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:224") - } return true } goto end73973101aad60079c62fa64624e21db1 @@ -4911,9 +4300,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:317") - } return true } goto end7b63870decde2515cb77ec4f8f76817c @@ -4934,9 +4320,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:318") - } return true } goto end70b43d531e2097a4f6293f66256a642e @@ -4956,9 +4339,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:535") - } return true } goto enddca5ce800a9eca157f243cb2fdb1408a @@ -4980,9 +4360,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:470") - } return true } goto end565f78e3a843dc73943b59227b39a1b3 @@ -5001,9 +4378,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = -1 - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:474") - } return true } goto end6033c7910d8cd536b31446e179e4610d @@ -5023,9 +4397,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c | d - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:508") - } return true } goto endbe5263f022dc10a5cf53c118937d79dd @@ -5047,9 +4418,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:313") - } return true } goto end1b883e30d860b6fac14ae98462c4f61a @@ -5070,9 +4438,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:314") - } return true } goto enda5bc49524a0cbd2241f792837d0a48a8 @@ -5092,9 +4457,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:533") - } return true } goto end2dd719b68f4938777ef0d820aab93659 @@ -5116,9 +4478,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:468") - } return true } goto end5b52623a724e8a7167c71289fb7192f1 @@ -5137,9 +4496,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = -1 - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:472") - } return true } goto end345a8ea439ef2ef54bd84fc8a0f73e97 @@ -5159,9 +4515,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c | d - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:506") - } return true } goto ende9ca05024248f782c88084715f81d727 @@ -5186,9 +4539,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:311") - } return true } goto end601f2bb3ccda102e484ff60adeaf6d26 @@ -5212,9 +4562,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:312") - } return true } goto end010afbebcd314e288509d79a16a6d5cc @@ -5234,9 +4581,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:532") - } return true } goto end47a27d30b82db576978c5a3a57b520fb @@ -5257,9 +4601,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:467") - } return true } goto end44534da6b9ce98d33fad7e20f0be1fbd @@ -5277,9 +4618,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = -1 - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:471") - } return true } goto endcde9b9d7c4527eaa5d50b252f50b43c1 @@ -5299,9 +4637,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c | d - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:505") - } return true } goto enda2488509b71db9abcb06a5115c4ddc2c @@ -5323,9 +4658,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:315") - } return true } goto end9f98df10892dbf170b49aace86ee0d7f @@ -5346,9 +4678,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:316") - } return true } goto end96405942c9ceb5fcb0ddb85a8709d015 @@ -5368,9 +4697,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:534") - } return true } goto endc6a23b64e541dc9cfc6a90fd7028e8c1 @@ -5392,9 +4718,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:469") - } return true } goto endbbbdec9091c8b4c58e587eac8a43402d @@ -5413,9 +4736,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = -1 - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:473") - } return true } goto ended87a5775f5e04b2d2a117a63d82dd9b @@ -5435,9 +4755,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c | d - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:507") - } return true } goto endba9221a8462b5c62e8d7c686f64c2778 @@ -5456,9 +4773,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = off v.AddArg(ptr) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:226") - } return true } goto end0429f947ee7ac49ff45a243e461a5290 @@ -5477,9 +4791,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:40") - } return true } goto end8fedf2c79d5607b7056b0ff015199cbd @@ -5498,9 +4809,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:39") - } return true } goto endea45bed9ca97d2995b68b53e6012d384 @@ -5519,9 +4827,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:38") - } return true } goto end3a446becaf2461f4f1a41faeef313f41 @@ -5540,9 +4845,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:41") - } return true } goto end6f8a8c559a167d1f0a5901d09a1fb248 @@ -5561,9 +4863,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(ptr) v.AddArg(mem) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:219") - } return true } goto enda02b1ad5a6f929b782190145f2c8628b @@ -5594,9 +4893,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:122") - } return true } goto end73239750a306668023d2c49875ac442f @@ -5627,9 +4923,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:121") - } return true } goto end9951e3b2e92c892256feece722b32219 @@ -5660,9 +4953,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:120") - } return true } goto end610d56d808c204abfa40d653447b2c17 @@ -5693,9 +4983,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:123") - } return true } goto end45e76a8d2b004e6802d53cf12b4757b3 @@ -5730,9 +5017,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:145") - } return true } goto endbcd8fd69ada08517f6f94f35da91e1c3 @@ -5767,9 +5051,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:144") - } return true } goto endec3994083e7f82857ecec05906c29aa6 @@ -5804,9 +5085,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:143") - } return true } goto end19da3883e21ffa3a45d7fc648ef38b66 @@ -5841,9 +5119,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:146") - } return true } goto end3c989f6931d059ea04e4ba93601b6c51 @@ -5874,9 +5149,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:117") - } return true } goto end056ede9885a9fc2f32615a2a03b35388 @@ -5907,9 +5179,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:116") - } return true } goto end30439bdc3517479ea25ae7f54408ba7f @@ -5940,9 +5209,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:115") - } return true } goto end49b47fd18b54461d8eea51f6e5889cd2 @@ -5973,9 +5239,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:118") - } return true } goto end46e045970a8b1afb9035605fc0e50c69 @@ -6010,9 +5273,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:140") - } return true } goto end5d1b8d7e1d1e53e621d13bb0eafc9102 @@ -6047,9 +5307,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:139") - } return true } goto end9c27383961c2161a9955012fce808cab @@ -6084,9 +5341,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:138") - } return true } goto end75dc7144497705c800e0c60dcd4a2828 @@ -6121,9 +5375,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:141") - } return true } goto enda7b94b2fd5cbcd12bb2dcd576bdca481 @@ -6154,9 +5405,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:112") - } return true } goto endc4bdfdc375a5c94978d936bd0db89cc5 @@ -6187,9 +5435,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:111") - } return true } goto end217f32bca5f6744b9a7de052f4fae13e @@ -6220,9 +5465,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:110") - } return true } goto end530dee0bcadf1cf5d092894b6210ffcd @@ -6253,9 +5495,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:113") - } return true } goto endf09baf4e0005c5eb4905f71ce4c8b306 @@ -6290,9 +5529,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:135") - } return true } goto endb370ee74ca256a604138321ddca9d543 @@ -6327,9 +5563,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:134") - } return true } goto end3cc6edf5b286a449332757ea12d2d601 @@ -6364,9 +5597,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:133") - } return true } goto end45de7b33396d9fd2ba377bd095f1d7a6 @@ -6401,9 +5631,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:136") - } return true } goto ende03fa68104fd18bb9b2bb94370e0c8b3 @@ -6434,9 +5661,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:127") - } return true } goto enda1adfc560334e10d5e83fbff27a8752f @@ -6467,9 +5691,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:126") - } return true } goto end17f63b4b712e715a33ac780193b59c2e @@ -6500,9 +5721,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:125") - } return true } goto end77d5c3ef9982ebd27c135d3461b7430b @@ -6533,9 +5751,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2.AddArg(y) v1.AddArg(v2) v.AddArg(v1) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:128") - } return true } goto end206712ffbda924142afbf384aeb8f09e @@ -6570,9 +5785,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:150") - } return true } goto endd303f390b49d9716dc783d5c4d57ddd1 @@ -6607,9 +5819,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:149") - } return true } goto ende12a524a6fc68eb245140c6919034337 @@ -6644,9 +5853,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:148") - } return true } goto end6ee53459daa5458d163c86ea02dd2f31 @@ -6681,9 +5887,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:151") - } return true } goto end07f447a7e25b048c41d412c242330ec0 @@ -6705,9 +5908,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c & 31 v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:342") - } return true } goto end3bf3d17717aa6c04462e56d1c87902ce @@ -6729,9 +5929,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c & 31 v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:340") - } return true } goto ende586a72c1b232ee0b63e37c71eeb8470 @@ -6753,9 +5950,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c & 63 v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:339") - } return true } goto end25e720ab203be2745dded5550e6d8a7c @@ -6777,9 +5971,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c & 31 v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:341") - } return true } goto endc46e3f211f94238f9a0aec3c498af490 @@ -6806,9 +5997,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = -1 - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:451") - } return true } goto enda9e02a887246381d02b3259b9df4050c @@ -6834,9 +6022,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 0 - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:452") - } return true } goto end3f8220527278b72a64148fcf9dc58bfe @@ -6862,9 +6047,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = -1 - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:453") - } return true } goto end880a2b9a12ed4f551bbd46473b9439bc @@ -6890,9 +6072,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 0 - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:454") - } return true } goto end3f08080e0f55d51afca2a131ed0c672e @@ -6918,9 +6097,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = -1 - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:455") - } return true } goto end91ed02166e0c0d696730e1704d0a682e @@ -6946,9 +6122,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 0 - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:456") - } return true } goto endc7edc3a13ec73ec4e6e87e7ab421a71a @@ -6974,9 +6147,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = -1 - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:457") - } return true } goto end0fe2997fc76ce00b1d496f7289ab345a @@ -7002,9 +6172,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 0 - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:458") - } return true } goto end3a07121fcc82f1a19da4226b07a757ce @@ -7031,9 +6198,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = -1 - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:443") - } return true } goto end378de7e659770f877c08b6b269073069 @@ -7059,9 +6223,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 0 - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:444") - } return true } goto enda7bfd1974bf83ca79653c560a718a86c @@ -7087,9 +6248,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = -1 - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:445") - } return true } goto end8c6d39847239120fa0fe953007eb40ae @@ -7115,9 +6273,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 0 - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:446") - } return true } goto end20885e855545e16ca77af2b9a2b69ea9 @@ -7143,9 +6298,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = -1 - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:447") - } return true } goto end16f61db69d07e67e9f408c2790a9de7c @@ -7171,9 +6323,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 0 - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:448") - } return true } goto end191ca427f7d5d2286bd290920c84a51d @@ -7199,9 +6348,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = -1 - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:449") - } return true } goto end3fd3f1e9660b9050c6a41b4fc948f793 @@ -7227,9 +6373,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 0 - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:450") - } return true } goto ende0d6edd92ae98e6dc041f65029d8b243 @@ -7249,9 +6392,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:375") - } return true } goto enda4ac36e94fc279d762b5a6c7c6cc665d @@ -7271,9 +6411,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:379") - } return true } goto end0468f5be6caf682fdea6b91d6648991e @@ -7293,9 +6430,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:374") - } return true } goto endc9eba7aa1e54a228570d2f5cc96f3565 @@ -7315,9 +6449,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:378") - } return true } goto end9d9031643469798b14b8cad1f5a7a1ba @@ -7337,9 +6468,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:380") - } return true } goto end5d2039c9368d8c0cfba23b5a85b459e1 @@ -7359,9 +6487,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:373") - } return true } goto endf7586738694c9cd0b74ae28bbadb649f @@ -7381,9 +6506,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:377") - } return true } goto end82c11eff6f842159f564f2dad3d2eedc @@ -7403,9 +6525,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:372") - } return true } goto ende33160cd86b9d4d3b77e02fb4658d5d3 @@ -7425,9 +6544,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:376") - } return true } goto end9307d96753efbeb888d1c98a6aba7a29 @@ -7447,9 +6563,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:381") - } return true } goto endbc71811b789475308014550f638026eb @@ -7471,9 +6584,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c & 31 v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:332") - } return true } goto end2d0d0111d831d8a575b5627284a6337a @@ -7495,9 +6605,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c & 31 v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:330") - } return true } goto end633f9ddcfbb63374c895a5f78da75d25 @@ -7519,9 +6626,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c & 63 v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:329") - } return true } goto end4d7e3a945cacdd6b6c8c0de6f465d4ae @@ -7543,9 +6647,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c & 31 v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:331") - } return true } goto endba96a52aa58d28b3357828051e0e695c @@ -7567,9 +6668,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c & 31 v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:337") - } return true } goto enddb1cd5aaa826d43fa4f6d1b2b8795e58 @@ -7591,9 +6689,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c & 31 v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:335") - } return true } goto end344b8b9202e1925e8d0561f1c21412fc @@ -7615,9 +6710,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c & 63 v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:334") - } return true } goto end699d35e2d5cfa08b8a3b1c8a183ddcf3 @@ -7639,9 +6731,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c & 31 v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:336") - } return true } goto endd75ff1f9b3e9ec9c942a39b6179da1b3 @@ -7663,9 +6752,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AuxInt = c - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:288") - } return true } goto end9ca5d2a70e2df1a5a3ed6786bce1f7b2 @@ -7689,9 +6775,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AuxInt = c v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:289") - } return true } goto endc288755d69b04d24a6aac32a73956411 @@ -7710,9 +6793,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 0 - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:527") - } return true } goto ende8904403d937d95b0d6133d3ec92bb45 @@ -7733,9 +6813,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c - d - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:489") - } return true } goto end0e2d5c3e3c02001a20d5433daa9e8317 @@ -7757,9 +6834,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c - d v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:493") - } return true } goto end48eccb421dfe0c678ea9c47113521d5a @@ -7781,9 +6855,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AuxInt = c - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:284") - } return true } goto end178c1d6c86f9c16f6497586c2f7d8625 @@ -7807,9 +6878,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AuxInt = c v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:285") - } return true } goto endb0efe6e15ec20486b849534a00483ae2 @@ -7828,9 +6896,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 0 - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:525") - } return true } goto end332f1f641f875c69bea7289191e69133 @@ -7851,9 +6916,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c - d - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:487") - } return true } goto endbe7466f3c09d9645544bdfc44c37c922 @@ -7875,9 +6937,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c - d v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:491") - } return true } goto endb5106962a865bc4654b170c2e29a72c4 @@ -7902,9 +6961,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AuxInt = c - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:282") - } return true } goto end9bbb7b20824a498752c605942fad89c2 @@ -7931,9 +6987,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AuxInt = c v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:283") - } return true } goto end8beb96de3efee9206d1bd4b7d777d2cb @@ -7952,9 +7005,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 0 - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:524") - } return true } goto endd87d1d839d2dc54d9c90fa4f73383480 @@ -7975,9 +7025,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c - d - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:486") - } return true } goto end96c09479fb3c043e875d89d3eb92f1d8 @@ -7999,9 +7046,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c - d v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:490") - } return true } goto enddd9d61b404480adb40cfd7fedd7e5ec4 @@ -8023,9 +7067,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AuxInt = c - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:286") - } return true } goto end135aa9100b2f61d58b37cede37b63731 @@ -8049,9 +7090,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AddArg(x) v0.AuxInt = c v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:287") - } return true } goto end44d23f7e65a4b1c42d0e6463f8e493b6 @@ -8070,9 +7108,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 0 - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:526") - } return true } goto endb970e7c318d04a1afe1dfe08a7ca0d9c @@ -8093,9 +7128,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c - d - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:488") - } return true } goto end0e5079577fcf00f5925291dbd68306aa @@ -8117,9 +7149,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c - d v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:492") - } return true } goto endb628696cf5b329d03782b8093093269b @@ -8136,9 +7165,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:62") - } return true } goto end21e4271c2b48a5aa3561ccfa8fa67cd9 @@ -8155,9 +7181,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:63") - } return true } goto endc6d242ee3a3e195ef0f9e8dae47ada75 @@ -8174,9 +7197,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:64") - } return true } goto endb9f1a8b2d01eee44964a71a01bca165c @@ -8193,9 +7213,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:59") - } return true } goto end372869f08e147404b80634e5f83fd506 @@ -8212,9 +7229,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:60") - } return true } goto end913e3575e5b4cf7f60585c108db40464 @@ -8231,9 +7245,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:61") - } return true } goto endcef6d6001d3f25cf5dacee11a46e5c8c @@ -8254,9 +7265,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = argwid v.Aux = target v.AddArg(mem) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:266") - } return true } goto end32c5cbec813d1c2ae94fc9b1090e4b2a @@ -8280,9 +7288,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(ptr) v.AddArg(val) v.AddArg(mem) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:209") - } return true } goto endbaeb60123806948cd2433605820d5af1 @@ -8305,9 +7310,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(ptr) v.AddArg(val) v.AddArg(mem) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:210") - } return true } goto end582e895008657c728c141c6b95070de7 @@ -8330,9 +7332,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(ptr) v.AddArg(val) v.AddArg(mem) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:211") - } return true } goto enda3f6a985b6ebb277665f80ad30b178df @@ -8355,9 +7354,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(ptr) v.AddArg(val) v.AddArg(mem) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:212") - } return true } goto ende2dee0bc82f631e3c6b0031bf8d224c1 @@ -8380,9 +7376,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(ptr) v.AddArg(val) v.AddArg(mem) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:213") - } return true } goto end6f343b676bf49740054e459f972b24f5 @@ -8401,9 +7394,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:21") - } return true } goto end54adc5de883c0460ca71c6ee464d4244 @@ -8422,9 +7412,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:20") - } return true } goto enddc3a2a488bda8c5856f93343e5ffe5f8 @@ -8443,9 +7430,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:19") - } return true } goto endd88d5646309fd9174584888ecc8aca2c @@ -8464,9 +7448,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:22") - } return true } goto end7d33bf9bdfa505f96b930563eca7955f @@ -8484,9 +7465,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:74") - } return true } goto end8e2f5e0a6e3a06423c077747de6c2bdd @@ -8504,9 +7482,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:76") - } return true } goto end5bed0e3a3c1c6374d86beb5a4397708c @@ -8524,9 +7499,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:75") - } return true } goto endef0b8032ce91979ce6cd0004260c04ee @@ -8544,9 +7516,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:78") - } return true } goto endd32fd6e0ce970c212835e6f71c3dcbfd @@ -8564,9 +7533,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:79") - } return true } goto end1212c4e84153210aff7fd630fb3e1883 @@ -8584,9 +7550,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:77") - } return true } goto end734f017d4b2810ca2288f7037365824c @@ -8608,9 +7571,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:326") - } return true } goto enda9ed9fdd115ffdffa8127c007c34d7b7 @@ -8631,9 +7591,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:327") - } return true } goto endb02a07d9dc7b802c59f013116e952f3f @@ -8652,9 +7609,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 0 - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:539") - } return true } goto end2afddc39503d04d572a3a07878f6c9c9 @@ -8675,9 +7629,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c ^ d - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:512") - } return true } goto end6d8d1b612af9d253605c8bc69b822903 @@ -8699,9 +7650,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:322") - } return true } goto enda9459d509d3416da67d13a22dd074a9c @@ -8722,9 +7670,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:323") - } return true } goto end9c1a0af00eeadd8aa325e55f1f3fb89c @@ -8743,9 +7688,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 0 - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:537") - } return true } goto end7bcf9cfeb69a0d7647389124eb53ce2a @@ -8766,9 +7708,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c ^ d - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:510") - } return true } goto end71238075b10b68a226903cc453c4715c @@ -8793,9 +7732,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:320") - } return true } goto end452341f950062e0483f16438fb9ec500 @@ -8819,9 +7755,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:321") - } return true } goto endd221a7e3daaaaa29ee385ad36e061b57 @@ -8840,9 +7773,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 0 - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:536") - } return true } goto end10575a5d711cf14e6d4dffbb0e8dfaeb @@ -8863,9 +7793,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c ^ d - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:509") - } return true } goto end3f404d4f07362319fbad2e1ba0827a9f @@ -8887,9 +7814,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:324") - } return true } goto end2ca109efd66c221a5691a4da95ec6c67 @@ -8910,9 +7834,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AuxInt = c v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:325") - } return true } goto end51ee62a06d4301e5a4aed7a6639b1d53 @@ -8931,9 +7852,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = 0 - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:538") - } return true } goto end07f332e857be0c2707797ed480a2faf4 @@ -8954,9 +7872,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c ^ d - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:511") - } return true } goto ende24881ccdfa8486c4593fd9aa5df1ed6 @@ -8975,9 +7890,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:45") - } return true } goto end20efdd5dfd5130abf818de5546a991a0 @@ -8996,9 +7908,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:44") - } return true } goto end9da6bce98b437e2609488346116a75d8 @@ -9017,9 +7926,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:43") - } return true } goto endc88cd189c2a6f07ecff324ed94809f8f @@ -9038,9 +7944,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(x) v.AddArg(y) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:46") - } return true } goto end50f4434ef96916d3e65ad3cc236d1723 @@ -9061,9 +7964,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.Type = mem.Type v.AddArg(mem) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:419") - } return true } goto endc9a38a60f0322f93682daa824611272c @@ -9088,9 +7988,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AuxInt = 0 v.AddArg(v0) v.AddArg(mem) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:420") - } return true } goto end56bcaef03cce4d15c03efff669bb5585 @@ -9115,9 +8012,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AuxInt = 0 v.AddArg(v0) v.AddArg(mem) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:421") - } return true } goto endf52f08f1f7b0ae220c4cfca6586a8586 @@ -9142,9 +8036,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AuxInt = 0 v.AddArg(v0) v.AddArg(mem) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:422") - } return true } goto end41c91e0c7a23e233de77812b5264fd10 @@ -9169,9 +8060,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AuxInt = 0 v.AddArg(v0) v.AddArg(mem) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:423") - } return true } goto end157ad586af643d8dac6cc84a776000ca @@ -9194,9 +8082,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = size v.AddArg(destptr) v.AddArg(mem) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:426") - } return true } goto endf0a22f1506977610ac0a310eee152075 @@ -9231,9 +8116,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1.AddArg(v2) v1.AddArg(mem) v.AddArg(v1) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:428") - } return true } goto end84c39fe2e8d40e0042a10741a0ef16bd @@ -9250,9 +8132,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:69") - } return true } goto endbfff79412a2cc96095069c66812844b4 @@ -9269,9 +8148,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:70") - } return true } goto end7a40262c5c856101058d2bd518ed0910 @@ -9288,9 +8164,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:71") - } return true } goto enddf83bdc8cc6c5673a9ef7aca7affe45a @@ -9307,9 +8180,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:66") - } return true } goto endd03d53d2a585727e4107ae1a3cc55479 @@ -9326,9 +8196,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:67") - } return true } goto endcbd33e965b3dab14fced5ae93d8949de @@ -9345,9 +8212,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:68") - } return true } goto end63ae7cc15db9d15189b2f1342604b2cb @@ -9373,9 +8237,6 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:439") - } return true } goto end6b8e9afc73b1c4d528f31a60d2575fae @@ -9397,9 +8258,6 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:434") - } return true } goto end0610f000a6988ee8310307ec2ea138f8 @@ -9421,9 +8279,6 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:432") - } return true } goto endf60c0660b6a8aa9565c97fc87f04eb34 @@ -9445,9 +8300,6 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:242") - } return true } goto end94277282f4b83f0c035b23711a075801 @@ -9468,9 +8320,6 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:243") - } return true } goto enda84798dd797927b54a9a2987421b2ba2 @@ -9491,9 +8340,6 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:244") - } return true } goto end3434ef985979cbf394455ab5b559567c @@ -9514,9 +8360,6 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:245") - } return true } goto endee147d81d8620a5e23cb92bd9f13cf8d @@ -9537,9 +8380,6 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:246") - } return true } goto ende7d85ccc850fc3963c50a91df096de17 @@ -9560,9 +8400,6 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:247") - } return true } goto endba4b54260ecda1b5731b129c0eb493d0 @@ -9583,9 +8420,6 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:248") - } return true } goto endf84eedfcd3f18f5c9c3f3d1045a24330 @@ -9606,9 +8440,6 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:249") - } return true } goto endfe0178f6f4406945ca8966817d04be60 @@ -9629,9 +8460,6 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:250") - } return true } goto end2b5a2d7756bdba01a732bf54d9acdb73 @@ -9652,9 +8480,6 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:251") - } return true } goto end9bea9963c3c5dfb97249a5feb8287f94 @@ -9676,9 +8501,6 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = v0 b.Succs[0] = yes b.Succs[1] = no - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:253") - } return true } goto end012351592edfc708bd3181d7e53f3993 @@ -9700,9 +8522,6 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:433") - } return true } goto end0d49d7d087fe7578e8015cf13dae37e3 @@ -9724,9 +8543,6 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:431") - } return true } goto end6a408cde0fee0ae7b7da0443c8d902bf @@ -9751,9 +8567,6 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:255") - } return true } goto end0b9ca165d6b395de676eebef94bc62f7 @@ -9777,9 +8590,6 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:256") - } return true } goto endaaba0ee4d0ff8c66a1c3107d2a14c4bc @@ -9803,9 +8613,6 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:257") - } return true } goto end1b689463137526b36ba9ceed1e76e512 @@ -9829,9 +8636,6 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:258") - } return true } goto end99eefee595c658b997f41577ed853c2e @@ -9855,9 +8659,6 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:259") - } return true } goto end371b67d3d63e9b92d848b09c3324e8b9 @@ -9881,9 +8682,6 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:260") - } return true } goto endd245f2aac2191d32e57cd2e321daa453 @@ -9907,9 +8705,6 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:261") - } return true } goto end90c4bec851e734d37457d611b1a5ff28 @@ -9933,9 +8728,6 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:262") - } return true } goto end3a68a28114e9b89ee0708823386bc1ee @@ -9959,9 +8751,6 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:263") - } return true } goto end16496f57185756e960d536b057c776c0 @@ -9985,9 +8774,6 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:264") - } return true } goto endbd122fd599aeb9e60881a0fa735e2fde @@ -10008,9 +8794,6 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:440") - } return true } goto end713001aba794e50b582fbff930e110af @@ -10032,9 +8815,6 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:438") - } return true } goto ende3e4ddc183ca1a46598b11c2d0d13966 @@ -10056,9 +8836,6 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:436") - } return true } goto end49818853af2e5251175d06c62768cae7 @@ -10080,9 +8857,6 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:437") - } return true } goto endd6698aac0d67261293b558c95ea17b4f @@ -10104,9 +8878,6 @@ func rewriteBlockAMD64(b *Block) bool { b.Control = cmp b.Succs[0] = yes b.Succs[1] = no - if logRewriteRules { - fmt.Println("rewrite AMD64.rules:435") - } return true } goto end35105dbc9646f02577167e45ae2f2fd2 diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index 7f787fc57e..e39305461d 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -2,8 +2,6 @@ // generated with: cd gen; go run *.go package ssa -import "fmt" - func rewriteValuegeneric(v *Value, config *Config) bool { b := v.Block switch v.Op { @@ -25,9 +23,6 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c + d - if logRewriteRules { - fmt.Println("rewrite generic.rules:23") - } return true } goto end8c46df6f85a11cb1d594076b0e467908 @@ -51,9 +46,6 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c + d - if logRewriteRules { - fmt.Println("rewrite generic.rules:24") - } return true } goto end145c1aec793b2befff34bc8983b48a38 @@ -80,9 +72,6 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v0.AddArg(idx) v.AddArg(v0) v.AddArg(mem) - if logRewriteRules { - fmt.Println("rewrite generic.rules:59") - } return true } goto end4894dd7b58383fee5f8a92be08437c33 @@ -103,9 +92,6 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite generic.rules:38") - } return true } goto end1ea17710dd4dd7ba4e710e0e4c7b5a56 @@ -126,9 +112,6 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite generic.rules:39") - } return true } goto end9a04ed536496e292c27bef4414128cbf @@ -149,9 +132,6 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite generic.rules:40") - } return true } goto ended44e29d5968f0f7b86972b7bf417ab3 @@ -172,9 +152,6 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.resetArgs() v.Type = x.Type v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite generic.rules:37") - } return true } goto end4d92ff3ba567d9afd38fc9ca113602ad @@ -201,9 +178,6 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v2.Type = config.Frontend().TypeUintptr() v2.AuxInt = int64(len(s.(string))) v.AddArg(v2) - if logRewriteRules { - fmt.Println("rewrite generic.rules:68") - } return true } goto end68cc91679848c7c30bd8b0a8ed533843 @@ -223,9 +197,6 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.Aux = true - if logRewriteRules { - fmt.Println("rewrite generic.rules:30") - } return true } goto enda503589f9b617e708a5ad3ddb047809f @@ -245,9 +216,6 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.Aux = true - if logRewriteRules { - fmt.Println("rewrite generic.rules:29") - } return true } goto endc94ae3b97d0090257b02152e437b3e17 @@ -267,9 +235,6 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.Aux = true - if logRewriteRules { - fmt.Println("rewrite generic.rules:28") - } return true } goto end4d21cead60174989467a9c8202dbb91d @@ -289,9 +254,6 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.Aux = true - if logRewriteRules { - fmt.Println("rewrite generic.rules:31") - } return true } goto end73dce8bba164e4f4a1dd701bf8cfb362 @@ -313,9 +275,6 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.resetArgs() v.AddArg(y) v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite generic.rules:51") - } return true } goto endcea7f7399afcff860c54d82230a9a934 @@ -346,9 +305,6 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v1.Type = config.Frontend().TypeUintptr() v1.AuxInt = 0 v.AddArg(v1) - if logRewriteRules { - fmt.Println("rewrite generic.rules:54") - } return true } goto end540dc8dfbc66adcd3db2d7e819c534f6 @@ -372,9 +328,6 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.Aux = inBounds(c, d) - if logRewriteRules { - fmt.Println("rewrite generic.rules:27") - } return true } goto enddfd340bc7103ca323354aec96b113c23 @@ -409,9 +362,6 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v1.AddArg(v2) v1.AddArg(mem) v.AddArg(v1) - if logRewriteRules { - fmt.Println("rewrite generic.rules:69") - } return true } goto end18afa4a6fdd6d0b92ed292840898c8f6 @@ -435,9 +385,6 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c * d - if logRewriteRules { - fmt.Println("rewrite generic.rules:25") - } return true } goto end7aea1048b5d1230974b97f17238380ae @@ -461,9 +408,6 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = c * d - if logRewriteRules { - fmt.Println("rewrite generic.rules:26") - } return true } goto end808c190f346658bb1ad032bf37a1059f @@ -483,9 +427,6 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.Aux = false - if logRewriteRules { - fmt.Println("rewrite generic.rules:34") - } return true } goto end192755dd3c2be992e9d3deb53794a8d2 @@ -505,9 +446,6 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.Aux = false - if logRewriteRules { - fmt.Println("rewrite generic.rules:33") - } return true } goto endeb23619fc85950a8df7b31126252c4dd @@ -527,9 +465,6 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.Aux = false - if logRewriteRules { - fmt.Println("rewrite generic.rules:32") - } return true } goto endfc6eea780fb4056afb9e4287076da60c @@ -549,9 +484,6 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.Aux = false - if logRewriteRules { - fmt.Println("rewrite generic.rules:35") - } return true } goto endcccf700d93c6d57765b80f92f7b3fa81 @@ -573,9 +505,6 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.resetArgs() v.AddArg(y) v.AddArg(x) - if logRewriteRules { - fmt.Println("rewrite generic.rules:52") - } return true } goto end94c68f7dc30c66ed42e507e01c4e5dc7 @@ -606,9 +535,6 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v1.Type = config.Frontend().TypeUintptr() v1.AuxInt = 0 v.AddArg(v1) - if logRewriteRules { - fmt.Println("rewrite generic.rules:55") - } return true } goto end67d723bb0f39a5c897816abcf411e5cf @@ -635,9 +561,6 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v1.AuxInt = t.Elem().Size() v0.AddArg(v1) v.AddArg(v0) - if logRewriteRules { - fmt.Println("rewrite generic.rules:60") - } return true } goto endf7546737f42c76a99699f241d41f491a @@ -666,9 +589,6 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v0.AddArg(v1) v.AddArg(v0) v.AddArg(mem) - if logRewriteRules { - fmt.Println("rewrite generic.rules:46") - } return true } goto end6696811bf6bd45e505d24c1a15c68e70 @@ -697,9 +617,6 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v0.AddArg(v1) v.AddArg(v0) v.AddArg(mem) - if logRewriteRules { - fmt.Println("rewrite generic.rules:45") - } return true } goto end9844ce3e290e81355493141e653e37d5 @@ -721,9 +638,6 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.resetArgs() v.AddArg(ptr) v.AddArg(mem) - if logRewriteRules { - fmt.Println("rewrite generic.rules:44") - } return true } goto end459613b83f95b65729d45c2ed663a153 @@ -755,9 +669,6 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.AddArg(dst) v.AddArg(src) v.AddArg(mem) - if logRewriteRules { - fmt.Println("rewrite generic.rules:65") - } return true } goto end324ffb6d2771808da4267f62c854e9c8 @@ -795,9 +706,6 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v2.AddArg(v3) v2.AddArg(mem) v.AddArg(v2) - if logRewriteRules { - fmt.Println("rewrite generic.rules:72") - } return true } goto enddf0c5a150f4b4bf6715fd2bd4bb4cc20 @@ -818,9 +726,6 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.resetArgs() v.Type = len.Type v.AddArg(len) - if logRewriteRules { - fmt.Println("rewrite generic.rules:71") - } return true } goto end0d922460b7e5ca88324034f4bd6c027c @@ -841,9 +746,6 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.resetArgs() v.Type = ptr.Type v.AddArg(ptr) - if logRewriteRules { - fmt.Println("rewrite generic.rules:70") - } return true } goto end061edc5d85c73ad909089af2556d9380 @@ -870,9 +772,6 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v0.AddArg(ptr) v.AddArg(v0) v.AddArg(mem) - if logRewriteRules { - fmt.Println("rewrite generic.rules:61") - } return true } goto end16fdb45e1dd08feb36e3cc3fb5ed8935 @@ -902,9 +801,6 @@ func rewriteBlockgeneric(b *Block) bool { b.Succs = b.Succs[:1] b.Succs[0] = yes b.Likely = BranchUnknown - if logRewriteRules { - fmt.Println("rewrite generic.rules:74") - } return true } goto end0f2bb0111a86be0436b44210dbd83a90 @@ -926,9 +822,6 @@ func rewriteBlockgeneric(b *Block) bool { b.Succs[0] = no b.Succs[1] = yes b.Likely *= -1 - if logRewriteRules { - fmt.Println("rewrite generic.rules:76") - } return true } goto endebe19c1c3c3bec068cdb2dd29ef57f96 @@ -954,9 +847,6 @@ func rewriteBlockgeneric(b *Block) bool { b.Succs = b.Succs[:1] b.Succs[0] = yes b.Likely = BranchUnknown - if logRewriteRules { - fmt.Println("rewrite generic.rules:77") - } return true } goto end9ff0273f9b1657f4afc287562ca889f0 @@ -982,9 +872,6 @@ func rewriteBlockgeneric(b *Block) bool { b.Succs = b.Succs[:1] b.Succs[0] = no b.Likely = BranchUnknown - if logRewriteRules { - fmt.Println("rewrite generic.rules:78") - } return true } goto endf401a4553c3c7c6bed64801da7bba076 -- cgit v1.3 From 3b705824ce6cf4827732eb32923835a327c5f963 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Thu, 13 Aug 2015 12:47:50 -0700 Subject: [dev.ssa] cmd/compile: fix constant subtraction rules (SUBQconst [x] y) computes y-x, not x-y. Fixes #12137 Change-Id: Idbd0554eee051102f562240d1756647843666ee6 Reviewed-on: https://go-review.googlesource.com/13631 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/gc/testdata/arith_ssa.go | 31 +++++++++ src/cmd/compile/internal/ssa/gen/AMD64.rules | 16 ++--- src/cmd/compile/internal/ssa/rewriteAMD64.go | 80 +++++++++++------------ 3 files changed, 79 insertions(+), 48 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/testdata/arith_ssa.go b/src/cmd/compile/internal/gc/testdata/arith_ssa.go index 0dbf9451ab..ca96988113 100644 --- a/src/cmd/compile/internal/gc/testdata/arith_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/arith_ssa.go @@ -222,6 +222,36 @@ func testLrot() { } +func sub1_ssa() uint64 { + switch { + } // prevent inlining + 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 + } +} + var failed = false func main() { @@ -233,6 +263,7 @@ func main() { testBitwiseLogic() testOcom() testLrot() + testSubConst() if failed { panic("failed") diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index ab8e44a444..ec142d801e 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -483,14 +483,14 @@ (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 [c-d]) -(SUBLconst [c] (MOVLconst [d])) -> (MOVLconst [c-d]) -(SUBWconst [c] (MOVWconst [d])) -> (MOVWconst [c-d]) -(SUBBconst [c] (MOVBconst [d])) -> (MOVBconst [c-d]) -(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) +(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) (NEGQ (MOVQconst [c])) -> (MOVQconst [-c]) (NEGL (MOVLconst [c])) -> (MOVLconst [-c]) (NEGW (MOVWconst [c])) -> (MOVWconst [-c]) diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index a18097f91e..a9f3ad79ab 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -6801,30 +6801,30 @@ func rewriteValueAMD64(v *Value, config *Config) bool { case OpAMD64SUBBconst: // match: (SUBBconst [c] (MOVBconst [d])) // cond: - // result: (MOVBconst [c-d]) + // result: (MOVBconst [d-c]) { c := v.AuxInt if v.Args[0].Op != OpAMD64MOVBconst { - goto end0e2d5c3e3c02001a20d5433daa9e8317 + goto enddc5383558e2f3eae507afcb94eada964 } d := v.Args[0].AuxInt v.Op = OpAMD64MOVBconst v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = c - d + v.AuxInt = d - c return true } - goto end0e2d5c3e3c02001a20d5433daa9e8317 - end0e2d5c3e3c02001a20d5433daa9e8317: + goto enddc5383558e2f3eae507afcb94eada964 + enddc5383558e2f3eae507afcb94eada964: ; // match: (SUBBconst [c] (SUBBconst [d] x)) // cond: - // result: (ADDBconst [c-d] x) + // result: (ADDBconst [-c-d] x) { c := v.AuxInt if v.Args[0].Op != OpAMD64SUBBconst { - goto end48eccb421dfe0c678ea9c47113521d5a + goto end035c57413a46eb347ecb3736d1510915 } d := v.Args[0].AuxInt x := v.Args[0].Args[0] @@ -6832,12 +6832,12 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = c - d + v.AuxInt = -c - d v.AddArg(x) return true } - goto end48eccb421dfe0c678ea9c47113521d5a - end48eccb421dfe0c678ea9c47113521d5a: + goto end035c57413a46eb347ecb3736d1510915 + end035c57413a46eb347ecb3736d1510915: ; case OpAMD64SUBL: // match: (SUBL x (MOVLconst [c])) @@ -6904,30 +6904,30 @@ func rewriteValueAMD64(v *Value, config *Config) bool { case OpAMD64SUBLconst: // match: (SUBLconst [c] (MOVLconst [d])) // cond: - // result: (MOVLconst [c-d]) + // result: (MOVLconst [d-c]) { c := v.AuxInt if v.Args[0].Op != OpAMD64MOVLconst { - goto endbe7466f3c09d9645544bdfc44c37c922 + goto end6c5c6d58d4bdd0a5c2f7bf10b343b41e } d := v.Args[0].AuxInt v.Op = OpAMD64MOVLconst v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = c - d + v.AuxInt = d - c return true } - goto endbe7466f3c09d9645544bdfc44c37c922 - endbe7466f3c09d9645544bdfc44c37c922: + goto end6c5c6d58d4bdd0a5c2f7bf10b343b41e + end6c5c6d58d4bdd0a5c2f7bf10b343b41e: ; // match: (SUBLconst [c] (SUBLconst [d] x)) // cond: - // result: (ADDLconst [c-d] x) + // result: (ADDLconst [-c-d] x) { c := v.AuxInt if v.Args[0].Op != OpAMD64SUBLconst { - goto endb5106962a865bc4654b170c2e29a72c4 + goto end0c9ffb11e8a56ced1b14dbf6bf9a6737 } d := v.Args[0].AuxInt x := v.Args[0].Args[0] @@ -6935,12 +6935,12 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = c - d + v.AuxInt = -c - d v.AddArg(x) return true } - goto endb5106962a865bc4654b170c2e29a72c4 - endb5106962a865bc4654b170c2e29a72c4: + goto end0c9ffb11e8a56ced1b14dbf6bf9a6737 + end0c9ffb11e8a56ced1b14dbf6bf9a6737: ; case OpAMD64SUBQ: // match: (SUBQ x (MOVQconst [c])) @@ -7013,30 +7013,30 @@ func rewriteValueAMD64(v *Value, config *Config) bool { case OpAMD64SUBQconst: // match: (SUBQconst [c] (MOVQconst [d])) // cond: - // result: (MOVQconst [c-d]) + // result: (MOVQconst [d-c]) { c := v.AuxInt if v.Args[0].Op != OpAMD64MOVQconst { - goto end96c09479fb3c043e875d89d3eb92f1d8 + goto endb0daebe6831cf381377c3e4248070f25 } d := v.Args[0].AuxInt v.Op = OpAMD64MOVQconst v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = c - d + v.AuxInt = d - c return true } - goto end96c09479fb3c043e875d89d3eb92f1d8 - end96c09479fb3c043e875d89d3eb92f1d8: + goto endb0daebe6831cf381377c3e4248070f25 + endb0daebe6831cf381377c3e4248070f25: ; // match: (SUBQconst [c] (SUBQconst [d] x)) // cond: - // result: (ADDQconst [c-d] x) + // result: (ADDQconst [-c-d] x) { c := v.AuxInt if v.Args[0].Op != OpAMD64SUBQconst { - goto enddd9d61b404480adb40cfd7fedd7e5ec4 + goto end2d40ddb5ae9e90679456254c61858d9d } d := v.Args[0].AuxInt x := v.Args[0].Args[0] @@ -7044,12 +7044,12 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = c - d + v.AuxInt = -c - d v.AddArg(x) return true } - goto enddd9d61b404480adb40cfd7fedd7e5ec4 - enddd9d61b404480adb40cfd7fedd7e5ec4: + goto end2d40ddb5ae9e90679456254c61858d9d + end2d40ddb5ae9e90679456254c61858d9d: ; case OpAMD64SUBW: // match: (SUBW x (MOVWconst [c])) @@ -7116,30 +7116,30 @@ func rewriteValueAMD64(v *Value, config *Config) bool { case OpAMD64SUBWconst: // match: (SUBWconst [c] (MOVWconst [d])) // cond: - // result: (MOVWconst [c-d]) + // result: (MOVWconst [d-c]) { c := v.AuxInt if v.Args[0].Op != OpAMD64MOVWconst { - goto end0e5079577fcf00f5925291dbd68306aa + goto endae629a229c399eaed7dbb95b1b0e6f8a } d := v.Args[0].AuxInt v.Op = OpAMD64MOVWconst v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = c - d + v.AuxInt = d - c return true } - goto end0e5079577fcf00f5925291dbd68306aa - end0e5079577fcf00f5925291dbd68306aa: + goto endae629a229c399eaed7dbb95b1b0e6f8a + endae629a229c399eaed7dbb95b1b0e6f8a: ; // match: (SUBWconst [c] (SUBWconst [d] x)) // cond: - // result: (ADDWconst [c-d] x) + // result: (ADDWconst [-c-d] x) { c := v.AuxInt if v.Args[0].Op != OpAMD64SUBWconst { - goto endb628696cf5b329d03782b8093093269b + goto enda59f08d12aa08717b0443b7bb1b71374 } d := v.Args[0].AuxInt x := v.Args[0].Args[0] @@ -7147,12 +7147,12 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = c - d + v.AuxInt = -c - d v.AddArg(x) return true } - goto endb628696cf5b329d03782b8093093269b - endb628696cf5b329d03782b8093093269b: + goto enda59f08d12aa08717b0443b7bb1b71374 + enda59f08d12aa08717b0443b7bb1b71374: ; case OpSignExt16to32: // match: (SignExt16to32 x) -- cgit v1.3 From bc1f5768ce4dbe0f8647172f7e8964054bccbb22 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Thu, 13 Aug 2015 13:12:17 -0700 Subject: [dev.ssa] cmd/compile: add register spec to getg This omission was causing the new regalloc to fail. Change-Id: If7ba7be38a436dbd0dd443828ddd7ebf6e35be0e Reviewed-on: https://go-review.googlesource.com/13632 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 2 +- src/cmd/compile/internal/ssa/opGen.go | 6 +++++- 2 files changed, 6 insertions(+), 2 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 903eea3057..9e8b2fa018 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -290,7 +290,7 @@ func init() { // Pseudo-ops {name: "LoweredPanicNilCheck"}, - {name: "LoweredGetG"}, + {name: "LoweredGetG", reg: gp01}, } var AMD64blocks = []blockData{ diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 425c7e468c..6f412806c8 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -2123,7 +2123,11 @@ var opcodeTable = [...]opInfo{ }, { name: "LoweredGetG", - reg: regInfo{}, + reg: regInfo{ + outputs: []regMask{ + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + }, }, { -- cgit v1.3 From 3e7904b648791e8d9df4930aed645ae7bbda5f94 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Wed, 12 Aug 2015 13:48:36 -0700 Subject: [dev.ssa] cmd/compile: improve inBounds rewrite rules Change-Id: Ia238187a89f820cd1620ab5acdbf1c8f003569b1 Reviewed-on: https://go-review.googlesource.com/13587 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/gen/AMD64.rules | 32 ++-- src/cmd/compile/internal/ssa/gen/generic.rules | 5 +- src/cmd/compile/internal/ssa/rewrite.go | 7 +- src/cmd/compile/internal/ssa/rewriteAMD64.go | 224 ++++++++++++------------- src/cmd/compile/internal/ssa/rewritegeneric.go | 88 +++++++++- 5 files changed, 216 insertions(+), 140 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index ec142d801e..a53f2ca388 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -440,22 +440,22 @@ (NE (InvertFlags cmp) yes no) -> (NE cmp yes no) // get rid of overflow code for constant shifts -(SBBQcarrymask (CMPQconst [c] (MOVQconst [d]))) && inBounds(d, c) -> (MOVQconst [-1]) -(SBBQcarrymask (CMPQconst [c] (MOVQconst [d]))) && !inBounds(d, c) -> (MOVQconst [0]) -(SBBQcarrymask (CMPLconst [c] (MOVLconst [d]))) && inBounds(int64(int32(d)), int64(int32(c))) -> (MOVQconst [-1]) -(SBBQcarrymask (CMPLconst [c] (MOVLconst [d]))) && !inBounds(int64(int32(d)), int64(int32(c))) -> (MOVQconst [0]) -(SBBQcarrymask (CMPWconst [c] (MOVWconst [d]))) && inBounds(int64(int16(d)), int64(int16(c))) -> (MOVQconst [-1]) -(SBBQcarrymask (CMPWconst [c] (MOVWconst [d]))) && !inBounds(int64(int16(d)), int64(int16(c))) -> (MOVQconst [0]) -(SBBQcarrymask (CMPBconst [c] (MOVBconst [d]))) && inBounds(int64(int8(d)), int64(int8(c))) -> (MOVQconst [-1]) -(SBBQcarrymask (CMPBconst [c] (MOVBconst [d]))) && !inBounds(int64(int8(d)), int64(int8(c))) -> (MOVQconst [0]) -(SBBLcarrymask (CMPQconst [c] (MOVQconst [d]))) && inBounds(d, c) -> (MOVLconst [-1]) -(SBBLcarrymask (CMPQconst [c] (MOVQconst [d]))) && !inBounds(d, c) -> (MOVLconst [0]) -(SBBLcarrymask (CMPLconst [c] (MOVLconst [d]))) && inBounds(int64(int32(d)), int64(int32(c))) -> (MOVLconst [-1]) -(SBBLcarrymask (CMPLconst [c] (MOVLconst [d]))) && !inBounds(int64(int32(d)), int64(int32(c))) -> (MOVLconst [0]) -(SBBLcarrymask (CMPWconst [c] (MOVWconst [d]))) && inBounds(int64(int16(d)), int64(int16(c))) -> (MOVLconst [-1]) -(SBBLcarrymask (CMPWconst [c] (MOVWconst [d]))) && !inBounds(int64(int16(d)), int64(int16(c))) -> (MOVLconst [0]) -(SBBLcarrymask (CMPBconst [c] (MOVBconst [d]))) && inBounds(int64(int8(d)), int64(int8(c))) -> (MOVLconst [-1]) -(SBBLcarrymask (CMPBconst [c] (MOVBconst [d]))) && !inBounds(int64(int8(d)), int64(int8(c))) -> (MOVLconst [0]) +(SBBQcarrymask (CMPQconst [c] (MOVQconst [d]))) && inBounds64(d, c) -> (MOVQconst [-1]) +(SBBQcarrymask (CMPQconst [c] (MOVQconst [d]))) && !inBounds64(d, c) -> (MOVQconst [0]) +(SBBQcarrymask (CMPLconst [c] (MOVLconst [d]))) && inBounds32(d, c) -> (MOVQconst [-1]) +(SBBQcarrymask (CMPLconst [c] (MOVLconst [d]))) && !inBounds32(d, c) -> (MOVQconst [0]) +(SBBQcarrymask (CMPWconst [c] (MOVWconst [d]))) && inBounds16(d, c) -> (MOVQconst [-1]) +(SBBQcarrymask (CMPWconst [c] (MOVWconst [d]))) && !inBounds16(d, c) -> (MOVQconst [0]) +(SBBQcarrymask (CMPBconst [c] (MOVBconst [d]))) && inBounds8(d, c) -> (MOVQconst [-1]) +(SBBQcarrymask (CMPBconst [c] (MOVBconst [d]))) && !inBounds8(d, c) -> (MOVQconst [0]) +(SBBLcarrymask (CMPQconst [c] (MOVQconst [d]))) && inBounds64(d, c) -> (MOVLconst [-1]) +(SBBLcarrymask (CMPQconst [c] (MOVQconst [d]))) && !inBounds64(d, c) -> (MOVLconst [0]) +(SBBLcarrymask (CMPLconst [c] (MOVLconst [d]))) && inBounds32(d, c) -> (MOVLconst [-1]) +(SBBLcarrymask (CMPLconst [c] (MOVLconst [d]))) && !inBounds32(d, c) -> (MOVLconst [0]) +(SBBLcarrymask (CMPWconst [c] (MOVWconst [d]))) && inBounds16(d, c) -> (MOVLconst [-1]) +(SBBLcarrymask (CMPWconst [c] (MOVWconst [d]))) && !inBounds16(d, c) -> (MOVLconst [0]) +(SBBLcarrymask (CMPBconst [c] (MOVBconst [d]))) && inBounds8(d, c) -> (MOVLconst [-1]) +(SBBLcarrymask (CMPBconst [c] (MOVBconst [d]))) && !inBounds8(d, c) -> (MOVLconst [0]) (ANDQconst [0] _) -> (MOVQconst [0]) (ANDLconst [c] _) && int32(c)==0 -> (MOVLconst [0]) (ANDWconst [c] _) && int16(c)==0 -> (MOVWconst [0]) diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index f4f49acb86..66bec779bb 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -24,7 +24,10 @@ (AddPtr (ConstPtr [c]) (ConstPtr [d])) -> (ConstPtr [c+d]) (Mul64 (Const64 [c]) (Const64 [d])) -> (Const64 [c*d]) (MulPtr (ConstPtr [c]) (ConstPtr [d])) -> (ConstPtr [c*d]) -(IsInBounds (ConstPtr [c]) (ConstPtr [d])) -> (ConstPtr {inBounds(c,d)}) +(IsInBounds (Const32 [c]) (Const32 [d])) -> (ConstBool {inBounds32(c,d)}) +(IsInBounds (Const64 [c]) (Const64 [d])) -> (ConstBool {inBounds64(c,d)}) +(IsInBounds (ConstPtr [c]) (ConstPtr [d])) && config.PtrSize == 4 -> (ConstBool {inBounds32(c,d)}) +(IsInBounds (ConstPtr [c]) (ConstPtr [d])) && config.PtrSize == 8 -> (ConstBool {inBounds64(c,d)}) (Eq64 x x) -> (ConstBool {true}) (Eq32 x x) -> (ConstBool {true}) (Eq16 x x) -> (ConstBool {true}) diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go index 39fc48df4a..aae8220f81 100644 --- a/src/cmd/compile/internal/ssa/rewrite.go +++ b/src/cmd/compile/internal/ssa/rewrite.go @@ -125,9 +125,10 @@ func mergeSym(x, y interface{}) interface{} { return nil } -func inBounds(idx, len int64) bool { - return idx >= 0 && idx < len -} +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 } // log2 returns logarithm in base of n. // expects n to be a power of 2. diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index a9f3ad79ab..6d74aad352 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -5978,19 +5978,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { ; case OpAMD64SBBLcarrymask: // match: (SBBLcarrymask (CMPQconst [c] (MOVQconst [d]))) - // cond: inBounds(d, c) + // cond: inBounds64(d, c) // result: (MOVLconst [-1]) { if v.Args[0].Op != OpAMD64CMPQconst { - goto enda9e02a887246381d02b3259b9df4050c + goto end490c8a7039bab41e90e564fbb8500233 } c := v.Args[0].AuxInt if v.Args[0].Args[0].Op != OpAMD64MOVQconst { - goto enda9e02a887246381d02b3259b9df4050c + goto end490c8a7039bab41e90e564fbb8500233 } d := v.Args[0].Args[0].AuxInt - if !(inBounds(d, c)) { - goto enda9e02a887246381d02b3259b9df4050c + if !(inBounds64(d, c)) { + goto end490c8a7039bab41e90e564fbb8500233 } v.Op = OpAMD64MOVLconst v.AuxInt = 0 @@ -5999,23 +5999,23 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = -1 return true } - goto enda9e02a887246381d02b3259b9df4050c - enda9e02a887246381d02b3259b9df4050c: + goto end490c8a7039bab41e90e564fbb8500233 + end490c8a7039bab41e90e564fbb8500233: ; // match: (SBBLcarrymask (CMPQconst [c] (MOVQconst [d]))) - // cond: !inBounds(d, c) + // cond: !inBounds64(d, c) // result: (MOVLconst [0]) { if v.Args[0].Op != OpAMD64CMPQconst { - goto end3f8220527278b72a64148fcf9dc58bfe + goto end95e703eabe71d831b7a3d2f9fabe7de9 } c := v.Args[0].AuxInt if v.Args[0].Args[0].Op != OpAMD64MOVQconst { - goto end3f8220527278b72a64148fcf9dc58bfe + goto end95e703eabe71d831b7a3d2f9fabe7de9 } d := v.Args[0].Args[0].AuxInt - if !(!inBounds(d, c)) { - goto end3f8220527278b72a64148fcf9dc58bfe + if !(!inBounds64(d, c)) { + goto end95e703eabe71d831b7a3d2f9fabe7de9 } v.Op = OpAMD64MOVLconst v.AuxInt = 0 @@ -6024,23 +6024,23 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 return true } - goto end3f8220527278b72a64148fcf9dc58bfe - end3f8220527278b72a64148fcf9dc58bfe: + goto end95e703eabe71d831b7a3d2f9fabe7de9 + end95e703eabe71d831b7a3d2f9fabe7de9: ; // match: (SBBLcarrymask (CMPLconst [c] (MOVLconst [d]))) - // cond: inBounds(int64(int32(d)), int64(int32(c))) + // cond: inBounds32(d, c) // result: (MOVLconst [-1]) { if v.Args[0].Op != OpAMD64CMPLconst { - goto end880a2b9a12ed4f551bbd46473b9439bc + goto end00c0a561340b0172c9a21f63648b86e2 } c := v.Args[0].AuxInt if v.Args[0].Args[0].Op != OpAMD64MOVLconst { - goto end880a2b9a12ed4f551bbd46473b9439bc + goto end00c0a561340b0172c9a21f63648b86e2 } d := v.Args[0].Args[0].AuxInt - if !(inBounds(int64(int32(d)), int64(int32(c)))) { - goto end880a2b9a12ed4f551bbd46473b9439bc + if !(inBounds32(d, c)) { + goto end00c0a561340b0172c9a21f63648b86e2 } v.Op = OpAMD64MOVLconst v.AuxInt = 0 @@ -6049,23 +6049,23 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = -1 return true } - goto end880a2b9a12ed4f551bbd46473b9439bc - end880a2b9a12ed4f551bbd46473b9439bc: + goto end00c0a561340b0172c9a21f63648b86e2 + end00c0a561340b0172c9a21f63648b86e2: ; // match: (SBBLcarrymask (CMPLconst [c] (MOVLconst [d]))) - // cond: !inBounds(int64(int32(d)), int64(int32(c))) + // cond: !inBounds32(d, c) // result: (MOVLconst [0]) { if v.Args[0].Op != OpAMD64CMPLconst { - goto end3f08080e0f55d51afca2a131ed0c672e + goto enda73c8bf14f7b45dd97c6a006e317b0b8 } c := v.Args[0].AuxInt if v.Args[0].Args[0].Op != OpAMD64MOVLconst { - goto end3f08080e0f55d51afca2a131ed0c672e + goto enda73c8bf14f7b45dd97c6a006e317b0b8 } d := v.Args[0].Args[0].AuxInt - if !(!inBounds(int64(int32(d)), int64(int32(c)))) { - goto end3f08080e0f55d51afca2a131ed0c672e + if !(!inBounds32(d, c)) { + goto enda73c8bf14f7b45dd97c6a006e317b0b8 } v.Op = OpAMD64MOVLconst v.AuxInt = 0 @@ -6074,23 +6074,23 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 return true } - goto end3f08080e0f55d51afca2a131ed0c672e - end3f08080e0f55d51afca2a131ed0c672e: + goto enda73c8bf14f7b45dd97c6a006e317b0b8 + enda73c8bf14f7b45dd97c6a006e317b0b8: ; // match: (SBBLcarrymask (CMPWconst [c] (MOVWconst [d]))) - // cond: inBounds(int64(int16(d)), int64(int16(c))) + // cond: inBounds16(d, c) // result: (MOVLconst [-1]) { if v.Args[0].Op != OpAMD64CMPWconst { - goto end91ed02166e0c0d696730e1704d0a682e + goto endb94dc44cd77f66ed3bf3742874b666fc } c := v.Args[0].AuxInt if v.Args[0].Args[0].Op != OpAMD64MOVWconst { - goto end91ed02166e0c0d696730e1704d0a682e + goto endb94dc44cd77f66ed3bf3742874b666fc } d := v.Args[0].Args[0].AuxInt - if !(inBounds(int64(int16(d)), int64(int16(c)))) { - goto end91ed02166e0c0d696730e1704d0a682e + if !(inBounds16(d, c)) { + goto endb94dc44cd77f66ed3bf3742874b666fc } v.Op = OpAMD64MOVLconst v.AuxInt = 0 @@ -6099,23 +6099,23 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = -1 return true } - goto end91ed02166e0c0d696730e1704d0a682e - end91ed02166e0c0d696730e1704d0a682e: + goto endb94dc44cd77f66ed3bf3742874b666fc + endb94dc44cd77f66ed3bf3742874b666fc: ; // match: (SBBLcarrymask (CMPWconst [c] (MOVWconst [d]))) - // cond: !inBounds(int64(int16(d)), int64(int16(c))) + // cond: !inBounds16(d, c) // result: (MOVLconst [0]) { if v.Args[0].Op != OpAMD64CMPWconst { - goto endc7edc3a13ec73ec4e6e87e7ab421a71a + goto end7a02def6194822f7ab937d78088504d2 } c := v.Args[0].AuxInt if v.Args[0].Args[0].Op != OpAMD64MOVWconst { - goto endc7edc3a13ec73ec4e6e87e7ab421a71a + goto end7a02def6194822f7ab937d78088504d2 } d := v.Args[0].Args[0].AuxInt - if !(!inBounds(int64(int16(d)), int64(int16(c)))) { - goto endc7edc3a13ec73ec4e6e87e7ab421a71a + if !(!inBounds16(d, c)) { + goto end7a02def6194822f7ab937d78088504d2 } v.Op = OpAMD64MOVLconst v.AuxInt = 0 @@ -6124,23 +6124,23 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 return true } - goto endc7edc3a13ec73ec4e6e87e7ab421a71a - endc7edc3a13ec73ec4e6e87e7ab421a71a: + goto end7a02def6194822f7ab937d78088504d2 + end7a02def6194822f7ab937d78088504d2: ; // match: (SBBLcarrymask (CMPBconst [c] (MOVBconst [d]))) - // cond: inBounds(int64(int8(d)), int64(int8(c))) + // cond: inBounds8(d, c) // result: (MOVLconst [-1]) { if v.Args[0].Op != OpAMD64CMPBconst { - goto end0fe2997fc76ce00b1d496f7289ab345a + goto end79c8e4a20761df731521e6cd956c4245 } c := v.Args[0].AuxInt if v.Args[0].Args[0].Op != OpAMD64MOVBconst { - goto end0fe2997fc76ce00b1d496f7289ab345a + goto end79c8e4a20761df731521e6cd956c4245 } d := v.Args[0].Args[0].AuxInt - if !(inBounds(int64(int8(d)), int64(int8(c)))) { - goto end0fe2997fc76ce00b1d496f7289ab345a + if !(inBounds8(d, c)) { + goto end79c8e4a20761df731521e6cd956c4245 } v.Op = OpAMD64MOVLconst v.AuxInt = 0 @@ -6149,23 +6149,23 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = -1 return true } - goto end0fe2997fc76ce00b1d496f7289ab345a - end0fe2997fc76ce00b1d496f7289ab345a: + goto end79c8e4a20761df731521e6cd956c4245 + end79c8e4a20761df731521e6cd956c4245: ; // match: (SBBLcarrymask (CMPBconst [c] (MOVBconst [d]))) - // cond: !inBounds(int64(int8(d)), int64(int8(c))) + // cond: !inBounds8(d, c) // result: (MOVLconst [0]) { if v.Args[0].Op != OpAMD64CMPBconst { - goto end3a07121fcc82f1a19da4226b07a757ce + goto end95b5b21dd7756ae41575759a1eff2bea } c := v.Args[0].AuxInt if v.Args[0].Args[0].Op != OpAMD64MOVBconst { - goto end3a07121fcc82f1a19da4226b07a757ce + goto end95b5b21dd7756ae41575759a1eff2bea } d := v.Args[0].Args[0].AuxInt - if !(!inBounds(int64(int8(d)), int64(int8(c)))) { - goto end3a07121fcc82f1a19da4226b07a757ce + if !(!inBounds8(d, c)) { + goto end95b5b21dd7756ae41575759a1eff2bea } v.Op = OpAMD64MOVLconst v.AuxInt = 0 @@ -6174,24 +6174,24 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 return true } - goto end3a07121fcc82f1a19da4226b07a757ce - end3a07121fcc82f1a19da4226b07a757ce: + goto end95b5b21dd7756ae41575759a1eff2bea + end95b5b21dd7756ae41575759a1eff2bea: ; case OpAMD64SBBQcarrymask: // match: (SBBQcarrymask (CMPQconst [c] (MOVQconst [d]))) - // cond: inBounds(d, c) + // cond: inBounds64(d, c) // result: (MOVQconst [-1]) { if v.Args[0].Op != OpAMD64CMPQconst { - goto end378de7e659770f877c08b6b269073069 + goto end0c26df98feb38f149eca12f33c15de1b } c := v.Args[0].AuxInt if v.Args[0].Args[0].Op != OpAMD64MOVQconst { - goto end378de7e659770f877c08b6b269073069 + goto end0c26df98feb38f149eca12f33c15de1b } d := v.Args[0].Args[0].AuxInt - if !(inBounds(d, c)) { - goto end378de7e659770f877c08b6b269073069 + if !(inBounds64(d, c)) { + goto end0c26df98feb38f149eca12f33c15de1b } v.Op = OpAMD64MOVQconst v.AuxInt = 0 @@ -6200,23 +6200,23 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = -1 return true } - goto end378de7e659770f877c08b6b269073069 - end378de7e659770f877c08b6b269073069: + goto end0c26df98feb38f149eca12f33c15de1b + end0c26df98feb38f149eca12f33c15de1b: ; // match: (SBBQcarrymask (CMPQconst [c] (MOVQconst [d]))) - // cond: !inBounds(d, c) + // cond: !inBounds64(d, c) // result: (MOVQconst [0]) { if v.Args[0].Op != OpAMD64CMPQconst { - goto enda7bfd1974bf83ca79653c560a718a86c + goto end8965aa1e1153e5ecd123bbb31a618570 } c := v.Args[0].AuxInt if v.Args[0].Args[0].Op != OpAMD64MOVQconst { - goto enda7bfd1974bf83ca79653c560a718a86c + goto end8965aa1e1153e5ecd123bbb31a618570 } d := v.Args[0].Args[0].AuxInt - if !(!inBounds(d, c)) { - goto enda7bfd1974bf83ca79653c560a718a86c + if !(!inBounds64(d, c)) { + goto end8965aa1e1153e5ecd123bbb31a618570 } v.Op = OpAMD64MOVQconst v.AuxInt = 0 @@ -6225,23 +6225,23 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 return true } - goto enda7bfd1974bf83ca79653c560a718a86c - enda7bfd1974bf83ca79653c560a718a86c: + goto end8965aa1e1153e5ecd123bbb31a618570 + end8965aa1e1153e5ecd123bbb31a618570: ; // match: (SBBQcarrymask (CMPLconst [c] (MOVLconst [d]))) - // cond: inBounds(int64(int32(d)), int64(int32(c))) + // cond: inBounds32(d, c) // result: (MOVQconst [-1]) { if v.Args[0].Op != OpAMD64CMPLconst { - goto end8c6d39847239120fa0fe953007eb40ae + goto end8772ede6098981a61af0f478841d7d54 } c := v.Args[0].AuxInt if v.Args[0].Args[0].Op != OpAMD64MOVLconst { - goto end8c6d39847239120fa0fe953007eb40ae + goto end8772ede6098981a61af0f478841d7d54 } d := v.Args[0].Args[0].AuxInt - if !(inBounds(int64(int32(d)), int64(int32(c)))) { - goto end8c6d39847239120fa0fe953007eb40ae + if !(inBounds32(d, c)) { + goto end8772ede6098981a61af0f478841d7d54 } v.Op = OpAMD64MOVQconst v.AuxInt = 0 @@ -6250,23 +6250,23 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = -1 return true } - goto end8c6d39847239120fa0fe953007eb40ae - end8c6d39847239120fa0fe953007eb40ae: + goto end8772ede6098981a61af0f478841d7d54 + end8772ede6098981a61af0f478841d7d54: ; // match: (SBBQcarrymask (CMPLconst [c] (MOVLconst [d]))) - // cond: !inBounds(int64(int32(d)), int64(int32(c))) + // cond: !inBounds32(d, c) // result: (MOVQconst [0]) { if v.Args[0].Op != OpAMD64CMPLconst { - goto end20885e855545e16ca77af2b9a2b69ea9 + goto end2d535e90075ee777fc616e6b9847a384 } c := v.Args[0].AuxInt if v.Args[0].Args[0].Op != OpAMD64MOVLconst { - goto end20885e855545e16ca77af2b9a2b69ea9 + goto end2d535e90075ee777fc616e6b9847a384 } d := v.Args[0].Args[0].AuxInt - if !(!inBounds(int64(int32(d)), int64(int32(c)))) { - goto end20885e855545e16ca77af2b9a2b69ea9 + if !(!inBounds32(d, c)) { + goto end2d535e90075ee777fc616e6b9847a384 } v.Op = OpAMD64MOVQconst v.AuxInt = 0 @@ -6275,23 +6275,23 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 return true } - goto end20885e855545e16ca77af2b9a2b69ea9 - end20885e855545e16ca77af2b9a2b69ea9: + goto end2d535e90075ee777fc616e6b9847a384 + end2d535e90075ee777fc616e6b9847a384: ; // match: (SBBQcarrymask (CMPWconst [c] (MOVWconst [d]))) - // cond: inBounds(int64(int16(d)), int64(int16(c))) + // cond: inBounds16(d, c) // result: (MOVQconst [-1]) { if v.Args[0].Op != OpAMD64CMPWconst { - goto end16f61db69d07e67e9f408c2790a9de7c + goto end3103c51e14b4fc894b4170f16f37eebc } c := v.Args[0].AuxInt if v.Args[0].Args[0].Op != OpAMD64MOVWconst { - goto end16f61db69d07e67e9f408c2790a9de7c + goto end3103c51e14b4fc894b4170f16f37eebc } d := v.Args[0].Args[0].AuxInt - if !(inBounds(int64(int16(d)), int64(int16(c)))) { - goto end16f61db69d07e67e9f408c2790a9de7c + if !(inBounds16(d, c)) { + goto end3103c51e14b4fc894b4170f16f37eebc } v.Op = OpAMD64MOVQconst v.AuxInt = 0 @@ -6300,23 +6300,23 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = -1 return true } - goto end16f61db69d07e67e9f408c2790a9de7c - end16f61db69d07e67e9f408c2790a9de7c: + goto end3103c51e14b4fc894b4170f16f37eebc + end3103c51e14b4fc894b4170f16f37eebc: ; // match: (SBBQcarrymask (CMPWconst [c] (MOVWconst [d]))) - // cond: !inBounds(int64(int16(d)), int64(int16(c))) + // cond: !inBounds16(d, c) // result: (MOVQconst [0]) { if v.Args[0].Op != OpAMD64CMPWconst { - goto end191ca427f7d5d2286bd290920c84a51d + goto enddae2191a59cfef5efb04ebab9354745c } c := v.Args[0].AuxInt if v.Args[0].Args[0].Op != OpAMD64MOVWconst { - goto end191ca427f7d5d2286bd290920c84a51d + goto enddae2191a59cfef5efb04ebab9354745c } d := v.Args[0].Args[0].AuxInt - if !(!inBounds(int64(int16(d)), int64(int16(c)))) { - goto end191ca427f7d5d2286bd290920c84a51d + if !(!inBounds16(d, c)) { + goto enddae2191a59cfef5efb04ebab9354745c } v.Op = OpAMD64MOVQconst v.AuxInt = 0 @@ -6325,23 +6325,23 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 return true } - goto end191ca427f7d5d2286bd290920c84a51d - end191ca427f7d5d2286bd290920c84a51d: + goto enddae2191a59cfef5efb04ebab9354745c + enddae2191a59cfef5efb04ebab9354745c: ; // match: (SBBQcarrymask (CMPBconst [c] (MOVBconst [d]))) - // cond: inBounds(int64(int8(d)), int64(int8(c))) + // cond: inBounds8(d, c) // result: (MOVQconst [-1]) { if v.Args[0].Op != OpAMD64CMPBconst { - goto end3fd3f1e9660b9050c6a41b4fc948f793 + goto end72e088325ca005b0251b1ee82da3c5d9 } c := v.Args[0].AuxInt if v.Args[0].Args[0].Op != OpAMD64MOVBconst { - goto end3fd3f1e9660b9050c6a41b4fc948f793 + goto end72e088325ca005b0251b1ee82da3c5d9 } d := v.Args[0].Args[0].AuxInt - if !(inBounds(int64(int8(d)), int64(int8(c)))) { - goto end3fd3f1e9660b9050c6a41b4fc948f793 + if !(inBounds8(d, c)) { + goto end72e088325ca005b0251b1ee82da3c5d9 } v.Op = OpAMD64MOVQconst v.AuxInt = 0 @@ -6350,23 +6350,23 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = -1 return true } - goto end3fd3f1e9660b9050c6a41b4fc948f793 - end3fd3f1e9660b9050c6a41b4fc948f793: + goto end72e088325ca005b0251b1ee82da3c5d9 + end72e088325ca005b0251b1ee82da3c5d9: ; // match: (SBBQcarrymask (CMPBconst [c] (MOVBconst [d]))) - // cond: !inBounds(int64(int8(d)), int64(int8(c))) + // cond: !inBounds8(d, c) // result: (MOVQconst [0]) { if v.Args[0].Op != OpAMD64CMPBconst { - goto ende0d6edd92ae98e6dc041f65029d8b243 + goto endcb388100f5b933aa94095096d2bb425e } c := v.Args[0].AuxInt if v.Args[0].Args[0].Op != OpAMD64MOVBconst { - goto ende0d6edd92ae98e6dc041f65029d8b243 + goto endcb388100f5b933aa94095096d2bb425e } d := v.Args[0].Args[0].AuxInt - if !(!inBounds(int64(int8(d)), int64(int8(c)))) { - goto ende0d6edd92ae98e6dc041f65029d8b243 + if !(!inBounds8(d, c)) { + goto endcb388100f5b933aa94095096d2bb425e } v.Op = OpAMD64MOVQconst v.AuxInt = 0 @@ -6375,8 +6375,8 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 return true } - goto ende0d6edd92ae98e6dc041f65029d8b243 - ende0d6edd92ae98e6dc041f65029d8b243: + goto endcb388100f5b933aa94095096d2bb425e + endcb388100f5b933aa94095096d2bb425e: ; case OpAMD64SETA: // match: (SETA (InvertFlags x)) diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index e39305461d..e4ec495b63 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -311,27 +311,99 @@ func rewriteValuegeneric(v *Value, config *Config) bool { end540dc8dfbc66adcd3db2d7e819c534f6: ; case OpIsInBounds: - // match: (IsInBounds (ConstPtr [c]) (ConstPtr [d])) + // match: (IsInBounds (Const32 [c]) (Const32 [d])) + // cond: + // result: (ConstBool {inBounds32(c,d)}) + { + if v.Args[0].Op != OpConst32 { + goto endc3396bf88b56276e1691abe62811dba5 + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst32 { + goto endc3396bf88b56276e1691abe62811dba5 + } + d := v.Args[1].AuxInt + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Aux = inBounds32(c, d) + return true + } + goto endc3396bf88b56276e1691abe62811dba5 + endc3396bf88b56276e1691abe62811dba5: + ; + // match: (IsInBounds (Const64 [c]) (Const64 [d])) // cond: - // result: (ConstPtr {inBounds(c,d)}) + // result: (ConstBool {inBounds64(c,d)}) + { + if v.Args[0].Op != OpConst64 { + goto end0b4b8178a54662835b00bfa503cf879a + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst64 { + goto end0b4b8178a54662835b00bfa503cf879a + } + d := v.Args[1].AuxInt + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Aux = inBounds64(c, d) + return true + } + goto end0b4b8178a54662835b00bfa503cf879a + end0b4b8178a54662835b00bfa503cf879a: + ; + // match: (IsInBounds (ConstPtr [c]) (ConstPtr [d])) + // cond: config.PtrSize == 4 + // result: (ConstBool {inBounds32(c,d)}) { if v.Args[0].Op != OpConstPtr { - goto enddfd340bc7103ca323354aec96b113c23 + goto end2c6938f68a67e08dbd96edb1e693e549 } c := v.Args[0].AuxInt if v.Args[1].Op != OpConstPtr { - goto enddfd340bc7103ca323354aec96b113c23 + goto end2c6938f68a67e08dbd96edb1e693e549 } d := v.Args[1].AuxInt - v.Op = OpConstPtr + if !(config.PtrSize == 4) { + goto end2c6938f68a67e08dbd96edb1e693e549 + } + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Aux = inBounds32(c, d) + return true + } + goto end2c6938f68a67e08dbd96edb1e693e549 + end2c6938f68a67e08dbd96edb1e693e549: + ; + // match: (IsInBounds (ConstPtr [c]) (ConstPtr [d])) + // cond: config.PtrSize == 8 + // result: (ConstBool {inBounds64(c,d)}) + { + if v.Args[0].Op != OpConstPtr { + goto end84d6ae817944985f572ecaac51999d6c + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConstPtr { + goto end84d6ae817944985f572ecaac51999d6c + } + d := v.Args[1].AuxInt + if !(config.PtrSize == 8) { + goto end84d6ae817944985f572ecaac51999d6c + } + v.Op = OpConstBool v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = inBounds(c, d) + v.Aux = inBounds64(c, d) return true } - goto enddfd340bc7103ca323354aec96b113c23 - enddfd340bc7103ca323354aec96b113c23: + goto end84d6ae817944985f572ecaac51999d6c + end84d6ae817944985f572ecaac51999d6c: ; case OpLoad: // match: (Load ptr mem) -- cgit v1.3 From 35fb514596b970a73be972fa917fa23ca74f7be6 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Mon, 10 Aug 2015 12:15:52 -0700 Subject: [dev.ssa] cmd/compile: add HTML SSA printer This is an initial implementation. There are many rough edges and TODOs, which will hopefully be polished out with use. Fixes #12071. Change-Id: I1d6fd5a343063b5200623bceef2c2cfcc885794e Reviewed-on: https://go-review.googlesource.com/13472 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 40 +++ src/cmd/compile/internal/ssa/compile.go | 3 + src/cmd/compile/internal/ssa/config.go | 16 +- src/cmd/compile/internal/ssa/deadcode.go | 17 +- src/cmd/compile/internal/ssa/html.go | 461 +++++++++++++++++++++++++++++++ src/cmd/compile/internal/ssa/print.go | 90 ++++-- src/cmd/internal/obj/obj.go | 25 +- 7 files changed, 607 insertions(+), 45 deletions(-) create mode 100644 src/cmd/compile/internal/ssa/html.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index c8ec01f5b6..882efc0dae 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -5,7 +5,9 @@ package gc import ( + "bytes" "fmt" + "html" "os" "strings" @@ -40,6 +42,18 @@ func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { s.f = s.config.NewFunc() s.f.Name = name + 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, name) + // TODO: generate and print a mapping from nodes to values and blocks + } + defer func() { + if !usessa { + s.config.HTML.Close() + } + }() + // If SSA support for the function is incomplete, // assume that any panics are due to violated // invariants. Swallow them silently. @@ -1811,6 +1825,30 @@ func genssa(f *ssa.Func, ptxt *obj.Prog, gcargs, gclocals *Sym) { } 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("") + buf.WriteString("
") + for p := ptxt; p != nil; p = p.Link { + buf.WriteString("
") + if v, ok := valueProgs[p]; ok { + buf.WriteString(v.HTML()) + } else if b, ok := blockProgs[p]; ok { + buf.WriteString(b.HTML()) + } + buf.WriteString("
") + buf.WriteString("
") + buf.WriteString(html.EscapeString(p.String())) + buf.WriteString("
") + buf.WriteString("") + } + buf.WriteString("
") + buf.WriteString("") + f.Config.HTML.WriteColumn("genssa", buf.String()) + ptxt.Ctxt.LineHist.PrintFilenameOnly = saved + } } // Emit static data @@ -1834,6 +1872,8 @@ func genssa(f *ssa.Func, ptxt *obj.Prog, gcargs, gclocals *Sym) { ggloblsym(gcargs, 4, obj.RODATA|obj.DUPOK) duint32(gclocals, 0, 0) ggloblsym(gclocals, 4, obj.RODATA|obj.DUPOK) + + f.Config.HTML.Close() } func genValue(v *ssa.Value) { diff --git a/src/cmd/compile/internal/ssa/compile.go b/src/cmd/compile/internal/ssa/compile.go index 7ab8ddf3dc..e85fb10e00 100644 --- a/src/cmd/compile/internal/ssa/compile.go +++ b/src/cmd/compile/internal/ssa/compile.go @@ -34,13 +34,16 @@ func Compile(f *Func) { // Run all the passes printFunc(f) + f.Config.HTML.WriteFunc("start", f) checkFunc(f) for _, p := range passes { phaseName = p.name f.Logf(" pass %s begin\n", p.name) + // TODO: capture logging during this pass, add it to the HTML p.fn(f) f.Logf(" pass %s end\n", p.name) printFunc(f) + f.Config.HTML.WriteFunc("after "+phaseName, f) checkFunc(f) } diff --git a/src/cmd/compile/internal/ssa/config.go b/src/cmd/compile/internal/ssa/config.go index 8aea59d13c..ad6441117c 100644 --- a/src/cmd/compile/internal/ssa/config.go +++ b/src/cmd/compile/internal/ssa/config.go @@ -11,6 +11,7 @@ type Config struct { 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 // TODO: more stuff. Compiler flags of interest, ... } @@ -31,12 +32,7 @@ type TypeSource interface { TypeBytePtr() Type // TODO: use unsafe.Pointer instead? } -type Frontend interface { - TypeSource - - // StringData returns a symbol pointing to the given string's contents. - StringData(string) interface{} // returns *gc.Sym - +type Logger interface { // Log logs a message from the compiler. Logf(string, ...interface{}) @@ -48,6 +44,14 @@ type Frontend interface { Unimplementedf(msg string, args ...interface{}) } +type Frontend interface { + TypeSource + Logger + + // StringData returns a symbol pointing to the given string's contents. + StringData(string) interface{} // returns *gc.Sym +} + // NewConfig returns a new configuration object for the given architecture. func NewConfig(arch string, fe Frontend) *Config { c := &Config{arch: arch, fe: fe} diff --git a/src/cmd/compile/internal/ssa/deadcode.go b/src/cmd/compile/internal/ssa/deadcode.go index 426e6865c0..109b3dd09f 100644 --- a/src/cmd/compile/internal/ssa/deadcode.go +++ b/src/cmd/compile/internal/ssa/deadcode.go @@ -4,10 +4,10 @@ package ssa -// deadcode removes dead code from f. -func deadcode(f *Func) { +// findlive returns the reachable blocks and live values in f. +func findlive(f *Func) (reachable []bool, live []bool) { // Find all reachable basic blocks. - reachable := make([]bool, f.NumBlocks()) + reachable = make([]bool, f.NumBlocks()) reachable[f.Entry.ID] = true p := []*Block{f.Entry} // stack-like worklist for len(p) > 0 { @@ -24,8 +24,8 @@ func deadcode(f *Func) { } // Find all live values - live := make([]bool, f.NumValues()) // flag to set for each live value - var q []*Value // stack-like worklist of unscanned values + live = make([]bool, f.NumValues()) // flag to set for each live value + var q []*Value // stack-like worklist of unscanned values // Starting set: all control values of reachable blocks are live. for _, b := range f.Blocks { @@ -54,6 +54,13 @@ func deadcode(f *Func) { } } + return reachable, live +} + +// deadcode removes dead code from f. +func deadcode(f *Func) { + reachable, live := findlive(f) + // Remove dead values from blocks' value list. Return dead // value ids to the allocator. for _, b := range f.Blocks { diff --git a/src/cmd/compile/internal/ssa/html.go b/src/cmd/compile/internal/ssa/html.go new file mode 100644 index 0000000000..581331a215 --- /dev/null +++ b/src/cmd/compile/internal/ssa/html.go @@ -0,0 +1,461 @@ +// 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("%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("") + w.WriteString(` + + + + +`) + // TODO: Add javascript click handlers for blocks + // to outline that block across all phases + w.WriteString("") + w.WriteString("

") + w.WriteString(html.EscapeString(name)) + w.WriteString("

") + w.WriteString(` +help +
+ +

+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.) +

+ +

+Faded out values and blocks are dead code that has not been eliminated. +

+ +

+Values printed in italics have a dependency cycle. +

+ +
+`) + w.WriteString("") + w.WriteString("") +} + +func (w *HTMLWriter) Close() { + if w == nil { + return + } + w.WriteString("") + w.WriteString("
") + w.WriteString("") + w.WriteString("") + 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("") + w.WriteString("

" + title + "

") + w.WriteString(html) + w.WriteString("") +} + +func (w *HTMLWriter) Printf(msg string, v ...interface{}) { + if _, err := fmt.Fprintf(w.File, msg, v...); err != nil { + w.Fatalf("%v", err) + } +} + +func (w *HTMLWriter) WriteString(s string) { + if _, err := w.File.WriteString(s); err != nil { + w.Fatalf("%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("%[1]s", 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("", 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 r != nil && r[v.ID] != nil { + s += " : " + r[v.ID].Name() + } + + s += "" + 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("%[1]s", html.EscapeString(b.String())) +} + +func (b *Block) LongHTML() string { + // TODO: improve this for HTML? + s := b.Kind.String() + 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() + } + } + return s +} + +func (f *Func) HTML() string { + var buf bytes.Buffer + fmt.Fprint(&buf, "") + p := htmlFuncPrinter{w: &buf} + fprintFunc(p, f) + + // fprintFunc(&buf, f) // TODO: HTML, not text,
for line breaks, etc. + fmt.Fprint(&buf, "") + 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, "
    ", b, dead) + fmt.Fprintf(p.w, "
  • %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, "
    • ") + if len(b.Values) > 0 { // start list of values + io.WriteString(p.w, "
  • ") + io.WriteString(p.w, "
      ") + } +} + +func (p htmlFuncPrinter) endBlock(b *Block) { + if len(b.Values) > 0 { // end list of values + io.WriteString(p.w, "
    ") + io.WriteString(p.w, "
    • ") + } + io.WriteString(p.w, "
  • ") + fmt.Fprint(p.w, b.LongHTML()) + io.WriteString(p.w, "
    • ") + io.WriteString(p.w, "
") + // io.WriteString(p.w, "") +} + +func (p htmlFuncPrinter) value(v *Value, live bool) { + var dead string + if !live { + dead = "dead-value" + } + fmt.Fprintf(p.w, "
  • ", dead) + fmt.Fprint(p.w, v.LongHTML()) + io.WriteString(p.w, "
    • ") +} + +func (p htmlFuncPrinter) startDepCycle() { + fmt.Fprintln(p.w, "") +} + +func (p htmlFuncPrinter) endDepCycle() { + fmt.Fprintln(p.w, "") +} diff --git a/src/cmd/compile/internal/ssa/print.go b/src/cmd/compile/internal/ssa/print.go index 2f9db4438f..192dc83b39 100644 --- a/src/cmd/compile/internal/ssa/print.go +++ b/src/cmd/compile/internal/ssa/print.go @@ -16,33 +16,77 @@ func printFunc(f *Func) { func (f *Func) String() string { var buf bytes.Buffer - fprintFunc(&buf, f) + p := stringFuncPrinter{w: &buf} + fprintFunc(p, f) return buf.String() } -func fprintFunc(w io.Writer, f *Func) { - fmt.Fprint(w, f.Name) - fmt.Fprint(w, " ") - fmt.Fprintln(w, f.Type) +type funcPrinter interface { + header(f *Func) + startBlock(b *Block, reachable bool) + endBlock(b *Block) + value(v *Value, live bool) + startDepCycle() + endDepCycle() +} + +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.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 fprintFunc(p funcPrinter, f *Func) { + reachable, live := findlive(f) + p.header(f) printed := make([]bool, f.NumValues()) for _, b := range f.Blocks { - fmt.Fprintf(w, " b%d:", b.ID) - if len(b.Preds) > 0 { - io.WriteString(w, " <-") - for _, pred := range b.Preds { - fmt.Fprintf(w, " b%d", pred.ID) - } - } - io.WriteString(w, "\n") + p.startBlock(b, reachable[b.ID]) if f.scheduled { // Order of Values has been decided - print in that order. for _, v := range b.Values { - fmt.Fprint(w, " ") - fmt.Fprintln(w, v.LongString()) + p.value(v, live[v.ID]) printed[v.ID] = true } - fmt.Fprintln(w, " "+b.LongString()) + p.endBlock(b) continue } @@ -52,8 +96,7 @@ func fprintFunc(w io.Writer, f *Func) { if v.Op != OpPhi { continue } - fmt.Fprint(w, " ") - fmt.Fprintln(w, v.LongString()) + p.value(v, live[v.ID]) printed[v.ID] = true n++ } @@ -73,25 +116,24 @@ func fprintFunc(w io.Writer, f *Func) { continue outer } } - fmt.Fprint(w, " ") - fmt.Fprintln(w, v.LongString()) + p.value(v, live[v.ID]) printed[v.ID] = true n++ } if m == n { - fmt.Fprintln(w, "dependency cycle!") + p.startDepCycle() for _, v := range b.Values { if printed[v.ID] { continue } - fmt.Fprint(w, " ") - fmt.Fprintln(w, v.LongString()) + p.value(v, live[v.ID]) printed[v.ID] = true n++ } + p.endDepCycle() } } - fmt.Fprintln(w, " "+b.LongString()) + p.endBlock(b) } } diff --git a/src/cmd/internal/obj/obj.go b/src/cmd/internal/obj/obj.go index af3290d3a5..6229bbb288 100644 --- a/src/cmd/internal/obj/obj.go +++ b/src/cmd/internal/obj/obj.go @@ -25,12 +25,13 @@ import ( // 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,24 @@ func (h *LineHist) LineString(lineno int) string { return "" } - 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)) + 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)) } } } -- cgit v1.3 From c55870a5412fb374c9c392a06c3949b291c48e15 Mon Sep 17 00:00:00 2001 From: Alexandru Moșoi Date: Fri, 7 Aug 2015 12:19:03 +0200 Subject: [dev.ssa] cmd/compile/internal/gc: handle all inputs for shifts. Disable CX as output for shift operations. Change-Id: I85e6b22d09009b38847082dc375b6108c2dee80a Reviewed-on: https://go-review.googlesource.com/13370 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/testdata/arith_ssa.go | 23 ++++++++++++++++++++++ src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 3 ++- src/cmd/compile/internal/ssa/opGen.go | 24 +++++++++++------------ 3 files changed, 37 insertions(+), 13 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/testdata/arith_ssa.go b/src/cmd/compile/internal/gc/testdata/arith_ssa.go index ca96988113..2a56e2163f 100644 --- a/src/cmd/compile/internal/gc/testdata/arith_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/arith_ssa.go @@ -141,6 +141,28 @@ func testBitwiseRshU_ssa(a uint32, b, c uint32) uint32 { return a >> b >> c } +func testShiftCX_ssa() int { + switch { + } // prevent inlining + 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<>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)<>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) @@ -263,6 +285,7 @@ func main() { testBitwiseLogic() testOcom() testLrot() + testShiftCX() testSubConst() if failed { diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 9e8b2fa018..6c517a950e 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -72,6 +72,7 @@ func init() { // Common individual register masks var ( + cx = buildReg("CX") gp = buildReg("AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R14 R15") gpsp = gp | buildReg("SP") gpspsb = gpsp | buildReg("SB") @@ -91,7 +92,7 @@ func init() { gp11sb = regInfo{inputs: []regMask{gpspsb}, outputs: gponly} gp21 = regInfo{inputs: []regMask{gpsp, gpsp}, outputs: gponly} gp21sb = regInfo{inputs: []regMask{gpspsb, gpsp}, outputs: gponly} - gp21shift = regInfo{inputs: []regMask{gpsp, buildReg("CX")}, outputs: gponly} + gp21shift = regInfo{inputs: []regMask{gpsp, cx}, outputs: []regMask{gp &^ cx}} gp2flags = regInfo{inputs: []regMask{gpsp, gpsp}, outputs: flagsonly} gp1flags = regInfo{inputs: []regMask{gpsp}, outputs: flagsonly} diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 6f412806c8..dd4462d258 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -1175,7 +1175,7 @@ var opcodeTable = [...]opInfo{ 2, // .CX }, outputs: []regMask{ - 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 65517, // .AX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, @@ -1188,7 +1188,7 @@ var opcodeTable = [...]opInfo{ 2, // .CX }, outputs: []regMask{ - 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 65517, // .AX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, @@ -1201,7 +1201,7 @@ var opcodeTable = [...]opInfo{ 2, // .CX }, outputs: []regMask{ - 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 65517, // .AX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, @@ -1214,7 +1214,7 @@ var opcodeTable = [...]opInfo{ 2, // .CX }, outputs: []regMask{ - 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 65517, // .AX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, @@ -1275,7 +1275,7 @@ var opcodeTable = [...]opInfo{ 2, // .CX }, outputs: []regMask{ - 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 65517, // .AX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, @@ -1288,7 +1288,7 @@ var opcodeTable = [...]opInfo{ 2, // .CX }, outputs: []regMask{ - 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 65517, // .AX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, @@ -1301,7 +1301,7 @@ var opcodeTable = [...]opInfo{ 2, // .CX }, outputs: []regMask{ - 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 65517, // .AX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, @@ -1314,7 +1314,7 @@ var opcodeTable = [...]opInfo{ 2, // .CX }, outputs: []regMask{ - 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 65517, // .AX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, @@ -1375,7 +1375,7 @@ var opcodeTable = [...]opInfo{ 2, // .CX }, outputs: []regMask{ - 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 65517, // .AX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, @@ -1388,7 +1388,7 @@ var opcodeTable = [...]opInfo{ 2, // .CX }, outputs: []regMask{ - 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 65517, // .AX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, @@ -1401,7 +1401,7 @@ var opcodeTable = [...]opInfo{ 2, // .CX }, outputs: []regMask{ - 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 65517, // .AX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, @@ -1414,7 +1414,7 @@ var opcodeTable = [...]opInfo{ 2, // .CX }, outputs: []regMask{ - 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 65517, // .AX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, }, }, -- cgit v1.3 From 7a6de6d5f2e1e8e8908022789cf129581c90a4c3 Mon Sep 17 00:00:00 2001 From: Alexandru Moșoi Date: Fri, 14 Aug 2015 13:23:11 +0200 Subject: [dev.ssa] cmd/compile/internal/ssa/gen: fold Mul8 properly. Mul8 is lowered to MULW, but the rules for constant folding do not handle the fact that the operands are int8. Change-Id: I2c336686d86249393a8079a471c6ff74e6228f3d Reviewed-on: https://go-review.googlesource.com/13642 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 4 +- src/cmd/compile/internal/ssa/gen/AMD64.rules | 8 ++-- src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 2 + src/cmd/compile/internal/ssa/opGen.go | 27 +++++++++++ src/cmd/compile/internal/ssa/rewriteAMD64.go | 69 ++++++++++++++++++++++++++-- 5 files changed, 100 insertions(+), 10 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 882efc0dae..ef6ca692a4 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1909,7 +1909,7 @@ func genValue(v *ssa.Value) { 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.OpAMD64MULQ, ssa.OpAMD64MULL, ssa.OpAMD64MULW, ssa.OpAMD64MULB: r := regnum(v) x := regnum(v.Args[0]) y := regnum(v.Args[1]) @@ -1996,7 +1996,7 @@ func genValue(v *ssa.Value) { p.From.Offset = v.AuxInt p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v) - case ssa.OpAMD64MULQconst, ssa.OpAMD64MULLconst, ssa.OpAMD64MULWconst: + case ssa.OpAMD64MULQconst, ssa.OpAMD64MULLconst, ssa.OpAMD64MULWconst, ssa.OpAMD64MULBconst: r := regnum(v) x := regnum(v.Args[0]) if r != x { diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index a53f2ca388..00a321ad3b 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -25,10 +25,7 @@ (MulPtr x y) -> (MULQ x y) (Mul32 x y) -> (MULL x y) (Mul16 x y) -> (MULW x y) -// Note: we use 16-bit multiply instructions for 8-bit multiplies because -// the 16-bit multiply instructions are more forgiving (they operate on -// any register instead of just AX/DX). -(Mul8 x y) -> (MULW x y) +(Mul8 x y) -> (MULB x y) (And64 x y) -> (ANDQ x y) (And32 x y) -> (ANDL x y) @@ -294,6 +291,8 @@ (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) @@ -498,6 +497,7 @@ (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]) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 6c517a950e..0a7268a2f6 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -133,9 +133,11 @@ func init() { {name: "MULQ", reg: gp21, asm: "IMULQ"}, // arg0 * arg1 {name: "MULL", reg: gp21, asm: "IMULL"}, // arg0 * arg1 {name: "MULW", reg: gp21, asm: "IMULW"}, // arg0 * arg1 + {name: "MULB", reg: gp21, asm: "IMULW"}, // arg0 * arg1 {name: "MULQconst", reg: gp11, asm: "IMULQ"}, // arg0 * auxint {name: "MULLconst", reg: gp11, asm: "IMULL"}, // arg0 * auxint {name: "MULWconst", reg: gp11, asm: "IMULW"}, // arg0 * auxint + {name: "MULBconst", reg: gp11, asm: "IMULW"}, // arg0 * auxint {name: "ANDQ", reg: gp21, asm: "ANDQ"}, // arg0 & arg1 {name: "ANDL", reg: gp21, asm: "ANDL"}, // arg0 & arg1 diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index dd4462d258..6a5acadde6 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -70,9 +70,11 @@ const ( OpAMD64MULQ OpAMD64MULL OpAMD64MULW + OpAMD64MULB OpAMD64MULQconst OpAMD64MULLconst OpAMD64MULWconst + OpAMD64MULBconst OpAMD64ANDQ OpAMD64ANDL OpAMD64ANDW @@ -630,6 +632,19 @@ var opcodeTable = [...]opInfo{ }, }, }, + { + name: "MULB", + asm: x86.AIMULW, + reg: regInfo{ + inputs: []regMask{ + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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: "MULQconst", asm: x86.AIMULQ, @@ -666,6 +681,18 @@ var opcodeTable = [...]opInfo{ }, }, }, + { + name: "MULBconst", + asm: x86.AIMULW, + reg: regInfo{ + inputs: []regMask{ + 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: "ANDQ", asm: x86.AANDQ, diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 6d74aad352..70cd4e6e15 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -3511,6 +3511,67 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end4e7df15ee55bdd73d8ecd61b759134d4 end4e7df15ee55bdd73d8ecd61b759134d4: ; + case OpAMD64MULB: + // match: (MULB x (MOVBconst [c])) + // cond: + // result: (MULBconst [c] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVBconst { + goto end66c6419213ddeb52b1c53fb589a70e5f + } + c := v.Args[1].AuxInt + v.Op = OpAMD64MULBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end66c6419213ddeb52b1c53fb589a70e5f + end66c6419213ddeb52b1c53fb589a70e5f: + ; + // match: (MULB (MOVBconst [c]) x) + // cond: + // result: (MULBconst [c] x) + { + if v.Args[0].Op != OpAMD64MOVBconst { + goto end7e82c8dbbba265b78035ca7df394bb06 + } + c := v.Args[0].AuxInt + x := v.Args[1] + v.Op = OpAMD64MULBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end7e82c8dbbba265b78035ca7df394bb06 + end7e82c8dbbba265b78035ca7df394bb06: + ; + case OpAMD64MULBconst: + // match: (MULBconst [c] (MOVBconst [d])) + // cond: + // result: (MOVBconst [c*d]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVBconst { + goto endf2db9f96016085f8cb4082b4af01b2aa + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c * d + return true + } + goto endf2db9f96016085f8cb4082b4af01b2aa + endf2db9f96016085f8cb4082b4af01b2aa: + ; case OpAMD64MULL: // match: (MULL x (MOVLconst [c])) // cond: @@ -3913,11 +3974,11 @@ func rewriteValueAMD64(v *Value, config *Config) bool { case OpMul8: // match: (Mul8 x y) // cond: - // result: (MULW x y) + // result: (MULB x y) { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64MULW + v.Op = OpAMD64MULB v.AuxInt = 0 v.Aux = nil v.resetArgs() @@ -3925,8 +3986,8 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(y) return true } - goto end861428e804347e8489a6424f2e6ce71c - end861428e804347e8489a6424f2e6ce71c: + goto endd876d6bc42a2285b801f42dadbd8757c + endd876d6bc42a2285b801f42dadbd8757c: ; case OpMulPtr: // match: (MulPtr x y) -- cgit v1.3 From 198fc9a9eb7104d459bb5fea0aba5f2ff2c6f8d4 Mon Sep 17 00:00:00 2001 From: Alexandru Moșoi Date: Fri, 14 Aug 2015 12:59:33 +0200 Subject: [dev.ssa] cmd/compile/internal/ssa/gen: more simplifications and foldings. Change-Id: I74d1267dbfced2663072b4f091732c0fb328690f Reviewed-on: https://go-review.googlesource.com/13641 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/gen/AMD64.rules | 4 + src/cmd/compile/internal/ssa/gen/generic.rules | 17 ++ src/cmd/compile/internal/ssa/rewriteAMD64.go | 80 +++++++ src/cmd/compile/internal/ssa/rewritegeneric.go | 312 +++++++++++++++++++++++++ 4 files changed, 413 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 00a321ad3b..09e88765b6 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -490,6 +490,10 @@ (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]) diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index 66bec779bb..74893cef78 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -37,6 +37,23 @@ (Neq16 x x) -> (ConstBool {false}) (Neq8 x x) -> (ConstBool {false}) +// simplifications +(Or64 x x) -> x +(Or32 x x) -> x +(Or16 x x) -> x +(Or8 x x) -> x +(And64 x x) -> x +(And32 x x) -> x +(And16 x x) -> x +(And8 x x) -> x +(Xor64 x x) -> (Const64 [0]) +(Xor32 x x) -> (Const32 [0]) +(Xor16 x x) -> (Const16 [0]) +(Xor8 x x) -> (Const8 [0]) +(Sub64 x x) -> (Const64 [0]) +(Sub32 x x) -> (Const32 [0]) +(Sub16 x x) -> (Const16 [0]) +(Sub8 x x) -> (Const8 [0]) (Com8 (Com8 x)) -> x (Com16 (Com16 x)) -> x (Com32 (Com32 x)) -> x diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 70cd4e6e15..f3369d6d5f 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -5974,6 +5974,26 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end3bf3d17717aa6c04462e56d1c87902ce end3bf3d17717aa6c04462e56d1c87902ce: ; + case OpAMD64SARBconst: + // match: (SARBconst [c] (MOVQconst [d])) + // cond: + // result: (MOVQconst [d>>uint64(c)]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVQconst { + goto end06e0e38775f0650ed672427d19cd8fff + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = d >> uint64(c) + return true + } + goto end06e0e38775f0650ed672427d19cd8fff + end06e0e38775f0650ed672427d19cd8fff: + ; case OpAMD64SARL: // match: (SARL x (MOVLconst [c])) // cond: @@ -5995,6 +6015,26 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto ende586a72c1b232ee0b63e37c71eeb8470 ende586a72c1b232ee0b63e37c71eeb8470: ; + case OpAMD64SARLconst: + // match: (SARLconst [c] (MOVQconst [d])) + // cond: + // result: (MOVQconst [d>>uint64(c)]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVQconst { + goto end8f34dc94323303e75b7bcc8e731cf1db + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = d >> uint64(c) + return true + } + goto end8f34dc94323303e75b7bcc8e731cf1db + end8f34dc94323303e75b7bcc8e731cf1db: + ; case OpAMD64SARQ: // match: (SARQ x (MOVQconst [c])) // cond: @@ -6016,6 +6056,26 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end25e720ab203be2745dded5550e6d8a7c end25e720ab203be2745dded5550e6d8a7c: ; + case OpAMD64SARQconst: + // match: (SARQconst [c] (MOVQconst [d])) + // cond: + // result: (MOVQconst [d>>uint64(c)]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVQconst { + goto endd949ba69a1ff71ba62c49b39c68f269e + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = d >> uint64(c) + return true + } + goto endd949ba69a1ff71ba62c49b39c68f269e + endd949ba69a1ff71ba62c49b39c68f269e: + ; case OpAMD64SARW: // match: (SARW x (MOVWconst [c])) // cond: @@ -6037,6 +6097,26 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endc46e3f211f94238f9a0aec3c498af490 endc46e3f211f94238f9a0aec3c498af490: ; + case OpAMD64SARWconst: + // match: (SARWconst [c] (MOVQconst [d])) + // cond: + // result: (MOVQconst [d>>uint64(c)]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVQconst { + goto endca23e80dba22ab574f843c7a4cef24ab + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = d >> uint64(c) + return true + } + goto endca23e80dba22ab574f843c7a4cef24ab + endca23e80dba22ab574f843c7a4cef24ab: + ; case OpAMD64SBBLcarrymask: // match: (SBBLcarrymask (CMPQconst [c] (MOVQconst [d]))) // cond: inBounds64(d, c) diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index e4ec495b63..8ce0eca9e4 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -51,6 +51,86 @@ func rewriteValuegeneric(v *Value, config *Config) bool { goto end145c1aec793b2befff34bc8983b48a38 end145c1aec793b2befff34bc8983b48a38: ; + case OpAnd16: + // match: (And16 x x) + // cond: + // result: x + { + x := v.Args[0] + if v.Args[1] != x { + goto end69ed6ee2a4fb0491b56c17f3c1926b10 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end69ed6ee2a4fb0491b56c17f3c1926b10 + end69ed6ee2a4fb0491b56c17f3c1926b10: + ; + case OpAnd32: + // match: (And32 x x) + // cond: + // result: x + { + x := v.Args[0] + if v.Args[1] != x { + goto endbbe8c3c5b2ca8f013aa178d856f3a99c + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto endbbe8c3c5b2ca8f013aa178d856f3a99c + endbbe8c3c5b2ca8f013aa178d856f3a99c: + ; + case OpAnd64: + // match: (And64 x x) + // cond: + // result: x + { + x := v.Args[0] + if v.Args[1] != x { + goto endc9736bf24d2e5cd8d662e1bcf3164640 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto endc9736bf24d2e5cd8d662e1bcf3164640 + endc9736bf24d2e5cd8d662e1bcf3164640: + ; + case OpAnd8: + // match: (And8 x x) + // cond: + // result: x + { + x := v.Args[0] + if v.Args[1] != x { + goto endeaf127389bd0d4b0e0e297830f8f463b + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto endeaf127389bd0d4b0e0e297830f8f463b + endeaf127389bd0d4b0e0e297830f8f463b: + ; case OpArrayIndex: // match: (ArrayIndex (Load ptr mem) idx) // cond: @@ -612,6 +692,86 @@ func rewriteValuegeneric(v *Value, config *Config) bool { goto end67d723bb0f39a5c897816abcf411e5cf end67d723bb0f39a5c897816abcf411e5cf: ; + case OpOr16: + // match: (Or16 x x) + // cond: + // result: x + { + x := v.Args[0] + if v.Args[1] != x { + goto end47a2f25fd31a76807aced3e2b126acdc + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end47a2f25fd31a76807aced3e2b126acdc + end47a2f25fd31a76807aced3e2b126acdc: + ; + case OpOr32: + // match: (Or32 x x) + // cond: + // result: x + { + x := v.Args[0] + if v.Args[1] != x { + goto end231e283e568e90bd9a3e6a4fa328c8a4 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end231e283e568e90bd9a3e6a4fa328c8a4 + end231e283e568e90bd9a3e6a4fa328c8a4: + ; + case OpOr64: + // match: (Or64 x x) + // cond: + // result: x + { + x := v.Args[0] + if v.Args[1] != x { + goto end6b0efc212016dc97d0e3939db04c81d9 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end6b0efc212016dc97d0e3939db04c81d9 + end6b0efc212016dc97d0e3939db04c81d9: + ; + case OpOr8: + // match: (Or8 x x) + // cond: + // result: x + { + x := v.Args[0] + if v.Args[1] != x { + goto end05295dbfafd6869af79b4daee9fda000 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end05295dbfafd6869af79b4daee9fda000 + end05295dbfafd6869af79b4daee9fda000: + ; case OpPtrIndex: // match: (PtrIndex ptr idx) // cond: @@ -848,6 +1008,158 @@ func rewriteValuegeneric(v *Value, config *Config) bool { } goto end16fdb45e1dd08feb36e3cc3fb5ed8935 end16fdb45e1dd08feb36e3cc3fb5ed8935: + ; + case OpSub16: + // match: (Sub16 x x) + // cond: + // result: (Const16 [0]) + { + x := v.Args[0] + if v.Args[1] != x { + goto end83da541391be564f2a08464e674a49e7 + } + v.Op = OpConst16 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end83da541391be564f2a08464e674a49e7 + end83da541391be564f2a08464e674a49e7: + ; + case OpSub32: + // match: (Sub32 x x) + // cond: + // result: (Const32 [0]) + { + x := v.Args[0] + if v.Args[1] != x { + goto enda747581e798f199e07f4ad69747cd069 + } + v.Op = OpConst32 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto enda747581e798f199e07f4ad69747cd069 + enda747581e798f199e07f4ad69747cd069: + ; + case OpSub64: + // match: (Sub64 x x) + // cond: + // result: (Const64 [0]) + { + x := v.Args[0] + if v.Args[1] != x { + goto end0387dc2b7bbe57d4aa54eab5d959da4b + } + v.Op = OpConst64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end0387dc2b7bbe57d4aa54eab5d959da4b + end0387dc2b7bbe57d4aa54eab5d959da4b: + ; + case OpSub8: + // match: (Sub8 x x) + // cond: + // result: (Const8 [0]) + { + x := v.Args[0] + if v.Args[1] != x { + goto end4e2ee15ef17611919a1a6b5f80bbfe18 + } + v.Op = OpConst8 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end4e2ee15ef17611919a1a6b5f80bbfe18 + end4e2ee15ef17611919a1a6b5f80bbfe18: + ; + case OpXor16: + // match: (Xor16 x x) + // cond: + // result: (Const16 [0]) + { + x := v.Args[0] + if v.Args[1] != x { + goto end5733ceb1903b8140248d8e2cac02fefe + } + v.Op = OpConst16 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end5733ceb1903b8140248d8e2cac02fefe + end5733ceb1903b8140248d8e2cac02fefe: + ; + case OpXor32: + // match: (Xor32 x x) + // cond: + // result: (Const32 [0]) + { + x := v.Args[0] + if v.Args[1] != x { + goto end268ca02df6515d648e0bfb4e90981d25 + } + v.Op = OpConst32 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end268ca02df6515d648e0bfb4e90981d25 + end268ca02df6515d648e0bfb4e90981d25: + ; + case OpXor64: + // match: (Xor64 x x) + // cond: + // result: (Const64 [0]) + { + x := v.Args[0] + if v.Args[1] != x { + goto endaf44e7f9fc58af30df69070953fb45ce + } + v.Op = OpConst64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto endaf44e7f9fc58af30df69070953fb45ce + endaf44e7f9fc58af30df69070953fb45ce: + ; + case OpXor8: + // match: (Xor8 x x) + // cond: + // result: (Const8 [0]) + { + x := v.Args[0] + if v.Args[1] != x { + goto end949b3a60b7d181688e6f79f93c782fc8 + } + v.Op = OpConst8 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end949b3a60b7d181688e6f79f93c782fc8 + end949b3a60b7d181688e6f79f93c782fc8: } return false } -- cgit v1.3 From d4cc51d4118027464f61034179908abd0005fab6 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Fri, 14 Aug 2015 21:47:20 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: Use explicit size for store ops Using the type of the store argument is not safe, it may change during rewriting, giving us the wrong store width. (Store ptr (Trunc32to16 val) mem) This should be a 2-byte store. But we have the rule: (Trunc32to16 x) -> x So if the Trunc rewrite happens before the Store -> MOVW rewrite, then the Store thinks that the value it is storing is 4 bytes in size and uses a MOVL. Bad things ensue. Fix this by encoding the store width explicitly in the auxint field. In general, we can't rely on the type of arguments, as they may change during rewrites. The type of the op itself (as used by the Load rules) is still ok to use. Change-Id: I9e2359e4f657bb0ea0e40038969628bf0f84e584 Reviewed-on: https://go-review.googlesource.com/13636 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/gc/ssa.go | 16 ++++- .../compile/internal/gc/testdata/loadstore_ssa.go | 29 +++++++++ src/cmd/compile/internal/ssa/deadstore_test.go | 14 ++-- src/cmd/compile/internal/ssa/func.go | 15 +++++ src/cmd/compile/internal/ssa/gen/AMD64.rules | 9 ++- src/cmd/compile/internal/ssa/gen/generic.rules | 3 +- src/cmd/compile/internal/ssa/gen/genericOps.go | 2 +- src/cmd/compile/internal/ssa/rewriteAMD64.go | 76 ++++++++-------------- src/cmd/compile/internal/ssa/rewritegeneric.go | 22 +++---- src/cmd/compile/internal/ssa/schedule_test.go | 6 +- src/cmd/compile/internal/ssa/shift_test.go | 2 +- 11 files changed, 113 insertions(+), 81 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index ef6ca692a4..d37181daf5 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -331,6 +331,11 @@ func (s *state) newValue3(op ssa.Op, t ssa.Type, arg0, arg1, arg2 *ssa.Value) *s 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) +} + // entryNewValue 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) @@ -1365,12 +1370,19 @@ func (s *state) expr(n *Node) *ssa.Value { } func (s *state) assign(op uint8, left *Node, right *Node) { + if left.Op == ONAME && isblank(left) { + if right != nil { + s.expr(right) + } + return + } // TODO: do write barrier // if op == OASWB + t := left.Type + dowidth(t) var val *ssa.Value if right == nil { // right == nil means use the zero value of the assigned type. - t := left.Type if !canSSA(left) { // if we can't ssa this memory, treat it as just zeroing out the backing memory addr := s.addr(left) @@ -1388,7 +1400,7 @@ func (s *state) assign(op uint8, left *Node, right *Node) { } // not ssa-able. Treat as a store. addr := s.addr(left) - s.vars[&memvar] = s.newValue3(ssa.OpStore, ssa.TypeMem, addr, val, s.mem()) + s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, t.Size(), addr, val, s.mem()) } // zeroVal returns the zero value for type t. diff --git a/src/cmd/compile/internal/gc/testdata/loadstore_ssa.go b/src/cmd/compile/internal/gc/testdata/loadstore_ssa.go index abca2a4bf8..cf37095742 100644 --- a/src/cmd/compile/internal/gc/testdata/loadstore_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/loadstore_ssa.go @@ -8,6 +8,8 @@ package main +import "fmt" + // testLoadStoreOrder tests for reordering of stores/loads. func testLoadStoreOrder() { z := uint32(1000) @@ -27,11 +29,38 @@ func testLoadStoreOrder_ssa(z *uint32, prec uint) int { 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 main() { testLoadStoreOrder() + testStoreSize() if failed { panic("failed") diff --git a/src/cmd/compile/internal/ssa/deadstore_test.go b/src/cmd/compile/internal/ssa/deadstore_test.go index 634192f25b..0f295296bd 100644 --- a/src/cmd/compile/internal/ssa/deadstore_test.go +++ b/src/cmd/compile/internal/ssa/deadstore_test.go @@ -19,10 +19,10 @@ func TestDeadStore(t *testing.T) { 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, 0, nil, "addr1", "v", "zero1"), - Valu("store2", OpStore, TypeMem, 0, nil, "addr2", "v", "store1"), - Valu("store3", OpStore, TypeMem, 0, nil, "addr1", "v", "store2"), - Valu("store4", OpStore, TypeMem, 0, nil, "addr3", "v", "store3"), + 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"))) @@ -54,7 +54,7 @@ func TestDeadStorePhi(t *testing.T) { Goto("loop")), Bloc("loop", Valu("phi", OpPhi, TypeMem, 0, nil, "start", "store"), - Valu("store", OpStore, TypeMem, 0, nil, "addr", "v", "phi"), + Valu("store", OpStore, TypeMem, 1, nil, "addr", "v", "phi"), If("v", "loop", "exit")), Bloc("exit", Exit("store"))) @@ -79,8 +79,8 @@ func TestDeadStoreTypes(t *testing.T) { Valu("v", OpConstBool, TypeBool, 0, true), Valu("addr1", OpAddr, t1, 0, nil, "sb"), Valu("addr2", OpAddr, t2, 0, nil, "sb"), - Valu("store1", OpStore, TypeMem, 0, nil, "addr1", "v", "start"), - Valu("store2", OpStore, TypeMem, 0, nil, "addr2", "v", "store1"), + Valu("store1", OpStore, TypeMem, 1, nil, "addr1", "v", "start"), + Valu("store2", OpStore, TypeMem, 1, nil, "addr2", "v", "store1"), Goto("exit")), Bloc("exit", Exit("store2"))) diff --git a/src/cmd/compile/internal/ssa/func.go b/src/cmd/compile/internal/ssa/func.go index 9b6eb7f831..97eb1a443a 100644 --- a/src/cmd/compile/internal/ssa/func.go +++ b/src/cmd/compile/internal/ssa/func.go @@ -249,6 +249,21 @@ func (b *Block) NewValue3(line int32, op Op, t Type, arg0, arg1, arg2 *Value) *V 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, aux int64, arg0, arg1, arg2 *Value) *Value { + v := &Value{ + ID: b.Func.vid.get(), + Op: op, + Type: t, + AuxInt: aux, + Block: b, + Line: line, + } + v.Args = []*Value{arg0, arg1, arg2} + b.Values = append(b.Values, v) + return v +} + // ConstInt returns an int constant representing its argument. func (f *Func) ConstInt8(line int32, t Type, c int8) *Value { // TODO: cache? diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 09e88765b6..0e36737337 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -203,11 +203,10 @@ (Load ptr mem) && is32BitInt(t) -> (MOVLload ptr mem) (Load ptr mem) && is16BitInt(t) -> (MOVWload ptr mem) (Load ptr mem) && (t.IsBoolean() || is8BitInt(t)) -> (MOVBload ptr mem) -(Store ptr val mem) && (is64BitInt(val.Type) || isPtr(val.Type)) -> (MOVQstore ptr val mem) -(Store ptr val mem) && is32BitInt(val.Type) -> (MOVLstore ptr val mem) -(Store ptr val mem) && is16BitInt(val.Type) -> (MOVWstore ptr val mem) -(Store ptr val mem) && is8BitInt(val.Type) -> (MOVBstore ptr val mem) -(Store ptr val mem) && val.Type.IsBoolean() -> (MOVBstore 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) // checks (IsNonNil p) -> (SETNE (TESTQ p p)) diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index 74893cef78..75cd186a43 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -81,8 +81,7 @@ (StructSelect [idx] (Load ptr mem)) -> (Load (OffPtr [idx] ptr) mem) // big-object moves -// TODO: fix size -(Store dst (Load src mem) mem) && t.Size() > 8 -> (Move [t.Size()] dst src mem) +(Store [size] dst (Load src mem) mem) && size > config.IntSize -> (Move [size] dst src mem) // string ops (ConstString {s}) -> (StringMake (Addr {config.fe.StringData(s.(string))} (SB )) (ConstPtr [int64(len(s.(string)))])) diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index ec4f038f43..496b57e2e1 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -218,7 +218,7 @@ var genericOps = []opData{ // Memory operations {name: "Load"}, // Load from arg0. arg1=memory - {name: "Store"}, // Store arg1 to arg0. arg2=memory. Returns memory. + {name: "Store"}, // Store arg1 to arg0. arg2=memory, auxint=size. Returns memory. {name: "Move"}, // arg0=destptr, arg1=srcptr, arg2=mem, auxint=size. Returns memory. {name: "Zero"}, // arg0=destptr, arg1=mem, auxint=size. Returns memory. diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index f3369d6d5f..502efc5640 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -7412,16 +7412,16 @@ func rewriteValueAMD64(v *Value, config *Config) bool { end32c5cbec813d1c2ae94fc9b1090e4b2a: ; case OpStore: - // match: (Store ptr val mem) - // cond: (is64BitInt(val.Type) || isPtr(val.Type)) + // match: (Store [8] ptr val mem) + // cond: // result: (MOVQstore ptr val mem) { + if v.AuxInt != 8 { + goto endd1eb7c3ea0c806e7a53ff3be86186eb7 + } ptr := v.Args[0] val := v.Args[1] mem := v.Args[2] - if !(is64BitInt(val.Type) || isPtr(val.Type)) { - goto endbaeb60123806948cd2433605820d5af1 - } v.Op = OpAMD64MOVQstore v.AuxInt = 0 v.Aux = nil @@ -7431,19 +7431,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto endbaeb60123806948cd2433605820d5af1 - endbaeb60123806948cd2433605820d5af1: + goto endd1eb7c3ea0c806e7a53ff3be86186eb7 + endd1eb7c3ea0c806e7a53ff3be86186eb7: ; - // match: (Store ptr val mem) - // cond: is32BitInt(val.Type) + // match: (Store [4] ptr val mem) + // cond: // result: (MOVLstore ptr val mem) { + if v.AuxInt != 4 { + goto end44e3b22360da76ecd59be9a8c2dd1347 + } ptr := v.Args[0] val := v.Args[1] mem := v.Args[2] - if !(is32BitInt(val.Type)) { - goto end582e895008657c728c141c6b95070de7 - } v.Op = OpAMD64MOVLstore v.AuxInt = 0 v.Aux = nil @@ -7453,19 +7453,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto end582e895008657c728c141c6b95070de7 - end582e895008657c728c141c6b95070de7: + goto end44e3b22360da76ecd59be9a8c2dd1347 + end44e3b22360da76ecd59be9a8c2dd1347: ; - // match: (Store ptr val mem) - // cond: is16BitInt(val.Type) + // match: (Store [2] ptr val mem) + // cond: // result: (MOVWstore ptr val mem) { + if v.AuxInt != 2 { + goto endd0342b7fd3d0713f3e26922660047c71 + } ptr := v.Args[0] val := v.Args[1] mem := v.Args[2] - if !(is16BitInt(val.Type)) { - goto enda3f6a985b6ebb277665f80ad30b178df - } v.Op = OpAMD64MOVWstore v.AuxInt = 0 v.Aux = nil @@ -7475,41 +7475,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto enda3f6a985b6ebb277665f80ad30b178df - enda3f6a985b6ebb277665f80ad30b178df: + goto endd0342b7fd3d0713f3e26922660047c71 + endd0342b7fd3d0713f3e26922660047c71: ; - // match: (Store ptr val mem) - // cond: is8BitInt(val.Type) + // match: (Store [1] ptr val mem) + // cond: // result: (MOVBstore ptr val mem) { - ptr := v.Args[0] - val := v.Args[1] - mem := v.Args[2] - if !(is8BitInt(val.Type)) { - goto ende2dee0bc82f631e3c6b0031bf8d224c1 + if v.AuxInt != 1 { + goto end8e76e20031197ca875889d2b4d0eb1d1 } - v.Op = OpAMD64MOVBstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(ptr) - v.AddArg(val) - v.AddArg(mem) - return true - } - goto ende2dee0bc82f631e3c6b0031bf8d224c1 - ende2dee0bc82f631e3c6b0031bf8d224c1: - ; - // match: (Store ptr val mem) - // cond: val.Type.IsBoolean() - // result: (MOVBstore ptr val mem) - { ptr := v.Args[0] val := v.Args[1] mem := v.Args[2] - if !(val.Type.IsBoolean()) { - goto end6f343b676bf49740054e459f972b24f5 - } v.Op = OpAMD64MOVBstore v.AuxInt = 0 v.Aux = nil @@ -7519,8 +7497,8 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto end6f343b676bf49740054e459f972b24f5 - end6f343b676bf49740054e459f972b24f5: + goto end8e76e20031197ca875889d2b4d0eb1d1 + end8e76e20031197ca875889d2b4d0eb1d1: ; case OpSub16: // match: (Sub16 x y) diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index 8ce0eca9e4..a0c5269e2e 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -876,35 +876,35 @@ func rewriteValuegeneric(v *Value, config *Config) bool { end459613b83f95b65729d45c2ed663a153: ; case OpStore: - // match: (Store dst (Load src mem) mem) - // cond: t.Size() > 8 - // result: (Move [t.Size()] dst src mem) + // match: (Store [size] dst (Load src mem) mem) + // cond: size > config.IntSize + // result: (Move [size] dst src mem) { + size := v.AuxInt dst := v.Args[0] if v.Args[1].Op != OpLoad { - goto end324ffb6d2771808da4267f62c854e9c8 + goto enda18a7163888e2f4fca9f38bae56cef42 } - t := v.Args[1].Type src := v.Args[1].Args[0] mem := v.Args[1].Args[1] if v.Args[2] != mem { - goto end324ffb6d2771808da4267f62c854e9c8 + goto enda18a7163888e2f4fca9f38bae56cef42 } - if !(t.Size() > 8) { - goto end324ffb6d2771808da4267f62c854e9c8 + if !(size > config.IntSize) { + goto enda18a7163888e2f4fca9f38bae56cef42 } v.Op = OpMove v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = t.Size() + v.AuxInt = size v.AddArg(dst) v.AddArg(src) v.AddArg(mem) return true } - goto end324ffb6d2771808da4267f62c854e9c8 - end324ffb6d2771808da4267f62c854e9c8: + goto enda18a7163888e2f4fca9f38bae56cef42 + enda18a7163888e2f4fca9f38bae56cef42: ; // match: (Store dst str mem) // cond: str.Type.IsString() diff --git a/src/cmd/compile/internal/ssa/schedule_test.go b/src/cmd/compile/internal/ssa/schedule_test.go index 45f3dbcac5..7f62ab9e3b 100644 --- a/src/cmd/compile/internal/ssa/schedule_test.go +++ b/src/cmd/compile/internal/ssa/schedule_test.go @@ -14,9 +14,9 @@ func TestSchedule(t *testing.T) { Valu("mem0", OpArg, TypeMem, 0, ".mem"), Valu("ptr", OpConst64, TypeInt64, 0xABCD, nil), Valu("v", OpConst64, TypeInt64, 12, nil), - Valu("mem1", OpStore, TypeMem, 0, nil, "ptr", "v", "mem0"), - Valu("mem2", OpStore, TypeMem, 0, nil, "ptr", "v", "mem1"), - Valu("mem3", OpStore, TypeInt64, 0, nil, "ptr", "sum", "mem2"), + 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"), diff --git a/src/cmd/compile/internal/ssa/shift_test.go b/src/cmd/compile/internal/ssa/shift_test.go index fc26ab82ca..611b418b6d 100644 --- a/src/cmd/compile/internal/ssa/shift_test.go +++ b/src/cmd/compile/internal/ssa/shift_test.go @@ -35,7 +35,7 @@ func makeConstShiftFunc(c *Config, amount int64, op Op, typ Type) fun { 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, 0, nil, "resptr", "shift", "mem"), + Valu("store", OpStore, TypeMem, 8, nil, "resptr", "shift", "mem"), Exit("store"))) Compile(fun.f) return fun -- cgit v1.3 From 270e2152c4645a72ac3263fcc92ce878e8035d71 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Mon, 17 Aug 2015 00:18:31 -0700 Subject: [dev.ssa] cmd/compile: fix dev.ssa build Broken by CL 13472. Change-Id: Ib65331b291c8fab4238ca91e085779bb954d70e8 Reviewed-on: https://go-review.googlesource.com/13638 Reviewed-by: David Chase --- src/cmd/internal/obj/obj.go | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/internal/obj/obj.go b/src/cmd/internal/obj/obj.go index 6229bbb288..937e3b9812 100644 --- a/src/cmd/internal/obj/obj.go +++ b/src/cmd/internal/obj/obj.go @@ -229,6 +229,10 @@ func (h *LineHist) LineString(lineno int) string { text := fmt.Sprintf("%s:%d", filename, stk.fileLineAt(lineno)) if stk.Directive && stk.Parent != nil { stk = stk.Parent + 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 -- cgit v1.3 From 997a9f32b01eb73ee3086e8c9141c1ed30c7ac8d Mon Sep 17 00:00:00 2001 From: David Chase Date: Wed, 12 Aug 2015 16:38:11 -0400 Subject: [dev.ssa] cmd/compile: first unoptimized cut at adding FP support Added F32 and F64 load, store, and addition. Added F32 and F64 multiply. Added F32 and F64 subtraction and division. Added X15 to "clobber" for FP sub/div Added FP constants Added separate FP test in gc/testdata Change-Id: Ifa60dbad948a40011b478d9605862c4b0cc9134c Reviewed-on: https://go-review.googlesource.com/13612 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 242 ++++++--- src/cmd/compile/internal/gc/ssa_test.go | 3 + src/cmd/compile/internal/gc/testdata/fp_ssa.go | 164 ++++++ src/cmd/compile/internal/ssa/func.go | 10 + src/cmd/compile/internal/ssa/gen/AMD64.rules | 46 +- src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 39 ++ src/cmd/compile/internal/ssa/gen/genericOps.go | 16 +- src/cmd/compile/internal/ssa/opGen.go | 294 +++++++++++ src/cmd/compile/internal/ssa/rewrite.go | 8 + src/cmd/compile/internal/ssa/rewriteAMD64.go | 700 +++++++++++++++++++++++++ 10 files changed, 1444 insertions(+), 78 deletions(-) create mode 100644 src/cmd/compile/internal/gc/testdata/fp_ssa.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index d37181daf5..4e115a0fcd 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -379,6 +379,12 @@ func (s *state) constInt32(t ssa.Type, c int32) *ssa.Value { 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) constIntPtr(t ssa.Type, c int64) *ssa.Value { if s.config.PtrSize == 4 && int64(int32(c)) != c { s.Fatalf("pointer constant too big %d", c) @@ -715,25 +721,29 @@ type opAndType struct { } 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{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{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, @@ -755,14 +765,19 @@ var opToSSA = map[opAndType]ssa.Op{ opAndType{OCOM, TINT64}: ssa.OpCom64, opAndType{OCOM, TUINT64}: ssa.OpCom64, - 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, 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{OAND, TINT8}: ssa.OpAnd8, opAndType{OAND, TUINT8}: ssa.OpAnd8, @@ -1042,6 +1057,18 @@ func (s *state) expr(n *Node) *ssa.Value { return s.entryNewValue0A(ssa.OpConstBool, n.Type, n.Val().U) case CTNIL: return s.entryNewValue0(ssa.OpConstNil, n.Type) + 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 + } + default: s.Unimplementedf("unhandled OLITERAL %v", n.Val().Ctype()) return nil @@ -1165,7 +1192,7 @@ func (s *state) expr(n *Node) *ssa.Value { a := s.expr(n.Left) b := s.expr(n.Right) return s.newValue2(s.ssaOp(n.Op, n.Left.Type), Types[TBOOL], a, b) - case OADD, OAND, OMUL, OOR, OSUB, OXOR: + case OADD, OAND, OMUL, OOR, OSUB, ODIV, OXOR: a := s.expr(n.Left) b := s.expr(n.Right) return s.newValue2(s.ssaOp(n.Op, n.Type), a.Type, a, b) @@ -1888,6 +1915,19 @@ func genssa(f *ssa.Func, ptxt *obj.Prog, gcargs, gclocals *Sym) { f.Config.HTML.Close() } +// opregreg emits instructions for +// dest := dest op src +// 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 genValue(v *ssa.Value) { lineno = v.Line switch v.Op { @@ -1917,20 +1957,17 @@ func genValue(v *ssa.Value) { p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v) // 2-address opcode arithmetic, symmetric - case ssa.OpAMD64ADDB, + 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.OpAMD64MULQ, ssa.OpAMD64MULL, ssa.OpAMD64MULW, ssa.OpAMD64MULB, + ssa.OpAMD64MULSS, ssa.OpAMD64MULSD: r := regnum(v) x := regnum(v.Args[0]) y := regnum(v.Args[1]) if x != r && y != r { - p := Prog(regMoveAMD64(v.Type.Size())) - p.From.Type = obj.TYPE_REG - p.From.Reg = x - p.To.Type = obj.TYPE_REG - p.To.Reg = r + opregreg(regMoveByTypeAMD64(v.Type), r, x) x = r } p := Prog(v.Op.Asm()) @@ -1954,23 +1991,34 @@ func genValue(v *ssa.Value) { neg = true } if x != r { - p := Prog(regMoveAMD64(v.Type.Size())) - p.From.Type = obj.TYPE_REG - p.From.Reg = x - p.To.Type = obj.TYPE_REG - p.To.Reg = r + opregreg(regMoveByTypeAMD64(v.Type), r, x) } + opregreg(v.Op.Asm(), r, y) - p := Prog(v.Op.Asm()) - p.From.Type = obj.TYPE_REG - p.To.Type = obj.TYPE_REG - p.To.Reg = r - p.From.Reg = y if neg { p := Prog(x86.ANEGQ) // TODO: use correct size? This is mostly a hack until regalloc does 2-address correctly 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(regMoveByTypeAMD64(v.Type), x15, y) + opregreg(regMoveByTypeAMD64(v.Type), r, x) + y = x15 + } else if x != r { + opregreg(regMoveByTypeAMD64(v.Type), r, x) + } + opregreg(v.Op.Asm(), r, y) + 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: @@ -2117,15 +2165,22 @@ func genValue(v *ssa.Value) { p.From.Offset = i p.To.Type = obj.TYPE_REG p.To.Reg = x - case ssa.OpAMD64MOVQload, ssa.OpAMD64MOVLload, ssa.OpAMD64MOVWload, ssa.OpAMD64MOVBload, ssa.OpAMD64MOVBQSXload, ssa.OpAMD64MOVBQZXload: + case ssa.OpAMD64MOVSSconst, ssa.OpAMD64MOVSDconst: + x := regnum(v) + p := Prog(v.Op.Asm()) + p.From.Type = obj.TYPE_FCONST + p.From.Val = v.Aux.(float64) + 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: 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: - p := Prog(x86.AMOVQ) + 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) @@ -2133,15 +2188,24 @@ func genValue(v *ssa.Value) { p.From.Index = regnum(v.Args[1]) p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v) - case ssa.OpAMD64MOVQstore, ssa.OpAMD64MOVLstore, ssa.OpAMD64MOVWstore, ssa.OpAMD64MOVBstore: + case 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.OpAMD64MOVQstore, ssa.OpAMD64MOVSSstore, ssa.OpAMD64MOVSDstore, ssa.OpAMD64MOVLstore, ssa.OpAMD64MOVWstore, ssa.OpAMD64MOVBstore: 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: - p := Prog(x86.AMOVQ) + 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 @@ -2149,6 +2213,15 @@ func genValue(v *ssa.Value) { p.To.Scale = 8 p.To.Index = regnum(v.Args[1]) addAux(&p.To, v) + case ssa.OpAMD64MOVSSstoreidx4: + 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.OpAMD64MOVLQSX, ssa.OpAMD64MOVWQSX, ssa.OpAMD64MOVBQSX, ssa.OpAMD64MOVLQZX, ssa.OpAMD64MOVWQZX, ssa.OpAMD64MOVBQZX: p := Prog(v.Op.Asm()) p.From.Type = obj.TYPE_REG @@ -2178,29 +2251,26 @@ func genValue(v *ssa.Value) { x := regnum(v.Args[0]) y := regnum(v) if x != y { - p := Prog(x86.AMOVQ) - p.From.Type = obj.TYPE_REG - p.From.Reg = x - p.To.Type = obj.TYPE_REG - p.To.Reg = y + opregreg(regMoveByTypeAMD64(v.Type), y, x) } case ssa.OpLoadReg: if v.Type.IsFlags() { v.Unimplementedf("load flags not implemented: %v", v.LongString()) return } - p := Prog(movSize(v.Type.Size())) + p := Prog(movSizeByType(v.Type)) p.From.Type = obj.TYPE_MEM p.From.Reg = x86.REG_SP p.From.Offset = localOffset(v.Args[0]) 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(movSize(v.Type.Size())) + p := Prog(movSizeByType(v.Type)) p.From.Type = obj.TYPE_REG p.From.Reg = regnum(v.Args[0]) p.To.Type = obj.TYPE_MEM @@ -2215,10 +2285,12 @@ func genValue(v *ssa.Value) { 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.OpConst8, ssa.OpConst16, ssa.OpConst32, ssa.OpConst64, ssa.OpConstString, ssa.OpConstNil, ssa.OpConstBool: + case ssa.OpConst8, ssa.OpConst16, ssa.OpConst32, ssa.OpConst64, ssa.OpConstString, ssa.OpConstNil, ssa.OpConstBool, + ssa.OpConst32F, ssa.OpConst64F: if v.Block.Func.RegAlloc[v.ID] != nil { v.Fatalf("const value %v shouldn't have a location", v) } + case ssa.OpArg: // memory arg needs no code // TODO: check that only mem arg goes here. @@ -2316,21 +2388,12 @@ func genValue(v *ssa.Value) { } } -// movSize returns the MOV instruction of the given width. -func movSize(width int64) (asm int) { - switch width { - case 1: - asm = x86.AMOVB - case 2: - asm = x86.AMOVW - case 4: - asm = x86.AMOVL - case 8: - asm = x86.AMOVQ - default: - panic(fmt.Errorf("bad movSize %d", width)) - } - return asm +// movSizeByType returns the MOV instruction of the given type. +func movSizeByType(t ssa.Type) (asm int) { + // For x86, there's no difference between reg move opcodes + // and memory move opcodes. + asm = regMoveByTypeAMD64(t) + return } // movZero generates a register indirect move with a 0 immediate and keeps track of bytes left and next offset @@ -2553,10 +2616,39 @@ func regMoveAMD64(width int64) int { case 8: return x86.AMOVQ default: - panic("bad register width") + panic("bad int register width") } } +func regMoveByTypeAMD64(t ssa.Type) int { + width := t.Size() + if t.IsFloat() { + switch width { + case 4: + return x86.AMOVSS + case 8: + return x86.AMOVSD + default: + panic("bad float register width") + } + } else { + switch width { + case 1: + return x86.AMOVB + case 2: + return x86.AMOVW + 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. diff --git a/src/cmd/compile/internal/gc/ssa_test.go b/src/cmd/compile/internal/gc/ssa_test.go index f51d6de871..f0060cb12d 100644 --- a/src/cmd/compile/internal/gc/ssa_test.go +++ b/src/cmd/compile/internal/gc/ssa_test.go @@ -45,3 +45,6 @@ func TestBreakContinue(t *testing.T) { runTest(t, "break_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") } 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 0000000000..73366cdfa8 --- /dev/null +++ b/src/cmd/compile/internal/gc/testdata/fp_ssa.go @@ -0,0 +1,164 @@ +// 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" + +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 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 expect64(s string, x, expected float64) int { + if x != expected { + println("Expected", expected, "for", s, ", got", x) + } + return 0 +} + +// 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 +} + +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 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 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 += 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) + + // 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) + + 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) + + if fails > 0 { + fmt.Printf("Saw %v failures\n", fails) + panic("Failed.") + } +} diff --git a/src/cmd/compile/internal/ssa/func.go b/src/cmd/compile/internal/ssa/func.go index 97eb1a443a..09bfff2bfc 100644 --- a/src/cmd/compile/internal/ssa/func.go +++ b/src/cmd/compile/internal/ssa/func.go @@ -285,6 +285,16 @@ func (f *Func) ConstIntPtr(line int32, t Type, c int64) *Value { // TODO: cache? return f.Entry.NewValue0I(line, OpConstPtr, t, c) } +func (f *Func) ConstFloat32(line int32, t Type, c float64) *Value { + // TODO: cache? + // For now stuff FP values into aux interface + return f.Entry.NewValue0A(line, OpConst32F, t, c) +} +func (f *Func) ConstFloat64(line int32, t Type, c float64) *Value { + // TODO: cache? + // For now stuff FP values into aux interface + return f.Entry.NewValue0A(line, OpConst64F, t, c) +} func (f *Func) Logf(msg string, args ...interface{}) { f.Config.Logf(msg, args...) } func (f *Func) Fatalf(msg string, args ...interface{}) { f.Config.Fatalf(msg, args...) } diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 0e36737337..9ea9781d93 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -15,17 +15,26 @@ (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) (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) (MulPtr 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) (And64 x y) -> (ANDQ x y) (And32 x y) -> (ANDL x y) @@ -203,6 +212,13 @@ (Load ptr mem) && is32BitInt(t) -> (MOVLload ptr mem) (Load ptr mem) && is16BitInt(t) -> (MOVWload ptr mem) (Load ptr mem) && (t.IsBoolean() || is8BitInt(t)) -> (MOVBload ptr mem) +(Load ptr mem) && is32BitFloat(t) -> (MOVSSload ptr mem) +(Load 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) @@ -225,6 +241,8 @@ (Const16 [val]) -> (MOVWconst [val]) (Const32 [val]) -> (MOVLconst [val]) (Const64 [val]) -> (MOVQconst [val]) +(Const32F {val}) -> (MOVSSconst {val}) +(Const64F {val}) -> (MOVSDconst {val}) (ConstPtr [val]) -> (MOVQconst [val]) (ConstNil) -> (MOVQconst [0]) (ConstBool {b}) && !b.(bool) -> (MOVBconst [0]) @@ -404,13 +422,39 @@ (MOVQstore [off1] {sym1} (LEAQ [off2] {sym2} base) val mem) && (sym1 == nil || sym2 == nil) -> (MOVQstore [addOff(off1,off2)] {mergeSym(sym1,sym2)} base val mem) +(MOVSSload [off1] (ADDQconst [off2] ptr) mem) -> (MOVSSload [addOff(off1, off2)] ptr mem) +(MOVSSstore [off1] (ADDQconst [off2] ptr) val mem) -> (MOVSSstore [addOff(off1, off2)] ptr val mem) + +(MOVSSload [off1] {sym1} (LEAQ [off2] {sym2} base) mem) && (sym1 == nil || sym2 == nil) -> + (MOVSSload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem) +(MOVSSstore [off1] {sym1} (LEAQ [off2] {sym2} base) val mem) && (sym1 == nil || sym2 == nil) -> + (MOVSSstore [addOff(off1,off2)] {mergeSym(sym1,sym2)} base val mem) + +(MOVSDload [off1] (ADDQconst [off2] ptr) mem) -> (MOVSDload [addOff(off1, off2)] ptr mem) +(MOVSDstore [off1] (ADDQconst [off2] ptr) val mem) -> (MOVSDstore [addOff(off1, off2)] ptr val mem) + +(MOVSDload [off1] {sym1} (LEAQ [off2] {sym2} base) mem) && (sym1 == nil || sym2 == nil) -> + (MOVSDload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem) +(MOVSDstore [off1] {sym1} (LEAQ [off2] {sym2} base) val mem) && (sym1 == nil || sym2 == nil) -> + (MOVSDstore [addOff(off1,off2)] {mergeSym(sym1,sym2)} base val mem) + // indexed loads and stores (MOVQload [off1] (LEAQ8 [off2] ptr idx) mem) -> (MOVQloadidx8 [addOff(off1, off2)] ptr idx mem) (MOVQstore [off1] (LEAQ8 [off2] ptr idx) val mem) -> (MOVQstoreidx8 [addOff(off1, off2)] ptr idx val mem) - (MOVQloadidx8 [off1] (ADDQconst [off2] ptr) idx mem) -> (MOVQloadidx8 [addOff(off1, off2)] ptr idx mem) (MOVQstoreidx8 [off1] (ADDQconst [off2] ptr) idx val mem) -> (MOVQstoreidx8 [addOff(off1, off2)] ptr idx val mem) +(MOVSSload [off1] (LEAQ4 [off2] ptr idx) mem) -> (MOVSSloadidx4 [addOff(off1, off2)] ptr idx mem) +(MOVSSstore [off1] (LEAQ4 [off2] ptr idx) val mem) -> (MOVSSstoreidx4 [addOff(off1, off2)] ptr idx val mem) +(MOVSSloadidx4 [off1] (ADDQconst [off2] ptr) idx mem) -> (MOVSSloadidx4 [addOff(off1, off2)] ptr idx mem) +(MOVSSstoreidx4 [off1] (ADDQconst [off2] ptr) idx val mem) -> (MOVSSstoreidx4 [addOff(off1, off2)] ptr idx val mem) + +(MOVSDload [off1] (LEAQ8 [off2] ptr idx) mem) -> (MOVSDloadidx8 [addOff(off1, off2)] ptr idx mem) +(MOVSDstore [off1] (LEAQ8 [off2] ptr idx) val mem) -> (MOVSDstoreidx8 [addOff(off1, off2)] ptr idx val mem) +(MOVSDloadidx8 [off1] (ADDQconst [off2] ptr) idx mem) -> (MOVSDloadidx8 [addOff(off1, off2)] ptr idx mem) +(MOVSDstoreidx8 [off1] (ADDQconst [off2] ptr) idx val mem) -> (MOVSDstoreidx8 [addOff(off1, off2)] ptr idx val mem) + + (ADDQconst [0] x) -> x // lower Zero instructions with word sizes diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 0a7268a2f6..8bdcfaaac7 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -73,7 +73,9 @@ func init() { // Common individual register masks var ( cx = buildReg("CX") + 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") @@ -82,6 +84,7 @@ func init() { // Common slices of register masks var ( gponly = []regMask{gp} + fponly = []regMask{fp} flagsonly = []regMask{flags} ) @@ -104,6 +107,20 @@ func init() { gpstore = regInfo{inputs: []regMask{gpspsb, gpsp, 0}} gpstoreconst = regInfo{inputs: []regMask{gpspsb, 0}} gpstoreidx = regInfo{inputs: []regMask{gpspsb, gpsp, gpsp, 0}} + + // fp11 = regInfo{inputs: fponly, outputs: fponly} + 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}} + // 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}} ) // Suffixes encode the bit width of various instructions. @@ -111,6 +128,28 @@ func init() { // TODO: 2-address instructions. Mark ops as needing matching input/output regs. var AMD64ops = []opData{ + // fp ops + {name: "ADDSS", reg: fp21, asm: "ADDSS"}, // fp32 add + {name: "ADDSD", reg: fp21, asm: "ADDSD"}, // fp64 add + {name: "SUBSS", reg: fp21x15, asm: "SUBSS"}, // fp32 sub + {name: "SUBSD", reg: fp21x15, asm: "SUBSD"}, // fp64 sub + {name: "MULSS", reg: fp21, asm: "MULSS"}, // fp32 mul + {name: "MULSD", reg: fp21, asm: "MULSD"}, // fp64 mul + {name: "DIVSS", reg: fp21x15, asm: "DIVSS"}, // fp32 div + {name: "DIVSD", reg: fp21x15, asm: "DIVSD"}, // fp64 div + + {name: "MOVSSload", reg: fpload, asm: "MOVSS"}, // fp32 load + {name: "MOVSDload", reg: fpload, asm: "MOVSD"}, // fp64 load + {name: "MOVSSconst", reg: fp01, asm: "MOVSS"}, // fp32 constant + {name: "MOVSDconst", reg: fp01, asm: "MOVSD"}, // fp64 constant + {name: "MOVSSloadidx4", reg: fploadidx, asm: "MOVSS"}, // fp32 load + {name: "MOVSDloadidx8", reg: fploadidx, asm: "MOVSD"}, // fp64 load + + {name: "MOVSSstore", reg: fpstore, asm: "MOVSS"}, // fp32 store + {name: "MOVSDstore", reg: fpstore, asm: "MOVSD"}, // fp64 store + {name: "MOVSSstoreidx4", reg: fpstoreidx, asm: "MOVSS"}, // fp32 indexed by 4i store + {name: "MOVSDstoreidx8", reg: fpstoreidx, asm: "MOVSD"}, // fp64 indexed by 8i store + // binary ops {name: "ADDQ", reg: gp21, asm: "ADDQ"}, // arg0 + arg1 {name: "ADDL", reg: gp21, asm: "ADDL"}, // arg0 + arg1 diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 496b57e2e1..1488e0f644 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -13,19 +13,29 @@ var genericOps = []opData{ {name: "Add32"}, {name: "Add64"}, {name: "AddPtr"}, - // TODO: Add32F, Add64F, Add64C, Add128C + {name: "Add32F"}, + {name: "Add64F"}, + // TODO: Add64C, Add128C {name: "Sub8"}, // arg0 - arg1 {name: "Sub16"}, {name: "Sub32"}, {name: "Sub64"}, - // TODO: Sub32F, Sub64F, Sub64C, Sub128C + {name: "Sub32F"}, + {name: "Sub64F"}, + // TODO: Sub64C, Sub128C {name: "Mul8"}, // arg0 * arg1 {name: "Mul16"}, {name: "Mul32"}, {name: "Mul64"}, {name: "MulPtr"}, // MulPtr is used for address calculations + {name: "Mul32F"}, + {name: "Mul64F"}, + + {name: "Div32F"}, // arg0 / arg1 + {name: "Div64F"}, + // TODO: Div8, Div16, Div32, Div64 and unsigned {name: "And8"}, // arg0 & arg1 {name: "And16"}, @@ -200,6 +210,8 @@ var genericOps = []opData{ {name: "Const16"}, {name: "Const32"}, {name: "Const64"}, + {name: "Const32F"}, + {name: "Const64F"}, {name: "ConstPtr"}, // pointer-sized integer constant // TODO: Const32F, ... diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 6a5acadde6..2155cd318e 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -51,6 +51,24 @@ 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 @@ -204,15 +222,23 @@ const ( OpAdd32 OpAdd64 OpAddPtr + OpAdd32F + OpAdd64F OpSub8 OpSub16 OpSub32 OpSub64 + OpSub32F + OpSub64F OpMul8 OpMul16 OpMul32 OpMul64 OpMulPtr + OpMul32F + OpMul64F + OpDiv32F + OpDiv64F OpAnd8 OpAnd16 OpAnd32 @@ -339,6 +365,8 @@ const ( OpConst16 OpConst32 OpConst64 + OpConst32F + OpConst64F OpConstPtr OpArg OpAddr @@ -393,6 +421,232 @@ const ( var opcodeTable = [...]opInfo{ {name: "OpInvalid"}, + { + name: "ADDSS", + asm: x86.AADDSS, + reg: regInfo{ + inputs: []regMask{ + 4294901760, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15 + 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", + asm: x86.AADDSD, + reg: regInfo{ + inputs: []regMask{ + 4294901760, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15 + 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", + asm: x86.ASUBSS, + reg: regInfo{ + inputs: []regMask{ + 2147418112, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 + 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", + asm: x86.ASUBSD, + reg: regInfo{ + inputs: []regMask{ + 2147418112, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 + 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", + asm: x86.AMULSS, + reg: regInfo{ + inputs: []regMask{ + 4294901760, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15 + 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", + asm: x86.AMULSD, + reg: regInfo{ + inputs: []regMask{ + 4294901760, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15 + 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", + asm: x86.ADIVSS, + reg: regInfo{ + inputs: []regMask{ + 2147418112, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 + 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", + asm: x86.ADIVSD, + reg: regInfo{ + inputs: []regMask{ + 2147418112, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 + 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", + asm: x86.AMOVSS, + reg: regInfo{ + inputs: []regMask{ + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB + 0, + }, + outputs: []regMask{ + 4294901760, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15 + }, + }, + }, + { + name: "MOVSDload", + asm: x86.AMOVSD, + reg: regInfo{ + inputs: []regMask{ + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB + 0, + }, + outputs: []regMask{ + 4294901760, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15 + }, + }, + }, + { + name: "MOVSSconst", + 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", + 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", + asm: x86.AMOVSS, + reg: regInfo{ + inputs: []regMask{ + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 0, + }, + outputs: []regMask{ + 4294901760, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15 + }, + }, + }, + { + name: "MOVSDloadidx8", + asm: x86.AMOVSD, + reg: regInfo{ + inputs: []regMask{ + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 0, + }, + outputs: []regMask{ + 4294901760, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15 + }, + }, + }, + { + name: "MOVSSstore", + asm: x86.AMOVSS, + reg: regInfo{ + inputs: []regMask{ + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB + 4294901760, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15 + 0, + }, + }, + }, + { + name: "MOVSDstore", + asm: x86.AMOVSD, + reg: regInfo{ + inputs: []regMask{ + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB + 4294901760, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15 + 0, + }, + }, + }, + { + name: "MOVSSstoreidx4", + asm: x86.AMOVSS, + reg: regInfo{ + inputs: []regMask{ + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 4294901760, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15 + 0, + }, + }, + }, + { + name: "MOVSDstoreidx8", + asm: x86.AMOVSD, + reg: regInfo{ + inputs: []regMask{ + 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB + 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 4294901760, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15 + 0, + }, + }, + }, { name: "ADDQ", asm: x86.AADDQ, @@ -2177,6 +2431,14 @@ var opcodeTable = [...]opInfo{ name: "AddPtr", generic: true, }, + { + name: "Add32F", + generic: true, + }, + { + name: "Add64F", + generic: true, + }, { name: "Sub8", generic: true, @@ -2193,6 +2455,14 @@ var opcodeTable = [...]opInfo{ name: "Sub64", generic: true, }, + { + name: "Sub32F", + generic: true, + }, + { + name: "Sub64F", + generic: true, + }, { name: "Mul8", generic: true, @@ -2213,6 +2483,22 @@ var opcodeTable = [...]opInfo{ name: "MulPtr", generic: true, }, + { + name: "Mul32F", + generic: true, + }, + { + name: "Mul64F", + generic: true, + }, + { + name: "Div32F", + generic: true, + }, + { + name: "Div64F", + generic: true, + }, { name: "And8", generic: true, @@ -2717,6 +3003,14 @@ var opcodeTable = [...]opInfo{ name: "Const64", generic: true, }, + { + name: "Const32F", + generic: true, + }, + { + name: "Const64F", + generic: true, + }, { name: "ConstPtr", generic: true, diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go index aae8220f81..4b9430abab 100644 --- a/src/cmd/compile/internal/ssa/rewrite.go +++ b/src/cmd/compile/internal/ssa/rewrite.go @@ -76,6 +76,14 @@ func applyRewrite(f *Func, rb func(*Block) bool, rv func(*Value, *Config) bool) // 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() } diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 502efc5640..75393ad58a 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -1076,6 +1076,24 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endc445ea2a65385445676cd684ae9a42b5 endc445ea2a65385445676cd684ae9a42b5: ; + case OpAdd32F: + // match: (Add32F x y) + // cond: + // result: (ADDSS x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ADDSS + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end5d82e1c10823774894c036b7c5b8fed4 + end5d82e1c10823774894c036b7c5b8fed4: + ; case OpAdd64: // match: (Add64 x y) // cond: @@ -1094,6 +1112,24 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endd88f18b3f39e3ccc201477a616f0abc0 endd88f18b3f39e3ccc201477a616f0abc0: ; + case OpAdd64F: + // match: (Add64F x y) + // cond: + // result: (ADDSD x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ADDSD + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end62f2de6c70abd214e6987ee37976653a + end62f2de6c70abd214e6987ee37976653a: + ; case OpAdd8: // match: (Add8 x y) // cond: @@ -1520,6 +1556,22 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto enddae5807662af67143a3ac3ad9c63bae5 enddae5807662af67143a3ac3ad9c63bae5: ; + case OpConst32F: + // match: (Const32F {val}) + // cond: + // result: (MOVSSconst {val}) + { + val := v.Aux + v.Op = OpAMD64MOVSSconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Aux = val + return true + } + goto end30a68b43982e55971cc58f893ae2c04a + end30a68b43982e55971cc58f893ae2c04a: + ; case OpConst64: // match: (Const64 [val]) // cond: @@ -1536,6 +1588,22 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endc630434ae7f143ab69d5f482a9b52b5f endc630434ae7f143ab69d5f482a9b52b5f: ; + case OpConst64F: + // match: (Const64F {val}) + // cond: + // result: (MOVSDconst {val}) + { + val := v.Aux + v.Op = OpAMD64MOVSDconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Aux = val + return true + } + goto end958041a44a2ee8fc571cbc0832fad285 + end958041a44a2ee8fc571cbc0832fad285: + ; case OpConst8: // match: (Const8 [val]) // cond: @@ -1620,6 +1688,42 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endc395c0a53eeccf597e225a07b53047d1 endc395c0a53eeccf597e225a07b53047d1: ; + case OpDiv32F: + // match: (Div32F x y) + // cond: + // result: (DIVSS x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64DIVSS + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto enddca0462c7b176c4138854d7d5627ab5b + enddca0462c7b176c4138854d7d5627ab5b: + ; + case OpDiv64F: + // match: (Div64F x y) + // cond: + // result: (DIVSD x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64DIVSD + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end12299d76db5144a60f564d34ba97eb43 + end12299d76db5144a60f564d34ba97eb43: + ; case OpEq16: // match: (Eq16 x y) // cond: @@ -2558,6 +2662,48 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end8f83bf72293670e75b22d6627bd13f0b end8f83bf72293670e75b22d6627bd13f0b: ; + // match: (Load ptr mem) + // cond: is32BitFloat(t) + // result: (MOVSSload ptr mem) + { + t := v.Type + ptr := v.Args[0] + mem := v.Args[1] + if !(is32BitFloat(t)) { + goto end63383c4895805881aabceebea3c4c533 + } + v.Op = OpAMD64MOVSSload + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto end63383c4895805881aabceebea3c4c533 + end63383c4895805881aabceebea3c4c533: + ; + // match: (Load ptr mem) + // cond: is64BitFloat(t) + // result: (MOVSDload ptr mem) + { + t := v.Type + ptr := v.Args[0] + mem := v.Args[1] + if !(is64BitFloat(t)) { + goto end99d0858c0a5bb72f0fe4decc748da812 + } + v.Op = OpAMD64MOVSDload + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto end99d0858c0a5bb72f0fe4decc748da812 + end99d0858c0a5bb72f0fe4decc748da812: + ; case OpLrot16: // match: (Lrot16 x [c]) // cond: @@ -3466,6 +3612,438 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end01c970657b0fdefeab82458c15022163 end01c970657b0fdefeab82458c15022163: ; + case OpAMD64MOVSDload: + // match: (MOVSDload [off1] (ADDQconst [off2] ptr) mem) + // cond: + // result: (MOVSDload [addOff(off1, off2)] ptr mem) + { + off1 := v.AuxInt + if v.Args[0].Op != OpAMD64ADDQconst { + goto endb30d8b19da953bcc24db5adcaf3cd3de + } + off2 := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + mem := v.Args[1] + v.Op = OpAMD64MOVSDload + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto endb30d8b19da953bcc24db5adcaf3cd3de + endb30d8b19da953bcc24db5adcaf3cd3de: + ; + // match: (MOVSDload [off1] {sym1} (LEAQ [off2] {sym2} base) mem) + // cond: (sym1 == nil || sym2 == nil) + // result: (MOVSDload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem) + { + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ { + goto end3d7dc2a0979c214ad64f1c782b3fdeec + } + off2 := v.Args[0].AuxInt + sym2 := v.Args[0].Aux + base := v.Args[0].Args[0] + mem := v.Args[1] + if !(sym1 == nil || sym2 == nil) { + goto end3d7dc2a0979c214ad64f1c782b3fdeec + } + v.Op = OpAMD64MOVSDload + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(base) + v.AddArg(mem) + return true + } + goto end3d7dc2a0979c214ad64f1c782b3fdeec + end3d7dc2a0979c214ad64f1c782b3fdeec: + ; + // match: (MOVSDload [off1] (LEAQ8 [off2] ptr idx) mem) + // cond: + // result: (MOVSDloadidx8 [addOff(off1, off2)] ptr idx mem) + { + off1 := v.AuxInt + if v.Args[0].Op != OpAMD64LEAQ8 { + goto end290f413641e9c9b3a21dbffb8e6f51ce + } + off2 := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + idx := v.Args[0].Args[1] + mem := v.Args[1] + v.Op = OpAMD64MOVSDloadidx8 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.AddArg(ptr) + v.AddArg(idx) + v.AddArg(mem) + return true + } + goto end290f413641e9c9b3a21dbffb8e6f51ce + end290f413641e9c9b3a21dbffb8e6f51ce: + ; + case OpAMD64MOVSDloadidx8: + // match: (MOVSDloadidx8 [off1] (ADDQconst [off2] ptr) idx mem) + // cond: + // result: (MOVSDloadidx8 [addOff(off1, off2)] ptr idx mem) + { + off1 := v.AuxInt + if v.Args[0].Op != OpAMD64ADDQconst { + goto enda922ba4bafd07007398d143ff201635a + } + off2 := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + idx := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64MOVSDloadidx8 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.AddArg(ptr) + v.AddArg(idx) + v.AddArg(mem) + return true + } + goto enda922ba4bafd07007398d143ff201635a + enda922ba4bafd07007398d143ff201635a: + ; + case OpAMD64MOVSDstore: + // match: (MOVSDstore [off1] (ADDQconst [off2] ptr) val mem) + // cond: + // result: (MOVSDstore [addOff(off1, off2)] ptr val mem) + { + off1 := v.AuxInt + if v.Args[0].Op != OpAMD64ADDQconst { + goto endb8906053f3ffca146218392d4358440e + } + off2 := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + val := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64MOVSDstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.AddArg(ptr) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto endb8906053f3ffca146218392d4358440e + endb8906053f3ffca146218392d4358440e: + ; + // match: (MOVSDstore [off1] {sym1} (LEAQ [off2] {sym2} base) val mem) + // cond: (sym1 == nil || sym2 == nil) + // result: (MOVSDstore [addOff(off1,off2)] {mergeSym(sym1,sym2)} base val mem) + { + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ { + goto endc62528d624da256376080f662fa73cc5 + } + 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 !(sym1 == nil || sym2 == nil) { + goto endc62528d624da256376080f662fa73cc5 + } + v.Op = OpAMD64MOVSDstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(base) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto endc62528d624da256376080f662fa73cc5 + endc62528d624da256376080f662fa73cc5: + ; + // match: (MOVSDstore [off1] (LEAQ8 [off2] ptr idx) val mem) + // cond: + // result: (MOVSDstoreidx8 [addOff(off1, off2)] ptr idx val mem) + { + off1 := v.AuxInt + if v.Args[0].Op != OpAMD64LEAQ8 { + goto endd76d67faa7541d73e075d15443daec5f + } + off2 := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + idx := v.Args[0].Args[1] + val := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64MOVSDstoreidx8 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.AddArg(ptr) + v.AddArg(idx) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto endd76d67faa7541d73e075d15443daec5f + endd76d67faa7541d73e075d15443daec5f: + ; + case OpAMD64MOVSDstoreidx8: + // match: (MOVSDstoreidx8 [off1] (ADDQconst [off2] ptr) idx val mem) + // cond: + // result: (MOVSDstoreidx8 [addOff(off1, off2)] ptr idx val mem) + { + off1 := v.AuxInt + if v.Args[0].Op != OpAMD64ADDQconst { + goto endc0c523fd517b8432a9f946e3c3c54c83 + } + off2 := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + idx := v.Args[1] + val := v.Args[2] + mem := v.Args[3] + v.Op = OpAMD64MOVSDstoreidx8 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.AddArg(ptr) + v.AddArg(idx) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto endc0c523fd517b8432a9f946e3c3c54c83 + endc0c523fd517b8432a9f946e3c3c54c83: + ; + case OpAMD64MOVSSload: + // match: (MOVSSload [off1] (ADDQconst [off2] ptr) mem) + // cond: + // result: (MOVSSload [addOff(off1, off2)] ptr mem) + { + off1 := v.AuxInt + if v.Args[0].Op != OpAMD64ADDQconst { + goto endfd8ae39356d66610e8efcc54825cc022 + } + off2 := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + mem := v.Args[1] + v.Op = OpAMD64MOVSSload + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto endfd8ae39356d66610e8efcc54825cc022 + endfd8ae39356d66610e8efcc54825cc022: + ; + // match: (MOVSSload [off1] {sym1} (LEAQ [off2] {sym2} base) mem) + // cond: (sym1 == nil || sym2 == nil) + // result: (MOVSSload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem) + { + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ { + goto end86f5c0b840432898d1e4624da1ad8918 + } + off2 := v.Args[0].AuxInt + sym2 := v.Args[0].Aux + base := v.Args[0].Args[0] + mem := v.Args[1] + if !(sym1 == nil || sym2 == nil) { + goto end86f5c0b840432898d1e4624da1ad8918 + } + v.Op = OpAMD64MOVSSload + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(base) + v.AddArg(mem) + return true + } + goto end86f5c0b840432898d1e4624da1ad8918 + end86f5c0b840432898d1e4624da1ad8918: + ; + // match: (MOVSSload [off1] (LEAQ4 [off2] ptr idx) mem) + // cond: + // result: (MOVSSloadidx4 [addOff(off1, off2)] ptr idx mem) + { + off1 := v.AuxInt + if v.Args[0].Op != OpAMD64LEAQ4 { + goto end479f98c68c30173148913157084607d2 + } + off2 := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + idx := v.Args[0].Args[1] + mem := v.Args[1] + v.Op = OpAMD64MOVSSloadidx4 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.AddArg(ptr) + v.AddArg(idx) + v.AddArg(mem) + return true + } + goto end479f98c68c30173148913157084607d2 + end479f98c68c30173148913157084607d2: + ; + case OpAMD64MOVSSloadidx4: + // match: (MOVSSloadidx4 [off1] (ADDQconst [off2] ptr) idx mem) + // cond: + // result: (MOVSSloadidx4 [addOff(off1, off2)] ptr idx mem) + { + off1 := v.AuxInt + if v.Args[0].Op != OpAMD64ADDQconst { + goto end45b6855e44d0714ef12a148d4ed57ea0 + } + off2 := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + idx := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64MOVSSloadidx4 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.AddArg(ptr) + v.AddArg(idx) + v.AddArg(mem) + return true + } + goto end45b6855e44d0714ef12a148d4ed57ea0 + end45b6855e44d0714ef12a148d4ed57ea0: + ; + case OpAMD64MOVSSstore: + // match: (MOVSSstore [off1] (ADDQconst [off2] ptr) val mem) + // cond: + // result: (MOVSSstore [addOff(off1, off2)] ptr val mem) + { + off1 := v.AuxInt + if v.Args[0].Op != OpAMD64ADDQconst { + goto endd5dd6aabcca196087990cf227b93376a + } + off2 := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + val := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64MOVSSstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.AddArg(ptr) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto endd5dd6aabcca196087990cf227b93376a + endd5dd6aabcca196087990cf227b93376a: + ; + // match: (MOVSSstore [off1] {sym1} (LEAQ [off2] {sym2} base) val mem) + // cond: (sym1 == nil || sym2 == nil) + // result: (MOVSSstore [addOff(off1,off2)] {mergeSym(sym1,sym2)} base val mem) + { + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ { + goto endbb6c6bcd6d4f898318314e310920f8d9 + } + 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 !(sym1 == nil || sym2 == nil) { + goto endbb6c6bcd6d4f898318314e310920f8d9 + } + v.Op = OpAMD64MOVSSstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(base) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto endbb6c6bcd6d4f898318314e310920f8d9 + endbb6c6bcd6d4f898318314e310920f8d9: + ; + // match: (MOVSSstore [off1] (LEAQ4 [off2] ptr idx) val mem) + // cond: + // result: (MOVSSstoreidx4 [addOff(off1, off2)] ptr idx val mem) + { + off1 := v.AuxInt + if v.Args[0].Op != OpAMD64LEAQ4 { + goto end20b3a5a13e1c44d49e59eb4af0749503 + } + off2 := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + idx := v.Args[0].Args[1] + val := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64MOVSSstoreidx4 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.AddArg(ptr) + v.AddArg(idx) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto end20b3a5a13e1c44d49e59eb4af0749503 + end20b3a5a13e1c44d49e59eb4af0749503: + ; + case OpAMD64MOVSSstoreidx4: + // match: (MOVSSstoreidx4 [off1] (ADDQconst [off2] ptr) idx val mem) + // cond: + // result: (MOVSSstoreidx4 [addOff(off1, off2)] ptr idx val mem) + { + off1 := v.AuxInt + if v.Args[0].Op != OpAMD64ADDQconst { + goto end97e6b5fc52597982bc1a9e4b14561d96 + } + off2 := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + idx := v.Args[1] + val := v.Args[2] + mem := v.Args[3] + v.Op = OpAMD64MOVSSstoreidx4 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.AddArg(ptr) + v.AddArg(idx) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto end97e6b5fc52597982bc1a9e4b14561d96 + end97e6b5fc52597982bc1a9e4b14561d96: + ; case OpAMD64MOVWstore: // match: (MOVWstore ptr (MOVWQSX x) mem) // cond: @@ -3953,6 +4531,24 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto ende144381f85808e5144782804768e2859 ende144381f85808e5144782804768e2859: ; + case OpMul32F: + // match: (Mul32F x y) + // cond: + // result: (MULSS x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64MULSS + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end32105a3bfe0237b799b69d83b3f171ca + end32105a3bfe0237b799b69d83b3f171ca: + ; case OpMul64: // match: (Mul64 x y) // cond: @@ -3971,6 +4567,24 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end38da21e77ac329eb643b20e7d97d5853 end38da21e77ac329eb643b20e7d97d5853: ; + case OpMul64F: + // match: (Mul64F x y) + // cond: + // result: (MULSD x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64MULSD + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end0ff6e1919fb0a3e549eb82b43edf1f52 + end0ff6e1919fb0a3e549eb82b43edf1f52: + ; case OpMul8: // match: (Mul8 x y) // cond: @@ -7412,6 +8026,56 @@ func rewriteValueAMD64(v *Value, config *Config) bool { end32c5cbec813d1c2ae94fc9b1090e4b2a: ; case OpStore: + // match: (Store [8] ptr val mem) + // cond: is64BitFloat(val.Type) + // result: (MOVSDstore ptr val mem) + { + if v.AuxInt != 8 { + goto endaeec4f61bc8e67dbf3fa2f79fe4c2b9e + } + ptr := v.Args[0] + val := v.Args[1] + mem := v.Args[2] + if !(is64BitFloat(val.Type)) { + goto endaeec4f61bc8e67dbf3fa2f79fe4c2b9e + } + v.Op = OpAMD64MOVSDstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto endaeec4f61bc8e67dbf3fa2f79fe4c2b9e + endaeec4f61bc8e67dbf3fa2f79fe4c2b9e: + ; + // match: (Store [4] ptr val mem) + // cond: is32BitFloat(val.Type) + // result: (MOVSSstore ptr val mem) + { + if v.AuxInt != 4 { + goto endf638ca0a75871b5062da15324d0e0384 + } + ptr := v.Args[0] + val := v.Args[1] + mem := v.Args[2] + if !(is32BitFloat(val.Type)) { + goto endf638ca0a75871b5062da15324d0e0384 + } + v.Op = OpAMD64MOVSSstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto endf638ca0a75871b5062da15324d0e0384 + endf638ca0a75871b5062da15324d0e0384: + ; // match: (Store [8] ptr val mem) // cond: // result: (MOVQstore ptr val mem) @@ -7536,6 +8200,24 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto enddc3a2a488bda8c5856f93343e5ffe5f8 enddc3a2a488bda8c5856f93343e5ffe5f8: ; + case OpSub32F: + // match: (Sub32F x y) + // cond: + // result: (SUBSS x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SUBSS + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end20193c1804b0e707702a884fb8abd60d + end20193c1804b0e707702a884fb8abd60d: + ; case OpSub64: // match: (Sub64 x y) // cond: @@ -7554,6 +8236,24 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endd88d5646309fd9174584888ecc8aca2c endd88d5646309fd9174584888ecc8aca2c: ; + case OpSub64F: + // match: (Sub64F x y) + // cond: + // result: (SUBSD x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SUBSD + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end5d5af7b8a3326bf9151f00a0013b73d7 + end5d5af7b8a3326bf9151f00a0013b73d7: + ; case OpSub8: // match: (Sub8 x y) // cond: -- cgit v1.3 From 759b9c3b80da47a8db59f015bfca551a2a15ae18 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Mon, 17 Aug 2015 00:29:56 -0700 Subject: [dev.ssa] cmd/compile: add likely annotations to blocks in html This was missing from CL 13472 due to a badly synced client. Change-Id: If59fc669125dd1caa335dacfbf0f8dbd7b074312 Reviewed-on: https://go-review.googlesource.com/13639 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/html.go | 6 ++++++ 1 file changed, 6 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/html.go b/src/cmd/compile/internal/ssa/html.go index 581331a215..848e016129 100644 --- a/src/cmd/compile/internal/ssa/html.go +++ b/src/cmd/compile/internal/ssa/html.go @@ -389,6 +389,12 @@ func (b *Block) LongHTML() string { s += " " + c.HTML() } } + switch b.Likely { + case BranchUnlikely: + s += " (unlikely)" + case BranchLikely: + s += " (likely)" + } return s } -- cgit v1.3 From 0b46b42943ee9d7ad4e9a19772d22468718173c9 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Tue, 11 Aug 2015 12:51:33 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: New register allocator Implement a global (whole function) register allocator. This replaces the local (per basic block) register allocator. Clobbering of registers by instructions is handled properly. A separate change will add the correct clobbers to all the instructions. Change-Id: I38ce4dc7dccb8303c1c0e0295fe70247b0a3f2ea Reviewed-on: https://go-review.googlesource.com/13622 Reviewed-by: Josh Bleecher Snyder Reviewed-by: Todd Neal --- src/cmd/compile/internal/gc/ssa.go | 12 +- .../compile/internal/gc/testdata/regalloc_ssa.go | 57 ++ src/cmd/compile/internal/ssa/deadcode.go | 8 + src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 34 +- src/cmd/compile/internal/ssa/gen/main.go | 42 +- src/cmd/compile/internal/ssa/html.go | 2 +- src/cmd/compile/internal/ssa/op.go | 7 +- src/cmd/compile/internal/ssa/opGen.go | 909 ++++++++-------- src/cmd/compile/internal/ssa/regalloc.go | 1081 ++++++++++++++------ src/cmd/compile/internal/ssa/stackalloc.go | 18 +- src/cmd/compile/internal/ssa/tighten.go | 7 - src/cmd/compile/internal/ssa/value.go | 4 +- 12 files changed, 1439 insertions(+), 742 deletions(-) create mode 100644 src/cmd/compile/internal/gc/testdata/regalloc_ssa.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 4e115a0fcd..ef90ed40e7 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -2277,7 +2277,10 @@ func genValue(v *ssa.Value) { p.To.Reg = x86.REG_SP p.To.Offset = localOffset(v) case ssa.OpPhi: - // just check to make sure regalloc did it right + // 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 { @@ -2376,13 +2379,16 @@ func genValue(v *ssa.Value) { case ssa.OpAMD64InvertFlags: v.Fatalf("InvertFlags should never make it to codegen %v", v) case ssa.OpAMD64REPSTOSQ: + p := Prog(x86.AXORL) // TODO: lift out zeroing into its own instruction? + p.From.Type = obj.TYPE_REG + p.From.Reg = x86.REG_AX + p.To.Type = obj.TYPE_REG + p.To.Reg = x86.REG_AX Prog(x86.AREP) Prog(x86.ASTOSQ) - v.Unimplementedf("REPSTOSQ clobbers not implemented: %s", v.LongString()) case ssa.OpAMD64REPMOVSB: Prog(x86.AREP) Prog(x86.AMOVSB) - v.Unimplementedf("REPMOVSB clobbers not implemented: %s", v.LongString()) default: v.Unimplementedf("genValue not implemented: %s", v.LongString()) } 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 0000000000..f752692952 --- /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/ssa/deadcode.go b/src/cmd/compile/internal/ssa/deadcode.go index 109b3dd09f..8c306c8412 100644 --- a/src/cmd/compile/internal/ssa/deadcode.go +++ b/src/cmd/compile/internal/ssa/deadcode.go @@ -59,6 +59,14 @@ func findlive(f *Func) (reachable []bool, live []bool) { // 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") + } + reachable, live := findlive(f) // Remove dead values from blocks' value list. Return dead diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 8bdcfaaac7..5aa5e60e33 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -72,13 +72,14 @@ func init() { // Common individual register masks var ( - cx = buildReg("CX") - 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") + cx = buildReg("CX") + 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 @@ -90,16 +91,16 @@ func init() { // Common regInfo var ( - gp01 = regInfo{inputs: []regMask{}, outputs: gponly} - gp11 = regInfo{inputs: []regMask{gpsp}, outputs: gponly} - gp11sb = regInfo{inputs: []regMask{gpspsb}, outputs: gponly} - gp21 = regInfo{inputs: []regMask{gpsp, gpsp}, outputs: gponly} - gp21sb = regInfo{inputs: []regMask{gpspsb, gpsp}, outputs: gponly} - gp21shift = regInfo{inputs: []regMask{gpsp, cx}, outputs: []regMask{gp &^ cx}} + gp01 = regInfo{inputs: []regMask{}, outputs: gponly, clobbers: flags} + gp11 = regInfo{inputs: []regMask{gpsp}, outputs: gponly, clobbers: flags} + gp11sb = regInfo{inputs: []regMask{gpspsb}, outputs: gponly, clobbers: flags} + gp21 = regInfo{inputs: []regMask{gpsp, gpsp}, outputs: gponly, clobbers: flags} + gp21sb = regInfo{inputs: []regMask{gpspsb, gpsp}, outputs: gponly, clobbers: flags} + gp21shift = regInfo{inputs: []regMask{gpsp, cx}, outputs: []regMask{gp &^ cx}, clobbers: flags} gp2flags = regInfo{inputs: []regMask{gpsp, gpsp}, outputs: flagsonly} gp1flags = regInfo{inputs: []regMask{gpsp}, outputs: flagsonly} - flagsgp = regInfo{inputs: flagsonly, outputs: gponly} + flagsgp = regInfo{inputs: flagsonly, outputs: gponly, clobbers: flags} gpload = regInfo{inputs: []regMask{gpspsb, 0}, outputs: gponly} gploadidx = regInfo{inputs: []regMask{gpspsb, gpsp, 0}, outputs: gponly} @@ -122,6 +123,7 @@ func init() { 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 @@ -318,8 +320,8 @@ func init() { {name: "REPSTOSQ", reg: regInfo{[]regMask{buildReg("DI"), buildReg("CX")}, buildReg("DI AX CX"), nil}}, // store arg1 8-byte words containing zero into arg0 using STOSQ. arg2=mem. //TODO: set register clobber to everything? - {name: "CALLstatic"}, // call static function aux.(*gc.Sym). arg0=mem, returns mem - {name: "CALLclosure", reg: regInfo{[]regMask{gpsp, buildReg("DX"), 0}, 0, nil}}, // call function via closure. arg0=codeptr, arg1=closure, arg2=mem returns mem + {name: "CALLstatic", reg: regInfo{clobbers: callerSave}}, // call static function aux.(*gc.Sym). arg0=mem, returns mem + {name: "CALLclosure", reg: regInfo{[]regMask{gpsp, buildReg("DX"), 0}, callerSave, nil}}, // call function via closure. arg0=codeptr, arg1=closure, arg2=mem returns mem {name: "REPMOVSB", reg: regInfo{[]regMask{buildReg("DI"), buildReg("SI"), buildReg("CX")}, buildReg("DI SI CX"), nil}}, // move arg2 bytes from arg1 to arg0. arg3=mem, returns memory diff --git a/src/cmd/compile/internal/ssa/gen/main.go b/src/cmd/compile/internal/ssa/gen/main.go index 97ac802cbd..6620c0a1d0 100644 --- a/src/cmd/compile/internal/ssa/gen/main.go +++ b/src/cmd/compile/internal/ssa/gen/main.go @@ -15,6 +15,7 @@ import ( "io/ioutil" "log" "regexp" + "sort" ) type arch struct { @@ -125,11 +126,22 @@ func genOp() { fmt.Fprintf(w, "asm: x86.A%s,\n", v.asm) } fmt.Fprintln(w, "reg:regInfo{") - // reg inputs - if len(v.reg.inputs) > 0 { - fmt.Fprintln(w, "inputs: []regMask{") - for _, r := range v.reg.inputs { - fmt.Fprintf(w, "%d,%s\n", r, a.regMaskComment(r)) + + // 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, "},") } @@ -205,3 +217,23 @@ func genLower() { 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/html.go b/src/cmd/compile/internal/ssa/html.go index 848e016129..5c23320680 100644 --- a/src/cmd/compile/internal/ssa/html.go +++ b/src/cmd/compile/internal/ssa/html.go @@ -362,7 +362,7 @@ func (v *Value) LongHTML() string { s += fmt.Sprintf(" %s", a.HTML()) } r := v.Block.Func.RegAlloc - if r != nil && r[v.ID] != nil { + if int(v.ID) < len(r) && r[v.ID] != nil { s += " : " + r[v.ID].Name() } diff --git a/src/cmd/compile/internal/ssa/op.go b/src/cmd/compile/internal/ssa/op.go index 4ca8c770cb..356084fb02 100644 --- a/src/cmd/compile/internal/ssa/op.go +++ b/src/cmd/compile/internal/ssa/op.go @@ -19,8 +19,13 @@ type opInfo struct { generic bool // this is a generic (arch-independent) opcode } +type inputInfo struct { + idx int // index in Args array + regs regMask // allowed input registers +} + type regInfo struct { - inputs []regMask + inputs []inputInfo // ordered in register allocation order clobbers regMask outputs []regMask // NOTE: values can only have 1 output for now. } diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 2155cd318e..cbabbfade5 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -425,9 +425,9 @@ var opcodeTable = [...]opInfo{ name: "ADDSS", asm: x86.AADDSS, reg: regInfo{ - inputs: []regMask{ - 4294901760, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15 - 4294901760, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15 + 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 @@ -438,9 +438,9 @@ var opcodeTable = [...]opInfo{ name: "ADDSD", asm: x86.AADDSD, reg: regInfo{ - inputs: []regMask{ - 4294901760, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15 - 4294901760, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15 + 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 @@ -451,9 +451,9 @@ var opcodeTable = [...]opInfo{ name: "SUBSS", asm: x86.ASUBSS, reg: regInfo{ - inputs: []regMask{ - 2147418112, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 - 2147418112, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 + 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{ @@ -465,9 +465,9 @@ var opcodeTable = [...]opInfo{ name: "SUBSD", asm: x86.ASUBSD, reg: regInfo{ - inputs: []regMask{ - 2147418112, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 - 2147418112, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 + 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{ @@ -479,9 +479,9 @@ var opcodeTable = [...]opInfo{ name: "MULSS", asm: x86.AMULSS, reg: regInfo{ - inputs: []regMask{ - 4294901760, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15 - 4294901760, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15 + 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 @@ -492,9 +492,9 @@ var opcodeTable = [...]opInfo{ name: "MULSD", asm: x86.AMULSD, reg: regInfo{ - inputs: []regMask{ - 4294901760, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15 - 4294901760, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15 + 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 @@ -505,9 +505,9 @@ var opcodeTable = [...]opInfo{ name: "DIVSS", asm: x86.ADIVSS, reg: regInfo{ - inputs: []regMask{ - 2147418112, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 - 2147418112, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 + 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{ @@ -519,9 +519,9 @@ var opcodeTable = [...]opInfo{ name: "DIVSD", asm: x86.ADIVSD, reg: regInfo{ - inputs: []regMask{ - 2147418112, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 - 2147418112, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 + 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{ @@ -533,9 +533,8 @@ var opcodeTable = [...]opInfo{ name: "MOVSSload", asm: x86.AMOVSS, reg: regInfo{ - inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB - 0, + 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 @@ -546,9 +545,8 @@ var opcodeTable = [...]opInfo{ name: "MOVSDload", asm: x86.AMOVSD, reg: regInfo{ - inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB - 0, + 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 @@ -577,10 +575,9 @@ var opcodeTable = [...]opInfo{ name: "MOVSSloadidx4", asm: x86.AMOVSS, reg: regInfo{ - inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 0, + 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 @@ -591,10 +588,9 @@ var opcodeTable = [...]opInfo{ name: "MOVSDloadidx8", asm: x86.AMOVSD, reg: regInfo{ - inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 0, + 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 @@ -605,10 +601,9 @@ var opcodeTable = [...]opInfo{ name: "MOVSSstore", asm: x86.AMOVSS, reg: regInfo{ - inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB - 4294901760, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15 - 0, + 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 }, }, }, @@ -616,10 +611,9 @@ var opcodeTable = [...]opInfo{ name: "MOVSDstore", asm: x86.AMOVSD, reg: regInfo{ - inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB - 4294901760, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15 - 0, + 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 }, }, }, @@ -627,11 +621,10 @@ var opcodeTable = [...]opInfo{ name: "MOVSSstoreidx4", asm: x86.AMOVSS, reg: regInfo{ - inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 4294901760, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15 - 0, + 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 }, }, }, @@ -639,11 +632,10 @@ var opcodeTable = [...]opInfo{ name: "MOVSDstoreidx8", asm: x86.AMOVSD, reg: regInfo{ - inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 4294901760, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15 - 0, + 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 }, }, }, @@ -651,10 +643,11 @@ var opcodeTable = [...]opInfo{ name: "ADDQ", asm: x86.AADDQ, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -664,10 +657,11 @@ var opcodeTable = [...]opInfo{ name: "ADDL", asm: x86.AADDL, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -677,10 +671,11 @@ var opcodeTable = [...]opInfo{ name: "ADDW", asm: x86.AADDW, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -690,10 +685,11 @@ var opcodeTable = [...]opInfo{ name: "ADDB", asm: x86.AADDB, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -703,9 +699,10 @@ var opcodeTable = [...]opInfo{ name: "ADDQconst", asm: x86.AADDQ, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -715,9 +712,10 @@ var opcodeTable = [...]opInfo{ name: "ADDLconst", asm: x86.AADDL, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -727,9 +725,10 @@ var opcodeTable = [...]opInfo{ name: "ADDWconst", asm: x86.AADDW, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -739,9 +738,10 @@ var opcodeTable = [...]opInfo{ name: "ADDBconst", asm: x86.AADDB, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -751,10 +751,11 @@ var opcodeTable = [...]opInfo{ name: "SUBQ", asm: x86.ASUBQ, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -764,10 +765,11 @@ var opcodeTable = [...]opInfo{ name: "SUBL", asm: x86.ASUBL, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -777,10 +779,11 @@ var opcodeTable = [...]opInfo{ name: "SUBW", asm: x86.ASUBW, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -790,10 +793,11 @@ var opcodeTable = [...]opInfo{ name: "SUBB", asm: x86.ASUBB, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -803,9 +807,10 @@ var opcodeTable = [...]opInfo{ name: "SUBQconst", asm: x86.ASUBQ, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -815,9 +820,10 @@ var opcodeTable = [...]opInfo{ name: "SUBLconst", asm: x86.ASUBL, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -827,9 +833,10 @@ var opcodeTable = [...]opInfo{ name: "SUBWconst", asm: x86.ASUBW, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -839,9 +846,10 @@ var opcodeTable = [...]opInfo{ name: "SUBBconst", asm: x86.ASUBB, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -851,10 +859,11 @@ var opcodeTable = [...]opInfo{ name: "MULQ", asm: x86.AIMULQ, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -864,10 +873,11 @@ var opcodeTable = [...]opInfo{ name: "MULL", asm: x86.AIMULL, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -877,10 +887,11 @@ var opcodeTable = [...]opInfo{ name: "MULW", asm: x86.AIMULW, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -890,10 +901,11 @@ var opcodeTable = [...]opInfo{ name: "MULB", asm: x86.AIMULW, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -903,9 +915,10 @@ var opcodeTable = [...]opInfo{ name: "MULQconst", asm: x86.AIMULQ, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -915,9 +928,10 @@ var opcodeTable = [...]opInfo{ name: "MULLconst", asm: x86.AIMULL, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -927,9 +941,10 @@ var opcodeTable = [...]opInfo{ name: "MULWconst", asm: x86.AIMULW, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -939,9 +954,10 @@ var opcodeTable = [...]opInfo{ name: "MULBconst", asm: x86.AIMULW, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -951,10 +967,11 @@ var opcodeTable = [...]opInfo{ name: "ANDQ", asm: x86.AANDQ, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -964,10 +981,11 @@ var opcodeTable = [...]opInfo{ name: "ANDL", asm: x86.AANDL, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -977,10 +995,11 @@ var opcodeTable = [...]opInfo{ name: "ANDW", asm: x86.AANDW, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -990,10 +1009,11 @@ var opcodeTable = [...]opInfo{ name: "ANDB", asm: x86.AANDB, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -1003,9 +1023,10 @@ var opcodeTable = [...]opInfo{ name: "ANDQconst", asm: x86.AANDQ, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -1015,9 +1036,10 @@ var opcodeTable = [...]opInfo{ name: "ANDLconst", asm: x86.AANDL, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -1027,9 +1049,10 @@ var opcodeTable = [...]opInfo{ name: "ANDWconst", asm: x86.AANDW, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -1039,9 +1062,10 @@ var opcodeTable = [...]opInfo{ name: "ANDBconst", asm: x86.AANDB, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -1051,10 +1075,11 @@ var opcodeTable = [...]opInfo{ name: "ORQ", asm: x86.AORQ, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -1064,10 +1089,11 @@ var opcodeTable = [...]opInfo{ name: "ORL", asm: x86.AORL, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -1077,10 +1103,11 @@ var opcodeTable = [...]opInfo{ name: "ORW", asm: x86.AORW, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -1090,10 +1117,11 @@ var opcodeTable = [...]opInfo{ name: "ORB", asm: x86.AORB, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -1103,9 +1131,10 @@ var opcodeTable = [...]opInfo{ name: "ORQconst", asm: x86.AORQ, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -1115,9 +1144,10 @@ var opcodeTable = [...]opInfo{ name: "ORLconst", asm: x86.AORL, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -1127,9 +1157,10 @@ var opcodeTable = [...]opInfo{ name: "ORWconst", asm: x86.AORW, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -1139,9 +1170,10 @@ var opcodeTable = [...]opInfo{ name: "ORBconst", asm: x86.AORB, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -1151,10 +1183,11 @@ var opcodeTable = [...]opInfo{ name: "XORQ", asm: x86.AXORQ, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -1164,10 +1197,11 @@ var opcodeTable = [...]opInfo{ name: "XORL", asm: x86.AXORL, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -1177,10 +1211,11 @@ var opcodeTable = [...]opInfo{ name: "XORW", asm: x86.AXORW, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -1190,10 +1225,11 @@ var opcodeTable = [...]opInfo{ name: "XORB", asm: x86.AXORB, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -1203,9 +1239,10 @@ var opcodeTable = [...]opInfo{ name: "XORQconst", asm: x86.AXORQ, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -1215,9 +1252,10 @@ var opcodeTable = [...]opInfo{ name: "XORLconst", asm: x86.AXORL, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -1227,9 +1265,10 @@ var opcodeTable = [...]opInfo{ name: "XORWconst", asm: x86.AXORW, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -1239,9 +1278,10 @@ var opcodeTable = [...]opInfo{ name: "XORBconst", asm: x86.AXORB, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -1251,9 +1291,9 @@ var opcodeTable = [...]opInfo{ name: "CMPQ", asm: x86.ACMPQ, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 @@ -1264,9 +1304,9 @@ var opcodeTable = [...]opInfo{ name: "CMPL", asm: x86.ACMPL, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 @@ -1277,9 +1317,9 @@ var opcodeTable = [...]opInfo{ name: "CMPW", asm: x86.ACMPW, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 @@ -1290,9 +1330,9 @@ var opcodeTable = [...]opInfo{ name: "CMPB", asm: x86.ACMPB, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 @@ -1303,8 +1343,8 @@ var opcodeTable = [...]opInfo{ name: "CMPQconst", asm: x86.ACMPQ, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + inputs: []inputInfo{ + {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, outputs: []regMask{ 8589934592, // .FLAGS @@ -1315,8 +1355,8 @@ var opcodeTable = [...]opInfo{ name: "CMPLconst", asm: x86.ACMPL, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + inputs: []inputInfo{ + {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, outputs: []regMask{ 8589934592, // .FLAGS @@ -1327,8 +1367,8 @@ var opcodeTable = [...]opInfo{ name: "CMPWconst", asm: x86.ACMPW, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + inputs: []inputInfo{ + {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, outputs: []regMask{ 8589934592, // .FLAGS @@ -1339,8 +1379,8 @@ var opcodeTable = [...]opInfo{ name: "CMPBconst", asm: x86.ACMPB, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + inputs: []inputInfo{ + {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, outputs: []regMask{ 8589934592, // .FLAGS @@ -1351,9 +1391,9 @@ var opcodeTable = [...]opInfo{ name: "TESTQ", asm: x86.ATESTQ, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 @@ -1364,9 +1404,9 @@ var opcodeTable = [...]opInfo{ name: "TESTL", asm: x86.ATESTL, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 @@ -1377,9 +1417,9 @@ var opcodeTable = [...]opInfo{ name: "TESTW", asm: x86.ATESTW, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 @@ -1390,9 +1430,9 @@ var opcodeTable = [...]opInfo{ name: "TESTB", asm: x86.ATESTB, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 @@ -1403,8 +1443,8 @@ var opcodeTable = [...]opInfo{ name: "TESTQconst", asm: x86.ATESTQ, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + inputs: []inputInfo{ + {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, outputs: []regMask{ 8589934592, // .FLAGS @@ -1415,8 +1455,8 @@ var opcodeTable = [...]opInfo{ name: "TESTLconst", asm: x86.ATESTL, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + inputs: []inputInfo{ + {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, outputs: []regMask{ 8589934592, // .FLAGS @@ -1427,8 +1467,8 @@ var opcodeTable = [...]opInfo{ name: "TESTWconst", asm: x86.ATESTW, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + inputs: []inputInfo{ + {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, outputs: []regMask{ 8589934592, // .FLAGS @@ -1439,8 +1479,8 @@ var opcodeTable = [...]opInfo{ name: "TESTBconst", asm: x86.ATESTB, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + inputs: []inputInfo{ + {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, outputs: []regMask{ 8589934592, // .FLAGS @@ -1451,10 +1491,11 @@ var opcodeTable = [...]opInfo{ name: "SHLQ", asm: x86.ASHLQ, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 2, // .CX + 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 }, @@ -1464,10 +1505,11 @@ var opcodeTable = [...]opInfo{ name: "SHLL", asm: x86.ASHLL, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 2, // .CX + 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 }, @@ -1477,10 +1519,11 @@ var opcodeTable = [...]opInfo{ name: "SHLW", asm: x86.ASHLW, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 2, // .CX + 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 }, @@ -1490,10 +1533,11 @@ var opcodeTable = [...]opInfo{ name: "SHLB", asm: x86.ASHLB, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 2, // .CX + 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 }, @@ -1503,9 +1547,10 @@ var opcodeTable = [...]opInfo{ name: "SHLQconst", asm: x86.ASHLQ, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -1515,9 +1560,10 @@ var opcodeTable = [...]opInfo{ name: "SHLLconst", asm: x86.ASHLL, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -1527,9 +1573,10 @@ var opcodeTable = [...]opInfo{ name: "SHLWconst", asm: x86.ASHLW, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -1539,9 +1586,10 @@ var opcodeTable = [...]opInfo{ name: "SHLBconst", asm: x86.ASHLB, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -1551,10 +1599,11 @@ var opcodeTable = [...]opInfo{ name: "SHRQ", asm: x86.ASHRQ, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 2, // .CX + 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 }, @@ -1564,10 +1613,11 @@ var opcodeTable = [...]opInfo{ name: "SHRL", asm: x86.ASHRL, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 2, // .CX + 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 }, @@ -1577,10 +1627,11 @@ var opcodeTable = [...]opInfo{ name: "SHRW", asm: x86.ASHRW, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 2, // .CX + 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 }, @@ -1590,10 +1641,11 @@ var opcodeTable = [...]opInfo{ name: "SHRB", asm: x86.ASHRB, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 2, // .CX + 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 }, @@ -1603,9 +1655,10 @@ var opcodeTable = [...]opInfo{ name: "SHRQconst", asm: x86.ASHRQ, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -1615,9 +1668,10 @@ var opcodeTable = [...]opInfo{ name: "SHRLconst", asm: x86.ASHRL, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -1627,9 +1681,10 @@ var opcodeTable = [...]opInfo{ name: "SHRWconst", asm: x86.ASHRW, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -1639,9 +1694,10 @@ var opcodeTable = [...]opInfo{ name: "SHRBconst", asm: x86.ASHRB, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -1651,10 +1707,11 @@ var opcodeTable = [...]opInfo{ name: "SARQ", asm: x86.ASARQ, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 2, // .CX + 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 }, @@ -1664,10 +1721,11 @@ var opcodeTable = [...]opInfo{ name: "SARL", asm: x86.ASARL, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 2, // .CX + 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 }, @@ -1677,10 +1735,11 @@ var opcodeTable = [...]opInfo{ name: "SARW", asm: x86.ASARW, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 2, // .CX + 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 }, @@ -1690,10 +1749,11 @@ var opcodeTable = [...]opInfo{ name: "SARB", asm: x86.ASARB, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 2, // .CX + 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 }, @@ -1703,9 +1763,10 @@ var opcodeTable = [...]opInfo{ name: "SARQconst", asm: x86.ASARQ, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -1715,9 +1776,10 @@ var opcodeTable = [...]opInfo{ name: "SARLconst", asm: x86.ASARL, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -1727,9 +1789,10 @@ var opcodeTable = [...]opInfo{ name: "SARWconst", asm: x86.ASARW, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -1739,9 +1802,10 @@ var opcodeTable = [...]opInfo{ name: "SARBconst", asm: x86.ASARB, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -1751,9 +1815,10 @@ var opcodeTable = [...]opInfo{ name: "ROLQconst", asm: x86.AROLQ, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -1763,9 +1828,10 @@ var opcodeTable = [...]opInfo{ name: "ROLLconst", asm: x86.AROLL, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -1775,9 +1841,10 @@ var opcodeTable = [...]opInfo{ name: "ROLWconst", asm: x86.AROLW, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -1787,9 +1854,10 @@ var opcodeTable = [...]opInfo{ name: "ROLBconst", asm: x86.AROLB, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -1799,9 +1867,10 @@ var opcodeTable = [...]opInfo{ name: "NEGQ", asm: x86.ANEGQ, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -1811,9 +1880,10 @@ var opcodeTable = [...]opInfo{ name: "NEGL", asm: x86.ANEGL, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -1823,9 +1893,10 @@ var opcodeTable = [...]opInfo{ name: "NEGW", asm: x86.ANEGW, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -1835,9 +1906,10 @@ var opcodeTable = [...]opInfo{ name: "NEGB", asm: x86.ANEGB, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -1847,9 +1919,10 @@ var opcodeTable = [...]opInfo{ name: "NOTQ", asm: x86.ANOTQ, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -1859,9 +1932,10 @@ var opcodeTable = [...]opInfo{ name: "NOTL", asm: x86.ANOTL, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -1871,9 +1945,10 @@ var opcodeTable = [...]opInfo{ name: "NOTW", asm: x86.ANOTW, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -1883,9 +1958,10 @@ var opcodeTable = [...]opInfo{ name: "NOTB", asm: x86.ANOTB, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -1895,9 +1971,10 @@ var opcodeTable = [...]opInfo{ name: "SBBQcarrymask", asm: x86.ASBBQ, reg: regInfo{ - inputs: []regMask{ - 8589934592, // .FLAGS + inputs: []inputInfo{ + {0, 8589934592}, // .FLAGS }, + clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -1907,9 +1984,10 @@ var opcodeTable = [...]opInfo{ name: "SBBLcarrymask", asm: x86.ASBBL, reg: regInfo{ - inputs: []regMask{ - 8589934592, // .FLAGS + inputs: []inputInfo{ + {0, 8589934592}, // .FLAGS }, + clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -1919,9 +1997,10 @@ var opcodeTable = [...]opInfo{ name: "SETEQ", asm: x86.ASETEQ, reg: regInfo{ - inputs: []regMask{ - 8589934592, // .FLAGS + inputs: []inputInfo{ + {0, 8589934592}, // .FLAGS }, + clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -1931,9 +2010,10 @@ var opcodeTable = [...]opInfo{ name: "SETNE", asm: x86.ASETNE, reg: regInfo{ - inputs: []regMask{ - 8589934592, // .FLAGS + inputs: []inputInfo{ + {0, 8589934592}, // .FLAGS }, + clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -1943,9 +2023,10 @@ var opcodeTable = [...]opInfo{ name: "SETL", asm: x86.ASETLT, reg: regInfo{ - inputs: []regMask{ - 8589934592, // .FLAGS + inputs: []inputInfo{ + {0, 8589934592}, // .FLAGS }, + clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -1955,9 +2036,10 @@ var opcodeTable = [...]opInfo{ name: "SETLE", asm: x86.ASETLE, reg: regInfo{ - inputs: []regMask{ - 8589934592, // .FLAGS + inputs: []inputInfo{ + {0, 8589934592}, // .FLAGS }, + clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -1967,9 +2049,10 @@ var opcodeTable = [...]opInfo{ name: "SETG", asm: x86.ASETGT, reg: regInfo{ - inputs: []regMask{ - 8589934592, // .FLAGS + inputs: []inputInfo{ + {0, 8589934592}, // .FLAGS }, + clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -1979,9 +2062,10 @@ var opcodeTable = [...]opInfo{ name: "SETGE", asm: x86.ASETGE, reg: regInfo{ - inputs: []regMask{ - 8589934592, // .FLAGS + inputs: []inputInfo{ + {0, 8589934592}, // .FLAGS }, + clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -1991,9 +2075,10 @@ var opcodeTable = [...]opInfo{ name: "SETB", asm: x86.ASETCS, reg: regInfo{ - inputs: []regMask{ - 8589934592, // .FLAGS + inputs: []inputInfo{ + {0, 8589934592}, // .FLAGS }, + clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -2003,9 +2088,10 @@ var opcodeTable = [...]opInfo{ name: "SETBE", asm: x86.ASETLS, reg: regInfo{ - inputs: []regMask{ - 8589934592, // .FLAGS + inputs: []inputInfo{ + {0, 8589934592}, // .FLAGS }, + clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -2015,9 +2101,10 @@ var opcodeTable = [...]opInfo{ name: "SETA", asm: x86.ASETHI, reg: regInfo{ - inputs: []regMask{ - 8589934592, // .FLAGS + inputs: []inputInfo{ + {0, 8589934592}, // .FLAGS }, + clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -2027,9 +2114,10 @@ var opcodeTable = [...]opInfo{ name: "SETAE", asm: x86.ASETCC, reg: regInfo{ - inputs: []regMask{ - 8589934592, // .FLAGS + inputs: []inputInfo{ + {0, 8589934592}, // .FLAGS }, + clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -2039,9 +2127,10 @@ var opcodeTable = [...]opInfo{ name: "MOVBQSX", asm: x86.AMOVBQSX, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -2051,9 +2140,10 @@ var opcodeTable = [...]opInfo{ name: "MOVBQZX", asm: x86.AMOVBQZX, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -2063,9 +2153,10 @@ var opcodeTable = [...]opInfo{ name: "MOVWQSX", asm: x86.AMOVWQSX, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -2075,9 +2166,10 @@ var opcodeTable = [...]opInfo{ name: "MOVWQZX", asm: x86.AMOVWQZX, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -2087,9 +2179,10 @@ var opcodeTable = [...]opInfo{ name: "MOVLQSX", asm: x86.AMOVLQSX, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -2099,9 +2192,10 @@ var opcodeTable = [...]opInfo{ name: "MOVLQZX", asm: x86.AMOVLQZX, reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, @@ -2111,6 +2205,7 @@ var opcodeTable = [...]opInfo{ name: "MOVBconst", asm: x86.AMOVB, reg: regInfo{ + clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -2120,6 +2215,7 @@ var opcodeTable = [...]opInfo{ name: "MOVWconst", asm: x86.AMOVW, reg: regInfo{ + clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -2129,6 +2225,7 @@ var opcodeTable = [...]opInfo{ name: "MOVLconst", asm: x86.AMOVL, reg: regInfo{ + clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -2138,6 +2235,7 @@ var opcodeTable = [...]opInfo{ name: "MOVQconst", asm: x86.AMOVQ, reg: regInfo{ + clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -2146,9 +2244,10 @@ var opcodeTable = [...]opInfo{ { name: "LEAQ", reg: regInfo{ - inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB + inputs: []inputInfo{ + {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB }, + clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -2157,10 +2256,11 @@ var opcodeTable = [...]opInfo{ { name: "LEAQ1", reg: regInfo{ - inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, + clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -2169,10 +2269,11 @@ var opcodeTable = [...]opInfo{ { name: "LEAQ2", reg: regInfo{ - inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, + clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -2181,10 +2282,11 @@ var opcodeTable = [...]opInfo{ { name: "LEAQ4", reg: regInfo{ - inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, + clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -2193,10 +2295,11 @@ var opcodeTable = [...]opInfo{ { name: "LEAQ8", reg: regInfo{ - inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + 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 }, + clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -2206,9 +2309,8 @@ var opcodeTable = [...]opInfo{ name: "MOVBload", asm: x86.AMOVB, reg: regInfo{ - inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB - 0, + 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 @@ -2219,9 +2321,8 @@ var opcodeTable = [...]opInfo{ name: "MOVBQSXload", asm: x86.AMOVBQSX, reg: regInfo{ - inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB - 0, + 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 @@ -2232,9 +2333,8 @@ var opcodeTable = [...]opInfo{ name: "MOVBQZXload", asm: x86.AMOVBQZX, reg: regInfo{ - inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB - 0, + 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 @@ -2245,9 +2345,8 @@ var opcodeTable = [...]opInfo{ name: "MOVWload", asm: x86.AMOVW, reg: regInfo{ - inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB - 0, + 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 @@ -2258,9 +2357,8 @@ var opcodeTable = [...]opInfo{ name: "MOVLload", asm: x86.AMOVL, reg: regInfo{ - inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB - 0, + 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 @@ -2271,9 +2369,8 @@ var opcodeTable = [...]opInfo{ name: "MOVQload", asm: x86.AMOVQ, reg: regInfo{ - inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB - 0, + 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 @@ -2284,10 +2381,9 @@ var opcodeTable = [...]opInfo{ name: "MOVQloadidx8", asm: x86.AMOVQ, reg: regInfo{ - inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 0, + 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 @@ -2298,10 +2394,9 @@ var opcodeTable = [...]opInfo{ name: "MOVBstore", asm: x86.AMOVB, reg: regInfo{ - inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 0, + 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 }, }, }, @@ -2309,10 +2404,9 @@ var opcodeTable = [...]opInfo{ name: "MOVWstore", asm: x86.AMOVW, reg: regInfo{ - inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 0, + 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 }, }, }, @@ -2320,10 +2414,9 @@ var opcodeTable = [...]opInfo{ name: "MOVLstore", asm: x86.AMOVL, reg: regInfo{ - inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 0, + 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 }, }, }, @@ -2331,10 +2424,9 @@ var opcodeTable = [...]opInfo{ name: "MOVQstore", asm: x86.AMOVQ, reg: regInfo{ - inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 0, + 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 }, }, }, @@ -2342,54 +2434,54 @@ var opcodeTable = [...]opInfo{ name: "MOVQstoreidx8", asm: x86.AMOVQ, reg: regInfo{ - inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 0, + 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: "MOVXzero", reg: regInfo{ - inputs: []regMask{ - 4295032831, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB - 0, + inputs: []inputInfo{ + {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB }, }, }, { name: "REPSTOSQ", reg: regInfo{ - inputs: []regMask{ - 128, // .DI - 2, // .CX + inputs: []inputInfo{ + {0, 128}, // .DI + {1, 2}, // .CX }, clobbers: 131, // .AX .CX .DI }, }, { name: "CALLstatic", - reg: regInfo{}, + 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", reg: regInfo{ - inputs: []regMask{ - 65535, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - 4, // .DX - 0, + 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: "REPMOVSB", reg: regInfo{ - inputs: []regMask{ - 128, // .DI - 64, // .SI - 2, // .CX + inputs: []inputInfo{ + {0, 128}, // .DI + {1, 64}, // .SI + {2, 2}, // .CX }, clobbers: 194, // .CX .SI .DI }, @@ -2405,6 +2497,7 @@ var opcodeTable = [...]opInfo{ { name: "LoweredGetG", reg: regInfo{ + clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index b8a2f24c33..d593faf95b 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -2,22 +2,132 @@ // 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 "sort" +import ( + "fmt" + "unsafe" +) -func setloc(home []Location, v *Value, loc Location) []Location { - for v.ID >= ID(len(home)) { - home = append(home, nil) - } - home[v.ID] = loc - return home +const regDebug = 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 uint +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 @@ -84,343 +194,719 @@ func pickReg(r regMask) register { } } -// regalloc performs register allocation on f. It sets f.RegAlloc -// to the resulting allocation. -func regalloc(f *Func) { - // For now, a very simple allocator. Everything has a home - // location on the stack (TBD as a subsequent stackalloc pass). - // Values live in the home locations at basic block boundaries. - // We use a simple greedy allocator within a basic block. - home := make([]Location, f.NumValues()) +// A use is a record of a position (2*pc for value uses, odd numbers for other uses) +// and a value ID that is used at that position. +type use struct { + idx int32 + vid ID +} - addPhiCopies(f) // add copies of phi inputs in preceeding blocks +type valState struct { + regs regMask // the set of registers holding a Value (usually just one) + uses []int32 // sorted list of places where Value is used + usestorage [2]int32 + spill *Value // spilled copy of the Value + spill2 *Value // special alternate spill location used for phi resolution + spillUsed bool + spill2used bool +} - // Compute live values at the end of each block. - live := live(f) - lastUse := make([]int, f.NumValues()) +type regState struct { + v *Value // Original (preregalloc) Value stored in this register. + c *Value // A Value equal to v which is currently in register. Might be v or a copy of it. + // If a register is unused, v==c==nil +} - var oldSched []*Value +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 on each edge. live[b.ID][idx] is a list of value IDs + // which are live on b's idx'th successor edge. + live [][][]ID + + // current state of each (preregalloc) Value + values []valState + + // 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 + + // An ordered list (by idx) of all uses in the function + uses []use - // Hack to find sp and sb Values and assign them a register. - // TODO: make not so hacky; update the tighten pass when this is done - var sp, sb *Value - for _, v := range f.Entry.Values { - switch v.Op { - case OpSP: - sp = v - home = setloc(home, v, ®isters[4]) // TODO: arch-dependent - case OpSB: - sb = v - home = setloc(home, v, ®isters[32]) // TODO: arch-dependent + // Home locations (registers) for Values + home []Location + + // current block we're working on + curBlock *Block +} + +// 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 %d (dump %s/%s)\n", r, 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)) + } +} + +func (s *regAllocState) setHome(v *Value, r register) { + // Remember assignment. + for int(v.ID) >= len(s.home) { + s.home = append(s.home, nil) + s.home = s.home[:cap(s.home)] + } + s.home[v.ID] = ®isters[r] +} +func (s *regAllocState) getHome(v *Value) register { + if int(v.ID) >= len(s.home) || s.home[v.ID] == nil { + return noRegister + } + return register(s.home[v.ID].(*Register).Num) +} + +// 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 %d %s/%s\n", r, 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.setHome(c, r) +} + +// allocReg picks an unused register from regmask. If there is no unused register, +// a Value will be kicked out of a register to make room. +func (s *regAllocState) allocReg(mask regMask) register { + // Pick a register to use. + mask &^= s.nospill + if mask == 0 { + s.f.Fatalf("no register available") + } + + var r register + if unused := mask & ^s.used; unused != 0 { + // Pick an unused register. + return pickReg(unused) + // TODO: use affinity graph to pick a good register + } + // 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. + mask &^= 1<<4 | 1<<32 // don't spill SP or SB + maxuse := int32(-1) + for t := register(0); t < numRegs; t++ { + if mask>>t&1 == 0 { + continue + } + v := s.regs[t].v + if len(s.values[v.ID].uses) == 0 { + // This can happen when fixing up merge blocks at the end. + // We've already run through the use lists so they are empty. + // Any register would be ok at this point. + r = t + maxuse = 0 + break } + if n := s.values[v.ID].uses[0]; n > maxuse { + 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) *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 + } + + // SP and SB are allocated specially. No regular value should + // be allocated to them. + mask &^= 1<<4 | 1<<32 + + // Allocate a register. + r := s.allocReg(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(v.Line, OpCopy, v.Type, s.regs[r2].c) + } else { + // Load v from its spill location. + // TODO: rematerialize if we can. + if vi.spill2 != nil { + c = s.curBlock.NewValue1(v.Line, OpLoadReg, v.Type, vi.spill2) + vi.spill2used = true + } else { + c = s.curBlock.NewValue1(v.Line, OpLoadReg, v.Type, vi.spill) + vi.spillUsed = true + } + if v.Type.IsFlags() { + v.Unimplementedf("spill of flags not implemented yet") + } + } + 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()) + for i := range s.values { + s.values[i].uses = s.values[i].usestorage[:0] } + s.live = f.live() - // Register allocate each block separately. All live values will live - // in home locations (stack slots) between blocks. + // 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) + } - // Compute the index of the last use of each Value in the Block. - // Scheduling has already happened, so Values are totally ordered. - // lastUse[x] = max(i) where b.Value[i] uses Value x. - for i, v := range b.Values { - lastUse[v.ID] = -1 - for _, w := range v.Args { - // could condition this store on w.Block == b, but no need - lastUse[w.ID] = i + // Compute uses. We assign a PC to each Value in the program, in f.Blocks + // and then b.Values order. Uses are recorded using this numbering. + // Uses by Values are recorded as 2*PC. Special uses (block control values, + // pseudo-uses for backedges) are recorded as 2*(last PC in block)+1. + var pc int32 + for _, b := range f.Blocks { + // uses in regular Values + for _, v := range b.Values { + for _, a := range v.Args { + s.values[a.ID].uses = append(s.values[a.ID].uses, pc*2) + s.uses = append(s.uses, use{pc * 2, a.ID}) } + pc++ } - // Values which are live at block exit have a lastUse of len(b.Values). + // use as a block control value + endIdx := pc*2 - 1 if b.Control != nil { - lastUse[b.Control.ID] = len(b.Values) + s.values[b.Control.ID].uses = append(s.values[b.Control.ID].uses, endIdx) + s.uses = append(s.uses, use{endIdx, b.Control.ID}) } - // Values live after block exit have a lastUse of len(b.Values)+1. - for _, vid := range live[b.ID] { - lastUse[vid] = len(b.Values) + 1 + // uses by backedges + // Backedges are treated as uses so that the uses span the entire live + // range of the value. + for i, c := range b.Succs { + if blockOrder[c.ID] > blockOrder[b.ID] { + continue // forward edge + } + for _, vid := range s.live[b.ID][i] { + s.values[vid].uses = append(s.values[vid].uses, endIdx) + s.uses = append(s.uses, use{endIdx, vid}) + } } + } + if pc*2 < 0 { + f.Fatalf("pc too large: function too big") + } +} - // For each register, store which value it contains - type regInfo struct { - v *Value // stack-homed original value (or nil if empty) - c *Value // the register copy of v - dirty bool // if the stack-homed copy is out of date +// clearUses drops any uses <= useIdx. Any values which have no future +// uses are dropped from registers. +func (s *regAllocState) clearUses(useIdx int32) { + for len(s.uses) > 0 && s.uses[0].idx <= useIdx { + idx := s.uses[0].idx + vid := s.uses[0].vid + s.uses = s.uses[1:] + + vi := &s.values[vid] + if vi.uses[0] != idx { + s.f.Fatalf("use mismatch for v%d\n", vid) } - regs := make([]regInfo, numRegs) + vi.uses = vi.uses[1:] + if len(vi.uses) != 0 { + continue + } + // Value is dead, free all registers that hold it (except SP & SB). + s.freeRegs(vi.regs &^ (1<<4 | 1<<32)) + } +} - // TODO: hack: initialize fixed registers - regs[4] = regInfo{sp, sp, false} - regs[32] = regInfo{sb, sb, false} +// Sets the state of the registers to that encoded in state. +func (s *regAllocState) setState(state []regState) { + s.freeRegs(s.used) + for r, x := range state { + if x.c == nil { + continue + } + s.assignReg(register(r), x.v, x.c) + } +} - var used regMask // has a 1 for each non-nil entry in regs - var dirty regMask // has a 1 for each dirty entry in regs +func (s *regAllocState) regalloc(f *Func) { + liveset := newSparseSet(f.NumValues()) + argset := newSparseSet(f.NumValues()) + var oldSched []*Value + var phis []*Value + var stackPhis []*Value + var regPhis []*Value + + if f.Entry != f.Blocks[0] { + f.Fatalf("entry block must be first") + } + + var phiRegs []register + + // For each merge block, we record the starting register state (after phi ops) + // for that merge block. Indexed by blockid/regnum. + startRegs := make([][]*Value, f.NumBlocks()) + // end state of registers for each block, idexed by blockid/regnum. + endRegs := make([][]regState, f.NumBlocks()) + var pc int32 + for _, b := range f.Blocks { + s.curBlock = b - oldSched = append(oldSched[:0], b.Values...) + // 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] - for idx, v := range oldSched { - // For each instruction, do: - // set up inputs to v in registers - // pick output register - // run insn - // mark output register as dirty - // Note that v represents the Value at "home" (on the stack), and c - // is its register equivalent. There are two ways to establish c: - // - use of v. c will be a load from v's home. - // - definition of v. c will be identical to v but will live in - // a register. v will be modified into a spill of c. - regspec := opcodeTable[v.Op].reg - if v.Op == OpCopy { - // TODO: make this less of a hack - regspec = opcodeTable[OpAMD64ADDQconst].reg + // Initialize start state of block. + if b == f.Entry { + // Regalloc state is empty to start. + if nphi > 0 { + f.Fatalf("phis in entry block") } - inputs := regspec.inputs - outputs := regspec.outputs - if len(inputs) == 0 && len(outputs) == 0 { - // No register allocation required (or none specified yet) + } else if len(b.Preds) == 1 { + // Start regalloc state with the end state of the previous block. + s.setState(endRegs[b.Preds[0].ID]) + if nphi > 0 { + f.Fatalf("phis in single-predecessor block") + } + } 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(endRegs[p.ID]) + + // Drop anything not live on the c->b edge. + var idx2 int + for idx2 = 0; idx2 < len(p.Succs); idx2++ { + if p.Succs[idx2] == b { + break + } + } + liveset.clear() + liveset.addAll(s.live[p.ID][idx2]) + for r := register(0); r < numRegs; r++ { + v := s.regs[r].v + if v == nil { + continue + } + if !liveset.contains(v.ID) { + s.freeReg(r) + } + } + + // 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 used regMask + for _, v := range phis { + if v.Type.IsMemory() { + phiRegs = append(phiRegs, noRegister) + continue + } + regs := s.values[v.Args[idx].ID].regs + m := regs &^ used + var r register + if m != 0 { + r = pickReg(m) + used |= regMask(1) << r + } else { + r = noRegister + } + phiRegs = append(phiRegs, r) + } + // Change register user from phi input to phi. Add phi spill code. + for i, v := range phis { + if v.Type.IsMemory() { + 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 + // Transfer ownership of register from input arg to phi. + s.freeReg(r) + 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.values[v.ID].spill = spill + s.values[v.ID].spillUsed = false + } + + // Save the starting state for use by incoming edges below. + startRegs[b.ID] = make([]*Value, numRegs) + for r := register(0); r < numRegs; r++ { + startRegs[b.ID][r] = s.regs[r].v + } + } + + // Process all the non-phi values. + pc += int32(nphi) + for _, v := range oldSched { + 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) + pc++ continue } - if v.Op == OpCopy && v.Type.IsMemory() { + if v.Op == OpSB { + s.assignReg(32, v, v) // TODO: arch-dependent b.Values = append(b.Values, v) + pc++ continue } - - // Compute a good input ordering. Start with the most constrained input. - order := make([]intPair, len(inputs)) - for i, input := range inputs { - order[i] = intPair{countRegs(input), i} + s.clearUses(pc*2 - 1) + regspec := opcodeTable[v.Op].reg + if regDebug { + fmt.Printf("%d: working on %s %s %v\n", pc, v, v.LongString(), regspec) + } + 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) + pc++ + continue } - sort.Sort(byKey(order)) - // nospill contains registers that we can't spill because - // we already set them up for use by the current instruction. - var nospill regMask - nospill |= 0x100000010 // SP & SB can't be spilled (TODO: arch-specific) + // TODO: If value is rematerializeable, don't issue it here. + // Instead, rely on argument loading code to put it in a register when needed. - // Move inputs into registers - for _, o := range order { - w := v.Args[o.val] - mask := inputs[o.val] - if mask == 0 { - // Input doesn't need a register - continue - } - // TODO: 2-address overwrite instructions + // Move arguments to registers + for _, i := range regspec.inputs { + a := v.Args[i.idx] + v.Args[i.idx] = s.allocValToReg(a, i.regs, true) + } - // Find registers that w is already in - var wreg regMask - for r := register(0); r < numRegs; r++ { - if regs[r].v == w { - wreg |= regMask(1) << r - } - } + // Now that all args are in regs, we're ready to issue the value itself. + // Before we pick a register for the 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.clearUses(pc * 2) + + // Dump any registers which will be clobbered + s.freeRegs(regspec.clobbers) + + // Pick register for output. + var r register + var mask regMask + if len(regspec.outputs) > 0 { + mask = regspec.outputs[0] + } + if mask != 0 { + r = s.allocReg(mask) + s.assignReg(r, v, v) + } - var r register - if mask&wreg != 0 { - // w is already in an allowed register. We're done. - r = pickReg(mask & wreg) - } else { - // Pick a register for w - // Priorities (in order) - // - an unused register - // - a clean register - // - a dirty register - // TODO: for used registers, pick the one whose next use is the - // farthest in the future. - mask &^= nospill - if mask & ^dirty != 0 { - mask &^= dirty - } - if mask & ^used != 0 { - mask &^= used - } - r = pickReg(mask) - - // Kick out whomever is using this register. - if regs[r].v != nil { - x := regs[r].v - c := regs[r].c - if regs[r].dirty && lastUse[x.ID] >= idx { - // Write x back to home. Its value is currently held in c. - x.Op = OpStoreReg - x.Aux = nil - x.resetArgs() - x.AddArg(c) - b.Values = append(b.Values, x) - regs[r].dirty = false - dirty &^= regMask(1) << r - } - regs[r].v = nil - regs[r].c = nil - used &^= regMask(1) << r - } + // Issue the Value itself. + b.Values = append(b.Values, v) - // Load w into this register - var c *Value - if len(w.Args) == 0 { - // Materialize w - if w.Op == OpSB { - c = w - } else if w.Op == OpSP { - c = b.NewValue1(w.Line, OpCopy, w.Type, w) - } else { - c = b.NewValue0IA(w.Line, w.Op, w.Type, w.AuxInt, w.Aux) - } - } else if len(w.Args) == 1 && (w.Args[0].Op == OpSP || w.Args[0].Op == OpSB) { - // Materialize offsets from SP/SB - c = b.NewValue1IA(w.Line, w.Op, w.Type, w.AuxInt, w.Aux, w.Args[0]) - } else if wreg != 0 { - // Copy from another register. - // Typically just an optimization, but this is - // required if w is dirty. - s := pickReg(wreg) - // inv: s != r - c = b.NewValue1(w.Line, OpCopy, w.Type, regs[s].c) - } else { - // Load from home location - c = b.NewValue1(w.Line, OpLoadReg, w.Type, w) - } - home = setloc(home, c, ®isters[r]) - // Remember what we did - regs[r].v = w - regs[r].c = c - regs[r].dirty = false - used |= regMask(1) << r - } + // Issue a spill for this value. We issue spills unconditionally, + // then at the end of regalloc delete the ones we never use. + spill := b.NewValue1(v.Line, OpStoreReg, v.Type, v) + s.values[v.ID].spill = spill + s.values[v.ID].spillUsed = false - // Replace w with its in-register copy. - v.SetArg(o.val, regs[r].c) + // Increment pc for next Value. + pc++ + } - // Remember not to undo this register assignment until after - // the instruction is issued. - nospill |= regMask(1) << r - } + // Load control value into reg + if b.Control != nil && !b.Control.Type.IsMemory() { + // TODO: regspec for block control values, instead of using + // register set from the control op's output. + s.allocValToReg(b.Control, opcodeTable[b.Control.Op].reg.outputs[0], false) + } - // TODO: do any clobbering + // Record endRegs + endRegs[b.ID] = make([]regState, numRegs) + copy(endRegs[b.ID], s.regs) - // pick a register for v itself. - if len(outputs) > 1 { - panic("can't do multi-output yet") + // Allow control Values and Values live only on backedges to be dropped. + s.clearUses(pc*2 - 1) + } + + // Process merge block input edges. They are the tricky ones. + dst := make([]*Value, numRegs) + for _, b := range f.Blocks { + if len(b.Preds) <= 1 { + continue + } + for i, p := range b.Preds { + if regDebug { + fmt.Printf("processing %s->%s\n", p, b) } - if len(outputs) == 0 || outputs[0] == 0 { - // output doesn't need a register - b.Values = append(b.Values, v) - } else { - mask := outputs[0] - if mask & ^dirty != 0 { - mask &^= dirty + + // Find phis, separate them into stack & register classes. + stackPhis = stackPhis[:0] + regPhis = regPhis[:0] + for _, v := range b.Values { + if v.Op != OpPhi { + break } - if mask & ^used != 0 { - mask &^= used + if v.Type.IsMemory() { + continue } - r := pickReg(mask) - - // Kick out whomever is using this register. - if regs[r].v != nil { - x := regs[r].v - c := regs[r].c - if regs[r].dirty && lastUse[x.ID] >= idx { - // Write x back to home. Its value is currently held in c. - x.Op = OpStoreReg - x.Aux = nil - x.resetArgs() - x.AddArg(c) - b.Values = append(b.Values, x) - regs[r].dirty = false - dirty &^= regMask(1) << r - } - regs[r].v = nil - regs[r].c = nil - used &^= regMask(1) << r + if s.getHome(v) != noRegister { + regPhis = append(regPhis, v) + } else { + stackPhis = append(stackPhis, v) } - - // Reissue v with new op, with r as its home. - c := b.NewValue0IA(v.Line, v.Op, v.Type, v.AuxInt, v.Aux) - c.AddArgs(v.Args...) - home = setloc(home, c, ®isters[r]) - - // Remember what we did - regs[r].v = v - regs[r].c = c - regs[r].dirty = true - used |= regMask(1) << r - dirty |= regMask(1) << r } - } - // If the block ends in a call, we must put the call after the spill code. - var call *Value - if b.Kind == BlockCall { - call = b.Control - if call != b.Values[len(b.Values)-1] { - b.Fatalf("call not at end of block %v %v", b, call) + // Start with the state that exists at the end of the + // predecessor block. We'll be adding instructions here + // to shuffle registers & stack phis into the right spot. + s.setState(endRegs[p.ID]) + s.curBlock = p + + // Handle stack-based phi ops first. We need to handle them + // first because we need a register with which to copy them. + + // We must be careful not to overwrite any stack phis which are + // themselves args of other phis. For example: + // v1 = phi(v2, v3) : 8(SP) + // v2 = phi(v4, v5) : 16(SP) + // Here we must not write v2 until v2 is read and written to v1. + // The situation could be even more complicated, with cycles, etc. + // So in the interest of being simple, we find all the phis which + // are arguments of other phis and copy their values to a temporary + // location first. This temporary location is called "spill2" and + // represents a higher-priority but temporary spill location for the value. + // Note this is not a problem for register-based phis because + // if needed we will use the spilled location as the source, and + // the spill location is not clobbered by the code generated here. + argset.clear() + for _, v := range stackPhis { + argset.add(v.Args[i].ID) } - b.Values = b.Values[:len(b.Values)-1] - // TODO: do this for all control types? - } - - // at the end of the block, spill any remaining dirty, live values - for r := register(0); r < numRegs; r++ { - if !regs[r].dirty { - continue + for _, v := range regPhis { + argset.add(v.Args[i].ID) } - v := regs[r].v - c := regs[r].c - if lastUse[v.ID] <= len(oldSched) { - if v == v.Block.Control { - // link control value to register version - v.Block.Control = c + for _, v := range stackPhis { + if !argset.contains(v.ID) { + continue } - continue // not live after block + // This stack-based phi is the argument of some other + // phi in this block. We must make a copy of its + // value so that we don't clobber it prematurely. + c := s.allocValToReg(v, s.values[v.ID].regs|1<<0, false) + d := p.NewValue1(v.Line, OpStoreReg, v.Type, c) + s.values[v.ID].spill2 = d } - // change v to be a copy of c - v.Op = OpStoreReg - v.Aux = nil - v.resetArgs() - v.AddArg(c) - b.Values = append(b.Values, v) + // Assign to stack-based phis. We do stack phis first because + // we might need a register to do the assignment. + for _, v := range stackPhis { + // Load phi arg into a register, then store it with a StoreReg. + // If already in a register, use that. If not, use register 0. + // TODO: choose a better default register (set of reg by type?). + c := s.allocValToReg(v.Args[i], s.values[v.Args[i].ID].regs|1<<0, false) + v.Args[i] = p.NewValue1(v.Line, OpStoreReg, v.Type, c) + } + // Figure out what value goes in each register. + for r := register(0); r < numRegs; r++ { + dst[r] = startRegs[b.ID][r] + } + // Handle register-based phi ops. + for _, v := range regPhis { + r := s.getHome(v) + if dst[r] != v { + f.Fatalf("dst not right") + } + v.Args[i] = s.allocValToReg(v.Args[i], regMask(1)<CX and CX->DX, do the latter first. Now if we do the + // former first then the latter must be a restore instead of a register move. + + // Erase any spills we never used + for i := range s.values { + vi := s.values[i] + if vi.spillUsed { + continue + } + spill := vi.spill + if spill == nil { + // Constants, SP, SB, ... + continue } + spill.Op = OpInvalid + spill.Type = TypeInvalid + spill.resetArgs() } - f.RegAlloc = home - deadcode(f) // remove values that had all of their uses rematerialized. TODO: separate pass? -} - -// addPhiCopies adds copies of phi inputs in the blocks -// immediately preceding the phi's block. -func addPhiCopies(f *Func) { for _, b := range f.Blocks { - phis := true // all phis should appear first; confirm that as we go + i := 0 for _, v := range b.Values { - switch { - case v.Op == OpPhi && !phis: - f.Fatalf("phi var %v not at beginning of block %v:\n%s\n", v, v.Block, f) - break - case v.Op != OpPhi: - phis = false + if v.Op == OpInvalid { continue - case v.Type.IsMemory(): // TODO: only "regallocable" types - continue - } - for i, w := range v.Args { - c := b.Preds[i] - cpy := c.NewValue1(w.Line, OpCopy, v.Type, w) - v.Args[i] = cpy } + 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 } + + // Set final regalloc result. + f.RegAlloc = s.home } -// live returns a map from block ID to a list of value IDs live at the end of that block +// live returns a map from block ID and successor edge index to a list +// of value IDs live on that edge. // 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 live(f *Func) [][]ID { - live := make([][]ID, f.NumBlocks()) +func (f *Func) live() [][][]ID { + live := make([][][]ID, f.NumBlocks()) + for _, b := range f.Blocks { + live[b.ID] = make([][]ID, len(b.Succs)) + } var phis []*Value s := newSparseSet(f.NumValues()) @@ -445,7 +931,11 @@ func live(f *Func) [][]ID { for _, b := range po { // Start with known live values at the end of the block s.clear() - s.addAll(live[b.ID]) + for i := 0; i < len(b.Succs); i++ { + s.addAll(live[b.ID][i]) + } + + // Mark control value as live if b.Control != nil { s.add(b.Control.ID) } @@ -467,19 +957,24 @@ func live(f *Func) [][]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 { + // Find index of b in p's successors. + var j int + for j = 0; j < len(p.Succs); j++ { + if p.Succs[j] == b { + break + } + } t.clear() - t.addAll(live[p.ID]) + t.addAll(live[p.ID][j]) t.addAll(s.contents()) for _, v := range phis { t.add(v.Args[i].ID) } - if t.size() == len(live[p.ID]) { + if t.size() == len(live[p.ID][j]) { continue } // grow p's live set - c := make([]ID, t.size()) - copy(c, t.contents()) - live[p.ID] = c + live[p.ID][j] = append(live[p.ID][j][:0], t.contents()...) changed = true } } @@ -490,13 +985,3 @@ func live(f *Func) [][]ID { } return live } - -// 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/stackalloc.go b/src/cmd/compile/internal/ssa/stackalloc.go index 064b84a804..626fb8f369 100644 --- a/src/cmd/compile/internal/ssa/stackalloc.go +++ b/src/cmd/compile/internal/ssa/stackalloc.go @@ -4,6 +4,15 @@ package ssa +// setloc sets the home location of v to loc. +func setloc(home []Location, v *Value, loc Location) []Location { + for v.ID >= ID(len(home)) { + home = append(home, nil) + } + home[v.ID] = loc + return home +} + // stackalloc allocates storage in the stack frame for // all Values that did not get a register. func stackalloc(f *Func) { @@ -26,7 +35,7 @@ func stackalloc(f *Func) { // so stackmap is smaller. // Assign stack locations to phis first, because we - // must also assign the same locations to the phi copies + // must also assign the same locations to the phi stores // introduced during regalloc. for _, b := range f.Blocks { for _, v := range b.Values { @@ -36,12 +45,19 @@ func stackalloc(f *Func) { if v.Type.IsMemory() { // TODO: only "regallocable" types continue } + if int(v.ID) < len(home) && home[v.ID] != nil { + continue // register-based phi + } + // stack-based phi n = align(n, v.Type.Alignment()) f.Logf("stackalloc: %d-%d for %v\n", n, n+v.Type.Size(), v) loc := &LocalSlot{n} n += v.Type.Size() home = setloc(home, v, loc) for _, w := range v.Args { + if w.Op != OpStoreReg { + f.Fatalf("stack-based phi must have StoreReg args") + } home = setloc(home, w, loc) } } diff --git a/src/cmd/compile/internal/ssa/tighten.go b/src/cmd/compile/internal/ssa/tighten.go index 02b1f701f5..a43218095e 100644 --- a/src/cmd/compile/internal/ssa/tighten.go +++ b/src/cmd/compile/internal/ssa/tighten.go @@ -57,13 +57,6 @@ func tighten(f *Func) { if v.Op == OpPhi { continue } - if v.Op == OpSB || v.Op == OpSP { - // regalloc expects OpSP and OpSB values to be in the entry block, - // so don't move them. - // TODO: Handle this more gracefully in regalloc and - // remove this restriction. - 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, diff --git a/src/cmd/compile/internal/ssa/value.go b/src/cmd/compile/internal/ssa/value.go index e6e23d5270..286edc0cda 100644 --- a/src/cmd/compile/internal/ssa/value.go +++ b/src/cmd/compile/internal/ssa/value.go @@ -11,7 +11,7 @@ import "fmt" // 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 0. There is no guarantee that there won't be occasional holes, though. + // 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. @@ -69,7 +69,7 @@ func (v *Value) LongString() string { s += fmt.Sprintf(" %v", a) } r := v.Block.Func.RegAlloc - if r != nil && r[v.ID] != nil { + if int(v.ID) < len(r) && r[v.ID] != nil { s += " : " + r[v.ID].Name() } return s -- cgit v1.3 From d9dc2f22302d1e0b6cfc01522939a37dd2d8a4e6 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Tue, 18 Aug 2015 10:28:58 -0700 Subject: [dev.ssa] cmd/compile: fix string store rewrite Store ops now need their size in the auxint field. I missed this one. Change-Id: I050fd6b5b00579883731702c426edafa3a5f7561 Reviewed-on: https://go-review.googlesource.com/13682 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/ssa/gen/generic.rules | 2 +- src/cmd/compile/internal/ssa/gen/rulegen.go | 2 +- src/cmd/compile/internal/ssa/rewritegeneric.go | 15 ++++++++++----- 3 files changed, 12 insertions(+), 7 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index 75cd186a43..db66a457c3 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -88,7 +88,7 @@ (Load ptr mem) && t.IsString() -> (StringMake (Load ptr mem) (Load (OffPtr [config.PtrSize] ptr) mem)) (StringPtr (StringMake ptr _)) -> ptr (StringLen (StringMake _ len)) -> len -(Store dst str mem) && str.Type.IsString() -> (Store (OffPtr [config.PtrSize] dst) (StringLen str) (Store dst (StringPtr str) mem)) +(Store [2*config.PtrSize] dst str mem) && str.Type.IsString() -> (Store [config.PtrSize] (OffPtr [config.PtrSize] dst) (StringLen str) (Store [config.PtrSize] dst (StringPtr str) mem)) (If (IsNonNil (GetG)) yes no) -> (Plain nil yes) diff --git a/src/cmd/compile/internal/ssa/gen/rulegen.go b/src/cmd/compile/internal/ssa/gen/rulegen.go index 57305413f9..057e68601b 100644 --- a/src/cmd/compile/internal/ssa/gen/rulegen.go +++ b/src/cmd/compile/internal/ssa/gen/rulegen.go @@ -560,7 +560,7 @@ func unbalanced(s string) bool { // 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) + b, err := regexp.MatchString("^[A-Za-z_][A-Za-z_0-9]*$", s) if err != nil { panic("bad variable regexp") } diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index a0c5269e2e..4c278cb168 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -906,20 +906,24 @@ func rewriteValuegeneric(v *Value, config *Config) bool { goto enda18a7163888e2f4fca9f38bae56cef42 enda18a7163888e2f4fca9f38bae56cef42: ; - // match: (Store dst str mem) + // match: (Store [2*config.PtrSize] dst str mem) // cond: str.Type.IsString() - // result: (Store (OffPtr [config.PtrSize] dst) (StringLen str) (Store dst (StringPtr str) mem)) + // result: (Store [config.PtrSize] (OffPtr [config.PtrSize] dst) (StringLen str) (Store [config.PtrSize] dst (StringPtr str) mem)) { + if v.AuxInt != 2*config.PtrSize { + goto end6942df62f9cb570a99ab97a5aeebfd2d + } dst := v.Args[0] str := v.Args[1] mem := v.Args[2] if !(str.Type.IsString()) { - goto enddf0c5a150f4b4bf6715fd2bd4bb4cc20 + goto end6942df62f9cb570a99ab97a5aeebfd2d } v.Op = OpStore v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.AuxInt = config.PtrSize v0 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) v0.Type = config.Frontend().TypeBytePtr() v0.AuxInt = config.PtrSize @@ -930,6 +934,7 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v1.AddArg(str) v.AddArg(v1) v2 := b.NewValue0(v.Line, OpStore, TypeInvalid) + v2.AuxInt = config.PtrSize v2.Type = TypeMem v2.AddArg(dst) v3 := b.NewValue0(v.Line, OpStringPtr, TypeInvalid) @@ -940,8 +945,8 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.AddArg(v2) return true } - goto enddf0c5a150f4b4bf6715fd2bd4bb4cc20 - enddf0c5a150f4b4bf6715fd2bd4bb4cc20: + goto end6942df62f9cb570a99ab97a5aeebfd2d + end6942df62f9cb570a99ab97a5aeebfd2d: ; case OpStringLen: // match: (StringLen (StringMake _ len)) -- cgit v1.3 From a45f2d8f2898d23804de473841d42670fcdda5dc Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Mon, 17 Aug 2015 17:46:06 -0500 Subject: [dev.ssa] cmd/compile/internal/ssa: implement ODIV Implement integer division for non-consts. Change-Id: If40cbde20e5f0ebb9993064def7be468e4eca076 Reviewed-on: https://go-review.googlesource.com/13644 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 80 +++ src/cmd/compile/internal/gc/ssa_test.go | 3 + .../internal/gc/testdata/arithBoundary_ssa.go | 640 +++++++++++++++++++++ src/cmd/compile/internal/ssa/TODO | 3 +- src/cmd/compile/internal/ssa/gen/AMD64.rules | 9 + src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 12 + src/cmd/compile/internal/ssa/gen/genericOps.go | 9 + src/cmd/compile/internal/ssa/opGen.go | 130 +++++ src/cmd/compile/internal/ssa/rewriteAMD64.go | 156 +++++ 9 files changed, 1041 insertions(+), 1 deletion(-) create mode 100644 src/cmd/compile/internal/gc/testdata/arithBoundary_ssa.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index ef90ed40e7..90b29b9b09 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -779,6 +779,15 @@ var opToSSA = map[opAndType]ssa.Op{ opAndType{ODIV, TFLOAT32}: ssa.OpDiv32F, opAndType{ODIV, TFLOAT64}: ssa.OpDiv64F, + 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{OAND, TINT8}: ssa.OpAnd8, opAndType{OAND, TUINT8}: ssa.OpAnd8, opAndType{OAND, TINT16}: ssa.OpAnd16, @@ -2019,6 +2028,77 @@ func genValue(v *ssa.Value) { } opregreg(v.Op.Asm(), r, y) + case ssa.OpAMD64DIVQ, ssa.OpAMD64DIVL, ssa.OpAMD64DIVW, + ssa.OpAMD64DIVQU, ssa.OpAMD64DIVLU, ssa.OpAMD64DIVWU: + + // 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. So we check for division + // by -1 and negate the input. + var j *obj.Prog + if v.Op == ssa.OpAMD64DIVQ || v.Op == ssa.OpAMD64DIVL || + v.Op == ssa.OpAMD64DIVW { + + var c *obj.Prog + switch v.Op { + case ssa.OpAMD64DIVQ: + c = Prog(x86.ACMPQ) + case ssa.OpAMD64DIVL: + c = Prog(x86.ACMPL) + case ssa.OpAMD64DIVW: + c = Prog(x86.ACMPW) + } + c.From.Type = obj.TYPE_REG + c.From.Reg = x + c.To.Type = obj.TYPE_CONST + c.To.Offset = -1 + + j = Prog(x86.AJEQ) + j.To.Type = obj.TYPE_BRANCH + + } + + // dividend is ax, so we sign extend to + // dx:ax for DIV input + switch v.Op { + case ssa.OpAMD64DIVQU: + fallthrough + case ssa.OpAMD64DIVLU: + fallthrough + case ssa.OpAMD64DIVWU: + 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 + case ssa.OpAMD64DIVQ: + Prog(x86.ACQO) + case ssa.OpAMD64DIVL: + Prog(x86.ACDQ) + case ssa.OpAMD64DIVW: + Prog(x86.ACWD) + } + + 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 + + n := Prog(x86.ANEGQ) + n.To.Type = obj.TYPE_REG + n.To.Reg = x86.REG_AX + + j.To.Val = n + j2.To.Val = Pc + } + 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: diff --git a/src/cmd/compile/internal/gc/ssa_test.go b/src/cmd/compile/internal/gc/ssa_test.go index f0060cb12d..d4dfa5d5bf 100644 --- a/src/cmd/compile/internal/gc/ssa_test.go +++ b/src/cmd/compile/internal/gc/ssa_test.go @@ -48,3 +48,6 @@ 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") } 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 0000000000..8f84026a5d --- /dev/null +++ b/src/cmd/compile/internal/gc/testdata/arithBoundary_ssa.go @@ -0,0 +1,640 @@ +package main + +import "fmt" + +type utd64 struct { + a, b uint64 + add, sub, mul, div uint64 +} +type itd64 struct { + a, b int64 + add, sub, mul, div int64 +} +type utd32 struct { + a, b uint32 + add, sub, mul, div uint32 +} +type itd32 struct { + a, b int32 + add, sub, mul, div int32 +} +type utd16 struct { + a, b uint16 + add, sub, mul, div uint16 +} +type itd16 struct { + a, b int16 + add, sub, mul, div int16 +} +type utd8 struct { + a, b uint8 + add, sub, mul, div uint8 +} +type itd8 struct { + a, b int8 + add, sub, mul, div int8 +} + +func add_uint64_ssa(a, b uint64) uint64 { + switch { + } + return a + b +} +func sub_uint64_ssa(a, b uint64) uint64 { + switch { + } + return a - b +} +func div_uint64_ssa(a, b uint64) uint64 { + switch { + } + return a / b +} +func mul_uint64_ssa(a, b uint64) uint64 { + switch { + } + return a * b +} +func add_int64_ssa(a, b int64) int64 { + switch { + } + return a + b +} +func sub_int64_ssa(a, b int64) int64 { + switch { + } + return a - b +} +func div_int64_ssa(a, b int64) int64 { + switch { + } + return a / b +} +func mul_int64_ssa(a, b int64) int64 { + switch { + } + return a * b +} +func add_uint32_ssa(a, b uint32) uint32 { + switch { + } + return a + b +} +func sub_uint32_ssa(a, b uint32) uint32 { + switch { + } + return a - b +} +func div_uint32_ssa(a, b uint32) uint32 { + switch { + } + return a / b +} +func mul_uint32_ssa(a, b uint32) uint32 { + switch { + } + return a * b +} +func add_int32_ssa(a, b int32) int32 { + switch { + } + return a + b +} +func sub_int32_ssa(a, b int32) int32 { + switch { + } + return a - b +} +func div_int32_ssa(a, b int32) int32 { + switch { + } + return a / b +} +func mul_int32_ssa(a, b int32) int32 { + switch { + } + return a * b +} +func add_uint16_ssa(a, b uint16) uint16 { + switch { + } + return a + b +} +func sub_uint16_ssa(a, b uint16) uint16 { + switch { + } + return a - b +} +func div_uint16_ssa(a, b uint16) uint16 { + switch { + } + return a / b +} +func mul_uint16_ssa(a, b uint16) uint16 { + switch { + } + return a * b +} +func add_int16_ssa(a, b int16) int16 { + switch { + } + return a + b +} +func sub_int16_ssa(a, b int16) int16 { + switch { + } + return a - b +} +func div_int16_ssa(a, b int16) int16 { + switch { + } + return a / b +} +func mul_int16_ssa(a, b int16) int16 { + switch { + } + return a * b +} +func add_uint8_ssa(a, b uint8) uint8 { + switch { + } + return a + b +} +func sub_uint8_ssa(a, b uint8) uint8 { + switch { + } + return a - b +} +func div_uint8_ssa(a, b uint8) uint8 { + switch { + } + return a / b +} +func mul_uint8_ssa(a, b uint8) uint8 { + switch { + } + return a * b +} +func add_int8_ssa(a, b int8) int8 { + switch { + } + return a + b +} +func sub_int8_ssa(a, b int8) int8 { + switch { + } + return a - b +} +func div_int8_ssa(a, b int8) int8 { + switch { + } + return a / b +} +func mul_int8_ssa(a, b int8) int8 { + switch { + } + 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}, + utd64{a: 0, b: 4294967296, add: 4294967296, sub: 18446744069414584320, mul: 0, div: 0}, + utd64{a: 0, b: 18446744073709551615, add: 18446744073709551615, sub: 1, mul: 0, div: 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}, + utd64{a: 1, b: 4294967296, add: 4294967297, sub: 18446744069414584321, mul: 4294967296, div: 0}, + utd64{a: 1, b: 18446744073709551615, add: 0, sub: 2, mul: 18446744073709551615, div: 0}, + utd64{a: 4294967296, b: 0, add: 4294967296, sub: 4294967296, mul: 0}, + utd64{a: 4294967296, b: 1, add: 4294967297, sub: 4294967295, mul: 4294967296, div: 4294967296}, + utd64{a: 4294967296, b: 4294967296, add: 8589934592, sub: 0, mul: 0, div: 1}, + utd64{a: 4294967296, b: 18446744073709551615, add: 4294967295, sub: 4294967297, mul: 18446744069414584320, div: 0}, + utd64{a: 18446744073709551615, b: 0, add: 18446744073709551615, sub: 18446744073709551615, mul: 0}, + utd64{a: 18446744073709551615, b: 1, add: 0, sub: 18446744073709551614, mul: 18446744073709551615, div: 18446744073709551615}, + utd64{a: 18446744073709551615, b: 4294967296, add: 4294967295, sub: 18446744069414584319, mul: 18446744069414584320, div: 4294967295}, + utd64{a: 18446744073709551615, b: 18446744073709551615, add: 18446744073709551614, sub: 0, mul: 1, div: 1}, +} +var int64_data []itd64 = []itd64{itd64{a: -9223372036854775808, b: -9223372036854775808, add: 0, sub: 0, mul: 0, div: 1}, + itd64{a: -9223372036854775808, b: -9223372036854775807, add: 1, sub: -1, mul: -9223372036854775808, div: 1}, + itd64{a: -9223372036854775808, b: -4294967296, add: 9223372032559808512, sub: -9223372032559808512, mul: 0, div: 2147483648}, + itd64{a: -9223372036854775808, b: -1, add: 9223372036854775807, sub: -9223372036854775807, mul: -9223372036854775808, div: -9223372036854775808}, + itd64{a: -9223372036854775808, b: 0, add: -9223372036854775808, sub: -9223372036854775808, mul: 0}, + itd64{a: -9223372036854775808, b: 1, add: -9223372036854775807, sub: 9223372036854775807, mul: -9223372036854775808, div: -9223372036854775808}, + itd64{a: -9223372036854775808, b: 4294967296, add: -9223372032559808512, sub: 9223372032559808512, mul: 0, div: -2147483648}, + itd64{a: -9223372036854775808, b: 9223372036854775806, add: -2, sub: 2, mul: 0, div: -1}, + itd64{a: -9223372036854775808, b: 9223372036854775807, add: -1, sub: 1, mul: -9223372036854775808, div: -1}, + itd64{a: -9223372036854775807, b: -9223372036854775808, add: 1, sub: 1, mul: -9223372036854775808, div: 0}, + itd64{a: -9223372036854775807, b: -9223372036854775807, add: 2, sub: 0, mul: 1, div: 1}, + itd64{a: -9223372036854775807, b: -4294967296, add: 9223372032559808513, sub: -9223372032559808511, mul: -4294967296, div: 2147483647}, + itd64{a: -9223372036854775807, b: -1, add: -9223372036854775808, sub: -9223372036854775806, mul: 9223372036854775807, div: 9223372036854775807}, + itd64{a: -9223372036854775807, b: 0, add: -9223372036854775807, sub: -9223372036854775807, mul: 0}, + itd64{a: -9223372036854775807, b: 1, add: -9223372036854775806, sub: -9223372036854775808, mul: -9223372036854775807, div: -9223372036854775807}, + itd64{a: -9223372036854775807, b: 4294967296, add: -9223372032559808511, sub: 9223372032559808513, mul: 4294967296, div: -2147483647}, + itd64{a: -9223372036854775807, b: 9223372036854775806, add: -1, sub: 3, mul: 9223372036854775806, div: -1}, + itd64{a: -9223372036854775807, b: 9223372036854775807, add: 0, sub: 2, mul: -1, div: -1}, + itd64{a: -4294967296, b: -9223372036854775808, add: 9223372032559808512, sub: 9223372032559808512, mul: 0, div: 0}, + itd64{a: -4294967296, b: -9223372036854775807, add: 9223372032559808513, sub: 9223372032559808511, mul: -4294967296, div: 0}, + itd64{a: -4294967296, b: -4294967296, add: -8589934592, sub: 0, mul: 0, div: 1}, + itd64{a: -4294967296, b: -1, add: -4294967297, sub: -4294967295, mul: 4294967296, div: 4294967296}, + itd64{a: -4294967296, b: 0, add: -4294967296, sub: -4294967296, mul: 0}, + itd64{a: -4294967296, b: 1, add: -4294967295, sub: -4294967297, mul: -4294967296, div: -4294967296}, + itd64{a: -4294967296, b: 4294967296, add: 0, sub: -8589934592, mul: 0, div: -1}, + itd64{a: -4294967296, b: 9223372036854775806, add: 9223372032559808510, sub: 9223372032559808514, mul: 8589934592, div: 0}, + itd64{a: -4294967296, b: 9223372036854775807, add: 9223372032559808511, sub: 9223372032559808513, mul: 4294967296, div: 0}, + itd64{a: -1, b: -9223372036854775808, add: 9223372036854775807, sub: 9223372036854775807, mul: -9223372036854775808, div: 0}, + itd64{a: -1, b: -9223372036854775807, add: -9223372036854775808, sub: 9223372036854775806, mul: 9223372036854775807, div: 0}, + itd64{a: -1, b: -4294967296, add: -4294967297, sub: 4294967295, mul: 4294967296, div: 0}, + itd64{a: -1, b: -1, add: -2, sub: 0, mul: 1, div: 1}, + itd64{a: -1, b: 0, add: -1, sub: -1, mul: 0}, + itd64{a: -1, b: 1, add: 0, sub: -2, mul: -1, div: -1}, + itd64{a: -1, b: 4294967296, add: 4294967295, sub: -4294967297, mul: -4294967296, div: 0}, + itd64{a: -1, b: 9223372036854775806, add: 9223372036854775805, sub: -9223372036854775807, mul: -9223372036854775806, div: 0}, + itd64{a: -1, b: 9223372036854775807, add: 9223372036854775806, sub: -9223372036854775808, mul: -9223372036854775807, div: 0}, + itd64{a: 0, b: -9223372036854775808, add: -9223372036854775808, sub: -9223372036854775808, mul: 0, div: 0}, + itd64{a: 0, b: -9223372036854775807, add: -9223372036854775807, sub: 9223372036854775807, mul: 0, div: 0}, + itd64{a: 0, b: -4294967296, add: -4294967296, sub: 4294967296, mul: 0, div: 0}, + itd64{a: 0, b: -1, add: -1, sub: 1, mul: 0, div: 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}, + itd64{a: 0, b: 4294967296, add: 4294967296, sub: -4294967296, mul: 0, div: 0}, + itd64{a: 0, b: 9223372036854775806, add: 9223372036854775806, sub: -9223372036854775806, mul: 0, div: 0}, + itd64{a: 0, b: 9223372036854775807, add: 9223372036854775807, sub: -9223372036854775807, mul: 0, div: 0}, + itd64{a: 1, b: -9223372036854775808, add: -9223372036854775807, sub: -9223372036854775807, mul: -9223372036854775808, div: 0}, + itd64{a: 1, b: -9223372036854775807, add: -9223372036854775806, sub: -9223372036854775808, mul: -9223372036854775807, div: 0}, + itd64{a: 1, b: -4294967296, add: -4294967295, sub: 4294967297, mul: -4294967296, div: 0}, + itd64{a: 1, b: -1, add: 0, sub: 2, mul: -1, div: -1}, + itd64{a: 1, b: 0, add: 1, sub: 1, mul: 0}, + itd64{a: 1, b: 1, add: 2, sub: 0, mul: 1, div: 1}, + itd64{a: 1, b: 4294967296, add: 4294967297, sub: -4294967295, mul: 4294967296, div: 0}, + itd64{a: 1, b: 9223372036854775806, add: 9223372036854775807, sub: -9223372036854775805, mul: 9223372036854775806, div: 0}, + itd64{a: 1, b: 9223372036854775807, add: -9223372036854775808, sub: -9223372036854775806, mul: 9223372036854775807, div: 0}, + itd64{a: 4294967296, b: -9223372036854775808, add: -9223372032559808512, sub: -9223372032559808512, mul: 0, div: 0}, + itd64{a: 4294967296, b: -9223372036854775807, add: -9223372032559808511, sub: -9223372032559808513, mul: 4294967296, div: 0}, + itd64{a: 4294967296, b: -4294967296, add: 0, sub: 8589934592, mul: 0, div: -1}, + itd64{a: 4294967296, b: -1, add: 4294967295, sub: 4294967297, mul: -4294967296, div: -4294967296}, + itd64{a: 4294967296, b: 0, add: 4294967296, sub: 4294967296, mul: 0}, + itd64{a: 4294967296, b: 1, add: 4294967297, sub: 4294967295, mul: 4294967296, div: 4294967296}, + itd64{a: 4294967296, b: 4294967296, add: 8589934592, sub: 0, mul: 0, div: 1}, + itd64{a: 4294967296, b: 9223372036854775806, add: -9223372032559808514, sub: -9223372032559808510, mul: -8589934592, div: 0}, + itd64{a: 4294967296, b: 9223372036854775807, add: -9223372032559808513, sub: -9223372032559808511, mul: -4294967296, div: 0}, + itd64{a: 9223372036854775806, b: -9223372036854775808, add: -2, sub: -2, mul: 0, div: 0}, + itd64{a: 9223372036854775806, b: -9223372036854775807, add: -1, sub: -3, mul: 9223372036854775806, div: 0}, + itd64{a: 9223372036854775806, b: -4294967296, add: 9223372032559808510, sub: -9223372032559808514, mul: 8589934592, div: -2147483647}, + itd64{a: 9223372036854775806, b: -1, add: 9223372036854775805, sub: 9223372036854775807, mul: -9223372036854775806, div: -9223372036854775806}, + itd64{a: 9223372036854775806, b: 0, add: 9223372036854775806, sub: 9223372036854775806, mul: 0}, + itd64{a: 9223372036854775806, b: 1, add: 9223372036854775807, sub: 9223372036854775805, mul: 9223372036854775806, div: 9223372036854775806}, + itd64{a: 9223372036854775806, b: 4294967296, add: -9223372032559808514, sub: 9223372032559808510, mul: -8589934592, div: 2147483647}, + itd64{a: 9223372036854775806, b: 9223372036854775806, add: -4, sub: 0, mul: 4, div: 1}, + itd64{a: 9223372036854775806, b: 9223372036854775807, add: -3, sub: -1, mul: -9223372036854775806, div: 0}, + itd64{a: 9223372036854775807, b: -9223372036854775808, add: -1, sub: -1, mul: -9223372036854775808, div: 0}, + itd64{a: 9223372036854775807, b: -9223372036854775807, add: 0, sub: -2, mul: -1, div: -1}, + itd64{a: 9223372036854775807, b: -4294967296, add: 9223372032559808511, sub: -9223372032559808513, mul: 4294967296, div: -2147483647}, + itd64{a: 9223372036854775807, b: -1, add: 9223372036854775806, sub: -9223372036854775808, mul: -9223372036854775807, div: -9223372036854775807}, + itd64{a: 9223372036854775807, b: 0, add: 9223372036854775807, sub: 9223372036854775807, mul: 0}, + itd64{a: 9223372036854775807, b: 1, add: -9223372036854775808, sub: 9223372036854775806, mul: 9223372036854775807, div: 9223372036854775807}, + itd64{a: 9223372036854775807, b: 4294967296, add: -9223372032559808513, sub: 9223372032559808511, mul: -4294967296, div: 2147483647}, + itd64{a: 9223372036854775807, b: 9223372036854775806, add: -3, sub: 1, mul: -9223372036854775806, div: 1}, + itd64{a: 9223372036854775807, b: 9223372036854775807, add: -2, sub: 0, mul: 1, div: 1}, +} +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}, + utd32{a: 0, b: 4294967295, add: 4294967295, sub: 1, mul: 0, div: 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}, + utd32{a: 1, b: 4294967295, add: 0, sub: 2, mul: 4294967295, div: 0}, + utd32{a: 4294967295, b: 0, add: 4294967295, sub: 4294967295, mul: 0}, + utd32{a: 4294967295, b: 1, add: 0, sub: 4294967294, mul: 4294967295, div: 4294967295}, + utd32{a: 4294967295, b: 4294967295, add: 4294967294, sub: 0, mul: 1, div: 1}, +} +var int32_data []itd32 = []itd32{itd32{a: -2147483648, b: -2147483648, add: 0, sub: 0, mul: 0, div: 1}, + itd32{a: -2147483648, b: -2147483647, add: 1, sub: -1, mul: -2147483648, div: 1}, + itd32{a: -2147483648, b: -1, add: 2147483647, sub: -2147483647, mul: -2147483648, div: -2147483648}, + itd32{a: -2147483648, b: 0, add: -2147483648, sub: -2147483648, mul: 0}, + itd32{a: -2147483648, b: 1, add: -2147483647, sub: 2147483647, mul: -2147483648, div: -2147483648}, + itd32{a: -2147483648, b: 2147483647, add: -1, sub: 1, mul: -2147483648, div: -1}, + itd32{a: -2147483647, b: -2147483648, add: 1, sub: 1, mul: -2147483648, div: 0}, + itd32{a: -2147483647, b: -2147483647, add: 2, sub: 0, mul: 1, div: 1}, + itd32{a: -2147483647, b: -1, add: -2147483648, sub: -2147483646, mul: 2147483647, div: 2147483647}, + itd32{a: -2147483647, b: 0, add: -2147483647, sub: -2147483647, mul: 0}, + itd32{a: -2147483647, b: 1, add: -2147483646, sub: -2147483648, mul: -2147483647, div: -2147483647}, + itd32{a: -2147483647, b: 2147483647, add: 0, sub: 2, mul: -1, div: -1}, + itd32{a: -1, b: -2147483648, add: 2147483647, sub: 2147483647, mul: -2147483648, div: 0}, + itd32{a: -1, b: -2147483647, add: -2147483648, sub: 2147483646, mul: 2147483647, div: 0}, + itd32{a: -1, b: -1, add: -2, sub: 0, mul: 1, div: 1}, + itd32{a: -1, b: 0, add: -1, sub: -1, mul: 0}, + itd32{a: -1, b: 1, add: 0, sub: -2, mul: -1, div: -1}, + itd32{a: -1, b: 2147483647, add: 2147483646, sub: -2147483648, mul: -2147483647, div: 0}, + itd32{a: 0, b: -2147483648, add: -2147483648, sub: -2147483648, mul: 0, div: 0}, + itd32{a: 0, b: -2147483647, add: -2147483647, sub: 2147483647, mul: 0, div: 0}, + itd32{a: 0, b: -1, add: -1, sub: 1, mul: 0, div: 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}, + itd32{a: 0, b: 2147483647, add: 2147483647, sub: -2147483647, mul: 0, div: 0}, + itd32{a: 1, b: -2147483648, add: -2147483647, sub: -2147483647, mul: -2147483648, div: 0}, + itd32{a: 1, b: -2147483647, add: -2147483646, sub: -2147483648, mul: -2147483647, div: 0}, + itd32{a: 1, b: -1, add: 0, sub: 2, mul: -1, div: -1}, + itd32{a: 1, b: 0, add: 1, sub: 1, mul: 0}, + itd32{a: 1, b: 1, add: 2, sub: 0, mul: 1, div: 1}, + itd32{a: 1, b: 2147483647, add: -2147483648, sub: -2147483646, mul: 2147483647, div: 0}, + itd32{a: 2147483647, b: -2147483648, add: -1, sub: -1, mul: -2147483648, div: 0}, + itd32{a: 2147483647, b: -2147483647, add: 0, sub: -2, mul: -1, div: -1}, + itd32{a: 2147483647, b: -1, add: 2147483646, sub: -2147483648, mul: -2147483647, div: -2147483647}, + itd32{a: 2147483647, b: 0, add: 2147483647, sub: 2147483647, mul: 0}, + itd32{a: 2147483647, b: 1, add: -2147483648, sub: 2147483646, mul: 2147483647, div: 2147483647}, + itd32{a: 2147483647, b: 2147483647, add: -2, sub: 0, mul: 1, div: 1}, +} +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}, + utd16{a: 0, b: 65535, add: 65535, sub: 1, mul: 0, div: 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}, + utd16{a: 1, b: 65535, add: 0, sub: 2, mul: 65535, div: 0}, + utd16{a: 65535, b: 0, add: 65535, sub: 65535, mul: 0}, + utd16{a: 65535, b: 1, add: 0, sub: 65534, mul: 65535, div: 65535}, + utd16{a: 65535, b: 65535, add: 65534, sub: 0, mul: 1, div: 1}, +} +var int16_data []itd16 = []itd16{itd16{a: -32768, b: -32768, add: 0, sub: 0, mul: 0, div: 1}, + itd16{a: -32768, b: -32767, add: 1, sub: -1, mul: -32768, div: 1}, + itd16{a: -32768, b: -1, add: 32767, sub: -32767, mul: -32768, div: -32768}, + itd16{a: -32768, b: 0, add: -32768, sub: -32768, mul: 0}, + itd16{a: -32768, b: 1, add: -32767, sub: 32767, mul: -32768, div: -32768}, + itd16{a: -32768, b: 32766, add: -2, sub: 2, mul: 0, div: -1}, + itd16{a: -32768, b: 32767, add: -1, sub: 1, mul: -32768, div: -1}, + itd16{a: -32767, b: -32768, add: 1, sub: 1, mul: -32768, div: 0}, + itd16{a: -32767, b: -32767, add: 2, sub: 0, mul: 1, div: 1}, + itd16{a: -32767, b: -1, add: -32768, sub: -32766, mul: 32767, div: 32767}, + itd16{a: -32767, b: 0, add: -32767, sub: -32767, mul: 0}, + itd16{a: -32767, b: 1, add: -32766, sub: -32768, mul: -32767, div: -32767}, + itd16{a: -32767, b: 32766, add: -1, sub: 3, mul: 32766, div: -1}, + itd16{a: -32767, b: 32767, add: 0, sub: 2, mul: -1, div: -1}, + itd16{a: -1, b: -32768, add: 32767, sub: 32767, mul: -32768, div: 0}, + itd16{a: -1, b: -32767, add: -32768, sub: 32766, mul: 32767, div: 0}, + itd16{a: -1, b: -1, add: -2, sub: 0, mul: 1, div: 1}, + itd16{a: -1, b: 0, add: -1, sub: -1, mul: 0}, + itd16{a: -1, b: 1, add: 0, sub: -2, mul: -1, div: -1}, + itd16{a: -1, b: 32766, add: 32765, sub: -32767, mul: -32766, div: 0}, + itd16{a: -1, b: 32767, add: 32766, sub: -32768, mul: -32767, div: 0}, + itd16{a: 0, b: -32768, add: -32768, sub: -32768, mul: 0, div: 0}, + itd16{a: 0, b: -32767, add: -32767, sub: 32767, mul: 0, div: 0}, + itd16{a: 0, b: -1, add: -1, sub: 1, mul: 0, div: 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}, + itd16{a: 0, b: 32766, add: 32766, sub: -32766, mul: 0, div: 0}, + itd16{a: 0, b: 32767, add: 32767, sub: -32767, mul: 0, div: 0}, + itd16{a: 1, b: -32768, add: -32767, sub: -32767, mul: -32768, div: 0}, + itd16{a: 1, b: -32767, add: -32766, sub: -32768, mul: -32767, div: 0}, + itd16{a: 1, b: -1, add: 0, sub: 2, mul: -1, div: -1}, + itd16{a: 1, b: 0, add: 1, sub: 1, mul: 0}, + itd16{a: 1, b: 1, add: 2, sub: 0, mul: 1, div: 1}, + itd16{a: 1, b: 32766, add: 32767, sub: -32765, mul: 32766, div: 0}, + itd16{a: 1, b: 32767, add: -32768, sub: -32766, mul: 32767, div: 0}, + itd16{a: 32766, b: -32768, add: -2, sub: -2, mul: 0, div: 0}, + itd16{a: 32766, b: -32767, add: -1, sub: -3, mul: 32766, div: 0}, + itd16{a: 32766, b: -1, add: 32765, sub: 32767, mul: -32766, div: -32766}, + itd16{a: 32766, b: 0, add: 32766, sub: 32766, mul: 0}, + itd16{a: 32766, b: 1, add: 32767, sub: 32765, mul: 32766, div: 32766}, + itd16{a: 32766, b: 32766, add: -4, sub: 0, mul: 4, div: 1}, + itd16{a: 32766, b: 32767, add: -3, sub: -1, mul: -32766, div: 0}, + itd16{a: 32767, b: -32768, add: -1, sub: -1, mul: -32768, div: 0}, + itd16{a: 32767, b: -32767, add: 0, sub: -2, mul: -1, div: -1}, + itd16{a: 32767, b: -1, add: 32766, sub: -32768, mul: -32767, div: -32767}, + itd16{a: 32767, b: 0, add: 32767, sub: 32767, mul: 0}, + itd16{a: 32767, b: 1, add: -32768, sub: 32766, mul: 32767, div: 32767}, + itd16{a: 32767, b: 32766, add: -3, sub: 1, mul: -32766, div: 1}, + itd16{a: 32767, b: 32767, add: -2, sub: 0, mul: 1, div: 1}, +} +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}, + utd8{a: 0, b: 255, add: 255, sub: 1, mul: 0, div: 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}, + utd8{a: 1, b: 255, add: 0, sub: 2, mul: 255, div: 0}, + utd8{a: 255, b: 0, add: 255, sub: 255, mul: 0}, + utd8{a: 255, b: 1, add: 0, sub: 254, mul: 255, div: 255}, + utd8{a: 255, b: 255, add: 254, sub: 0, mul: 1, div: 1}, +} +var int8_data []itd8 = []itd8{itd8{a: -128, b: -128, add: 0, sub: 0, mul: 0, div: 1}, + itd8{a: -128, b: -127, add: 1, sub: -1, mul: -128, div: 1}, + itd8{a: -128, b: -1, add: 127, sub: -127, mul: -128, div: -128}, + itd8{a: -128, b: 0, add: -128, sub: -128, mul: 0}, + itd8{a: -128, b: 1, add: -127, sub: 127, mul: -128, div: -128}, + itd8{a: -128, b: 126, add: -2, sub: 2, mul: 0, div: -1}, + itd8{a: -128, b: 127, add: -1, sub: 1, mul: -128, div: -1}, + itd8{a: -127, b: -128, add: 1, sub: 1, mul: -128, div: 0}, + itd8{a: -127, b: -127, add: 2, sub: 0, mul: 1, div: 1}, + itd8{a: -127, b: -1, add: -128, sub: -126, mul: 127, div: 127}, + itd8{a: -127, b: 0, add: -127, sub: -127, mul: 0}, + itd8{a: -127, b: 1, add: -126, sub: -128, mul: -127, div: -127}, + itd8{a: -127, b: 126, add: -1, sub: 3, mul: 126, div: -1}, + itd8{a: -127, b: 127, add: 0, sub: 2, mul: -1, div: -1}, + itd8{a: -1, b: -128, add: 127, sub: 127, mul: -128, div: 0}, + itd8{a: -1, b: -127, add: -128, sub: 126, mul: 127, div: 0}, + itd8{a: -1, b: -1, add: -2, sub: 0, mul: 1, div: 1}, + itd8{a: -1, b: 0, add: -1, sub: -1, mul: 0}, + itd8{a: -1, b: 1, add: 0, sub: -2, mul: -1, div: -1}, + itd8{a: -1, b: 126, add: 125, sub: -127, mul: -126, div: 0}, + itd8{a: -1, b: 127, add: 126, sub: -128, mul: -127, div: 0}, + itd8{a: 0, b: -128, add: -128, sub: -128, mul: 0, div: 0}, + itd8{a: 0, b: -127, add: -127, sub: 127, mul: 0, div: 0}, + itd8{a: 0, b: -1, add: -1, sub: 1, mul: 0, div: 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}, + itd8{a: 0, b: 126, add: 126, sub: -126, mul: 0, div: 0}, + itd8{a: 0, b: 127, add: 127, sub: -127, mul: 0, div: 0}, + itd8{a: 1, b: -128, add: -127, sub: -127, mul: -128, div: 0}, + itd8{a: 1, b: -127, add: -126, sub: -128, mul: -127, div: 0}, + itd8{a: 1, b: -1, add: 0, sub: 2, mul: -1, div: -1}, + itd8{a: 1, b: 0, add: 1, sub: 1, mul: 0}, + itd8{a: 1, b: 1, add: 2, sub: 0, mul: 1, div: 1}, + itd8{a: 1, b: 126, add: 127, sub: -125, mul: 126, div: 0}, + itd8{a: 1, b: 127, add: -128, sub: -126, mul: 127, div: 0}, + itd8{a: 126, b: -128, add: -2, sub: -2, mul: 0, div: 0}, + itd8{a: 126, b: -127, add: -1, sub: -3, mul: 126, div: 0}, + itd8{a: 126, b: -1, add: 125, sub: 127, mul: -126, div: -126}, + itd8{a: 126, b: 0, add: 126, sub: 126, mul: 0}, + itd8{a: 126, b: 1, add: 127, sub: 125, mul: 126, div: 126}, + itd8{a: 126, b: 126, add: -4, sub: 0, mul: 4, div: 1}, + itd8{a: 126, b: 127, add: -3, sub: -1, mul: -126, div: 0}, + itd8{a: 127, b: -128, add: -1, sub: -1, mul: -128, div: 0}, + itd8{a: 127, b: -127, add: 0, sub: -2, mul: -1, div: -1}, + itd8{a: 127, b: -1, add: 126, sub: -128, mul: -127, div: -127}, + itd8{a: 127, b: 0, add: 127, sub: 127, mul: 0}, + itd8{a: 127, b: 1, add: -128, sub: 126, mul: 127, div: 127}, + itd8{a: 127, b: 126, add: -3, sub: 1, mul: -126, div: 1}, + itd8{a: 127, b: 127, add: -2, sub: 0, mul: 1, div: 1}, +} +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 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 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 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 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 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 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 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 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/ssa/TODO b/src/cmd/compile/internal/ssa/TODO index d049bea872..1773dbbc98 100644 --- a/src/cmd/compile/internal/ssa/TODO +++ b/src/cmd/compile/internal/ssa/TODO @@ -5,7 +5,7 @@ Coverage -------- - Floating point numbers - Complex numbers -- Integer division +- Integer division (HMUL & MOD) - Fat objects (strings/slices/interfaces) vs. Phi - Defer? - Closure args @@ -49,6 +49,7 @@ Optimizations (better compiler) - OpStore uses 3 args. Increase the size of Value.argstorage to 3? - Constant cache - Reuseable slices (e.g. []int of size NumValues()) cached in Func +- Handle signed division overflow and sign extension earlier Regalloc -------- diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 9ea9781d93..0cde6f26d4 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -36,6 +36,15 @@ (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)) + (And64 x y) -> (ANDQ x y) (And32 x y) -> (ANDL x y) (And16 x y) -> (ANDW x y) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 5aa5e60e33..220e5b01cd 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -72,7 +72,9 @@ func init() { // 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") @@ -97,6 +99,8 @@ func init() { gp21 = regInfo{inputs: []regMask{gpsp, gpsp}, outputs: gponly, clobbers: flags} gp21sb = regInfo{inputs: []regMask{gpspsb, gpsp}, outputs: gponly, clobbers: flags} 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} gp2flags = regInfo{inputs: []regMask{gpsp, gpsp}, outputs: flagsonly} gp1flags = regInfo{inputs: []regMask{gpsp}, outputs: flagsonly} @@ -180,6 +184,14 @@ func init() { {name: "MULWconst", reg: gp11, asm: "IMULW"}, // arg0 * auxint {name: "MULBconst", reg: gp11, asm: "IMULW"}, // arg0 * auxint + {name: "DIVQ", reg: gp11div, asm: "IDIVQ"}, // arg0 / arg1 + {name: "DIVL", reg: gp11div, asm: "IDIVL"}, // arg0 / arg1 + {name: "DIVW", reg: gp11div, asm: "IDIVW"}, // arg0 / arg1 + + {name: "DIVQU", reg: gp11div, asm: "DIVQ"}, // arg0 / arg1 + {name: "DIVLU", reg: gp11div, asm: "DIVL"}, // arg0 / arg1 + {name: "DIVWU", reg: gp11div, asm: "DIVW"}, // arg0 / arg1 + {name: "ANDQ", reg: gp21, asm: "ANDQ"}, // arg0 & arg1 {name: "ANDL", reg: gp21, asm: "ANDL"}, // arg0 & arg1 {name: "ANDW", reg: gp21, asm: "ANDW"}, // arg0 & arg1 diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 1488e0f644..a0d8f8e000 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -37,6 +37,15 @@ var genericOps = []opData{ {name: "Div64F"}, // TODO: Div8, Div16, Div32, Div64 and unsigned + {name: "Div8"}, // arg0 / arg1 + {name: "Div8u"}, + {name: "Div16"}, + {name: "Div16u"}, + {name: "Div32"}, + {name: "Div32u"}, + {name: "Div64"}, + {name: "Div64u"}, + {name: "And8"}, // arg0 & arg1 {name: "And16"}, {name: "And32"}, diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index cbabbfade5..44fd6e3737 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -93,6 +93,12 @@ const ( OpAMD64MULLconst OpAMD64MULWconst OpAMD64MULBconst + OpAMD64DIVQ + OpAMD64DIVL + OpAMD64DIVW + OpAMD64DIVQU + OpAMD64DIVLU + OpAMD64DIVWU OpAMD64ANDQ OpAMD64ANDL OpAMD64ANDW @@ -239,6 +245,14 @@ const ( OpMul64F OpDiv32F OpDiv64F + OpDiv8 + OpDiv8u + OpDiv16 + OpDiv16u + OpDiv32 + OpDiv32u + OpDiv64 + OpDiv64u OpAnd8 OpAnd16 OpAnd32 @@ -963,6 +977,90 @@ var opcodeTable = [...]opInfo{ }, }, }, + { + name: "DIVQ", + 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", + 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", + 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", + 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", + 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", + 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: "ANDQ", asm: x86.AANDQ, @@ -2592,6 +2690,38 @@ var opcodeTable = [...]opInfo{ name: "Div64F", generic: true, }, + { + name: "Div8", + generic: true, + }, + { + name: "Div8u", + generic: true, + }, + { + name: "Div16", + generic: true, + }, + { + name: "Div16u", + generic: true, + }, + { + name: "Div32", + generic: true, + }, + { + name: "Div32u", + generic: true, + }, + { + name: "Div64", + generic: true, + }, + { + name: "Div64u", + generic: true, + }, { name: "And8", generic: true, diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 75393ad58a..993838b537 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -1688,6 +1688,60 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endc395c0a53eeccf597e225a07b53047d1 endc395c0a53eeccf597e225a07b53047d1: ; + case OpDiv16: + // match: (Div16 x y) + // cond: + // result: (DIVW x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64DIVW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto endb60a86e606726640c84d3e1e5a5ce890 + endb60a86e606726640c84d3e1e5a5ce890: + ; + case OpDiv16u: + // match: (Div16u x y) + // cond: + // result: (DIVWU x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64DIVWU + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end6af9e212a865593e506bfdf7db67c9ec + end6af9e212a865593e506bfdf7db67c9ec: + ; + case OpDiv32: + // match: (Div32 x y) + // cond: + // result: (DIVL x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64DIVL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto endf20ac71407e57c2904684d3cc33cf697 + endf20ac71407e57c2904684d3cc33cf697: + ; case OpDiv32F: // match: (Div32F x y) // cond: @@ -1706,6 +1760,42 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto enddca0462c7b176c4138854d7d5627ab5b enddca0462c7b176c4138854d7d5627ab5b: ; + case OpDiv32u: + // match: (Div32u x y) + // cond: + // result: (DIVLU x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64DIVLU + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto enda22604d23eeb1298008c97b817f60bbd + enda22604d23eeb1298008c97b817f60bbd: + ; + case OpDiv64: + // match: (Div64 x y) + // cond: + // result: (DIVQ x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64DIVQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end86490d9b337333dfc09a413e1e0120a9 + end86490d9b337333dfc09a413e1e0120a9: + ; case OpDiv64F: // match: (Div64F x y) // cond: @@ -1724,6 +1814,72 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end12299d76db5144a60f564d34ba97eb43 end12299d76db5144a60f564d34ba97eb43: ; + case OpDiv64u: + // match: (Div64u x y) + // cond: + // result: (DIVQU x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64DIVQU + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto endf871d8b397e5fad6a5b500cc0c759a8d + endf871d8b397e5fad6a5b500cc0c759a8d: + ; + case OpDiv8: + // match: (Div8 x y) + // cond: + // result: (DIVW (SignExt8to16 x) (SignExt8to16 y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64DIVW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpSignExt8to16, TypeInvalid) + v0.Type = config.Frontend().TypeInt16() + v0.AddArg(x) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpSignExt8to16, TypeInvalid) + v1.Type = config.Frontend().TypeInt16() + v1.AddArg(y) + v.AddArg(v1) + return true + } + goto ende25a7899b9c7a869f74226b4b6033084 + ende25a7899b9c7a869f74226b4b6033084: + ; + case OpDiv8u: + // match: (Div8u x y) + // cond: + // result: (DIVWU (ZeroExt8to16 x) (ZeroExt8to16 y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64DIVWU + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpZeroExt8to16, TypeInvalid) + v0.Type = config.Frontend().TypeUInt16() + v0.AddArg(x) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpZeroExt8to16, TypeInvalid) + v1.Type = config.Frontend().TypeUInt16() + v1.AddArg(y) + v.AddArg(v1) + return true + } + goto ende655b41d48feafc4d139b815a3b7b55c + ende655b41d48feafc4d139b815a3b7b55c: + ; case OpEq16: // match: (Eq16 x y) // cond: -- cgit v1.3 From 67cbd5b51d3700fc1976f71a711882bfdd7e8304 Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Tue, 18 Aug 2015 19:14:47 -0500 Subject: [dev.ssa] cmd/compile/internal/ssa: implement OHMUL Adds support for high multiply which is used by the frontend when rewriting const division. The frontend currently only does this for 8, 16, and 32 bit integer arithmetic. Change-Id: I9b6c6018f3be827a50ee6c185454ebc79b3094c8 Reviewed-on: https://go-review.googlesource.com/13696 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 30 +- src/cmd/compile/internal/gc/ssa_test.go | 3 + .../compile/internal/gc/testdata/arithConst_ssa.go | 3979 ++++++++++++++++++++ src/cmd/compile/internal/gc/testdata/arith_ssa.go | 2 +- src/cmd/compile/internal/ssa/TODO | 3 +- src/cmd/compile/internal/ssa/gen/AMD64.rules | 7 + src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 10 +- src/cmd/compile/internal/ssa/gen/genericOps.go | 8 + src/cmd/compile/internal/ssa/opGen.go | 120 + src/cmd/compile/internal/ssa/rewriteAMD64.go | 108 + 10 files changed, 4266 insertions(+), 4 deletions(-) create mode 100644 src/cmd/compile/internal/gc/testdata/arithConst_ssa.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 90b29b9b09..f2dd20bcb4 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -779,6 +779,13 @@ var opToSSA = map[opAndType]ssa.Op{ 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, @@ -1201,7 +1208,7 @@ func (s *state) expr(n *Node) *ssa.Value { a := s.expr(n.Left) b := s.expr(n.Right) return s.newValue2(s.ssaOp(n.Op, n.Left.Type), Types[TBOOL], a, b) - case OADD, OAND, OMUL, OOR, OSUB, ODIV, OXOR: + case OADD, OAND, OMUL, OOR, OSUB, ODIV, OXOR, OHMUL: a := s.expr(n.Left) b := s.expr(n.Right) return s.newValue2(s.ssaOp(n.Op, n.Type), a.Type, a, b) @@ -2099,6 +2106,27 @@ func genValue(v *ssa.Value) { j2.To.Val = Pc } + case ssa.OpAMD64HMULL, ssa.OpAMD64HMULW, ssa.OpAMD64HMULB, + ssa.OpAMD64HMULLU, ssa.OpAMD64HMULWU, ssa.OpAMD64HMULBU: + // the frontend rewrites constant division by 8/16/32 bit integers into + // HMUL by a constant + + // 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.OpAMD64SHLQ, ssa.OpAMD64SHLL, ssa.OpAMD64SHLW, ssa.OpAMD64SHLB, ssa.OpAMD64SHRQ, ssa.OpAMD64SHRL, ssa.OpAMD64SHRW, ssa.OpAMD64SHRB, ssa.OpAMD64SARQ, ssa.OpAMD64SARL, ssa.OpAMD64SARW, ssa.OpAMD64SARB: diff --git a/src/cmd/compile/internal/gc/ssa_test.go b/src/cmd/compile/internal/gc/ssa_test.go index d4dfa5d5bf..071522bc2f 100644 --- a/src/cmd/compile/internal/gc/ssa_test.go +++ b/src/cmd/compile/internal/gc/ssa_test.go @@ -51,3 +51,6 @@ 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") } 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 0000000000..93420aee66 --- /dev/null +++ b/src/cmd/compile/internal/gc/testdata/arithConst_ssa.go @@ -0,0 +1,3979 @@ +package main + +import "fmt" + +func add_uint64_0_ssa(a uint64) uint64 { + switch { + } + return a + 0 +} +func add_0_uint64_ssa(a uint64) uint64 { + switch { + } + return 0 + a +} + +func add_uint64_1_ssa(a uint64) uint64 { + switch { + } + return a + 1 +} +func add_1_uint64_ssa(a uint64) uint64 { + switch { + } + return 1 + a +} + +func add_uint64_4294967296_ssa(a uint64) uint64 { + switch { + } + return a + 4294967296 +} +func add_4294967296_uint64_ssa(a uint64) uint64 { + switch { + } + return 4294967296 + a +} + +func add_uint64_18446744073709551615_ssa(a uint64) uint64 { + switch { + } + return a + 18446744073709551615 +} +func add_18446744073709551615_uint64_ssa(a uint64) uint64 { + switch { + } + return 18446744073709551615 + a +} + +func sub_uint64_0_ssa(a uint64) uint64 { + switch { + } + return a - 0 +} +func sub_0_uint64_ssa(a uint64) uint64 { + switch { + } + return 0 - a +} + +func sub_uint64_1_ssa(a uint64) uint64 { + switch { + } + return a - 1 +} +func sub_1_uint64_ssa(a uint64) uint64 { + switch { + } + return 1 - a +} + +func sub_uint64_4294967296_ssa(a uint64) uint64 { + switch { + } + return a - 4294967296 +} +func sub_4294967296_uint64_ssa(a uint64) uint64 { + switch { + } + return 4294967296 - a +} + +func sub_uint64_18446744073709551615_ssa(a uint64) uint64 { + switch { + } + return a - 18446744073709551615 +} +func sub_18446744073709551615_uint64_ssa(a uint64) uint64 { + switch { + } + return 18446744073709551615 - a +} + +func div_0_uint64_ssa(a uint64) uint64 { + switch { + } + return 0 / a +} + +func div_uint64_1_ssa(a uint64) uint64 { + switch { + } + return a / 1 +} +func div_1_uint64_ssa(a uint64) uint64 { + switch { + } + return 1 / a +} + +func div_uint64_4294967296_ssa(a uint64) uint64 { + switch { + } + return a / 4294967296 +} +func div_4294967296_uint64_ssa(a uint64) uint64 { + switch { + } + return 4294967296 / a +} + +func div_uint64_18446744073709551615_ssa(a uint64) uint64 { + switch { + } + return a / 18446744073709551615 +} +func div_18446744073709551615_uint64_ssa(a uint64) uint64 { + switch { + } + return 18446744073709551615 / a +} + +func mul_uint64_0_ssa(a uint64) uint64 { + switch { + } + return a * 0 +} +func mul_0_uint64_ssa(a uint64) uint64 { + switch { + } + return 0 * a +} + +func mul_uint64_1_ssa(a uint64) uint64 { + switch { + } + return a * 1 +} +func mul_1_uint64_ssa(a uint64) uint64 { + switch { + } + return 1 * a +} + +func mul_uint64_4294967296_ssa(a uint64) uint64 { + switch { + } + return a * 4294967296 +} +func mul_4294967296_uint64_ssa(a uint64) uint64 { + switch { + } + return 4294967296 * a +} + +func mul_uint64_18446744073709551615_ssa(a uint64) uint64 { + switch { + } + return a * 18446744073709551615 +} +func mul_18446744073709551615_uint64_ssa(a uint64) uint64 { + switch { + } + return 18446744073709551615 * a +} + +func add_int64_Neg9223372036854775808_ssa(a int64) int64 { + switch { + } + return a + -9223372036854775808 +} +func add_Neg9223372036854775808_int64_ssa(a int64) int64 { + switch { + } + return -9223372036854775808 + a +} + +func add_int64_Neg9223372036854775807_ssa(a int64) int64 { + switch { + } + return a + -9223372036854775807 +} +func add_Neg9223372036854775807_int64_ssa(a int64) int64 { + switch { + } + return -9223372036854775807 + a +} + +func add_int64_Neg4294967296_ssa(a int64) int64 { + switch { + } + return a + -4294967296 +} +func add_Neg4294967296_int64_ssa(a int64) int64 { + switch { + } + return -4294967296 + a +} + +func add_int64_Neg1_ssa(a int64) int64 { + switch { + } + return a + -1 +} +func add_Neg1_int64_ssa(a int64) int64 { + switch { + } + return -1 + a +} + +func add_int64_0_ssa(a int64) int64 { + switch { + } + return a + 0 +} +func add_0_int64_ssa(a int64) int64 { + switch { + } + return 0 + a +} + +func add_int64_1_ssa(a int64) int64 { + switch { + } + return a + 1 +} +func add_1_int64_ssa(a int64) int64 { + switch { + } + return 1 + a +} + +func add_int64_4294967296_ssa(a int64) int64 { + switch { + } + return a + 4294967296 +} +func add_4294967296_int64_ssa(a int64) int64 { + switch { + } + return 4294967296 + a +} + +func add_int64_9223372036854775806_ssa(a int64) int64 { + switch { + } + return a + 9223372036854775806 +} +func add_9223372036854775806_int64_ssa(a int64) int64 { + switch { + } + return 9223372036854775806 + a +} + +func add_int64_9223372036854775807_ssa(a int64) int64 { + switch { + } + return a + 9223372036854775807 +} +func add_9223372036854775807_int64_ssa(a int64) int64 { + switch { + } + return 9223372036854775807 + a +} + +func sub_int64_Neg9223372036854775808_ssa(a int64) int64 { + switch { + } + return a - -9223372036854775808 +} +func sub_Neg9223372036854775808_int64_ssa(a int64) int64 { + switch { + } + return -9223372036854775808 - a +} + +func sub_int64_Neg9223372036854775807_ssa(a int64) int64 { + switch { + } + return a - -9223372036854775807 +} +func sub_Neg9223372036854775807_int64_ssa(a int64) int64 { + switch { + } + return -9223372036854775807 - a +} + +func sub_int64_Neg4294967296_ssa(a int64) int64 { + switch { + } + return a - -4294967296 +} +func sub_Neg4294967296_int64_ssa(a int64) int64 { + switch { + } + return -4294967296 - a +} + +func sub_int64_Neg1_ssa(a int64) int64 { + switch { + } + return a - -1 +} +func sub_Neg1_int64_ssa(a int64) int64 { + switch { + } + return -1 - a +} + +func sub_int64_0_ssa(a int64) int64 { + switch { + } + return a - 0 +} +func sub_0_int64_ssa(a int64) int64 { + switch { + } + return 0 - a +} + +func sub_int64_1_ssa(a int64) int64 { + switch { + } + return a - 1 +} +func sub_1_int64_ssa(a int64) int64 { + switch { + } + return 1 - a +} + +func sub_int64_4294967296_ssa(a int64) int64 { + switch { + } + return a - 4294967296 +} +func sub_4294967296_int64_ssa(a int64) int64 { + switch { + } + return 4294967296 - a +} + +func sub_int64_9223372036854775806_ssa(a int64) int64 { + switch { + } + return a - 9223372036854775806 +} +func sub_9223372036854775806_int64_ssa(a int64) int64 { + switch { + } + return 9223372036854775806 - a +} + +func sub_int64_9223372036854775807_ssa(a int64) int64 { + switch { + } + return a - 9223372036854775807 +} +func sub_9223372036854775807_int64_ssa(a int64) int64 { + switch { + } + return 9223372036854775807 - a +} + +func div_int64_Neg9223372036854775808_ssa(a int64) int64 { + switch { + } + return a / -9223372036854775808 +} +func div_Neg9223372036854775808_int64_ssa(a int64) int64 { + switch { + } + return -9223372036854775808 / a +} + +func div_int64_Neg9223372036854775807_ssa(a int64) int64 { + switch { + } + return a / -9223372036854775807 +} +func div_Neg9223372036854775807_int64_ssa(a int64) int64 { + switch { + } + return -9223372036854775807 / a +} + +func div_int64_Neg4294967296_ssa(a int64) int64 { + switch { + } + return a / -4294967296 +} +func div_Neg4294967296_int64_ssa(a int64) int64 { + switch { + } + return -4294967296 / a +} + +func div_int64_Neg1_ssa(a int64) int64 { + switch { + } + return a / -1 +} +func div_Neg1_int64_ssa(a int64) int64 { + switch { + } + return -1 / a +} + +func div_0_int64_ssa(a int64) int64 { + switch { + } + return 0 / a +} + +func div_int64_1_ssa(a int64) int64 { + switch { + } + return a / 1 +} +func div_1_int64_ssa(a int64) int64 { + switch { + } + return 1 / a +} + +func div_int64_4294967296_ssa(a int64) int64 { + switch { + } + return a / 4294967296 +} +func div_4294967296_int64_ssa(a int64) int64 { + switch { + } + return 4294967296 / a +} + +func div_int64_9223372036854775806_ssa(a int64) int64 { + switch { + } + return a / 9223372036854775806 +} +func div_9223372036854775806_int64_ssa(a int64) int64 { + switch { + } + return 9223372036854775806 / a +} + +func div_int64_9223372036854775807_ssa(a int64) int64 { + switch { + } + return a / 9223372036854775807 +} +func div_9223372036854775807_int64_ssa(a int64) int64 { + switch { + } + return 9223372036854775807 / a +} + +func mul_int64_Neg9223372036854775808_ssa(a int64) int64 { + switch { + } + return a * -9223372036854775808 +} +func mul_Neg9223372036854775808_int64_ssa(a int64) int64 { + switch { + } + return -9223372036854775808 * a +} + +func mul_int64_Neg9223372036854775807_ssa(a int64) int64 { + switch { + } + return a * -9223372036854775807 +} +func mul_Neg9223372036854775807_int64_ssa(a int64) int64 { + switch { + } + return -9223372036854775807 * a +} + +func mul_int64_Neg4294967296_ssa(a int64) int64 { + switch { + } + return a * -4294967296 +} +func mul_Neg4294967296_int64_ssa(a int64) int64 { + switch { + } + return -4294967296 * a +} + +func mul_int64_Neg1_ssa(a int64) int64 { + switch { + } + return a * -1 +} +func mul_Neg1_int64_ssa(a int64) int64 { + switch { + } + return -1 * a +} + +func mul_int64_0_ssa(a int64) int64 { + switch { + } + return a * 0 +} +func mul_0_int64_ssa(a int64) int64 { + switch { + } + return 0 * a +} + +func mul_int64_1_ssa(a int64) int64 { + switch { + } + return a * 1 +} +func mul_1_int64_ssa(a int64) int64 { + switch { + } + return 1 * a +} + +func mul_int64_4294967296_ssa(a int64) int64 { + switch { + } + return a * 4294967296 +} +func mul_4294967296_int64_ssa(a int64) int64 { + switch { + } + return 4294967296 * a +} + +func mul_int64_9223372036854775806_ssa(a int64) int64 { + switch { + } + return a * 9223372036854775806 +} +func mul_9223372036854775806_int64_ssa(a int64) int64 { + switch { + } + return 9223372036854775806 * a +} + +func mul_int64_9223372036854775807_ssa(a int64) int64 { + switch { + } + return a * 9223372036854775807 +} +func mul_9223372036854775807_int64_ssa(a int64) int64 { + switch { + } + return 9223372036854775807 * a +} + +func add_uint32_0_ssa(a uint32) uint32 { + switch { + } + return a + 0 +} +func add_0_uint32_ssa(a uint32) uint32 { + switch { + } + return 0 + a +} + +func add_uint32_1_ssa(a uint32) uint32 { + switch { + } + return a + 1 +} +func add_1_uint32_ssa(a uint32) uint32 { + switch { + } + return 1 + a +} + +func add_uint32_4294967295_ssa(a uint32) uint32 { + switch { + } + return a + 4294967295 +} +func add_4294967295_uint32_ssa(a uint32) uint32 { + switch { + } + return 4294967295 + a +} + +func sub_uint32_0_ssa(a uint32) uint32 { + switch { + } + return a - 0 +} +func sub_0_uint32_ssa(a uint32) uint32 { + switch { + } + return 0 - a +} + +func sub_uint32_1_ssa(a uint32) uint32 { + switch { + } + return a - 1 +} +func sub_1_uint32_ssa(a uint32) uint32 { + switch { + } + return 1 - a +} + +func sub_uint32_4294967295_ssa(a uint32) uint32 { + switch { + } + return a - 4294967295 +} +func sub_4294967295_uint32_ssa(a uint32) uint32 { + switch { + } + return 4294967295 - a +} + +func div_0_uint32_ssa(a uint32) uint32 { + switch { + } + return 0 / a +} + +func div_uint32_1_ssa(a uint32) uint32 { + switch { + } + return a / 1 +} +func div_1_uint32_ssa(a uint32) uint32 { + switch { + } + return 1 / a +} + +func div_uint32_4294967295_ssa(a uint32) uint32 { + switch { + } + return a / 4294967295 +} +func div_4294967295_uint32_ssa(a uint32) uint32 { + switch { + } + return 4294967295 / a +} + +func mul_uint32_0_ssa(a uint32) uint32 { + switch { + } + return a * 0 +} +func mul_0_uint32_ssa(a uint32) uint32 { + switch { + } + return 0 * a +} + +func mul_uint32_1_ssa(a uint32) uint32 { + switch { + } + return a * 1 +} +func mul_1_uint32_ssa(a uint32) uint32 { + switch { + } + return 1 * a +} + +func mul_uint32_4294967295_ssa(a uint32) uint32 { + switch { + } + return a * 4294967295 +} +func mul_4294967295_uint32_ssa(a uint32) uint32 { + switch { + } + return 4294967295 * a +} + +func add_int32_Neg2147483648_ssa(a int32) int32 { + switch { + } + return a + -2147483648 +} +func add_Neg2147483648_int32_ssa(a int32) int32 { + switch { + } + return -2147483648 + a +} + +func add_int32_Neg2147483647_ssa(a int32) int32 { + switch { + } + return a + -2147483647 +} +func add_Neg2147483647_int32_ssa(a int32) int32 { + switch { + } + return -2147483647 + a +} + +func add_int32_Neg1_ssa(a int32) int32 { + switch { + } + return a + -1 +} +func add_Neg1_int32_ssa(a int32) int32 { + switch { + } + return -1 + a +} + +func add_int32_0_ssa(a int32) int32 { + switch { + } + return a + 0 +} +func add_0_int32_ssa(a int32) int32 { + switch { + } + return 0 + a +} + +func add_int32_1_ssa(a int32) int32 { + switch { + } + return a + 1 +} +func add_1_int32_ssa(a int32) int32 { + switch { + } + return 1 + a +} + +func add_int32_2147483647_ssa(a int32) int32 { + switch { + } + return a + 2147483647 +} +func add_2147483647_int32_ssa(a int32) int32 { + switch { + } + return 2147483647 + a +} + +func sub_int32_Neg2147483648_ssa(a int32) int32 { + switch { + } + return a - -2147483648 +} +func sub_Neg2147483648_int32_ssa(a int32) int32 { + switch { + } + return -2147483648 - a +} + +func sub_int32_Neg2147483647_ssa(a int32) int32 { + switch { + } + return a - -2147483647 +} +func sub_Neg2147483647_int32_ssa(a int32) int32 { + switch { + } + return -2147483647 - a +} + +func sub_int32_Neg1_ssa(a int32) int32 { + switch { + } + return a - -1 +} +func sub_Neg1_int32_ssa(a int32) int32 { + switch { + } + return -1 - a +} + +func sub_int32_0_ssa(a int32) int32 { + switch { + } + return a - 0 +} +func sub_0_int32_ssa(a int32) int32 { + switch { + } + return 0 - a +} + +func sub_int32_1_ssa(a int32) int32 { + switch { + } + return a - 1 +} +func sub_1_int32_ssa(a int32) int32 { + switch { + } + return 1 - a +} + +func sub_int32_2147483647_ssa(a int32) int32 { + switch { + } + return a - 2147483647 +} +func sub_2147483647_int32_ssa(a int32) int32 { + switch { + } + return 2147483647 - a +} + +func div_int32_Neg2147483648_ssa(a int32) int32 { + switch { + } + return a / -2147483648 +} +func div_Neg2147483648_int32_ssa(a int32) int32 { + switch { + } + return -2147483648 / a +} + +func div_int32_Neg2147483647_ssa(a int32) int32 { + switch { + } + return a / -2147483647 +} +func div_Neg2147483647_int32_ssa(a int32) int32 { + switch { + } + return -2147483647 / a +} + +func div_int32_Neg1_ssa(a int32) int32 { + switch { + } + return a / -1 +} +func div_Neg1_int32_ssa(a int32) int32 { + switch { + } + return -1 / a +} + +func div_0_int32_ssa(a int32) int32 { + switch { + } + return 0 / a +} + +func div_int32_1_ssa(a int32) int32 { + switch { + } + return a / 1 +} +func div_1_int32_ssa(a int32) int32 { + switch { + } + return 1 / a +} + +func div_int32_2147483647_ssa(a int32) int32 { + switch { + } + return a / 2147483647 +} +func div_2147483647_int32_ssa(a int32) int32 { + switch { + } + return 2147483647 / a +} + +func mul_int32_Neg2147483648_ssa(a int32) int32 { + switch { + } + return a * -2147483648 +} +func mul_Neg2147483648_int32_ssa(a int32) int32 { + switch { + } + return -2147483648 * a +} + +func mul_int32_Neg2147483647_ssa(a int32) int32 { + switch { + } + return a * -2147483647 +} +func mul_Neg2147483647_int32_ssa(a int32) int32 { + switch { + } + return -2147483647 * a +} + +func mul_int32_Neg1_ssa(a int32) int32 { + switch { + } + return a * -1 +} +func mul_Neg1_int32_ssa(a int32) int32 { + switch { + } + return -1 * a +} + +func mul_int32_0_ssa(a int32) int32 { + switch { + } + return a * 0 +} +func mul_0_int32_ssa(a int32) int32 { + switch { + } + return 0 * a +} + +func mul_int32_1_ssa(a int32) int32 { + switch { + } + return a * 1 +} +func mul_1_int32_ssa(a int32) int32 { + switch { + } + return 1 * a +} + +func mul_int32_2147483647_ssa(a int32) int32 { + switch { + } + return a * 2147483647 +} +func mul_2147483647_int32_ssa(a int32) int32 { + switch { + } + return 2147483647 * a +} + +func add_uint16_0_ssa(a uint16) uint16 { + switch { + } + return a + 0 +} +func add_0_uint16_ssa(a uint16) uint16 { + switch { + } + return 0 + a +} + +func add_uint16_1_ssa(a uint16) uint16 { + switch { + } + return a + 1 +} +func add_1_uint16_ssa(a uint16) uint16 { + switch { + } + return 1 + a +} + +func add_uint16_65535_ssa(a uint16) uint16 { + switch { + } + return a + 65535 +} +func add_65535_uint16_ssa(a uint16) uint16 { + switch { + } + return 65535 + a +} + +func sub_uint16_0_ssa(a uint16) uint16 { + switch { + } + return a - 0 +} +func sub_0_uint16_ssa(a uint16) uint16 { + switch { + } + return 0 - a +} + +func sub_uint16_1_ssa(a uint16) uint16 { + switch { + } + return a - 1 +} +func sub_1_uint16_ssa(a uint16) uint16 { + switch { + } + return 1 - a +} + +func sub_uint16_65535_ssa(a uint16) uint16 { + switch { + } + return a - 65535 +} +func sub_65535_uint16_ssa(a uint16) uint16 { + switch { + } + return 65535 - a +} + +func div_0_uint16_ssa(a uint16) uint16 { + switch { + } + return 0 / a +} + +func div_uint16_1_ssa(a uint16) uint16 { + switch { + } + return a / 1 +} +func div_1_uint16_ssa(a uint16) uint16 { + switch { + } + return 1 / a +} + +func div_uint16_65535_ssa(a uint16) uint16 { + switch { + } + return a / 65535 +} +func div_65535_uint16_ssa(a uint16) uint16 { + switch { + } + return 65535 / a +} + +func mul_uint16_0_ssa(a uint16) uint16 { + switch { + } + return a * 0 +} +func mul_0_uint16_ssa(a uint16) uint16 { + switch { + } + return 0 * a +} + +func mul_uint16_1_ssa(a uint16) uint16 { + switch { + } + return a * 1 +} +func mul_1_uint16_ssa(a uint16) uint16 { + switch { + } + return 1 * a +} + +func mul_uint16_65535_ssa(a uint16) uint16 { + switch { + } + return a * 65535 +} +func mul_65535_uint16_ssa(a uint16) uint16 { + switch { + } + return 65535 * a +} + +func add_int16_Neg32768_ssa(a int16) int16 { + switch { + } + return a + -32768 +} +func add_Neg32768_int16_ssa(a int16) int16 { + switch { + } + return -32768 + a +} + +func add_int16_Neg32767_ssa(a int16) int16 { + switch { + } + return a + -32767 +} +func add_Neg32767_int16_ssa(a int16) int16 { + switch { + } + return -32767 + a +} + +func add_int16_Neg1_ssa(a int16) int16 { + switch { + } + return a + -1 +} +func add_Neg1_int16_ssa(a int16) int16 { + switch { + } + return -1 + a +} + +func add_int16_0_ssa(a int16) int16 { + switch { + } + return a + 0 +} +func add_0_int16_ssa(a int16) int16 { + switch { + } + return 0 + a +} + +func add_int16_1_ssa(a int16) int16 { + switch { + } + return a + 1 +} +func add_1_int16_ssa(a int16) int16 { + switch { + } + return 1 + a +} + +func add_int16_32766_ssa(a int16) int16 { + switch { + } + return a + 32766 +} +func add_32766_int16_ssa(a int16) int16 { + switch { + } + return 32766 + a +} + +func add_int16_32767_ssa(a int16) int16 { + switch { + } + return a + 32767 +} +func add_32767_int16_ssa(a int16) int16 { + switch { + } + return 32767 + a +} + +func sub_int16_Neg32768_ssa(a int16) int16 { + switch { + } + return a - -32768 +} +func sub_Neg32768_int16_ssa(a int16) int16 { + switch { + } + return -32768 - a +} + +func sub_int16_Neg32767_ssa(a int16) int16 { + switch { + } + return a - -32767 +} +func sub_Neg32767_int16_ssa(a int16) int16 { + switch { + } + return -32767 - a +} + +func sub_int16_Neg1_ssa(a int16) int16 { + switch { + } + return a - -1 +} +func sub_Neg1_int16_ssa(a int16) int16 { + switch { + } + return -1 - a +} + +func sub_int16_0_ssa(a int16) int16 { + switch { + } + return a - 0 +} +func sub_0_int16_ssa(a int16) int16 { + switch { + } + return 0 - a +} + +func sub_int16_1_ssa(a int16) int16 { + switch { + } + return a - 1 +} +func sub_1_int16_ssa(a int16) int16 { + switch { + } + return 1 - a +} + +func sub_int16_32766_ssa(a int16) int16 { + switch { + } + return a - 32766 +} +func sub_32766_int16_ssa(a int16) int16 { + switch { + } + return 32766 - a +} + +func sub_int16_32767_ssa(a int16) int16 { + switch { + } + return a - 32767 +} +func sub_32767_int16_ssa(a int16) int16 { + switch { + } + return 32767 - a +} + +func div_int16_Neg32768_ssa(a int16) int16 { + switch { + } + return a / -32768 +} +func div_Neg32768_int16_ssa(a int16) int16 { + switch { + } + return -32768 / a +} + +func div_int16_Neg32767_ssa(a int16) int16 { + switch { + } + return a / -32767 +} +func div_Neg32767_int16_ssa(a int16) int16 { + switch { + } + return -32767 / a +} + +func div_int16_Neg1_ssa(a int16) int16 { + switch { + } + return a / -1 +} +func div_Neg1_int16_ssa(a int16) int16 { + switch { + } + return -1 / a +} + +func div_0_int16_ssa(a int16) int16 { + switch { + } + return 0 / a +} + +func div_int16_1_ssa(a int16) int16 { + switch { + } + return a / 1 +} +func div_1_int16_ssa(a int16) int16 { + switch { + } + return 1 / a +} + +func div_int16_32766_ssa(a int16) int16 { + switch { + } + return a / 32766 +} +func div_32766_int16_ssa(a int16) int16 { + switch { + } + return 32766 / a +} + +func div_int16_32767_ssa(a int16) int16 { + switch { + } + return a / 32767 +} +func div_32767_int16_ssa(a int16) int16 { + switch { + } + return 32767 / a +} + +func mul_int16_Neg32768_ssa(a int16) int16 { + switch { + } + return a * -32768 +} +func mul_Neg32768_int16_ssa(a int16) int16 { + switch { + } + return -32768 * a +} + +func mul_int16_Neg32767_ssa(a int16) int16 { + switch { + } + return a * -32767 +} +func mul_Neg32767_int16_ssa(a int16) int16 { + switch { + } + return -32767 * a +} + +func mul_int16_Neg1_ssa(a int16) int16 { + switch { + } + return a * -1 +} +func mul_Neg1_int16_ssa(a int16) int16 { + switch { + } + return -1 * a +} + +func mul_int16_0_ssa(a int16) int16 { + switch { + } + return a * 0 +} +func mul_0_int16_ssa(a int16) int16 { + switch { + } + return 0 * a +} + +func mul_int16_1_ssa(a int16) int16 { + switch { + } + return a * 1 +} +func mul_1_int16_ssa(a int16) int16 { + switch { + } + return 1 * a +} + +func mul_int16_32766_ssa(a int16) int16 { + switch { + } + return a * 32766 +} +func mul_32766_int16_ssa(a int16) int16 { + switch { + } + return 32766 * a +} + +func mul_int16_32767_ssa(a int16) int16 { + switch { + } + return a * 32767 +} +func mul_32767_int16_ssa(a int16) int16 { + switch { + } + return 32767 * a +} + +func add_uint8_0_ssa(a uint8) uint8 { + switch { + } + return a + 0 +} +func add_0_uint8_ssa(a uint8) uint8 { + switch { + } + return 0 + a +} + +func add_uint8_1_ssa(a uint8) uint8 { + switch { + } + return a + 1 +} +func add_1_uint8_ssa(a uint8) uint8 { + switch { + } + return 1 + a +} + +func add_uint8_255_ssa(a uint8) uint8 { + switch { + } + return a + 255 +} +func add_255_uint8_ssa(a uint8) uint8 { + switch { + } + return 255 + a +} + +func sub_uint8_0_ssa(a uint8) uint8 { + switch { + } + return a - 0 +} +func sub_0_uint8_ssa(a uint8) uint8 { + switch { + } + return 0 - a +} + +func sub_uint8_1_ssa(a uint8) uint8 { + switch { + } + return a - 1 +} +func sub_1_uint8_ssa(a uint8) uint8 { + switch { + } + return 1 - a +} + +func sub_uint8_255_ssa(a uint8) uint8 { + switch { + } + return a - 255 +} +func sub_255_uint8_ssa(a uint8) uint8 { + switch { + } + return 255 - a +} + +func div_0_uint8_ssa(a uint8) uint8 { + switch { + } + return 0 / a +} + +func div_uint8_1_ssa(a uint8) uint8 { + switch { + } + return a / 1 +} +func div_1_uint8_ssa(a uint8) uint8 { + switch { + } + return 1 / a +} + +func div_uint8_255_ssa(a uint8) uint8 { + switch { + } + return a / 255 +} +func div_255_uint8_ssa(a uint8) uint8 { + switch { + } + return 255 / a +} + +func mul_uint8_0_ssa(a uint8) uint8 { + switch { + } + return a * 0 +} +func mul_0_uint8_ssa(a uint8) uint8 { + switch { + } + return 0 * a +} + +func mul_uint8_1_ssa(a uint8) uint8 { + switch { + } + return a * 1 +} +func mul_1_uint8_ssa(a uint8) uint8 { + switch { + } + return 1 * a +} + +func mul_uint8_255_ssa(a uint8) uint8 { + switch { + } + return a * 255 +} +func mul_255_uint8_ssa(a uint8) uint8 { + switch { + } + return 255 * a +} + +func add_int8_Neg128_ssa(a int8) int8 { + switch { + } + return a + -128 +} +func add_Neg128_int8_ssa(a int8) int8 { + switch { + } + return -128 + a +} + +func add_int8_Neg127_ssa(a int8) int8 { + switch { + } + return a + -127 +} +func add_Neg127_int8_ssa(a int8) int8 { + switch { + } + return -127 + a +} + +func add_int8_Neg1_ssa(a int8) int8 { + switch { + } + return a + -1 +} +func add_Neg1_int8_ssa(a int8) int8 { + switch { + } + return -1 + a +} + +func add_int8_0_ssa(a int8) int8 { + switch { + } + return a + 0 +} +func add_0_int8_ssa(a int8) int8 { + switch { + } + return 0 + a +} + +func add_int8_1_ssa(a int8) int8 { + switch { + } + return a + 1 +} +func add_1_int8_ssa(a int8) int8 { + switch { + } + return 1 + a +} + +func add_int8_126_ssa(a int8) int8 { + switch { + } + return a + 126 +} +func add_126_int8_ssa(a int8) int8 { + switch { + } + return 126 + a +} + +func add_int8_127_ssa(a int8) int8 { + switch { + } + return a + 127 +} +func add_127_int8_ssa(a int8) int8 { + switch { + } + return 127 + a +} + +func sub_int8_Neg128_ssa(a int8) int8 { + switch { + } + return a - -128 +} +func sub_Neg128_int8_ssa(a int8) int8 { + switch { + } + return -128 - a +} + +func sub_int8_Neg127_ssa(a int8) int8 { + switch { + } + return a - -127 +} +func sub_Neg127_int8_ssa(a int8) int8 { + switch { + } + return -127 - a +} + +func sub_int8_Neg1_ssa(a int8) int8 { + switch { + } + return a - -1 +} +func sub_Neg1_int8_ssa(a int8) int8 { + switch { + } + return -1 - a +} + +func sub_int8_0_ssa(a int8) int8 { + switch { + } + return a - 0 +} +func sub_0_int8_ssa(a int8) int8 { + switch { + } + return 0 - a +} + +func sub_int8_1_ssa(a int8) int8 { + switch { + } + return a - 1 +} +func sub_1_int8_ssa(a int8) int8 { + switch { + } + return 1 - a +} + +func sub_int8_126_ssa(a int8) int8 { + switch { + } + return a - 126 +} +func sub_126_int8_ssa(a int8) int8 { + switch { + } + return 126 - a +} + +func sub_int8_127_ssa(a int8) int8 { + switch { + } + return a - 127 +} +func sub_127_int8_ssa(a int8) int8 { + switch { + } + return 127 - a +} + +func div_int8_Neg128_ssa(a int8) int8 { + switch { + } + return a / -128 +} +func div_Neg128_int8_ssa(a int8) int8 { + switch { + } + return -128 / a +} + +func div_int8_Neg127_ssa(a int8) int8 { + switch { + } + return a / -127 +} +func div_Neg127_int8_ssa(a int8) int8 { + switch { + } + return -127 / a +} + +func div_int8_Neg1_ssa(a int8) int8 { + switch { + } + return a / -1 +} +func div_Neg1_int8_ssa(a int8) int8 { + switch { + } + return -1 / a +} + +func div_0_int8_ssa(a int8) int8 { + switch { + } + return 0 / a +} + +func div_int8_1_ssa(a int8) int8 { + switch { + } + return a / 1 +} +func div_1_int8_ssa(a int8) int8 { + switch { + } + return 1 / a +} + +func div_int8_126_ssa(a int8) int8 { + switch { + } + return a / 126 +} +func div_126_int8_ssa(a int8) int8 { + switch { + } + return 126 / a +} + +func div_int8_127_ssa(a int8) int8 { + switch { + } + return a / 127 +} +func div_127_int8_ssa(a int8) int8 { + switch { + } + return 127 / a +} + +func mul_int8_Neg128_ssa(a int8) int8 { + switch { + } + return a * -128 +} +func mul_Neg128_int8_ssa(a int8) int8 { + switch { + } + return -128 * a +} + +func mul_int8_Neg127_ssa(a int8) int8 { + switch { + } + return a * -127 +} +func mul_Neg127_int8_ssa(a int8) int8 { + switch { + } + return -127 * a +} + +func mul_int8_Neg1_ssa(a int8) int8 { + switch { + } + return a * -1 +} +func mul_Neg1_int8_ssa(a int8) int8 { + switch { + } + return -1 * a +} + +func mul_int8_0_ssa(a int8) int8 { + switch { + } + return a * 0 +} +func mul_0_int8_ssa(a int8) int8 { + switch { + } + return 0 * a +} + +func mul_int8_1_ssa(a int8) int8 { + switch { + } + return a * 1 +} +func mul_1_int8_ssa(a int8) int8 { + switch { + } + return 1 * a +} + +func mul_int8_126_ssa(a int8) int8 { + switch { + } + return a * 126 +} +func mul_126_int8_ssa(a int8) int8 { + switch { + } + return 126 * a +} + +func mul_int8_127_ssa(a int8) int8 { + switch { + } + return a * 127 +} +func mul_127_int8_ssa(a int8) int8 { + switch { + } + return 127 * a +} + +var failed bool + +func main() { + + 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 := 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 := 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 := 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 := 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 := 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 := 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("adiv_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("bdiv_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 := 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 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 index 2a56e2163f..f6f123c0be 100644 --- a/src/cmd/compile/internal/gc/testdata/arith_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/arith_ssa.go @@ -8,7 +8,7 @@ package main -// test64BitConstMulti tests that rewrite rules don't fold 64 bit constants +// test64BitConstMult tests that rewrite rules don't fold 64 bit constants // into multiply instructions. func test64BitConstMult() { want := int64(103079215109) diff --git a/src/cmd/compile/internal/ssa/TODO b/src/cmd/compile/internal/ssa/TODO index 1773dbbc98..9e52a67ed0 100644 --- a/src/cmd/compile/internal/ssa/TODO +++ b/src/cmd/compile/internal/ssa/TODO @@ -5,7 +5,7 @@ Coverage -------- - Floating point numbers - Complex numbers -- Integer division (HMUL & MOD) +- Integer division (MOD) - Fat objects (strings/slices/interfaces) vs. Phi - Defer? - Closure args @@ -50,6 +50,7 @@ Optimizations (better compiler) - Constant cache - Reuseable slices (e.g. []int of size NumValues()) cached in Func - Handle signed division overflow and sign extension earlier +- Implement 64 bit const division with high multiply, maybe in the frontend? Regalloc -------- diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 0cde6f26d4..21f4d01296 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -45,6 +45,13 @@ (Div8 x y) -> (DIVW (SignExt8to16 x) (SignExt8to16 y)) (Div8u x y) -> (DIVWU (ZeroExt8to16 x) (ZeroExt8to16 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) + (And64 x y) -> (ANDQ x y) (And32 x y) -> (ANDL x y) (And16 x y) -> (ANDW x y) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 220e5b01cd..24c8a199b5 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -101,6 +101,8 @@ func init() { 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} gp2flags = regInfo{inputs: []regMask{gpsp, gpsp}, outputs: flagsonly} gp1flags = regInfo{inputs: []regMask{gpsp}, outputs: flagsonly} @@ -184,10 +186,16 @@ func init() { {name: "MULWconst", reg: gp11, asm: "IMULW"}, // arg0 * auxint {name: "MULBconst", reg: gp11, asm: "IMULW"}, // arg0 * auxint + {name: "HMULL", reg: gp11hmul, asm: "IMULL"}, // (arg0 * arg1) >> width + {name: "HMULW", reg: gp11hmul, asm: "IMULW"}, // (arg0 * arg1) >> width + {name: "HMULB", reg: gp11hmul, asm: "IMULB"}, // (arg0 * arg1) >> width + {name: "HMULLU", reg: gp11hmul, asm: "MULL"}, // (arg0 * arg1) >> width + {name: "HMULWU", reg: gp11hmul, asm: "MULW"}, // (arg0 * arg1) >> width + {name: "HMULBU", reg: gp11hmul, asm: "MULB"}, // (arg0 * arg1) >> width + {name: "DIVQ", reg: gp11div, asm: "IDIVQ"}, // arg0 / arg1 {name: "DIVL", reg: gp11div, asm: "IDIVL"}, // arg0 / arg1 {name: "DIVW", reg: gp11div, asm: "IDIVW"}, // arg0 / arg1 - {name: "DIVQU", reg: gp11div, asm: "DIVQ"}, // arg0 / arg1 {name: "DIVLU", reg: gp11div, asm: "DIVL"}, // arg0 / arg1 {name: "DIVWU", reg: gp11div, asm: "DIVW"}, // arg0 / arg1 diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index a0d8f8e000..44eed6aeba 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -37,6 +37,14 @@ var genericOps = []opData{ {name: "Div64F"}, // TODO: Div8, Div16, Div32, Div64 and unsigned + {name: "Hmul8"}, // (arg0 * arg1) >> width + {name: "Hmul8u"}, + {name: "Hmul16"}, + {name: "Hmul16u"}, + {name: "Hmul32"}, + {name: "Hmul32u"}, + // frontend currently doesn't generate a 64 bit hmul + {name: "Div8"}, // arg0 / arg1 {name: "Div8u"}, {name: "Div16"}, diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 44fd6e3737..f8e5e623b6 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -93,6 +93,12 @@ const ( OpAMD64MULLconst OpAMD64MULWconst OpAMD64MULBconst + OpAMD64HMULL + OpAMD64HMULW + OpAMD64HMULB + OpAMD64HMULLU + OpAMD64HMULWU + OpAMD64HMULBU OpAMD64DIVQ OpAMD64DIVL OpAMD64DIVW @@ -245,6 +251,12 @@ const ( OpMul64F OpDiv32F OpDiv64F + OpHmul8 + OpHmul8u + OpHmul16 + OpHmul16u + OpHmul32 + OpHmul32u OpDiv8 OpDiv8u OpDiv16 @@ -977,6 +989,90 @@ var opcodeTable = [...]opInfo{ }, }, }, + { + name: "HMULL", + 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", + 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", + 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: "HMULLU", + 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", + 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", + 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: "DIVQ", asm: x86.AIDIVQ, @@ -2690,6 +2786,30 @@ var opcodeTable = [...]opInfo{ name: "Div64F", generic: true, }, + { + name: "Hmul8", + generic: true, + }, + { + name: "Hmul8u", + generic: true, + }, + { + name: "Hmul16", + generic: true, + }, + { + name: "Hmul16u", + generic: true, + }, + { + name: "Hmul32", + generic: true, + }, + { + name: "Hmul32u", + generic: true, + }, { name: "Div8", generic: true, diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 993838b537..4013611b88 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -2335,6 +2335,114 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end22eaafbcfe70447f79d9b3e6cc395bbd end22eaafbcfe70447f79d9b3e6cc395bbd: ; + case OpHmul16: + // match: (Hmul16 x y) + // cond: + // result: (HMULW x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64HMULW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end1b9ff394bb3b06fc109637656b6875f5 + end1b9ff394bb3b06fc109637656b6875f5: + ; + case OpHmul16u: + // match: (Hmul16u x y) + // cond: + // result: (HMULWU x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64HMULWU + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto endee9089e794a43f2ce1619a6ef61670f4 + endee9089e794a43f2ce1619a6ef61670f4: + ; + case OpHmul32: + // match: (Hmul32 x y) + // cond: + // result: (HMULL x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64HMULL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end7c83c91ef2634f0b1da4f49350b437b1 + end7c83c91ef2634f0b1da4f49350b437b1: + ; + case OpHmul32u: + // match: (Hmul32u x y) + // cond: + // result: (HMULLU x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64HMULLU + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end3c4f36611dc8815aa2a63d4ec0eaa06d + end3c4f36611dc8815aa2a63d4ec0eaa06d: + ; + case OpHmul8: + // match: (Hmul8 x y) + // cond: + // result: (HMULB x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64HMULB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end51b2cc9f1ed15314e68fc81024f281a7 + end51b2cc9f1ed15314e68fc81024f281a7: + ; + case OpHmul8u: + // match: (Hmul8u x y) + // cond: + // result: (HMULBU x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64HMULBU + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto ende68d7b3a3c774cedc3522af9d635c39d + ende68d7b3a3c774cedc3522af9d635c39d: + ; case OpITab: // match: (ITab (Load ptr mem)) // cond: -- cgit v1.3 From 46e62f873a34b06348bdaf231f1b72367950732e Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Tue, 18 Aug 2015 14:17:30 -0700 Subject: [dev.ssa] cmd/compile: used Bounded field to fix empty range loops for i, v := range a { } Walk converts this to a regular for loop, like this: for i := 0, p := &a[0]; i < len(a); i++, p++ { v := *p } Unfortunately, &a[0] fails its bounds check when a is the empty slice (or string). The old compiler gets around this by marking &a[0] as Bounded, meaning "don't emit bounds checks for this index op". This change makes SSA honor that same mark. The SSA compiler hasn't implemented bounds check panics yet, so the failed bounds check just causes the current routine to return immediately. Fixes bytes package tests. Change-Id: Ibe838853ef4046c92f76adbded8cca3b1e449e0b Reviewed-on: https://go-review.googlesource.com/13685 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/gc/ssa.go | 12 +++++++++--- src/cmd/compile/internal/gc/testdata/ctl_ssa.go | 15 +++++++++++++++ 2 files changed, 24 insertions(+), 3 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index f2dd20bcb4..6a5ecbf04d 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1313,7 +1313,9 @@ func (s *state) expr(n *Node) *ssa.Value { len = s.constInt(Types[TINT], n.Left.Type.Bound) elemtype = n.Left.Type.Type } - s.boundsCheck(i, len) + if !n.Bounded { + s.boundsCheck(i, len) + } return s.newValue2(ssa.OpArrayIndex, elemtype, a, i) } else { // slice p := s.addr(n) @@ -1530,7 +1532,9 @@ func (s *state) addr(n *Node) *ssa.Value { i := s.expr(n.Right) i = s.extendIndex(i) len := s.newValue1(ssa.OpSliceLen, Types[TUINTPTR], a) - s.boundsCheck(i, len) + if !n.Bounded { + s.boundsCheck(i, len) + } p := s.newValue1(ssa.OpSlicePtr, Ptrto(n.Left.Type.Type), a) return s.newValue2(ssa.OpPtrIndex, Ptrto(n.Left.Type.Type), p, i) } else { // array @@ -1538,7 +1542,9 @@ func (s *state) addr(n *Node) *ssa.Value { i := s.expr(n.Right) i = s.extendIndex(i) len := s.constInt(Types[TINT], n.Left.Type.Bound) - s.boundsCheck(i, len) + if !n.Bounded { + s.boundsCheck(i, len) + } return s.newValue2(ssa.OpPtrIndex, Ptrto(n.Left.Type.Type), a, i) } case OIND: diff --git a/src/cmd/compile/internal/gc/testdata/ctl_ssa.go b/src/cmd/compile/internal/gc/testdata/ctl_ssa.go index 7377c9aee8..f7c3b80799 100644 --- a/src/cmd/compile/internal/gc/testdata/ctl_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/ctl_ssa.go @@ -43,10 +43,25 @@ func testPhiControl() { } } +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 + } +} + var failed = false func main() { testPhiControl() + testEmptyRange() if failed { panic("failed") } -- cgit v1.3 From 8d23681cc836db6ed233564781747592f1c41225 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Tue, 18 Aug 2015 15:25:40 -0700 Subject: [dev.ssa] cmd/compile: implement more panic stuff Implement index check panics (and slice check panics, for when we need those). Clean up nil check. Now that the new regalloc is in we can use the register we just tested as the address 0 destination. Remove jumps after panic calls, they are unreachable. Change-Id: Ifee6e510cdea49cc7c7056887e4f06c67488d491 Reviewed-on: https://go-review.googlesource.com/13687 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/gc/ssa.go | 50 +++++++++++++++++++------- src/cmd/compile/internal/ssa/gen/AMD64.rules | 2 ++ src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 5 ++- src/cmd/compile/internal/ssa/gen/genericOps.go | 6 ++-- src/cmd/compile/internal/ssa/opGen.go | 24 +++++++++++++ src/cmd/compile/internal/ssa/rewriteAMD64.go | 32 +++++++++++++++++ 6 files changed, 104 insertions(+), 15 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 6a5ecbf04d..1fb5485183 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1617,6 +1617,9 @@ func (s *state) nilCheck(ptr *ssa.Value) { // 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. @@ -1627,9 +1630,15 @@ func (s *state) boundsCheck(idx, len *ssa.Value) { b.Control = cmp b.Likely = ssa.BranchLikely bNext := s.f.NewBlock(ssa.BlockPlain) + bPanic := s.f.NewBlock(ssa.BlockPlain) addEdge(b, bNext) - addEdge(b, s.exit) - // TODO: don't go directly to s.exit. Go to a stub that calls panicindex first. + addEdge(b, bPanic) + addEdge(bPanic, s.exit) + s.startBlock(bPanic) + // The panic check takes/returns memory to ensure that the right + // memory state is observed if the panic happens. + s.vars[&memvar] = s.newValue1(ssa.OpPanicIndexCheck, ssa.TypeMem, s.mem()) + s.endBlock() s.startBlock(bNext) } @@ -2416,20 +2425,26 @@ func genValue(v *ssa.Value) { Warnl(int(v.Line), "generated nil check") } // Write to memory address 0. It doesn't matter what we write; use AX. - // XORL AX, AX; MOVL AX, (AX) is shorter than MOVL AX, 0. - // TODO: If we had the pointer (v.Args[0]) in a register r, - // we could use MOVL AX, (r) instead of having to zero AX. - // But it isn't worth loading r just to accomplish that. - p := Prog(x86.AXORL) - p.From.Type = obj.TYPE_REG - p.From.Reg = x86.REG_AX - p.To.Type = obj.TYPE_REG - p.To.Reg = x86.REG_AX + // Input 0 is the pointer we just checked, use it as the destination. + r := regnum(v.Args[0]) q := Prog(x86.AMOVL) q.From.Type = obj.TYPE_REG q.From.Reg = x86.REG_AX q.To.Type = obj.TYPE_MEM - q.To.Reg = x86.REG_AX + q.To.Reg = r + // TODO: need AUNDEF here? + case ssa.OpAMD64LoweredPanicIndexCheck: + p := Prog(obj.ACALL) + p.To.Type = obj.TYPE_MEM + p.To.Name = obj.NAME_EXTERN + p.To.Sym = Linksym(Panicindex.Sym) + // TODO: need AUNDEF here? + case ssa.OpAMD64LoweredPanicSliceCheck: + p := Prog(obj.ACALL) + p.To.Type = obj.TYPE_MEM + p.To.Name = obj.NAME_EXTERN + p.To.Sym = Linksym(panicslice.Sym) + // TODO: need AUNDEF here? case ssa.OpAMD64LoweredGetG: r := regnum(v) // See the comments in cmd/internal/obj/x86/obj6.go @@ -2545,6 +2560,17 @@ var blockJump = [...]struct{ asm, invasm int }{ func genBlock(b, next *ssa.Block, branches []branch) []branch { lineno = b.Line + + // after a panic call, don't emit any branch code + if len(b.Values) > 0 { + switch b.Values[len(b.Values)-1].Op { + case ssa.OpAMD64LoweredPanicNilCheck, + ssa.OpAMD64LoweredPanicIndexCheck, + ssa.OpAMD64LoweredPanicSliceCheck: + return branches + } + } + switch b.Kind { case ssa.BlockPlain: if b.Succs[0] != next { diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 21f4d01296..919336e869 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -245,6 +245,8 @@ (IsInBounds idx len) -> (SETB (CMPQ idx len)) (PanicNilCheck ptr mem) -> (LoweredPanicNilCheck ptr mem) +(PanicIndexCheck mem) -> (LoweredPanicIndexCheck mem) +(PanicSliceCheck mem) -> (LoweredPanicSliceCheck mem) (GetG) -> (LoweredGetG) (Move [size] dst src mem) -> (REPMOVSB dst src (MOVQconst [size]) mem) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 24c8a199b5..e633f82348 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -103,6 +103,7 @@ func init() { clobbers: dx | flags} gp11hmul = regInfo{inputs: []regMask{ax, gpsp}, outputs: []regMask{dx}, clobbers: ax | flags} + gp10 = regInfo{inputs: []regMask{gp}} gp2flags = regInfo{inputs: []regMask{gpsp, gpsp}, outputs: flagsonly} gp1flags = regInfo{inputs: []regMask{gpsp}, outputs: flagsonly} @@ -353,7 +354,9 @@ func init() { {name: "InvertFlags"}, // reverse direction of arg0 // Pseudo-ops - {name: "LoweredPanicNilCheck"}, + {name: "LoweredPanicNilCheck", reg: gp10}, + {name: "LoweredPanicIndexCheck"}, + {name: "LoweredPanicSliceCheck"}, {name: "LoweredGetG", reg: gp01}, } diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 44eed6aeba..2024788c5d 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -282,8 +282,10 @@ var genericOps = []opData{ {name: "IsInBounds"}, // 0 <= arg0 < arg1 // Pseudo-ops - {name: "PanicNilCheck"}, // trigger a dereference fault; arg0=nil ptr, arg1=mem - {name: "GetG"}, // runtime.getg() (read g pointer) + {name: "PanicNilCheck"}, // trigger a dereference fault; arg0=nil ptr, arg1=mem, returns mem + {name: "PanicIndexCheck"}, // trigger a bounds check failure, arg0=mem, returns mem + {name: "PanicSliceCheck"}, // trigger a slice bounds check failure, arg0=mem, returns mem + {name: "GetG"}, // runtime.getg() (read g pointer) // Indexing operations {name: "ArrayIndex"}, // arg0=array, arg1=index. Returns a[i] diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index f8e5e623b6..003aacffbb 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -227,6 +227,8 @@ const ( OpAMD64REPMOVSB OpAMD64InvertFlags OpAMD64LoweredPanicNilCheck + OpAMD64LoweredPanicIndexCheck + OpAMD64LoweredPanicSliceCheck OpAMD64LoweredGetG OpAdd8 @@ -426,6 +428,8 @@ const ( OpIsNonNil OpIsInBounds OpPanicNilCheck + OpPanicIndexCheck + OpPanicSliceCheck OpGetG OpArrayIndex OpPtrIndex @@ -2686,6 +2690,18 @@ var opcodeTable = [...]opInfo{ }, { name: "LoweredPanicNilCheck", + reg: regInfo{ + inputs: []inputInfo{ + {0, 65519}, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + }, + }, + { + name: "LoweredPanicIndexCheck", + reg: regInfo{}, + }, + { + name: "LoweredPanicSliceCheck", reg: regInfo{}, }, { @@ -3486,6 +3502,14 @@ var opcodeTable = [...]opInfo{ name: "PanicNilCheck", generic: true, }, + { + name: "PanicIndexCheck", + generic: true, + }, + { + name: "PanicSliceCheck", + generic: true, + }, { name: "GetG", generic: true, diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 4013611b88..4265cfcb84 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -5789,6 +5789,22 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end6f8a8c559a167d1f0a5901d09a1fb248 end6f8a8c559a167d1f0a5901d09a1fb248: ; + case OpPanicIndexCheck: + // match: (PanicIndexCheck mem) + // cond: + // result: (LoweredPanicIndexCheck mem) + { + mem := v.Args[0] + v.Op = OpAMD64LoweredPanicIndexCheck + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(mem) + return true + } + goto enda5014ba73d3550a5b66424044395c70f + enda5014ba73d3550a5b66424044395c70f: + ; case OpPanicNilCheck: // match: (PanicNilCheck ptr mem) // cond: @@ -5807,6 +5823,22 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto enda02b1ad5a6f929b782190145f2c8628b enda02b1ad5a6f929b782190145f2c8628b: ; + case OpPanicSliceCheck: + // match: (PanicSliceCheck mem) + // cond: + // result: (LoweredPanicSliceCheck mem) + { + mem := v.Args[0] + v.Op = OpAMD64LoweredPanicSliceCheck + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(mem) + return true + } + goto end238ed0074810b55bd2bba7b45cdeed68 + end238ed0074810b55bd2bba7b45cdeed68: + ; case OpRsh16Ux16: // match: (Rsh16Ux16 x y) // cond: -- cgit v1.3 From 9f954db170dff18a33fbd333082cd8758851f936 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Tue, 18 Aug 2015 10:26:28 -0700 Subject: [dev.ssa] cmd/compile: add decompose pass Decompose breaks compound objects up into pieces that can be operated on by the target architecture. The decompose pass only does phi ops, the rest is done by the rewrite rules in generic.rules. Compound objects include strings,slices,interfaces,structs,arrays. Arrays aren't decomposed because of indexing (we could support constant indexes, but dynamic indexes can't be handled using SSA). Structs will come in a subsequent CL. TODO: after this pass we have lost the association between, e.g., a string's pointer and its size. It would be nice if we could keep that information around for debugging info somehow. Change-Id: I6379ab962a7beef62297d0f68c421f22aa0a0901 Reviewed-on: https://go-review.googlesource.com/13683 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/gc/ssa.go | 56 ++- .../compile/internal/gc/testdata/compound_ssa.go | 91 ++++ src/cmd/compile/internal/gc/type.go | 4 + src/cmd/compile/internal/ssa/compile.go | 3 + src/cmd/compile/internal/ssa/decompose.go | 93 +++++ src/cmd/compile/internal/ssa/gen/generic.rules | 84 +++- src/cmd/compile/internal/ssa/gen/genericOps.go | 8 +- src/cmd/compile/internal/ssa/opGen.go | 20 + src/cmd/compile/internal/ssa/rewritegeneric.go | 459 +++++++++++++++------ src/cmd/compile/internal/ssa/type.go | 30 +- src/cmd/compile/internal/ssa/type_test.go | 30 +- 11 files changed, 712 insertions(+), 166 deletions(-) create mode 100644 src/cmd/compile/internal/gc/testdata/compound_ssa.go create mode 100644 src/cmd/compile/internal/ssa/decompose.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 1fb5485183..a324ed2a42 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1072,7 +1072,15 @@ func (s *state) expr(n *Node) *ssa.Value { case CTBOOL: return s.entryNewValue0A(ssa.OpConstBool, n.Type, n.Val().U) case CTNIL: - return s.entryNewValue0(ssa.OpConstNil, n.Type) + 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() { @@ -1470,6 +1478,10 @@ func (s *state) zeroVal(t *Type) *ssa.Value { return s.entryNewValue0(ssa.OpConstNil, t) case t.IsBoolean(): return s.entryNewValue0A(ssa.OpConstBool, t, false) // TODO: store bools as 0/1 in AuxInt? + case t.IsInterface(): + return s.entryNewValue0(ssa.OpConstInterface, t) + case t.IsSlice(): + return s.entryNewValue0(ssa.OpConstSlice, t) } s.Unimplementedf("zero for type %v not implemented", t) return nil @@ -1582,11 +1594,47 @@ func canSSA(n *Node) bool { if n.Class == PPARAMOUT { return false } - if Isfat(n.Type) { + 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 } - return true - // TODO: try to make more variables SSAable. + 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) > 4 { + // 4 is an arbitrary constant. Same reasoning + // as above, lots of small fields would waste + // register space needed by other values. + return false + } + for t1 := t.Type; t1 != nil; t1 = t1.Down { + if !canSSAType(t1.Type) { + return false + } + } + return false // until it is implemented + //return true + default: + return true + } } // nilCheck generates nil pointer checking code. 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 0000000000..9b84ce4b11 --- /dev/null +++ b/src/cmd/compile/internal/gc/testdata/compound_ssa.go @@ -0,0 +1,91 @@ +// 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 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() + if failed { + panic("failed") + } +} diff --git a/src/cmd/compile/internal/gc/type.go b/src/cmd/compile/internal/gc/type.go index f60d01b3bb..bcad025ba6 100644 --- a/src/cmd/compile/internal/gc/type.go +++ b/src/cmd/compile/internal/gc/type.go @@ -68,6 +68,10 @@ func (t *Type) IsSlice() bool { return t.Etype == TARRAY && t.Bound < 0 } +func (t *Type) IsInterface() bool { + return t.Etype == TINTER +} + func (t *Type) Elem() ssa.Type { return t.Type } diff --git a/src/cmd/compile/internal/ssa/compile.go b/src/cmd/compile/internal/ssa/compile.go index e85fb10e00..7413e721fe 100644 --- a/src/cmd/compile/internal/ssa/compile.go +++ b/src/cmd/compile/internal/ssa/compile.go @@ -60,6 +60,7 @@ type pass struct { var passes = [...]pass{ {"phielim", phielim}, {"copyelim", copyelim}, + {"decompose", decompose}, {"early deadcode", deadcode}, // remove generated dead code to avoid doing pointless work during opt {"opt", opt}, {"opt deadcode", deadcode}, // remove any blocks orphaned during opt @@ -103,6 +104,8 @@ var passOrder = [...]constraint{ // 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 compound objects + {"decompose", "opt"}, // don't layout blocks until critical edges have been removed {"critical", "layout"}, // regalloc requires the removal of all critical edges diff --git a/src/cmd/compile/internal/ssa/decompose.go b/src/cmd/compile/internal/ssa/decompose.go new file mode 100644 index 0000000000..534ffc269e --- /dev/null +++ b/src/cmd/compile/internal/ssa/decompose.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 ssa + +// decompose converts phi ops on compound types into phi +// ops on simple types. +// (The remaining compound ops are decomposed with rewrite rules.) +func decompose(f *Func) { + for _, b := range f.Blocks { + for _, v := range b.Values { + if v.Op != OpPhi { + continue + } + switch { + case v.Type.IsString(): + decomposeStringPhi(v) + case v.Type.IsSlice(): + decomposeSlicePhi(v) + case v.Type.IsInterface(): + decomposeInterfacePhi(v) + //case v.Type.IsStruct(): + // decomposeStructPhi(v) + case v.Type.Size() > f.Config.IntSize: + f.Unimplementedf("undecomposed type %s", v.Type) + } + } + } + // TODO: decompose complex? + // TODO: decompose 64-bit ops on 32-bit archs? +} + +func decomposeStringPhi(v *Value) { + fe := v.Block.Func.Config.fe + ptrType := fe.TypeBytePtr() + lenType := fe.TypeUintptr() + + 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.Op = OpStringMake + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v.AddArg(len) +} + +func decomposeSlicePhi(v *Value) { + fe := v.Block.Func.Config.fe + ptrType := fe.TypeBytePtr() + lenType := fe.TypeUintptr() + + 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.Op = OpSliceMake + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v.AddArg(len) + v.AddArg(cap) +} + +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.Op = OpIMake + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(itab) + v.AddArg(data) +} +func decomposeStructPhi(v *Value) { + // TODO +} diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index db66a457c3..7be00569ea 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -59,36 +59,90 @@ (Com32 (Com32 x)) -> x (Com64 (Com64 x)) -> x -// tear apart slices -// TODO: anything that generates a slice needs to go in here. -(SlicePtr (Load ptr mem)) -> (Load ptr mem) -(SliceLen (Load ptr mem)) -> (Load (AddPtr ptr (ConstPtr [config.PtrSize])) mem) -(SliceCap (Load ptr mem)) -> (Load (AddPtr ptr (ConstPtr [config.PtrSize*2])) mem) - // slice and interface comparisons // the frontend ensures that we can only compare against nil // start by putting nil on the right to simplify the other rules (EqFat x y) && x.Op == OpConstNil && y.Op != OpConstNil -> (EqFat y x) (NeqFat x y) && x.Op == OpConstNil && y.Op != OpConstNil -> (NeqFat y x) // it suffices to check the first word (backing array for slices, dynamic type for interfaces) -(EqFat (Load ptr mem) (ConstNil)) -> (EqPtr (Load ptr mem) (ConstPtr [0])) -(NeqFat (Load ptr mem) (ConstNil)) -> (NeqPtr (Load ptr mem) (ConstPtr [0])) +(EqFat (Load ptr mem) (ConstNil)) -> (EqPtr (Load ptr mem) (ConstPtr [0])) +(NeqFat (Load ptr mem) (ConstNil)) -> (NeqPtr (Load ptr mem) (ConstPtr [0])) // indexing operations // Note: bounds check has already been done (ArrayIndex (Load ptr mem) idx) -> (Load (PtrIndex ptr idx) mem) -(PtrIndex ptr idx) -> (AddPtr ptr (MulPtr idx (ConstPtr [t.Elem().Size()]))) +(PtrIndex ptr idx) -> (AddPtr ptr (MulPtr idx (ConstPtr [t.Elem().Size()]))) (StructSelect [idx] (Load ptr mem)) -> (Load (OffPtr [idx] ptr) mem) -// big-object moves -(Store [size] dst (Load src mem) mem) && size > config.IntSize -> (Move [size] dst src mem) - // string ops -(ConstString {s}) -> (StringMake (Addr {config.fe.StringData(s.(string))} (SB )) (ConstPtr [int64(len(s.(string)))])) -(Load ptr mem) && t.IsString() -> (StringMake (Load ptr mem) (Load (OffPtr [config.PtrSize] ptr) mem)) (StringPtr (StringMake ptr _)) -> ptr (StringLen (StringMake _ len)) -> len -(Store [2*config.PtrSize] dst str mem) && str.Type.IsString() -> (Store [config.PtrSize] (OffPtr [config.PtrSize] dst) (StringLen str) (Store [config.PtrSize] dst (StringPtr str) mem)) +(ConstString {s}) -> + (StringMake + (Addr {config.fe.StringData(s.(string))} + (SB )) + (ConstPtr [int64(len(s.(string)))])) +(Load ptr mem) && t.IsString() -> + (StringMake + (Load ptr mem) + (Load + (OffPtr [config.PtrSize] ptr) + mem)) +(Store [2*config.PtrSize] dst (StringMake ptr len) mem) -> + (Store [config.PtrSize] + (OffPtr [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) -> + (SliceMake + (ConstNil ) + (ConstPtr ) + (ConstPtr )) + +(Load ptr mem) && t.IsSlice() -> + (SliceMake + (Load ptr mem) + (Load + (OffPtr [config.PtrSize] ptr) + mem) + (Load + (OffPtr [2*config.PtrSize] ptr) + mem)) +(Store [3*config.PtrSize] dst (SliceMake ptr len cap) mem) -> + (Store [config.PtrSize] + (OffPtr [2*config.PtrSize] dst) + cap + (Store [config.PtrSize] + (OffPtr [config.PtrSize] dst) + len + (Store [config.PtrSize] dst ptr mem))) + +// interface ops +(ITab (IMake itab _)) -> itab +(IData (IMake _ data)) -> data +(ConstInterface) -> + (IMake + (ConstNil ) + (ConstNil )) +(Load ptr mem) && t.IsInterface() -> + (IMake + (Load ptr mem) + (Load + (OffPtr [config.PtrSize] ptr) + mem)) +(Store [2*config.PtrSize] dst (IMake itab data) mem) -> + (Store [config.PtrSize] + (OffPtr [config.PtrSize] dst) + data + (Store [config.PtrSize] dst itab mem)) + +// big-object moves (TODO: remove?) +(Store [size] dst (Load src mem) mem) && size > config.IntSize -> (Move [size] dst src mem) (If (IsNonNil (GetG)) yes no) -> (Plain nil yes) diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 2024788c5d..5b8b064bb5 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -229,7 +229,9 @@ var genericOps = []opData{ {name: "Const64"}, {name: "Const32F"}, {name: "Const64F"}, - {name: "ConstPtr"}, // pointer-sized integer constant + {name: "ConstPtr"}, // pointer-sized integer constant + {name: "ConstInterface"}, // nil interface + {name: "ConstSlice"}, // nil slice // TODO: Const32F, ... // Constant-like things @@ -305,7 +307,9 @@ var genericOps = []opData{ {name: "StringLen"}, // len(arg0) // Interfaces - {name: "ITab"}, // arg0=interface, returns itable field + {name: "IMake"}, // arg0=itab, arg1=data + {name: "ITab"}, // arg0=interface, returns itable field + {name: "IData"}, // arg0=interface, returns data field // Spill&restore ops for the register allocator. These are // semantically identical to OpCopy; they do not take/return diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 003aacffbb..17d4edb221 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -396,6 +396,8 @@ const ( OpConst32F OpConst64F OpConstPtr + OpConstInterface + OpConstSlice OpArg OpAddr OpSP @@ -442,7 +444,9 @@ const ( OpStringMake OpStringPtr OpStringLen + OpIMake OpITab + OpIData OpStoreReg OpLoadReg OpFwdRef @@ -3374,6 +3378,14 @@ var opcodeTable = [...]opInfo{ name: "ConstPtr", generic: true, }, + { + name: "ConstInterface", + generic: true, + }, + { + name: "ConstSlice", + generic: true, + }, { name: "Arg", generic: true, @@ -3558,10 +3570,18 @@ var opcodeTable = [...]opInfo{ name: "StringLen", generic: true, }, + { + name: "IMake", + generic: true, + }, { name: "ITab", generic: true, }, + { + name: "IData", + generic: true, + }, { name: "StoreReg", generic: true, diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index 4c278cb168..bd53e05230 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -237,10 +237,53 @@ func rewriteValuegeneric(v *Value, config *Config) bool { goto end4d92ff3ba567d9afd38fc9ca113602ad end4d92ff3ba567d9afd38fc9ca113602ad: ; + case OpConstInterface: + // match: (ConstInterface) + // cond: + // result: (IMake (ConstNil ) (ConstNil )) + { + v.Op = OpIMake + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpConstNil, TypeInvalid) + v0.Type = config.fe.TypeBytePtr() + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpConstNil, TypeInvalid) + v1.Type = config.fe.TypeBytePtr() + v.AddArg(v1) + return true + } + goto end0367bd8f20a320cc41568f2b28657f6b + end0367bd8f20a320cc41568f2b28657f6b: + ; + case OpConstSlice: + // match: (ConstSlice) + // cond: + // result: (SliceMake (ConstNil ) (ConstPtr ) (ConstPtr )) + { + v.Op = OpSliceMake + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpConstNil, TypeInvalid) + v0.Type = config.fe.TypeBytePtr() + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpConstPtr, TypeInvalid) + v1.Type = config.fe.TypeUintptr() + v.AddArg(v1) + v2 := b.NewValue0(v.Line, OpConstPtr, TypeInvalid) + v2.Type = config.fe.TypeUintptr() + v.AddArg(v2) + return true + } + goto endfd2d8ffcd55eaf8a5092a20c3ae61ba3 + endfd2d8ffcd55eaf8a5092a20c3ae61ba3: + ; case OpConstString: // match: (ConstString {s}) // cond: - // result: (StringMake (Addr {config.fe.StringData(s.(string))} (SB )) (ConstPtr [int64(len(s.(string)))])) + // result: (StringMake (Addr {config.fe.StringData(s.(string))} (SB )) (ConstPtr [int64(len(s.(string)))])) { s := v.Aux v.Op = OpStringMake @@ -248,20 +291,20 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAddr, TypeInvalid) - v0.Type = config.Frontend().TypeBytePtr() + v0.Type = config.fe.TypeBytePtr() v0.Aux = config.fe.StringData(s.(string)) v1 := b.NewValue0(v.Line, OpSB, TypeInvalid) - v1.Type = config.Frontend().TypeUintptr() + v1.Type = config.fe.TypeUintptr() v0.AddArg(v1) v.AddArg(v0) v2 := b.NewValue0(v.Line, OpConstPtr, TypeInvalid) - v2.Type = config.Frontend().TypeUintptr() + v2.Type = config.fe.TypeUintptr() v2.AuxInt = int64(len(s.(string))) v.AddArg(v2) return true } - goto end68cc91679848c7c30bd8b0a8ed533843 - end68cc91679848c7c30bd8b0a8ed533843: + goto end51a3d96f2d304db9a52f36ee6b29c14e + end51a3d96f2d304db9a52f36ee6b29c14e: ; case OpEq16: // match: (Eq16 x x) @@ -362,33 +405,73 @@ func rewriteValuegeneric(v *Value, config *Config) bool { ; // match: (EqFat (Load ptr mem) (ConstNil)) // cond: - // result: (EqPtr (Load ptr mem) (ConstPtr [0])) + // result: (EqPtr (Load ptr mem) (ConstPtr [0])) { if v.Args[0].Op != OpLoad { - goto end540dc8dfbc66adcd3db2d7e819c534f6 + goto ende10070e5ddd3dc059674d25ccc6a63b5 } ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] if v.Args[1].Op != OpConstNil { - goto end540dc8dfbc66adcd3db2d7e819c534f6 + goto ende10070e5ddd3dc059674d25ccc6a63b5 } v.Op = OpEqPtr v.AuxInt = 0 v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpLoad, TypeInvalid) - v0.Type = config.Frontend().TypeUintptr() + v0.Type = config.fe.TypeUintptr() v0.AddArg(ptr) v0.AddArg(mem) v.AddArg(v0) v1 := b.NewValue0(v.Line, OpConstPtr, TypeInvalid) - v1.Type = config.Frontend().TypeUintptr() + v1.Type = config.fe.TypeUintptr() v1.AuxInt = 0 v.AddArg(v1) return true } - goto end540dc8dfbc66adcd3db2d7e819c534f6 - end540dc8dfbc66adcd3db2d7e819c534f6: + goto ende10070e5ddd3dc059674d25ccc6a63b5 + ende10070e5ddd3dc059674d25ccc6a63b5: + ; + case OpIData: + // match: (IData (IMake _ data)) + // cond: + // result: data + { + if v.Args[0].Op != OpIMake { + goto endbfa1bb944cdc07933effb16a35152e12 + } + data := v.Args[0].Args[1] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = data.Type + v.AddArg(data) + return true + } + goto endbfa1bb944cdc07933effb16a35152e12 + endbfa1bb944cdc07933effb16a35152e12: + ; + case OpITab: + // match: (ITab (IMake itab _)) + // cond: + // result: itab + { + if v.Args[0].Op != OpIMake { + goto endfcbb9414a776ff9c8512da3e0f4d8fbd + } + itab := v.Args[0].Args[0] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = itab.Type + v.AddArg(itab) + return true + } + goto endfcbb9414a776ff9c8512da3e0f4d8fbd + endfcbb9414a776ff9c8512da3e0f4d8fbd: ; case OpIsInBounds: // match: (IsInBounds (Const32 [c]) (Const32 [d])) @@ -488,36 +571,111 @@ func rewriteValuegeneric(v *Value, config *Config) bool { case OpLoad: // match: (Load ptr mem) // cond: t.IsString() - // result: (StringMake (Load ptr mem) (Load (OffPtr [config.PtrSize] ptr) mem)) + // result: (StringMake (Load ptr mem) (Load (OffPtr [config.PtrSize] ptr) mem)) { t := v.Type ptr := v.Args[0] mem := v.Args[1] if !(t.IsString()) { - goto end18afa4a6fdd6d0b92ed292840898c8f6 + goto end7c75255555bf9dd796298d9f6eaf9cf2 } v.Op = OpStringMake v.AuxInt = 0 v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpLoad, TypeInvalid) - v0.Type = config.Frontend().TypeBytePtr() + v0.Type = config.fe.TypeBytePtr() + v0.AddArg(ptr) + v0.AddArg(mem) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpLoad, TypeInvalid) + v1.Type = config.fe.TypeUintptr() + v2 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) + v2.Type = config.fe.TypeUintptr().PtrTo() + v2.AuxInt = config.PtrSize + v2.AddArg(ptr) + v1.AddArg(v2) + v1.AddArg(mem) + v.AddArg(v1) + return true + } + goto end7c75255555bf9dd796298d9f6eaf9cf2 + end7c75255555bf9dd796298d9f6eaf9cf2: + ; + // match: (Load ptr mem) + // cond: t.IsSlice() + // result: (SliceMake (Load ptr mem) (Load (OffPtr [config.PtrSize] ptr) mem) (Load (OffPtr [2*config.PtrSize] ptr) mem)) + { + t := v.Type + ptr := v.Args[0] + mem := v.Args[1] + if !(t.IsSlice()) { + goto end12c46556d962198680eb3238859e3016 + } + v.Op = OpSliceMake + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpLoad, TypeInvalid) + v0.Type = config.fe.TypeBytePtr() v0.AddArg(ptr) v0.AddArg(mem) v.AddArg(v0) v1 := b.NewValue0(v.Line, OpLoad, TypeInvalid) - v1.Type = config.Frontend().TypeUintptr() + v1.Type = config.fe.TypeUintptr() v2 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v2.Type = config.Frontend().TypeBytePtr() + v2.Type = config.fe.TypeUintptr().PtrTo() v2.AuxInt = config.PtrSize v2.AddArg(ptr) v1.AddArg(v2) v1.AddArg(mem) v.AddArg(v1) + v3 := b.NewValue0(v.Line, OpLoad, TypeInvalid) + v3.Type = config.fe.TypeUintptr() + v4 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) + v4.Type = config.fe.TypeUintptr().PtrTo() + v4.AuxInt = 2 * config.PtrSize + v4.AddArg(ptr) + v3.AddArg(v4) + v3.AddArg(mem) + v.AddArg(v3) return true } - goto end18afa4a6fdd6d0b92ed292840898c8f6 - end18afa4a6fdd6d0b92ed292840898c8f6: + goto end12c46556d962198680eb3238859e3016 + end12c46556d962198680eb3238859e3016: + ; + // match: (Load ptr mem) + // cond: t.IsInterface() + // result: (IMake (Load ptr mem) (Load (OffPtr [config.PtrSize] ptr) mem)) + { + t := v.Type + ptr := v.Args[0] + mem := v.Args[1] + if !(t.IsInterface()) { + goto end12671c83ebe3ccbc8e53383765ee7675 + } + v.Op = OpIMake + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpLoad, TypeInvalid) + v0.Type = config.fe.TypeBytePtr() + v0.AddArg(ptr) + v0.AddArg(mem) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpLoad, TypeInvalid) + v1.Type = config.fe.TypeBytePtr() + v2 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) + v2.Type = config.fe.TypeBytePtr().PtrTo() + v2.AuxInt = config.PtrSize + v2.AddArg(ptr) + v1.AddArg(v2) + v1.AddArg(mem) + v.AddArg(v1) + return true + } + goto end12671c83ebe3ccbc8e53383765ee7675 + end12671c83ebe3ccbc8e53383765ee7675: ; case OpMul64: // match: (Mul64 (Const64 [c]) (Const64 [d])) @@ -664,33 +822,33 @@ func rewriteValuegeneric(v *Value, config *Config) bool { ; // match: (NeqFat (Load ptr mem) (ConstNil)) // cond: - // result: (NeqPtr (Load ptr mem) (ConstPtr [0])) + // result: (NeqPtr (Load ptr mem) (ConstPtr [0])) { if v.Args[0].Op != OpLoad { - goto end67d723bb0f39a5c897816abcf411e5cf + goto end423eea941d60473e73140e25f5818bfb } ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] if v.Args[1].Op != OpConstNil { - goto end67d723bb0f39a5c897816abcf411e5cf + goto end423eea941d60473e73140e25f5818bfb } v.Op = OpNeqPtr v.AuxInt = 0 v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpLoad, TypeInvalid) - v0.Type = config.Frontend().TypeUintptr() + v0.Type = config.fe.TypeUintptr() v0.AddArg(ptr) v0.AddArg(mem) v.AddArg(v0) v1 := b.NewValue0(v.Line, OpConstPtr, TypeInvalid) - v1.Type = config.Frontend().TypeUintptr() + v1.Type = config.fe.TypeUintptr() v1.AuxInt = 0 v.AddArg(v1) return true } - goto end67d723bb0f39a5c897816abcf411e5cf - end67d723bb0f39a5c897816abcf411e5cf: + goto end423eea941d60473e73140e25f5818bfb + end423eea941d60473e73140e25f5818bfb: ; case OpOr16: // match: (Or16 x x) @@ -775,7 +933,7 @@ func rewriteValuegeneric(v *Value, config *Config) bool { case OpPtrIndex: // match: (PtrIndex ptr idx) // cond: - // result: (AddPtr ptr (MulPtr idx (ConstPtr [t.Elem().Size()]))) + // result: (AddPtr ptr (MulPtr idx (ConstPtr [t.Elem().Size()]))) { t := v.Type ptr := v.Args[0] @@ -786,96 +944,201 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.resetArgs() v.AddArg(ptr) v0 := b.NewValue0(v.Line, OpMulPtr, TypeInvalid) - v0.Type = config.Frontend().TypeUintptr() + v0.Type = config.fe.TypeUintptr() v0.AddArg(idx) v1 := b.NewValue0(v.Line, OpConstPtr, TypeInvalid) - v1.Type = config.Frontend().TypeUintptr() + v1.Type = config.fe.TypeUintptr() v1.AuxInt = t.Elem().Size() v0.AddArg(v1) v.AddArg(v0) return true } - goto endf7546737f42c76a99699f241d41f491a - endf7546737f42c76a99699f241d41f491a: + goto end1e1c5ef80c11231f89a5439cdda98359 + end1e1c5ef80c11231f89a5439cdda98359: ; case OpSliceCap: - // match: (SliceCap (Load ptr mem)) + // match: (SliceCap (SliceMake _ _ cap)) // cond: - // result: (Load (AddPtr ptr (ConstPtr [config.PtrSize*2])) mem) + // result: cap { - if v.Args[0].Op != OpLoad { - goto end6696811bf6bd45e505d24c1a15c68e70 + if v.Args[0].Op != OpSliceMake { + goto end1bd11616743632b33b410964667fb3c6 } - ptr := v.Args[0].Args[0] - mem := v.Args[0].Args[1] - v.Op = OpLoad + cap := v.Args[0].Args[2] + v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAddPtr, TypeInvalid) - v0.Type = ptr.Type - v0.AddArg(ptr) - v1 := b.NewValue0(v.Line, OpConstPtr, TypeInvalid) - v1.Type = config.Frontend().TypeUintptr() - v1.AuxInt = config.PtrSize * 2 - v0.AddArg(v1) - v.AddArg(v0) - v.AddArg(mem) + v.Type = cap.Type + v.AddArg(cap) return true } - goto end6696811bf6bd45e505d24c1a15c68e70 - end6696811bf6bd45e505d24c1a15c68e70: + goto end1bd11616743632b33b410964667fb3c6 + end1bd11616743632b33b410964667fb3c6: ; case OpSliceLen: - // match: (SliceLen (Load ptr mem)) + // match: (SliceLen (SliceMake _ len _)) // cond: - // result: (Load (AddPtr ptr (ConstPtr [config.PtrSize])) mem) + // result: len { - if v.Args[0].Op != OpLoad { - goto end9844ce3e290e81355493141e653e37d5 + if v.Args[0].Op != OpSliceMake { + goto endebb2090199d13e4c2ae52fb3e778f7fd } - ptr := v.Args[0].Args[0] - mem := v.Args[0].Args[1] - v.Op = OpLoad + len := v.Args[0].Args[1] + v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAddPtr, TypeInvalid) - v0.Type = ptr.Type - v0.AddArg(ptr) - v1 := b.NewValue0(v.Line, OpConstPtr, TypeInvalid) - v1.Type = config.Frontend().TypeUintptr() - v1.AuxInt = config.PtrSize - v0.AddArg(v1) - v.AddArg(v0) - v.AddArg(mem) + v.Type = len.Type + v.AddArg(len) return true } - goto end9844ce3e290e81355493141e653e37d5 - end9844ce3e290e81355493141e653e37d5: + goto endebb2090199d13e4c2ae52fb3e778f7fd + endebb2090199d13e4c2ae52fb3e778f7fd: ; case OpSlicePtr: - // match: (SlicePtr (Load ptr mem)) + // match: (SlicePtr (SliceMake ptr _ _ )) // cond: - // result: (Load ptr mem) + // result: ptr { - if v.Args[0].Op != OpLoad { - goto end459613b83f95b65729d45c2ed663a153 + if v.Args[0].Op != OpSliceMake { + goto end526acc0a705137a5d25577499206720b } ptr := v.Args[0].Args[0] - mem := v.Args[0].Args[1] - v.Op = OpLoad + v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.Type = ptr.Type v.AddArg(ptr) - v.AddArg(mem) return true } - goto end459613b83f95b65729d45c2ed663a153 - end459613b83f95b65729d45c2ed663a153: + goto end526acc0a705137a5d25577499206720b + end526acc0a705137a5d25577499206720b: ; case OpStore: + // match: (Store [2*config.PtrSize] dst (StringMake ptr len) mem) + // cond: + // result: (Store [config.PtrSize] (OffPtr [config.PtrSize] dst) len (Store [config.PtrSize] dst ptr mem)) + { + if v.AuxInt != 2*config.PtrSize { + goto end25ae4fc3dc01583a4adc45067d49940a + } + dst := v.Args[0] + if v.Args[1].Op != OpStringMake { + goto end25ae4fc3dc01583a4adc45067d49940a + } + ptr := v.Args[1].Args[0] + len := v.Args[1].Args[1] + mem := v.Args[2] + v.Op = OpStore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = config.PtrSize + v0 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) + v0.Type = config.fe.TypeUintptr().PtrTo() + v0.AuxInt = config.PtrSize + v0.AddArg(dst) + v.AddArg(v0) + v.AddArg(len) + v1 := b.NewValue0(v.Line, OpStore, TypeInvalid) + v1.Type = TypeMem + v1.AuxInt = config.PtrSize + v1.AddArg(dst) + v1.AddArg(ptr) + v1.AddArg(mem) + v.AddArg(v1) + return true + } + goto end25ae4fc3dc01583a4adc45067d49940a + end25ae4fc3dc01583a4adc45067d49940a: + ; + // match: (Store [3*config.PtrSize] dst (SliceMake ptr len cap) mem) + // cond: + // result: (Store [config.PtrSize] (OffPtr [2*config.PtrSize] dst) cap (Store [config.PtrSize] (OffPtr [config.PtrSize] dst) len (Store [config.PtrSize] dst ptr mem))) + { + if v.AuxInt != 3*config.PtrSize { + goto end39ab85d51c8cd7f5d54e3eea4fb79a96 + } + dst := v.Args[0] + if v.Args[1].Op != OpSliceMake { + goto end39ab85d51c8cd7f5d54e3eea4fb79a96 + } + ptr := v.Args[1].Args[0] + len := v.Args[1].Args[1] + cap := v.Args[1].Args[2] + mem := v.Args[2] + v.Op = OpStore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = config.PtrSize + v0 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) + v0.Type = config.fe.TypeUintptr().PtrTo() + v0.AuxInt = 2 * config.PtrSize + v0.AddArg(dst) + v.AddArg(v0) + v.AddArg(cap) + v1 := b.NewValue0(v.Line, OpStore, TypeInvalid) + v1.Type = TypeMem + v1.AuxInt = config.PtrSize + v2 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) + v2.Type = config.fe.TypeUintptr().PtrTo() + v2.AuxInt = config.PtrSize + v2.AddArg(dst) + v1.AddArg(v2) + v1.AddArg(len) + v3 := b.NewValue0(v.Line, OpStore, TypeInvalid) + v3.Type = TypeMem + v3.AuxInt = config.PtrSize + v3.AddArg(dst) + v3.AddArg(ptr) + v3.AddArg(mem) + v1.AddArg(v3) + v.AddArg(v1) + return true + } + goto end39ab85d51c8cd7f5d54e3eea4fb79a96 + end39ab85d51c8cd7f5d54e3eea4fb79a96: + ; + // match: (Store [2*config.PtrSize] dst (IMake itab data) mem) + // cond: + // result: (Store [config.PtrSize] (OffPtr [config.PtrSize] dst) data (Store [config.PtrSize] dst itab mem)) + { + if v.AuxInt != 2*config.PtrSize { + goto end63b77ae78d92c05d496202e8b6b96ff3 + } + dst := v.Args[0] + if v.Args[1].Op != OpIMake { + goto end63b77ae78d92c05d496202e8b6b96ff3 + } + itab := v.Args[1].Args[0] + data := v.Args[1].Args[1] + mem := v.Args[2] + v.Op = OpStore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = config.PtrSize + v0 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) + v0.Type = config.fe.TypeBytePtr().PtrTo() + v0.AuxInt = config.PtrSize + v0.AddArg(dst) + v.AddArg(v0) + v.AddArg(data) + v1 := b.NewValue0(v.Line, OpStore, TypeInvalid) + v1.Type = TypeMem + v1.AuxInt = config.PtrSize + v1.AddArg(dst) + v1.AddArg(itab) + v1.AddArg(mem) + v.AddArg(v1) + return true + } + goto end63b77ae78d92c05d496202e8b6b96ff3 + end63b77ae78d92c05d496202e8b6b96ff3: + ; // match: (Store [size] dst (Load src mem) mem) // cond: size > config.IntSize // result: (Move [size] dst src mem) @@ -906,48 +1169,6 @@ func rewriteValuegeneric(v *Value, config *Config) bool { goto enda18a7163888e2f4fca9f38bae56cef42 enda18a7163888e2f4fca9f38bae56cef42: ; - // match: (Store [2*config.PtrSize] dst str mem) - // cond: str.Type.IsString() - // result: (Store [config.PtrSize] (OffPtr [config.PtrSize] dst) (StringLen str) (Store [config.PtrSize] dst (StringPtr str) mem)) - { - if v.AuxInt != 2*config.PtrSize { - goto end6942df62f9cb570a99ab97a5aeebfd2d - } - dst := v.Args[0] - str := v.Args[1] - mem := v.Args[2] - if !(str.Type.IsString()) { - goto end6942df62f9cb570a99ab97a5aeebfd2d - } - v.Op = OpStore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = config.PtrSize - v0 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v0.Type = config.Frontend().TypeBytePtr() - v0.AuxInt = config.PtrSize - v0.AddArg(dst) - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpStringLen, TypeInvalid) - v1.Type = config.Frontend().TypeUintptr() - v1.AddArg(str) - v.AddArg(v1) - v2 := b.NewValue0(v.Line, OpStore, TypeInvalid) - v2.AuxInt = config.PtrSize - v2.Type = TypeMem - v2.AddArg(dst) - v3 := b.NewValue0(v.Line, OpStringPtr, TypeInvalid) - v3.Type = config.Frontend().TypeBytePtr() - v3.AddArg(str) - v2.AddArg(v3) - v2.AddArg(mem) - v.AddArg(v2) - return true - } - goto end6942df62f9cb570a99ab97a5aeebfd2d - end6942df62f9cb570a99ab97a5aeebfd2d: - ; case OpStringLen: // match: (StringLen (StringMake _ len)) // cond: diff --git a/src/cmd/compile/internal/ssa/type.go b/src/cmd/compile/internal/ssa/type.go index d6e8384cf0..c6cc889420 100644 --- a/src/cmd/compile/internal/ssa/type.go +++ b/src/cmd/compile/internal/ssa/type.go @@ -18,6 +18,8 @@ type Type interface { IsFloat() bool IsPtr() bool IsString() bool + IsSlice() bool + IsInterface() bool IsMemory() bool // special ssa-package-only types IsFlags() bool @@ -36,19 +38,21 @@ type CompilerType struct { Flags bool } -func (t *CompilerType) Size() int64 { return 0 } -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) IsPtr() bool { return false } -func (t *CompilerType) IsString() bool { return false } -func (t *CompilerType) IsMemory() bool { return t.Memory } -func (t *CompilerType) IsFlags() bool { return t.Flags } -func (t *CompilerType) String() string { return t.Name } -func (t *CompilerType) Elem() Type { panic("not implemented") } -func (t *CompilerType) PtrTo() Type { panic("not implemented") } +func (t *CompilerType) Size() int64 { return 0 } +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) IsPtr() bool { return false } +func (t *CompilerType) IsString() bool { return false } +func (t *CompilerType) IsSlice() 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) String() string { return t.Name } +func (t *CompilerType) Elem() Type { panic("not implemented") } +func (t *CompilerType) PtrTo() Type { panic("not implemented") } func (t *CompilerType) Equal(u Type) bool { x, ok := u.(*CompilerType) diff --git a/src/cmd/compile/internal/ssa/type_test.go b/src/cmd/compile/internal/ssa/type_test.go index 29bd5cd131..3dfa5f7c0b 100644 --- a/src/cmd/compile/internal/ssa/type_test.go +++ b/src/cmd/compile/internal/ssa/type_test.go @@ -14,24 +14,28 @@ type TypeImpl struct { Float bool Ptr bool string bool + slice 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) IsPtr() bool { return t.Ptr } -func (t *TypeImpl) IsString() bool { return t.string } -func (t *TypeImpl) IsMemory() bool { return false } -func (t *TypeImpl) IsFlags() bool { return false } -func (t *TypeImpl) String() string { return t.Name } -func (t *TypeImpl) Elem() Type { return t.Elem_ } -func (t *TypeImpl) PtrTo() Type { panic("not implemented") } +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) IsPtr() bool { return t.Ptr } +func (t *TypeImpl) IsString() bool { return t.string } +func (t *TypeImpl) IsSlice() bool { return t.slice } +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) String() string { return t.Name } +func (t *TypeImpl) Elem() Type { return t.Elem_ } +func (t *TypeImpl) PtrTo() Type { panic("not implemented") } func (t *TypeImpl) Equal(u Type) bool { x, ok := u.(*TypeImpl) -- cgit v1.3 From 8f51ae8ba5acbd4e91bd7c1c59b375513c395a22 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Fri, 21 Aug 2015 10:16:35 -0700 Subject: [dev.ssa] cmd/compile: SETcc instructions do not clobber flags This reduces the number of flags spilled during make.bash by > 90%. I am working (slowly) on the rest. Change-Id: I3c08ae228c33e2f726f615962996f0350c8d592b Reviewed-on: https://go-review.googlesource.com/13813 Reviewed-by: David Chase --- src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 27 ++++++++++++++------------- src/cmd/compile/internal/ssa/opGen.go | 10 ---------- 2 files changed, 14 insertions(+), 23 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index e633f82348..b218c66a64 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -105,9 +105,10 @@ func init() { clobbers: ax | flags} gp10 = regInfo{inputs: []regMask{gp}} - gp2flags = regInfo{inputs: []regMask{gpsp, gpsp}, outputs: flagsonly} - gp1flags = regInfo{inputs: []regMask{gpsp}, outputs: flagsonly} - flagsgp = regInfo{inputs: flagsonly, outputs: gponly, clobbers: flags} + gp2flags = regInfo{inputs: []regMask{gpsp, gpsp}, outputs: flagsonly} + gp1flags = regInfo{inputs: []regMask{gpsp}, outputs: flagsonly} + flagsgp = regInfo{inputs: flagsonly, outputs: gponly, clobbers: flags} + readflags = regInfo{inputs: flagsonly, outputs: gponly} gpload = regInfo{inputs: []regMask{gpspsb, 0}, outputs: gponly} gploadidx = regInfo{inputs: []regMask{gpspsb, gpsp, 0}, outputs: gponly} @@ -294,16 +295,16 @@ func init() { {name: "SBBLcarrymask", 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", reg: flagsgp, asm: "SETEQ"}, // extract == condition from arg0 - {name: "SETNE", reg: flagsgp, asm: "SETNE"}, // extract != condition from arg0 - {name: "SETL", reg: flagsgp, asm: "SETLT"}, // extract signed < condition from arg0 - {name: "SETLE", reg: flagsgp, asm: "SETLE"}, // extract signed <= condition from arg0 - {name: "SETG", reg: flagsgp, asm: "SETGT"}, // extract signed > condition from arg0 - {name: "SETGE", reg: flagsgp, asm: "SETGE"}, // extract signed >= condition from arg0 - {name: "SETB", reg: flagsgp, asm: "SETCS"}, // extract unsigned < condition from arg0 - {name: "SETBE", reg: flagsgp, asm: "SETLS"}, // extract unsigned <= condition from arg0 - {name: "SETA", reg: flagsgp, asm: "SETHI"}, // extract unsigned > condition from arg0 - {name: "SETAE", reg: flagsgp, asm: "SETCC"}, // extract unsigned >= condition from arg0 + {name: "SETEQ", reg: readflags, asm: "SETEQ"}, // extract == condition from arg0 + {name: "SETNE", reg: readflags, asm: "SETNE"}, // extract != condition from arg0 + {name: "SETL", reg: readflags, asm: "SETLT"}, // extract signed < condition from arg0 + {name: "SETLE", reg: readflags, asm: "SETLE"}, // extract signed <= condition from arg0 + {name: "SETG", reg: readflags, asm: "SETGT"}, // extract signed > condition from arg0 + {name: "SETGE", reg: readflags, asm: "SETGE"}, // extract signed >= condition from arg0 + {name: "SETB", reg: readflags, asm: "SETCS"}, // extract unsigned < condition from arg0 + {name: "SETBE", reg: readflags, asm: "SETLS"}, // extract unsigned <= condition from arg0 + {name: "SETA", reg: readflags, asm: "SETHI"}, // extract unsigned > condition from arg0 + {name: "SETAE", reg: readflags, asm: "SETCC"}, // extract unsigned >= condition from arg0 {name: "MOVBQSX", reg: gp11, asm: "MOVBQSX"}, // sign extend arg0 from int8 to int64 {name: "MOVBQZX", reg: gp11, asm: "MOVBQZX"}, // zero extend arg0 from int8 to int64 diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 17d4edb221..a2e087246d 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -2202,7 +2202,6 @@ var opcodeTable = [...]opInfo{ inputs: []inputInfo{ {0, 8589934592}, // .FLAGS }, - clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -2215,7 +2214,6 @@ var opcodeTable = [...]opInfo{ inputs: []inputInfo{ {0, 8589934592}, // .FLAGS }, - clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -2228,7 +2226,6 @@ var opcodeTable = [...]opInfo{ inputs: []inputInfo{ {0, 8589934592}, // .FLAGS }, - clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -2241,7 +2238,6 @@ var opcodeTable = [...]opInfo{ inputs: []inputInfo{ {0, 8589934592}, // .FLAGS }, - clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -2254,7 +2250,6 @@ var opcodeTable = [...]opInfo{ inputs: []inputInfo{ {0, 8589934592}, // .FLAGS }, - clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -2267,7 +2262,6 @@ var opcodeTable = [...]opInfo{ inputs: []inputInfo{ {0, 8589934592}, // .FLAGS }, - clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -2280,7 +2274,6 @@ var opcodeTable = [...]opInfo{ inputs: []inputInfo{ {0, 8589934592}, // .FLAGS }, - clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -2293,7 +2286,6 @@ var opcodeTable = [...]opInfo{ inputs: []inputInfo{ {0, 8589934592}, // .FLAGS }, - clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -2306,7 +2298,6 @@ var opcodeTable = [...]opInfo{ inputs: []inputInfo{ {0, 8589934592}, // .FLAGS }, - clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -2319,7 +2310,6 @@ var opcodeTable = [...]opInfo{ inputs: []inputInfo{ {0, 8589934592}, // .FLAGS }, - clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, -- cgit v1.3 From 7393c24877407ff2d3d1fad761e5aebbf6671ac3 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Fri, 21 Aug 2015 10:15:15 -0700 Subject: [dev.ssa] cmd/compile: everything is live and reachable after regalloc This CL makes function printing and HTML generation accurate after regalloc. Prior to this CL, text and HTML function outputs showed live values and blocks as dead. Change-Id: I70669cd8641af841447fc5d2ecbd754b281356f0 Reviewed-on: https://go-review.googlesource.com/13812 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/deadcode.go | 14 ++++++++++++++ 1 file changed, 14 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/deadcode.go b/src/cmd/compile/internal/ssa/deadcode.go index 8c306c8412..5ff082baff 100644 --- a/src/cmd/compile/internal/ssa/deadcode.go +++ b/src/cmd/compile/internal/ssa/deadcode.go @@ -6,6 +6,20 @@ package ssa // findlive returns the reachable blocks and live values in f. func findlive(f *Func) (reachable []bool, live []bool) { + // After regalloc, consider all blocks and values to be reachable and live. + // See the comment at the top of regalloc.go and in deadcode for details. + if f.RegAlloc != nil { + reachable = make([]bool, f.NumBlocks()) + for i := range reachable { + reachable[i] = true + } + live = make([]bool, f.NumValues()) + for i := range live { + live[i] = true + } + return reachable, live + } + // Find all reachable basic blocks. reachable = make([]bool, f.NumBlocks()) reachable[f.Entry.ID] = true -- cgit v1.3 From 57d9e7e3c4553ae9b6e59cabe95659cc8014efa9 Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Tue, 18 Aug 2015 19:51:44 -0500 Subject: [dev.ssa] cmd/compile/internal/ssa: implement OMOD Change-Id: Iec954c4daefef4ab3fa2c98bfb2c70b2dea8dffb Reviewed-on: https://go-review.googlesource.com/13743 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 74 ++- .../internal/gc/testdata/arithBoundary_ssa.go | 626 ++++++++++++--------- .../internal/gc/testdata/gen/arithBoundaryGen.go | 214 +++++++ src/cmd/compile/internal/ssa/gen/AMD64.rules | 9 + src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 9 + src/cmd/compile/internal/ssa/gen/genericOps.go | 10 +- src/cmd/compile/internal/ssa/opGen.go | 130 +++++ src/cmd/compile/internal/ssa/rewriteAMD64.go | 156 +++++ 8 files changed, 936 insertions(+), 292 deletions(-) create mode 100644 src/cmd/compile/internal/gc/testdata/gen/arithBoundaryGen.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index a324ed2a42..6d3359ad0e 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -795,6 +795,15 @@ var opToSSA = map[opAndType]ssa.Op{ 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, @@ -1216,7 +1225,7 @@ func (s *state) expr(n *Node) *ssa.Value { a := s.expr(n.Left) b := s.expr(n.Right) return s.newValue2(s.ssaOp(n.Op, n.Left.Type), Types[TBOOL], a, b) - case OADD, OAND, OMUL, OOR, OSUB, ODIV, OXOR, OHMUL: + case OADD, OAND, OMUL, OOR, OSUB, ODIV, OMOD, 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) @@ -2099,57 +2108,58 @@ func genValue(v *ssa.Value) { opregreg(v.Op.Asm(), r, y) case ssa.OpAMD64DIVQ, ssa.OpAMD64DIVL, ssa.OpAMD64DIVW, - ssa.OpAMD64DIVQU, ssa.OpAMD64DIVLU, ssa.OpAMD64DIVWU: + 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. So we check for division - // by -1 and negate the input. + // 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.OpAMD64DIVW || v.Op == ssa.OpAMD64MODQ || + v.Op == ssa.OpAMD64MODL || v.Op == ssa.OpAMD64MODW { var c *obj.Prog switch v.Op { - case ssa.OpAMD64DIVQ: + case ssa.OpAMD64DIVQ, ssa.OpAMD64MODQ: c = Prog(x86.ACMPQ) - case ssa.OpAMD64DIVL: + 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) - case ssa.OpAMD64DIVW: + 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 = Prog(x86.AJEQ) j.To.Type = obj.TYPE_BRANCH } - // dividend is ax, so we sign extend to - // dx:ax for DIV input - switch v.Op { - case ssa.OpAMD64DIVQU: - fallthrough - case ssa.OpAMD64DIVLU: - fallthrough - case ssa.OpAMD64DIVWU: + // 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 - case ssa.OpAMD64DIVQ: - Prog(x86.ACQO) - case ssa.OpAMD64DIVL: - Prog(x86.ACDQ) - case ssa.OpAMD64DIVW: - Prog(x86.ACWD) } p := Prog(v.Op.Asm()) @@ -2161,9 +2171,21 @@ func genValue(v *ssa.Value) { j2 := Prog(obj.AJMP) j2.To.Type = obj.TYPE_BRANCH - n := Prog(x86.ANEGQ) - n.To.Type = obj.TYPE_REG - n.To.Reg = x86.REG_AX + 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 diff --git a/src/cmd/compile/internal/gc/testdata/arithBoundary_ssa.go b/src/cmd/compile/internal/gc/testdata/arithBoundary_ssa.go index 8f84026a5d..9f1b9a4a60 100644 --- a/src/cmd/compile/internal/gc/testdata/arithBoundary_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/arithBoundary_ssa.go @@ -3,464 +3,504 @@ package main import "fmt" type utd64 struct { - a, b uint64 - add, sub, mul, div uint64 + a, b uint64 + add, sub, mul, div, mod uint64 } type itd64 struct { - a, b int64 - add, sub, mul, div int64 + a, b int64 + add, sub, mul, div, mod int64 } type utd32 struct { - a, b uint32 - add, sub, mul, div uint32 + a, b uint32 + add, sub, mul, div, mod uint32 } type itd32 struct { - a, b int32 - add, sub, mul, div int32 + a, b int32 + add, sub, mul, div, mod int32 } type utd16 struct { - a, b uint16 - add, sub, mul, div uint16 + a, b uint16 + add, sub, mul, div, mod uint16 } type itd16 struct { - a, b int16 - add, sub, mul, div int16 + a, b int16 + add, sub, mul, div, mod int16 } type utd8 struct { - a, b uint8 - add, sub, mul, div uint8 + a, b uint8 + add, sub, mul, div, mod uint8 } type itd8 struct { - a, b int8 - add, sub, mul, div int8 + a, b int8 + add, sub, mul, div, mod int8 } func add_uint64_ssa(a, b uint64) uint64 { switch { - } + } // prevent inlining return a + b } func sub_uint64_ssa(a, b uint64) uint64 { switch { - } + } // prevent inlining return a - b } func div_uint64_ssa(a, b uint64) uint64 { switch { - } + } // prevent inlining return a / b } +func mod_uint64_ssa(a, b uint64) uint64 { + switch { + } // prevent inlining + return a % b +} func mul_uint64_ssa(a, b uint64) uint64 { switch { - } + } // prevent inlining return a * b } func add_int64_ssa(a, b int64) int64 { switch { - } + } // prevent inlining return a + b } func sub_int64_ssa(a, b int64) int64 { switch { - } + } // prevent inlining return a - b } func div_int64_ssa(a, b int64) int64 { switch { - } + } // prevent inlining return a / b } +func mod_int64_ssa(a, b int64) int64 { + switch { + } // prevent inlining + return a % b +} func mul_int64_ssa(a, b int64) int64 { switch { - } + } // prevent inlining return a * b } func add_uint32_ssa(a, b uint32) uint32 { switch { - } + } // prevent inlining return a + b } func sub_uint32_ssa(a, b uint32) uint32 { switch { - } + } // prevent inlining return a - b } func div_uint32_ssa(a, b uint32) uint32 { switch { - } + } // prevent inlining return a / b } +func mod_uint32_ssa(a, b uint32) uint32 { + switch { + } // prevent inlining + return a % b +} func mul_uint32_ssa(a, b uint32) uint32 { switch { - } + } // prevent inlining return a * b } func add_int32_ssa(a, b int32) int32 { switch { - } + } // prevent inlining return a + b } func sub_int32_ssa(a, b int32) int32 { switch { - } + } // prevent inlining return a - b } func div_int32_ssa(a, b int32) int32 { switch { - } + } // prevent inlining return a / b } +func mod_int32_ssa(a, b int32) int32 { + switch { + } // prevent inlining + return a % b +} func mul_int32_ssa(a, b int32) int32 { switch { - } + } // prevent inlining return a * b } func add_uint16_ssa(a, b uint16) uint16 { switch { - } + } // prevent inlining return a + b } func sub_uint16_ssa(a, b uint16) uint16 { switch { - } + } // prevent inlining return a - b } func div_uint16_ssa(a, b uint16) uint16 { switch { - } + } // prevent inlining return a / b } +func mod_uint16_ssa(a, b uint16) uint16 { + switch { + } // prevent inlining + return a % b +} func mul_uint16_ssa(a, b uint16) uint16 { switch { - } + } // prevent inlining return a * b } func add_int16_ssa(a, b int16) int16 { switch { - } + } // prevent inlining return a + b } func sub_int16_ssa(a, b int16) int16 { switch { - } + } // prevent inlining return a - b } func div_int16_ssa(a, b int16) int16 { switch { - } + } // prevent inlining return a / b } +func mod_int16_ssa(a, b int16) int16 { + switch { + } // prevent inlining + return a % b +} func mul_int16_ssa(a, b int16) int16 { switch { - } + } // prevent inlining return a * b } func add_uint8_ssa(a, b uint8) uint8 { switch { - } + } // prevent inlining return a + b } func sub_uint8_ssa(a, b uint8) uint8 { switch { - } + } // prevent inlining return a - b } func div_uint8_ssa(a, b uint8) uint8 { switch { - } + } // prevent inlining return a / b } +func mod_uint8_ssa(a, b uint8) uint8 { + switch { + } // prevent inlining + return a % b +} func mul_uint8_ssa(a, b uint8) uint8 { switch { - } + } // prevent inlining return a * b } func add_int8_ssa(a, b int8) int8 { switch { - } + } // prevent inlining return a + b } func sub_int8_ssa(a, b int8) int8 { switch { - } + } // prevent inlining return a - b } func div_int8_ssa(a, b int8) int8 { switch { - } + } // prevent inlining return a / b } +func mod_int8_ssa(a, b int8) int8 { + switch { + } // prevent inlining + return a % b +} func mul_int8_ssa(a, b int8) int8 { switch { - } + } // prevent inlining 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}, - utd64{a: 0, b: 4294967296, add: 4294967296, sub: 18446744069414584320, mul: 0, div: 0}, - utd64{a: 0, b: 18446744073709551615, add: 18446744073709551615, sub: 1, mul: 0, div: 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}, - utd64{a: 1, b: 4294967296, add: 4294967297, sub: 18446744069414584321, mul: 4294967296, div: 0}, - utd64{a: 1, b: 18446744073709551615, add: 0, sub: 2, mul: 18446744073709551615, div: 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}, - utd64{a: 4294967296, b: 4294967296, add: 8589934592, sub: 0, mul: 0, div: 1}, - utd64{a: 4294967296, b: 18446744073709551615, add: 4294967295, sub: 4294967297, mul: 18446744069414584320, div: 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}, - utd64{a: 18446744073709551615, b: 4294967296, add: 4294967295, sub: 18446744069414584319, mul: 18446744069414584320, div: 4294967295}, - utd64{a: 18446744073709551615, b: 18446744073709551615, add: 18446744073709551614, sub: 0, mul: 1, div: 1}, -} -var int64_data []itd64 = []itd64{itd64{a: -9223372036854775808, b: -9223372036854775808, add: 0, sub: 0, mul: 0, div: 1}, - itd64{a: -9223372036854775808, b: -9223372036854775807, add: 1, sub: -1, mul: -9223372036854775808, div: 1}, - itd64{a: -9223372036854775808, b: -4294967296, add: 9223372032559808512, sub: -9223372032559808512, mul: 0, div: 2147483648}, - itd64{a: -9223372036854775808, b: -1, add: 9223372036854775807, sub: -9223372036854775807, mul: -9223372036854775808, div: -9223372036854775808}, + 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}, - itd64{a: -9223372036854775808, b: 4294967296, add: -9223372032559808512, sub: 9223372032559808512, mul: 0, div: -2147483648}, - itd64{a: -9223372036854775808, b: 9223372036854775806, add: -2, sub: 2, mul: 0, div: -1}, - itd64{a: -9223372036854775808, b: 9223372036854775807, add: -1, sub: 1, mul: -9223372036854775808, div: -1}, - itd64{a: -9223372036854775807, b: -9223372036854775808, add: 1, sub: 1, mul: -9223372036854775808, div: 0}, - itd64{a: -9223372036854775807, b: -9223372036854775807, add: 2, sub: 0, mul: 1, div: 1}, - itd64{a: -9223372036854775807, b: -4294967296, add: 9223372032559808513, sub: -9223372032559808511, mul: -4294967296, div: 2147483647}, - itd64{a: -9223372036854775807, b: -1, add: -9223372036854775808, sub: -9223372036854775806, mul: 9223372036854775807, div: 9223372036854775807}, + 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}, - itd64{a: -9223372036854775807, b: 4294967296, add: -9223372032559808511, sub: 9223372032559808513, mul: 4294967296, div: -2147483647}, - itd64{a: -9223372036854775807, b: 9223372036854775806, add: -1, sub: 3, mul: 9223372036854775806, div: -1}, - itd64{a: -9223372036854775807, b: 9223372036854775807, add: 0, sub: 2, mul: -1, div: -1}, - itd64{a: -4294967296, b: -9223372036854775808, add: 9223372032559808512, sub: 9223372032559808512, mul: 0, div: 0}, - itd64{a: -4294967296, b: -9223372036854775807, add: 9223372032559808513, sub: 9223372032559808511, mul: -4294967296, div: 0}, - itd64{a: -4294967296, b: -4294967296, add: -8589934592, sub: 0, mul: 0, div: 1}, - itd64{a: -4294967296, b: -1, add: -4294967297, sub: -4294967295, mul: 4294967296, div: 4294967296}, + 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}, - itd64{a: -4294967296, b: 4294967296, add: 0, sub: -8589934592, mul: 0, div: -1}, - itd64{a: -4294967296, b: 9223372036854775806, add: 9223372032559808510, sub: 9223372032559808514, mul: 8589934592, div: 0}, - itd64{a: -4294967296, b: 9223372036854775807, add: 9223372032559808511, sub: 9223372032559808513, mul: 4294967296, div: 0}, - itd64{a: -1, b: -9223372036854775808, add: 9223372036854775807, sub: 9223372036854775807, mul: -9223372036854775808, div: 0}, - itd64{a: -1, b: -9223372036854775807, add: -9223372036854775808, sub: 9223372036854775806, mul: 9223372036854775807, div: 0}, - itd64{a: -1, b: -4294967296, add: -4294967297, sub: 4294967295, mul: 4294967296, div: 0}, - itd64{a: -1, b: -1, add: -2, sub: 0, mul: 1, div: 1}, + 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}, - itd64{a: -1, b: 4294967296, add: 4294967295, sub: -4294967297, mul: -4294967296, div: 0}, - itd64{a: -1, b: 9223372036854775806, add: 9223372036854775805, sub: -9223372036854775807, mul: -9223372036854775806, div: 0}, - itd64{a: -1, b: 9223372036854775807, add: 9223372036854775806, sub: -9223372036854775808, mul: -9223372036854775807, div: 0}, - itd64{a: 0, b: -9223372036854775808, add: -9223372036854775808, sub: -9223372036854775808, mul: 0, div: 0}, - itd64{a: 0, b: -9223372036854775807, add: -9223372036854775807, sub: 9223372036854775807, mul: 0, div: 0}, - itd64{a: 0, b: -4294967296, add: -4294967296, sub: 4294967296, mul: 0, div: 0}, - itd64{a: 0, b: -1, add: -1, sub: 1, mul: 0, div: 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}, - itd64{a: 0, b: 4294967296, add: 4294967296, sub: -4294967296, mul: 0, div: 0}, - itd64{a: 0, b: 9223372036854775806, add: 9223372036854775806, sub: -9223372036854775806, mul: 0, div: 0}, - itd64{a: 0, b: 9223372036854775807, add: 9223372036854775807, sub: -9223372036854775807, mul: 0, div: 0}, - itd64{a: 1, b: -9223372036854775808, add: -9223372036854775807, sub: -9223372036854775807, mul: -9223372036854775808, div: 0}, - itd64{a: 1, b: -9223372036854775807, add: -9223372036854775806, sub: -9223372036854775808, mul: -9223372036854775807, div: 0}, - itd64{a: 1, b: -4294967296, add: -4294967295, sub: 4294967297, mul: -4294967296, div: 0}, - itd64{a: 1, b: -1, add: 0, sub: 2, mul: -1, div: -1}, + 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}, - itd64{a: 1, b: 4294967296, add: 4294967297, sub: -4294967295, mul: 4294967296, div: 0}, - itd64{a: 1, b: 9223372036854775806, add: 9223372036854775807, sub: -9223372036854775805, mul: 9223372036854775806, div: 0}, - itd64{a: 1, b: 9223372036854775807, add: -9223372036854775808, sub: -9223372036854775806, mul: 9223372036854775807, div: 0}, - itd64{a: 4294967296, b: -9223372036854775808, add: -9223372032559808512, sub: -9223372032559808512, mul: 0, div: 0}, - itd64{a: 4294967296, b: -9223372036854775807, add: -9223372032559808511, sub: -9223372032559808513, mul: 4294967296, div: 0}, - itd64{a: 4294967296, b: -4294967296, add: 0, sub: 8589934592, mul: 0, div: -1}, - itd64{a: 4294967296, b: -1, add: 4294967295, sub: 4294967297, mul: -4294967296, div: -4294967296}, + 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}, - itd64{a: 4294967296, b: 4294967296, add: 8589934592, sub: 0, mul: 0, div: 1}, - itd64{a: 4294967296, b: 9223372036854775806, add: -9223372032559808514, sub: -9223372032559808510, mul: -8589934592, div: 0}, - itd64{a: 4294967296, b: 9223372036854775807, add: -9223372032559808513, sub: -9223372032559808511, mul: -4294967296, div: 0}, - itd64{a: 9223372036854775806, b: -9223372036854775808, add: -2, sub: -2, mul: 0, div: 0}, - itd64{a: 9223372036854775806, b: -9223372036854775807, add: -1, sub: -3, mul: 9223372036854775806, div: 0}, - itd64{a: 9223372036854775806, b: -4294967296, add: 9223372032559808510, sub: -9223372032559808514, mul: 8589934592, div: -2147483647}, - itd64{a: 9223372036854775806, b: -1, add: 9223372036854775805, sub: 9223372036854775807, mul: -9223372036854775806, div: -9223372036854775806}, + 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}, - itd64{a: 9223372036854775806, b: 4294967296, add: -9223372032559808514, sub: 9223372032559808510, mul: -8589934592, div: 2147483647}, - itd64{a: 9223372036854775806, b: 9223372036854775806, add: -4, sub: 0, mul: 4, div: 1}, - itd64{a: 9223372036854775806, b: 9223372036854775807, add: -3, sub: -1, mul: -9223372036854775806, div: 0}, - itd64{a: 9223372036854775807, b: -9223372036854775808, add: -1, sub: -1, mul: -9223372036854775808, div: 0}, - itd64{a: 9223372036854775807, b: -9223372036854775807, add: 0, sub: -2, mul: -1, div: -1}, - itd64{a: 9223372036854775807, b: -4294967296, add: 9223372032559808511, sub: -9223372032559808513, mul: 4294967296, div: -2147483647}, - itd64{a: 9223372036854775807, b: -1, add: 9223372036854775806, sub: -9223372036854775808, mul: -9223372036854775807, div: -9223372036854775807}, + 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}, - itd64{a: 9223372036854775807, b: 4294967296, add: -9223372032559808513, sub: 9223372032559808511, mul: -4294967296, div: 2147483647}, - itd64{a: 9223372036854775807, b: 9223372036854775806, add: -3, sub: 1, mul: -9223372036854775806, div: 1}, - itd64{a: 9223372036854775807, b: 9223372036854775807, add: -2, sub: 0, mul: 1, div: 1}, + 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}, - utd32{a: 0, b: 4294967295, add: 4294967295, sub: 1, mul: 0, div: 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}, - utd32{a: 1, b: 4294967295, add: 0, sub: 2, mul: 4294967295, div: 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}, - utd32{a: 4294967295, b: 4294967295, add: 4294967294, sub: 0, mul: 1, div: 1}, + 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}, - itd32{a: -2147483648, b: -2147483647, add: 1, sub: -1, mul: -2147483648, div: 1}, - itd32{a: -2147483648, b: -1, add: 2147483647, sub: -2147483647, mul: -2147483648, div: -2147483648}, +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}, - itd32{a: -2147483648, b: 2147483647, add: -1, sub: 1, mul: -2147483648, div: -1}, - itd32{a: -2147483647, b: -2147483648, add: 1, sub: 1, mul: -2147483648, div: 0}, - itd32{a: -2147483647, b: -2147483647, add: 2, sub: 0, mul: 1, div: 1}, - itd32{a: -2147483647, b: -1, add: -2147483648, sub: -2147483646, mul: 2147483647, div: 2147483647}, + 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}, - itd32{a: -2147483647, b: 2147483647, add: 0, sub: 2, mul: -1, div: -1}, - itd32{a: -1, b: -2147483648, add: 2147483647, sub: 2147483647, mul: -2147483648, div: 0}, - itd32{a: -1, b: -2147483647, add: -2147483648, sub: 2147483646, mul: 2147483647, div: 0}, - itd32{a: -1, b: -1, add: -2, sub: 0, mul: 1, div: 1}, + 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}, - itd32{a: -1, b: 2147483647, add: 2147483646, sub: -2147483648, mul: -2147483647, div: 0}, - itd32{a: 0, b: -2147483648, add: -2147483648, sub: -2147483648, mul: 0, div: 0}, - itd32{a: 0, b: -2147483647, add: -2147483647, sub: 2147483647, mul: 0, div: 0}, - itd32{a: 0, b: -1, add: -1, sub: 1, mul: 0, div: 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}, - itd32{a: 0, b: 2147483647, add: 2147483647, sub: -2147483647, mul: 0, div: 0}, - itd32{a: 1, b: -2147483648, add: -2147483647, sub: -2147483647, mul: -2147483648, div: 0}, - itd32{a: 1, b: -2147483647, add: -2147483646, sub: -2147483648, mul: -2147483647, div: 0}, - itd32{a: 1, b: -1, add: 0, sub: 2, mul: -1, div: -1}, + 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}, - itd32{a: 1, b: 2147483647, add: -2147483648, sub: -2147483646, mul: 2147483647, div: 0}, - itd32{a: 2147483647, b: -2147483648, add: -1, sub: -1, mul: -2147483648, div: 0}, - itd32{a: 2147483647, b: -2147483647, add: 0, sub: -2, mul: -1, div: -1}, - itd32{a: 2147483647, b: -1, add: 2147483646, sub: -2147483648, mul: -2147483647, div: -2147483647}, + 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}, - itd32{a: 2147483647, b: 2147483647, add: -2, sub: 0, mul: 1, div: 1}, + 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}, - utd16{a: 0, b: 65535, add: 65535, sub: 1, mul: 0, div: 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}, - utd16{a: 1, b: 65535, add: 0, sub: 2, mul: 65535, div: 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}, - utd16{a: 65535, b: 65535, add: 65534, sub: 0, mul: 1, div: 1}, + 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}, - itd16{a: -32768, b: -32767, add: 1, sub: -1, mul: -32768, div: 1}, - itd16{a: -32768, b: -1, add: 32767, sub: -32767, mul: -32768, div: -32768}, +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}, - itd16{a: -32768, b: 32766, add: -2, sub: 2, mul: 0, div: -1}, - itd16{a: -32768, b: 32767, add: -1, sub: 1, mul: -32768, div: -1}, - itd16{a: -32767, b: -32768, add: 1, sub: 1, mul: -32768, div: 0}, - itd16{a: -32767, b: -32767, add: 2, sub: 0, mul: 1, div: 1}, - itd16{a: -32767, b: -1, add: -32768, sub: -32766, mul: 32767, div: 32767}, + 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}, - itd16{a: -32767, b: 32766, add: -1, sub: 3, mul: 32766, div: -1}, - itd16{a: -32767, b: 32767, add: 0, sub: 2, mul: -1, div: -1}, - itd16{a: -1, b: -32768, add: 32767, sub: 32767, mul: -32768, div: 0}, - itd16{a: -1, b: -32767, add: -32768, sub: 32766, mul: 32767, div: 0}, - itd16{a: -1, b: -1, add: -2, sub: 0, mul: 1, div: 1}, + 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}, - itd16{a: -1, b: 32766, add: 32765, sub: -32767, mul: -32766, div: 0}, - itd16{a: -1, b: 32767, add: 32766, sub: -32768, mul: -32767, div: 0}, - itd16{a: 0, b: -32768, add: -32768, sub: -32768, mul: 0, div: 0}, - itd16{a: 0, b: -32767, add: -32767, sub: 32767, mul: 0, div: 0}, - itd16{a: 0, b: -1, add: -1, sub: 1, mul: 0, div: 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}, - itd16{a: 0, b: 32766, add: 32766, sub: -32766, mul: 0, div: 0}, - itd16{a: 0, b: 32767, add: 32767, sub: -32767, mul: 0, div: 0}, - itd16{a: 1, b: -32768, add: -32767, sub: -32767, mul: -32768, div: 0}, - itd16{a: 1, b: -32767, add: -32766, sub: -32768, mul: -32767, div: 0}, - itd16{a: 1, b: -1, add: 0, sub: 2, mul: -1, div: -1}, + 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}, - itd16{a: 1, b: 32766, add: 32767, sub: -32765, mul: 32766, div: 0}, - itd16{a: 1, b: 32767, add: -32768, sub: -32766, mul: 32767, div: 0}, - itd16{a: 32766, b: -32768, add: -2, sub: -2, mul: 0, div: 0}, - itd16{a: 32766, b: -32767, add: -1, sub: -3, mul: 32766, div: 0}, - itd16{a: 32766, b: -1, add: 32765, sub: 32767, mul: -32766, div: -32766}, + 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}, - itd16{a: 32766, b: 32766, add: -4, sub: 0, mul: 4, div: 1}, - itd16{a: 32766, b: 32767, add: -3, sub: -1, mul: -32766, div: 0}, - itd16{a: 32767, b: -32768, add: -1, sub: -1, mul: -32768, div: 0}, - itd16{a: 32767, b: -32767, add: 0, sub: -2, mul: -1, div: -1}, - itd16{a: 32767, b: -1, add: 32766, sub: -32768, mul: -32767, div: -32767}, + 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}, - itd16{a: 32767, b: 32766, add: -3, sub: 1, mul: -32766, div: 1}, - itd16{a: 32767, b: 32767, add: -2, sub: 0, mul: 1, div: 1}, + 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}, - utd8{a: 0, b: 255, add: 255, sub: 1, mul: 0, div: 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}, - utd8{a: 1, b: 255, add: 0, sub: 2, mul: 255, div: 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}, - utd8{a: 255, b: 255, add: 254, sub: 0, mul: 1, div: 1}, + 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}, - itd8{a: -128, b: -127, add: 1, sub: -1, mul: -128, div: 1}, - itd8{a: -128, b: -1, add: 127, sub: -127, mul: -128, div: -128}, +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}, - itd8{a: -128, b: 126, add: -2, sub: 2, mul: 0, div: -1}, - itd8{a: -128, b: 127, add: -1, sub: 1, mul: -128, div: -1}, - itd8{a: -127, b: -128, add: 1, sub: 1, mul: -128, div: 0}, - itd8{a: -127, b: -127, add: 2, sub: 0, mul: 1, div: 1}, - itd8{a: -127, b: -1, add: -128, sub: -126, mul: 127, div: 127}, + 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}, - itd8{a: -127, b: 126, add: -1, sub: 3, mul: 126, div: -1}, - itd8{a: -127, b: 127, add: 0, sub: 2, mul: -1, div: -1}, - itd8{a: -1, b: -128, add: 127, sub: 127, mul: -128, div: 0}, - itd8{a: -1, b: -127, add: -128, sub: 126, mul: 127, div: 0}, - itd8{a: -1, b: -1, add: -2, sub: 0, mul: 1, div: 1}, + 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}, - itd8{a: -1, b: 126, add: 125, sub: -127, mul: -126, div: 0}, - itd8{a: -1, b: 127, add: 126, sub: -128, mul: -127, div: 0}, - itd8{a: 0, b: -128, add: -128, sub: -128, mul: 0, div: 0}, - itd8{a: 0, b: -127, add: -127, sub: 127, mul: 0, div: 0}, - itd8{a: 0, b: -1, add: -1, sub: 1, mul: 0, div: 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}, - itd8{a: 0, b: 126, add: 126, sub: -126, mul: 0, div: 0}, - itd8{a: 0, b: 127, add: 127, sub: -127, mul: 0, div: 0}, - itd8{a: 1, b: -128, add: -127, sub: -127, mul: -128, div: 0}, - itd8{a: 1, b: -127, add: -126, sub: -128, mul: -127, div: 0}, - itd8{a: 1, b: -1, add: 0, sub: 2, mul: -1, div: -1}, + 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}, - itd8{a: 1, b: 126, add: 127, sub: -125, mul: 126, div: 0}, - itd8{a: 1, b: 127, add: -128, sub: -126, mul: 127, div: 0}, - itd8{a: 126, b: -128, add: -2, sub: -2, mul: 0, div: 0}, - itd8{a: 126, b: -127, add: -1, sub: -3, mul: 126, div: 0}, - itd8{a: 126, b: -1, add: 125, sub: 127, mul: -126, div: -126}, + 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}, - itd8{a: 126, b: 126, add: -4, sub: 0, mul: 4, div: 1}, - itd8{a: 126, b: 127, add: -3, sub: -1, mul: -126, div: 0}, - itd8{a: 127, b: -128, add: -1, sub: -1, mul: -128, div: 0}, - itd8{a: 127, b: -127, add: 0, sub: -2, mul: -1, div: -1}, - itd8{a: 127, b: -1, add: 126, sub: -128, mul: -127, div: -127}, + 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}, - itd8{a: 127, b: 126, add: -3, sub: 1, mul: -126, div: 1}, - itd8{a: 127, b: 127, add: -2, sub: 0, mul: 1, div: 1}, + 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 @@ -481,6 +521,13 @@ func main() { 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) @@ -502,6 +549,13 @@ func main() { 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) @@ -523,6 +577,13 @@ func main() { 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) @@ -544,6 +605,13 @@ func main() { 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) @@ -565,6 +633,13 @@ func main() { 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) @@ -586,6 +661,13 @@ func main() { 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) @@ -607,6 +689,13 @@ func main() { 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) @@ -628,6 +717,13 @@ func main() { 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) 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 0000000000..19bb04b6f1 --- /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( + `func {{.Name}}_{{.Stype}}_ssa(a, b {{.Stype}}) {{.Stype}} { + switch{} // prevent inlining + 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/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 919336e869..582528801a 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -52,6 +52,15 @@ (Hmul8 x y) -> (HMULB x y) (Hmul8u x y) -> (HMULBU 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) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index b218c66a64..7469601fc7 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -103,6 +103,8 @@ func init() { 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} gp10 = regInfo{inputs: []regMask{gp}} gp2flags = regInfo{inputs: []regMask{gpsp, gpsp}, outputs: flagsonly} @@ -202,6 +204,13 @@ func init() { {name: "DIVLU", reg: gp11div, asm: "DIVL"}, // arg0 / arg1 {name: "DIVWU", reg: gp11div, asm: "DIVW"}, // arg0 / arg1 + {name: "MODQ", reg: gp11mod, asm: "IDIVQ"}, // arg0 % arg1 + {name: "MODL", reg: gp11mod, asm: "IDIVL"}, // arg0 % arg1 + {name: "MODW", reg: gp11mod, asm: "IDIVW"}, // arg0 % arg1 + {name: "MODQU", reg: gp11mod, asm: "DIVQ"}, // arg0 % arg1 + {name: "MODLU", reg: gp11mod, asm: "DIVL"}, // arg0 % arg1 + {name: "MODWU", reg: gp11mod, asm: "DIVW"}, // arg0 % arg1 + {name: "ANDQ", reg: gp21, asm: "ANDQ"}, // arg0 & arg1 {name: "ANDL", reg: gp21, asm: "ANDL"}, // arg0 & arg1 {name: "ANDW", reg: gp21, asm: "ANDW"}, // arg0 & arg1 diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 5b8b064bb5..78524a5e6b 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -35,7 +35,6 @@ var genericOps = []opData{ {name: "Div32F"}, // arg0 / arg1 {name: "Div64F"}, - // TODO: Div8, Div16, Div32, Div64 and unsigned {name: "Hmul8"}, // (arg0 * arg1) >> width {name: "Hmul8u"}, @@ -54,6 +53,15 @@ var genericOps = []opData{ {name: "Div64"}, {name: "Div64u"}, + {name: "Mod8"}, // arg0 % arg1 + {name: "Mod8u"}, + {name: "Mod16"}, + {name: "Mod16u"}, + {name: "Mod32"}, + {name: "Mod32u"}, + {name: "Mod64"}, + {name: "Mod64u"}, + {name: "And8"}, // arg0 & arg1 {name: "And16"}, {name: "And32"}, diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index a2e087246d..11fc3180cf 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -105,6 +105,12 @@ const ( OpAMD64DIVQU OpAMD64DIVLU OpAMD64DIVWU + OpAMD64MODQ + OpAMD64MODL + OpAMD64MODW + OpAMD64MODQU + OpAMD64MODLU + OpAMD64MODWU OpAMD64ANDQ OpAMD64ANDL OpAMD64ANDW @@ -267,6 +273,14 @@ const ( OpDiv32u OpDiv64 OpDiv64u + OpMod8 + OpMod8u + OpMod16 + OpMod16u + OpMod32 + OpMod32u + OpMod64 + OpMod64u OpAnd8 OpAnd16 OpAnd32 @@ -1165,6 +1179,90 @@ var opcodeTable = [...]opInfo{ }, }, }, + { + name: "MODQ", + 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", + 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", + 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", + 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", + 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", + 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", asm: x86.AANDQ, @@ -2852,6 +2950,38 @@ var opcodeTable = [...]opInfo{ name: "Div64u", generic: true, }, + { + name: "Mod8", + generic: true, + }, + { + name: "Mod8u", + generic: true, + }, + { + name: "Mod16", + generic: true, + }, + { + name: "Mod16u", + generic: true, + }, + { + name: "Mod32", + generic: true, + }, + { + name: "Mod32u", + generic: true, + }, + { + name: "Mod64", + generic: true, + }, + { + name: "Mod64u", + generic: true, + }, { name: "And8", generic: true, diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 4265cfcb84..3b2b7f03a7 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -4734,6 +4734,162 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end61dbc9d9e93dd6946a20a1f475b3f74b end61dbc9d9e93dd6946a20a1f475b3f74b: ; + case OpMod16: + // match: (Mod16 x y) + // cond: + // result: (MODW x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64MODW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end036bac694be9fe0d6b00b86c2e625990 + end036bac694be9fe0d6b00b86c2e625990: + ; + case OpMod16u: + // match: (Mod16u x y) + // cond: + // result: (MODWU x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64MODWU + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto enda75d900097f1510ca1c6df786bef0c24 + enda75d900097f1510ca1c6df786bef0c24: + ; + case OpMod32: + // match: (Mod32 x y) + // cond: + // result: (MODL x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64MODL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end12c8c0ecf3296810b8217cd4e40f7707 + end12c8c0ecf3296810b8217cd4e40f7707: + ; + case OpMod32u: + // match: (Mod32u x y) + // cond: + // result: (MODLU x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64MODLU + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end1f0892076cfd58733a08d3ab175a3c1c + end1f0892076cfd58733a08d3ab175a3c1c: + ; + case OpMod64: + // match: (Mod64 x y) + // cond: + // result: (MODQ x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64MODQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto endaae75f449baf5dc108be4e0439af97f2 + endaae75f449baf5dc108be4e0439af97f2: + ; + case OpMod64u: + // match: (Mod64u x y) + // cond: + // result: (MODQU x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64MODQU + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end0d4c8b9df77e59289fb14e2496559d1d + end0d4c8b9df77e59289fb14e2496559d1d: + ; + case OpMod8: + // match: (Mod8 x y) + // cond: + // result: (MODW (SignExt8to16 x) (SignExt8to16 y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64MODW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpSignExt8to16, TypeInvalid) + v0.Type = config.Frontend().TypeInt16() + v0.AddArg(x) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpSignExt8to16, TypeInvalid) + v1.Type = config.Frontend().TypeInt16() + v1.AddArg(y) + v.AddArg(v1) + return true + } + goto end13bfd4e75ea363f7b6926fa05136e193 + end13bfd4e75ea363f7b6926fa05136e193: + ; + case OpMod8u: + // match: (Mod8u x y) + // cond: + // result: (MODWU (ZeroExt8to16 x) (ZeroExt8to16 y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64MODWU + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpZeroExt8to16, TypeInvalid) + v0.Type = config.Frontend().TypeUInt16() + v0.AddArg(x) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpZeroExt8to16, TypeInvalid) + v1.Type = config.Frontend().TypeUInt16() + v1.AddArg(y) + v.AddArg(v1) + return true + } + goto end4c0e16e55b5f8f6d19811fc8d07eacf2 + end4c0e16e55b5f8f6d19811fc8d07eacf2: + ; case OpMove: // match: (Move [size] dst src mem) // cond: -- cgit v1.3 From 0ffd9c8cadae38a9334dcbb9dc7876f499deb474 Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Fri, 21 Aug 2015 21:38:41 -0500 Subject: [dev.ssa] cmd/compile/internal: mark len(map), len/cap(chan) unimplemented Mark these as unimplemented so we don't generate bad code. Change-Id: I101190c40a753faaa82193ac37e2978b20a96e4e Reviewed-on: https://go-review.googlesource.com/13748 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/gc/ssa.go | 10 ++++++++++ src/cmd/compile/internal/gc/type.go | 8 ++++++++ 2 files changed, 18 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 6d3359ad0e..a7349a8f1f 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1349,6 +1349,16 @@ func (s *state) expr(n *Node) *ssa.Value { 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(): + s.Unimplementedf("unhandled len(map)") + return nil + case n.Left.Type.IsChan(): + if n.Op == OCAP { + s.Unimplementedf("unhandled cap(chan)") + } else { + s.Unimplementedf("unhandled len(chan)") + } + return nil default: // array return s.constInt(Types[TINT], n.Left.Type.Bound) } diff --git a/src/cmd/compile/internal/gc/type.go b/src/cmd/compile/internal/gc/type.go index bcad025ba6..697152bebd 100644 --- a/src/cmd/compile/internal/gc/type.go +++ b/src/cmd/compile/internal/gc/type.go @@ -64,6 +64,14 @@ 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 } -- cgit v1.3 From 220e70540445c26463238ff094b6254055ac2b31 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Sat, 22 Aug 2015 13:30:45 -0700 Subject: [dev.ssa] cmd/compile: make "*Value".String more robust Change-Id: I4ae38440a33574421c9e3e350701e86e8a224b92 Reviewed-on: https://go-review.googlesource.com/13842 Reviewed-by: Todd Neal Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/value.go | 3 +++ 1 file changed, 3 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/value.go b/src/cmd/compile/internal/ssa/value.go index 286edc0cda..04ea17cce9 100644 --- a/src/cmd/compile/internal/ssa/value.go +++ b/src/cmd/compile/internal/ssa/value.go @@ -48,6 +48,9 @@ type Value struct { // 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) } -- cgit v1.3 From f3171994e92a7cf70ddb52aff557d22559de9b18 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Sat, 22 Aug 2015 09:52:36 -0700 Subject: [dev.ssa] cmd/compile: mark LEA and MOV instructions as not clobbering flags This further reduces the number of flags spills during make.bash by about 50%. Note that GetG is implemented by one or two MOVs, which is why it does not clobber flags. Change-Id: I6fede8c027b7dc340e00d1e15df1b87bf2b2d9ec Reviewed-on: https://go-review.googlesource.com/13843 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 19 ++++++++++--------- src/cmd/compile/internal/ssa/opGen.go | 16 ---------------- 2 files changed, 10 insertions(+), 25 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 7469601fc7..86b51ecef2 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -93,11 +93,12 @@ func init() { // Common regInfo var ( - gp01 = regInfo{inputs: []regMask{}, outputs: gponly, clobbers: flags} + gp01 = regInfo{inputs: []regMask{}, outputs: gponly} gp11 = regInfo{inputs: []regMask{gpsp}, outputs: gponly, clobbers: flags} - gp11sb = regInfo{inputs: []regMask{gpspsb}, 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, 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} @@ -315,12 +316,12 @@ func init() { {name: "SETA", reg: readflags, asm: "SETHI"}, // extract unsigned > condition from arg0 {name: "SETAE", reg: readflags, asm: "SETCC"}, // extract unsigned >= condition from arg0 - {name: "MOVBQSX", reg: gp11, asm: "MOVBQSX"}, // sign extend arg0 from int8 to int64 - {name: "MOVBQZX", reg: gp11, asm: "MOVBQZX"}, // zero extend arg0 from int8 to int64 - {name: "MOVWQSX", reg: gp11, asm: "MOVWQSX"}, // sign extend arg0 from int16 to int64 - {name: "MOVWQZX", reg: gp11, asm: "MOVWQZX"}, // zero extend arg0 from int16 to int64 - {name: "MOVLQSX", reg: gp11, asm: "MOVLQSX"}, // sign extend arg0 from int32 to int64 - {name: "MOVLQZX", reg: gp11, asm: "MOVLQZX"}, // zero extend arg0 from int32 to int64 + {name: "MOVBQSX", reg: gp11nf, asm: "MOVBQSX"}, // sign extend arg0 from int8 to int64 + {name: "MOVBQZX", reg: gp11nf, asm: "MOVBQZX"}, // zero extend arg0 from int8 to int64 + {name: "MOVWQSX", reg: gp11nf, asm: "MOVWQSX"}, // sign extend arg0 from int16 to int64 + {name: "MOVWQZX", reg: gp11nf, asm: "MOVWQZX"}, // zero extend arg0 from int16 to int64 + {name: "MOVLQSX", reg: gp11nf, asm: "MOVLQSX"}, // sign extend arg0 from int32 to int64 + {name: "MOVLQZX", reg: gp11nf, asm: "MOVLQZX"}, // zero extend arg0 from int32 to int64 {name: "MOVBconst", reg: gp01, asm: "MOVB"}, // 8 low bits of auxint {name: "MOVWconst", reg: gp01, asm: "MOVW"}, // 16 low bits of auxint diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 11fc3180cf..5346f757fb 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -2261,7 +2261,6 @@ var opcodeTable = [...]opInfo{ 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 }, @@ -2420,7 +2419,6 @@ var opcodeTable = [...]opInfo{ 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 }, @@ -2433,7 +2431,6 @@ var opcodeTable = [...]opInfo{ 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 }, @@ -2446,7 +2443,6 @@ var opcodeTable = [...]opInfo{ 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 }, @@ -2459,7 +2455,6 @@ var opcodeTable = [...]opInfo{ 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 }, @@ -2472,7 +2467,6 @@ var opcodeTable = [...]opInfo{ 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 }, @@ -2495,7 +2489,6 @@ var opcodeTable = [...]opInfo{ name: "MOVBconst", asm: x86.AMOVB, reg: regInfo{ - clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -2505,7 +2498,6 @@ var opcodeTable = [...]opInfo{ name: "MOVWconst", asm: x86.AMOVW, reg: regInfo{ - clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -2515,7 +2507,6 @@ var opcodeTable = [...]opInfo{ name: "MOVLconst", asm: x86.AMOVL, reg: regInfo{ - clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -2525,7 +2516,6 @@ var opcodeTable = [...]opInfo{ name: "MOVQconst", asm: x86.AMOVQ, reg: regInfo{ - clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -2537,7 +2527,6 @@ var opcodeTable = [...]opInfo{ inputs: []inputInfo{ {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB }, - clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -2550,7 +2539,6 @@ var opcodeTable = [...]opInfo{ {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 }, - clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -2563,7 +2551,6 @@ var opcodeTable = [...]opInfo{ {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 }, - clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -2576,7 +2563,6 @@ var opcodeTable = [...]opInfo{ {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 }, - clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -2589,7 +2575,6 @@ var opcodeTable = [...]opInfo{ {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 }, - clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -2799,7 +2784,6 @@ var opcodeTable = [...]opInfo{ { name: "LoweredGetG", reg: regInfo{ - clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, -- cgit v1.3 From 9f8f8c27dca1b27e9567df4f3aa4e7d8c31f3ec2 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Sat, 22 Aug 2015 19:38:12 -0700 Subject: [dev.ssa] cmd/compile: support spilling and loading flags This CL takes a simple approach to spilling and loading flags. We never spill. When a load is needed, we recalculate, loading the arguments as needed. This is simple and architecture-independent. It is not very efficient, but as of this CL, there are fewer than 200 flag spills during make.bash. This was tested by manually reverting CLs 13813 and 13843, causing SETcc, MOV, and LEA instructions to clobber flags, which dramatically increases the number of flags spills. With that done, all stdlib tests that used to pass still pass. For future reference, here are some other, more efficient amd64-only schemes that we could adapt in the future if needed. (1) Spill exactly the flags needed. For example, if we know that the flags will be needed by a SETcc or Jcc op later, we could use SETcc to extract just the relevant flag. When needed, we could use TESTB and change the op to JNE/SETNE. (Alternatively, we could leave the op unaltered and prepare an appropriate CMPB instruction to produce the desired flag.) However, this requires separate handling for every instruction that uses the flags register, including (say) SBBQcarrymask. We could enable this on an ad hoc basis for common cases and fall back to recalculation for other cases. (2) Spill all flags with PUSHF and POPF This modifies SP, which the runtime won't like. It also requires coordination with stackalloc to make sure that we have a stack slot ready for use. (3) Spill almost all flags with LAHF, SETO, and SAHF See http://blog.freearrow.com/archives/396 for details. This would handle all the flags we currently use. However, LAHF and SAHF are not universally available and it requires arranging for AX to be free. Change-Id: Ie36600fd8e807ef2bee83e2e2ae3685112a7f276 Reviewed-on: https://go-review.googlesource.com/13844 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/regalloc.go | 52 +++++++++++++++++++++++++++----- 1 file changed, 44 insertions(+), 8 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index d593faf95b..b62f9042b6 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -38,6 +38,12 @@ // 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. // +// Flags values are special. Instead of attempting to spill and restore the flags +// register, we recalculate it if needed. +// There are more efficient schemes (see the discussion in CL 13844), +// but flag restoration is empirically rare, and this approach is simple +// and architecture-independent. +// // 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). @@ -391,17 +397,45 @@ func (s *regAllocState) allocValToReg(v *Value, mask regMask, nospill bool) *Val } c = s.curBlock.NewValue1(v.Line, OpCopy, v.Type, s.regs[r2].c) } else { + switch { + // It is difficult to spill and reload flags on many architectures. + // Instead, we regenerate the flags register by issuing the same instruction again. + // This requires (possibly) spilling and reloading that instruction's args. + case v.Type.IsFlags(): + ns := s.nospill + // Place v's arguments in registers, spilling and loading as needed + args := make([]*Value, 0, len(v.Args)) + regspec := opcodeTable[v.Op].reg + for _, i := range regspec.inputs { + a := v.Args[i.idx] + // Extract the original arguments to v + for a.Op == OpLoadReg || a.Op == OpStoreReg || a.Op == OpCopy { + a = a.Args[0] + } + if a.Type.IsFlags() { + s.f.Fatalf("cannot load flags value with flags arg: %v has unwrapped arg %v", v.LongString(), a.LongString()) + } + cc := s.allocValToReg(a, i.regs, true) + args = append(args, cc) + } + s.nospill = ns + // Recalculate v + c = s.curBlock.NewValue0(v.Line, v.Op, v.Type) + c.Aux = v.Aux + c.AuxInt = v.AuxInt + c.resetArgs() + c.AddArgs(args...) + // Load v from its spill location. // TODO: rematerialize if we can. - if vi.spill2 != nil { + case vi.spill2 != nil: c = s.curBlock.NewValue1(v.Line, OpLoadReg, v.Type, vi.spill2) vi.spill2used = true - } else { + case vi.spill != nil: c = s.curBlock.NewValue1(v.Line, OpLoadReg, v.Type, vi.spill) vi.spillUsed = true - } - if v.Type.IsFlags() { - v.Unimplementedf("spill of flags not implemented yet") + default: + s.f.Fatalf("attempt to load unspilled value %v", v.LongString()) } } s.assignReg(r, v, c) @@ -716,9 +750,11 @@ func (s *regAllocState) regalloc(f *Func) { // Issue a spill for this value. We issue spills unconditionally, // then at the end of regalloc delete the ones we never use. - spill := b.NewValue1(v.Line, OpStoreReg, v.Type, v) - s.values[v.ID].spill = spill - s.values[v.ID].spillUsed = false + if !v.Type.IsFlags() { + spill := b.NewValue1(v.Line, OpStoreReg, v.Type, v) + s.values[v.ID].spill = spill + s.values[v.ID].spillUsed = false + } // Increment pc for next Value. pc++ -- cgit v1.3 From 5844603f143a859902386a8d70ac6abb732f4ccd Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Sun, 23 Aug 2015 20:29:43 -0700 Subject: [dev.ssa] cmd/compile: streamline unimplemented strings This aids in making sense of the aggregate set of work outstanding. Interest in the details of any particular implementation failure is better handled locally anyway. In my local tree, running make.bash after this CL yields: 14.85% 1811 SSA unimplemented: unhandled expr SLICEARR 13.84% 1687 SSA unimplemented: unhandled expr CALLINTER 11.84% 1444 SSA unimplemented: unhandled stmt RETJMP 10.24% 1249 SSA unimplemented: unhandled expr EFACE 8.52% 1039 SSA unimplemented: unhandled expr SLICE 4.92% 600 SSA unimplemented: local variable with class PAUTO,heap unimplemented 4.90% 598 SSA unimplemented: unhandled expr SLICESTR 3.91% 477 SSA unimplemented: local variable with class PFUNC unimplemented 3.45% 421 SSA unimplemented: not lowered: IMake INTER PTR64 PTR64 3.42% 417 SSA unimplemented: unhandled expr APPEND 3.21% 391 SSA unimplemented: unhandled expr CLOSUREVAR 3.06% 373 SSA unimplemented: unhandled stmt DEFER 3.04% 371 SSA unimplemented: unhandled stmt AS2DOTTYPE 1.61% 196 SSA unimplemented: unhandled expr DOTTYPE 1.56% 190 SSA unimplemented: not lowered: Load STRUCT PTR64 mem 0.79% 96 SSA unimplemented: not lowered: StringMake STRING PTR64 UINTPTR 0.69% 84 SSA unimplemented: unhandled binary op NE FLOAT64 0.53% 65 SSA unimplemented: unhandled expr STRUCTLIT 0.50% 61 SSA unimplemented: not lowered: SliceMake ARRAY PTR64 UINTPTR UINTPTR 0.45% 55 SSA unimplemented: zero for type float64 not implemented 0.44% 54 SSA unimplemented: unhandled addr CLOSUREVAR 0.38% 46 SSA unimplemented: unhandled binary op EQ FLOAT64 0.35% 43 SSA unimplemented: unhandled binary op LT FLOAT64 0.34% 42 SSA unimplemented: unhandled len(map) 0.33% 40 SSA unimplemented: unhandled stmt FALL 0.23% 28 SSA unimplemented: CONVNOP closure 0.21% 25 SSA unimplemented: local variable with class PPARAM,heap unimplemented 0.21% 25 SSA unimplemented: unhandled binary op GT FLOAT64 0.18% 22 SSA unimplemented: unhandled OCONV FLOAT32 -> FLOAT64 0.18% 22 SSA unimplemented: unhandled expr REAL 0.16% 20 SSA unimplemented: unhandled stmt PROC 0.16% 19 SSA unimplemented: unhandled closure arg 0.15% 18 SSA unimplemented: unhandled OCONV INT64 -> FLOAT64 0.12% 15 SSA unimplemented: unhandled expr CFUNC 0.10% 12 SSA unimplemented: unhandled OCONV UINT64 -> FLOAT64 0.09% 11 SSA unimplemented: unhandled OLITERAL 4 0.09% 11 SSA unimplemented: unhandled expr IMAG 0.07% 9 SSA unimplemented: unhandled binary op GE FLOAT64 0.07% 9 SSA unimplemented: unhandled binary op MINUS FLOAT64 0.06% 7 SSA unimplemented: unhandled OCONV FLOAT64 -> FLOAT32 0.06% 7 SSA unimplemented: unhandled binary op NE FLOAT32 0.06% 7 SSA unimplemented: variable address class 5 not implemented 0.05% 6 SSA unimplemented: not lowered: Load COMPLEX128 PTR64 mem 0.05% 6 SSA unimplemented: unhandled expr SLICE3ARR 0.04% 5 SSA unimplemented: unhandled binary op LE FLOAT64 0.03% 4 SSA unimplemented: unhandled OCONV UINTPTR -> FLOAT64 0.03% 4 SSA unimplemented: unhandled binary op EQ COMPLEX128 0.03% 4 SSA unimplemented: unhandled binary op EQ FLOAT32 0.03% 4 SSA unimplemented: unhandled expr COMPLEX 0.02% 3 SSA unimplemented: local variable with class PPARAMOUT,heap unimplemented 0.02% 3 SSA unimplemented: not lowered: Load ARRAY PTR64 mem 0.02% 3 SSA unimplemented: unhandled OCONV INT32 -> FLOAT64 0.02% 3 SSA unimplemented: unhandled OCONV INT64 -> FLOAT32 0.02% 3 SSA unimplemented: unhandled expr SLICE3 0.02% 2 SSA unimplemented: unhandled OCONV COMPLEX64 -> COMPLEX128 0.02% 2 SSA unimplemented: unhandled OCONV FLOAT64 -> INT64 0.02% 2 SSA unimplemented: unhandled OCONV FLOAT64 -> UINT64 0.02% 2 SSA unimplemented: unhandled OCONV INT -> FLOAT64 0.02% 2 SSA unimplemented: unhandled OCONV UINT64 -> FLOAT32 0.02% 2 SSA unimplemented: unhandled binary op EQ COMPLEX64 0.02% 2 SSA unimplemented: unhandled binary op MINUS FLOAT32 0.02% 2 SSA unimplemented: zero for type complex128 not implemented 0.02% 2 SSA unimplemented: zero for type complex64 not implemented 0.02% 2 SSA unimplemented: zero for type float32 not implemented 0.01% 1 SSA unimplemented: not lowered: EqFat BOOL INTER INTER 0.01% 1 SSA unimplemented: not lowered: Store mem UINTPTR COMPLEX128 mem 0.01% 1 SSA unimplemented: unhandled OCONV UINT32 -> FLOAT64 0.01% 1 SSA unimplemented: unhandled cap(chan) 0.01% 1 SSA unimplemented: unhandled expr ARRAYLIT 0.01% 1 SSA unimplemented: unhandled expr PLUS 0.01% 1 SSA unimplemented: unhandled stmt CHECKNIL Change-Id: I43474fe6d6ec22a9f57239090136f6e97eebfdf2 Reviewed-on: https://go-review.googlesource.com/13848 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 14 +++++++------- src/cmd/compile/internal/gc/type.go | 4 ++++ src/cmd/compile/internal/ssa/lower.go | 6 +++++- src/cmd/compile/internal/ssa/type.go | 32 ++++++++++++++++--------------- src/cmd/compile/internal/ssa/type_test.go | 31 +++++++++++++++--------------- 5 files changed, 49 insertions(+), 38 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index a7349a8f1f..0f0610e139 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -100,7 +100,7 @@ func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { if n.Class&PHEAP != 0 { str = ",heap" } - s.Unimplementedf("local variable %v with class %s%s unimplemented", n, classnames[n.Class&^PHEAP], str) + s.Unimplementedf("local variable with class %s%s unimplemented", classnames[n.Class&^PHEAP], str) } } // nodfp is a special argument which is the function's FP. @@ -936,7 +936,7 @@ func (s *state) ssaOp(op uint8, t *Type) ssa.Op { etype := s.concreteEtype(t) x, ok := opToSSA[opAndType{op, etype}] if !ok { - s.Unimplementedf("unhandled binary op %s etype=%s", opnames[op], Econv(int(etype), 0)) + s.Unimplementedf("unhandled binary op %s %s", opnames[op], Econv(int(etype), 0)) } return x } @@ -1110,7 +1110,7 @@ func (s *state) expr(n *Node) *ssa.Value { to := n.Type from := n.Left.Type if to.Etype == TFUNC { - s.Unimplementedf("CONVNOP closure %v -> %v", n.Type, n.Left.Type) + s.Unimplementedf("CONVNOP closure") return nil } @@ -1217,7 +1217,7 @@ func (s *state) expr(n *Node) *ssa.Value { } return s.newValue1(op, n.Type, x) } - s.Unimplementedf("unhandled OCONV %s -> %s", n.Left.Type, n.Type) + s.Unimplementedf("unhandled OCONV %s -> %s", Econv(int(n.Left.Type.Etype), 0), Econv(int(n.Type.Etype), 0)) return nil // binary ops @@ -1546,7 +1546,7 @@ func (s *state) addr(n *Node) *ssa.Value { case PAUTO | PHEAP: return s.expr(n.Name.Heapaddr) default: - s.Unimplementedf("variable address of %v not implemented", n) + s.Unimplementedf("variable address class %v not implemented", n.Class) return nil } case OINDREG: @@ -1590,7 +1590,7 @@ func (s *state) addr(n *Node) *ssa.Value { s.nilCheck(p) return s.newValue2(ssa.OpAddPtr, p.Type, p, s.constIntPtr(Types[TUINTPTR], n.Xoffset)) default: - s.Unimplementedf("addr: bad op %v", Oconv(int(n.Op), 0)) + s.Unimplementedf("unhandled addr %v", Oconv(int(n.Op), 0)) return nil } } @@ -1814,7 +1814,7 @@ func (s *state) lookupVarIncoming(b *ssa.Block, t ssa.Type, name *Node) *ssa.Val addr := s.decladdrs[name] if addr == nil { // TODO: closure args reach here. - s.Unimplementedf("variable %s not found", name) + s.Unimplementedf("unhandled closure arg") } 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) diff --git a/src/cmd/compile/internal/gc/type.go b/src/cmd/compile/internal/gc/type.go index 697152bebd..e2d8925839 100644 --- a/src/cmd/compile/internal/gc/type.go +++ b/src/cmd/compile/internal/gc/type.go @@ -23,6 +23,10 @@ func (t *Type) Alignment() int64 { return int64(t.Align) } +func (t *Type) SimpleString() string { + return Econv(int(t.Etype), 0) +} + func (t *Type) Equal(u ssa.Type) bool { x, ok := u.(*Type) if !ok { diff --git a/src/cmd/compile/internal/ssa/lower.go b/src/cmd/compile/internal/ssa/lower.go index 56ee062b92..3dac264fac 100644 --- a/src/cmd/compile/internal/ssa/lower.go +++ b/src/cmd/compile/internal/ssa/lower.go @@ -24,7 +24,11 @@ func checkLower(f *Func) { case OpSP, OpSB, OpArg, OpCopy, OpPhi: continue // ok not to lower } - f.Unimplementedf("%s not lowered", v.LongString()) + 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/type.go b/src/cmd/compile/internal/ssa/type.go index c6cc889420..15dbddd1fc 100644 --- a/src/cmd/compile/internal/ssa/type.go +++ b/src/cmd/compile/internal/ssa/type.go @@ -28,6 +28,7 @@ type Type interface { PtrTo() Type // given T, return *T String() string + SimpleString() string // a coarser generic description of T, e.g. T's underlying type Equal(Type) bool } @@ -38,21 +39,22 @@ type CompilerType struct { Flags bool } -func (t *CompilerType) Size() int64 { return 0 } -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) IsPtr() bool { return false } -func (t *CompilerType) IsString() bool { return false } -func (t *CompilerType) IsSlice() 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) String() string { return t.Name } -func (t *CompilerType) Elem() Type { panic("not implemented") } -func (t *CompilerType) PtrTo() Type { panic("not implemented") } +func (t *CompilerType) Size() int64 { return 0 } +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) IsPtr() bool { return false } +func (t *CompilerType) IsString() bool { return false } +func (t *CompilerType) IsSlice() 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) 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) Equal(u Type) bool { x, ok := u.(*CompilerType) diff --git a/src/cmd/compile/internal/ssa/type_test.go b/src/cmd/compile/internal/ssa/type_test.go index 3dfa5f7c0b..5f0413c397 100644 --- a/src/cmd/compile/internal/ssa/type_test.go +++ b/src/cmd/compile/internal/ssa/type_test.go @@ -21,21 +21,22 @@ type TypeImpl struct { 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) IsPtr() bool { return t.Ptr } -func (t *TypeImpl) IsString() bool { return t.string } -func (t *TypeImpl) IsSlice() bool { return t.slice } -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) String() string { return t.Name } -func (t *TypeImpl) Elem() Type { return t.Elem_ } -func (t *TypeImpl) PtrTo() Type { panic("not implemented") } +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) IsPtr() bool { return t.Ptr } +func (t *TypeImpl) IsString() bool { return t.string } +func (t *TypeImpl) IsSlice() bool { return t.slice } +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) 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) Equal(u Type) bool { x, ok := u.(*TypeImpl) -- cgit v1.3 From 01490eb96cb0ff15d6b749fc11db99f53891be61 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Sun, 23 Aug 2015 21:14:25 -0700 Subject: [dev.ssa] cmd/compile: make sure to keep offset and sym of MOV opcodes. MOVXload and MOVXstore opcodes have both an auxint offset and an aux offset (a symbol name, like a local or arg or global). Make sure we keep those values during rewrites. Change-Id: Ic9fd61bf295b5d1457784c281079a4fb38f7ad3b Reviewed-on: https://go-review.googlesource.com/13849 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/ssa/gen/AMD64.rules | 115 ++-- src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 25 +- src/cmd/compile/internal/ssa/rewrite.go | 5 + src/cmd/compile/internal/ssa/rewriteAMD64.go | 795 +++++++++++++++++++++------ 4 files changed, 707 insertions(+), 233 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 582528801a..c59da55dbf 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -424,62 +424,87 @@ (SETNE (InvertFlags x)) -> (SETNE x) // sign extended loads -(MOVBQSX (MOVBload ptr mem)) -> (MOVBQSXload ptr mem) -(MOVBQZX (MOVBload ptr mem)) -> (MOVBQZXload ptr mem) +(MOVBQSX (MOVBload [off] {sym} ptr mem)) -> (MOVBQSXload [off] {sym} ptr mem) +(MOVBQZX (MOVBload [off] {sym} ptr mem)) -> (MOVBQZXload [off] {sym} ptr mem) // TODO: more // Don't extend before storing -(MOVLstore ptr (MOVLQSX x) mem) -> (MOVLstore ptr x mem) -(MOVWstore ptr (MOVWQSX x) mem) -> (MOVWstore ptr x mem) -(MOVBstore ptr (MOVBQSX x) mem) -> (MOVBstore ptr x mem) -(MOVLstore ptr (MOVLQZX x) mem) -> (MOVLstore ptr x mem) -(MOVWstore ptr (MOVWQZX x) mem) -> (MOVWstore ptr x mem) -(MOVBstore ptr (MOVBQZX x) mem) -> (MOVBstore ptr x mem) +(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] (ADDQconst [off2] ptr) mem) -> (MOVQload [addOff(off1, off2)] ptr mem) -(MOVQstore [off1] (ADDQconst [off2] ptr) val mem) -> (MOVQstore [addOff(off1, off2)] ptr val mem) - -(MOVQload [off1] {sym1} (LEAQ [off2] {sym2} base) mem) && (sym1 == nil || sym2 == nil) -> - (MOVQload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem) -(MOVQstore [off1] {sym1} (LEAQ [off2] {sym2} base) val mem) && (sym1 == nil || sym2 == nil) -> - (MOVQstore [addOff(off1,off2)] {mergeSym(sym1,sym2)} base val mem) - -(MOVSSload [off1] (ADDQconst [off2] ptr) mem) -> (MOVSSload [addOff(off1, off2)] ptr mem) -(MOVSSstore [off1] (ADDQconst [off2] ptr) val mem) -> (MOVSSstore [addOff(off1, off2)] ptr val mem) - -(MOVSSload [off1] {sym1} (LEAQ [off2] {sym2} base) mem) && (sym1 == nil || sym2 == nil) -> - (MOVSSload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem) -(MOVSSstore [off1] {sym1} (LEAQ [off2] {sym2} base) val mem) && (sym1 == nil || sym2 == nil) -> - (MOVSSstore [addOff(off1,off2)] {mergeSym(sym1,sym2)} base val mem) - -(MOVSDload [off1] (ADDQconst [off2] ptr) mem) -> (MOVSDload [addOff(off1, off2)] ptr mem) -(MOVSDstore [off1] (ADDQconst [off2] ptr) val mem) -> (MOVSDstore [addOff(off1, off2)] ptr val mem) - -(MOVSDload [off1] {sym1} (LEAQ [off2] {sym2} base) mem) && (sym1 == nil || sym2 == nil) -> - (MOVSDload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem) -(MOVSDstore [off1] {sym1} (LEAQ [off2] {sym2} base) val mem) && (sym1 == nil || sym2 == nil) -> - (MOVSDstore [addOff(off1,off2)] {mergeSym(sym1,sym2)} base val mem) +(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) + +(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) + +// 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) + +(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) // indexed loads and stores -(MOVQload [off1] (LEAQ8 [off2] ptr idx) mem) -> (MOVQloadidx8 [addOff(off1, off2)] ptr idx mem) -(MOVQstore [off1] (LEAQ8 [off2] ptr idx) val mem) -> (MOVQstoreidx8 [addOff(off1, off2)] ptr idx val mem) -(MOVQloadidx8 [off1] (ADDQconst [off2] ptr) idx mem) -> (MOVQloadidx8 [addOff(off1, off2)] ptr idx mem) -(MOVQstoreidx8 [off1] (ADDQconst [off2] ptr) idx val mem) -> (MOVQstoreidx8 [addOff(off1, off2)] ptr idx val mem) - -(MOVSSload [off1] (LEAQ4 [off2] ptr idx) mem) -> (MOVSSloadidx4 [addOff(off1, off2)] ptr idx mem) -(MOVSSstore [off1] (LEAQ4 [off2] ptr idx) val mem) -> (MOVSSstoreidx4 [addOff(off1, off2)] ptr idx val mem) -(MOVSSloadidx4 [off1] (ADDQconst [off2] ptr) idx mem) -> (MOVSSloadidx4 [addOff(off1, off2)] ptr idx mem) -(MOVSSstoreidx4 [off1] (ADDQconst [off2] ptr) idx val mem) -> (MOVSSstoreidx4 [addOff(off1, off2)] ptr idx val mem) - -(MOVSDload [off1] (LEAQ8 [off2] ptr idx) mem) -> (MOVSDloadidx8 [addOff(off1, off2)] ptr idx mem) -(MOVSDstore [off1] (LEAQ8 [off2] ptr idx) val mem) -> (MOVSDstoreidx8 [addOff(off1, off2)] ptr idx val mem) -(MOVSDloadidx8 [off1] (ADDQconst [off2] ptr) idx mem) -> (MOVSDloadidx8 [addOff(off1, off2)] ptr idx mem) -(MOVSDstoreidx8 [off1] (ADDQconst [off2] ptr) idx val mem) -> (MOVSDstoreidx8 [addOff(off1, off2)] ptr idx val mem) +(MOVQloadidx8 [off1] {sym} (ADDQconst [off2] ptr) idx mem) -> (MOVQloadidx8 [addOff(off1, off2)] {sym} ptr idx mem) +(MOVQstoreidx8 [off1] {sym} (ADDQconst [off2] ptr) idx val mem) -> (MOVQstoreidx8 [addOff(off1, off2)] {sym} ptr idx val mem) +(MOVSSloadidx4 [off1] {sym} (ADDQconst [off2] {sym} ptr) idx mem) -> (MOVSSloadidx4 [addOff(off1, off2)] {sym} ptr idx mem) +(MOVSSstoreidx4 [off1] {sym} (ADDQconst [off2] {sym} ptr) idx val mem) -> (MOVSSstoreidx4 [addOff(off1, off2)] {sym} ptr idx val mem) +(MOVSDloadidx8 [off1] {sym} (ADDQconst [off2] {sym} ptr) idx mem) -> (MOVSDloadidx8 [addOff(off1, off2)] {sym} ptr idx mem) +(MOVSDstoreidx8 [off1] {sym} (ADDQconst [off2] {sym} ptr) idx val mem) -> (MOVSDstoreidx8 [addOff(off1, off2)] {sym} ptr idx val mem) + +(MOVQload [off1] {sym1} (LEAQ8 [off2] {sym2} ptr idx) mem) && canMergeSym(sym1, sym2) -> + (MOVQloadidx8 [addOff(off1, off2)] {mergeSym(sym1,sym2)} ptr idx 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) + +(MOVSSload [off1] {sym1} (LEAQ4 [off2] {sym2} ptr idx) mem) && canMergeSym(sym1, sym2) -> + (MOVSSloadidx4 [addOff(off1, off2)] {mergeSym(sym1,sym2)} ptr idx 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) + +(MOVSDload [off1] {sym1} (LEAQ8 [off2] {sym2} ptr idx) mem) && canMergeSym(sym1, sym2) -> + (MOVSDloadidx8 [addOff(off1, off2)] {mergeSym(sym1,sym2)} ptr idx 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) (ADDQconst [0] x) -> x diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 86b51ecef2..3ee802ec9f 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -334,26 +334,27 @@ func init() { {name: "LEAQ4", reg: gp21sb}, // arg0 + 4*arg1 + auxint {name: "LEAQ8", reg: gp21sb}, // arg0 + 8*arg1 + auxint - {name: "MOVBload", reg: gpload, asm: "MOVB"}, // load byte from arg0+auxint. arg1=mem + // auxint+aux == add auxint and the offset of the symbol in aux (if any) to the effective address + {name: "MOVBload", reg: gpload, asm: "MOVB"}, // load byte from arg0+auxint+aux. arg1=mem {name: "MOVBQSXload", reg: gpload, asm: "MOVBQSX"}, // ditto, extend to int64 {name: "MOVBQZXload", reg: gpload, asm: "MOVBQZX"}, // ditto, extend to uint64 - {name: "MOVWload", reg: gpload, asm: "MOVW"}, // load 2 bytes from arg0+auxint. arg1=mem - {name: "MOVLload", reg: gpload, asm: "MOVL"}, // load 4 bytes from arg0+auxint. arg1=mem - {name: "MOVQload", reg: gpload, asm: "MOVQ"}, // load 8 bytes from arg0+auxint. arg1=mem - {name: "MOVQloadidx8", reg: gploadidx, asm: "MOVQ"}, // load 8 bytes from arg0+8*arg1+auxint. arg2=mem - {name: "MOVBstore", reg: gpstore, asm: "MOVB"}, // store byte in arg1 to arg0+auxint. arg2=mem - {name: "MOVWstore", reg: gpstore, asm: "MOVW"}, // store 2 bytes in arg1 to arg0+auxint. arg2=mem - {name: "MOVLstore", reg: gpstore, asm: "MOVL"}, // store 4 bytes in arg1 to arg0+auxint. arg2=mem - {name: "MOVQstore", reg: gpstore, asm: "MOVQ"}, // store 8 bytes in arg1 to arg0+auxint. arg2=mem - {name: "MOVQstoreidx8", reg: gpstoreidx, asm: "MOVQ"}, // store 8 bytes in arg2 to arg0+8*arg1+auxint. arg3=mem + {name: "MOVWload", reg: gpload, asm: "MOVW"}, // load 2 bytes from arg0+auxint+aux. arg1=mem + {name: "MOVLload", reg: gpload, asm: "MOVL"}, // load 4 bytes from arg0+auxint+aux. arg1=mem + {name: "MOVQload", reg: gpload, asm: "MOVQ"}, // load 8 bytes from arg0+auxint+aux. arg1=mem + {name: "MOVQloadidx8", reg: gploadidx, asm: "MOVQ"}, // load 8 bytes from arg0+8*arg1+auxint+aux. arg2=mem + {name: "MOVBstore", reg: gpstore, asm: "MOVB"}, // store byte in arg1 to arg0+auxint+aux. arg2=mem + {name: "MOVWstore", reg: gpstore, asm: "MOVW"}, // store 2 bytes in arg1 to arg0+auxint+aux. arg2=mem + {name: "MOVLstore", reg: gpstore, asm: "MOVL"}, // store 4 bytes in arg1 to arg0+auxint+aux. arg2=mem + {name: "MOVQstore", reg: gpstore, asm: "MOVQ"}, // store 8 bytes in arg1 to arg0+auxint+aux. arg2=mem + {name: "MOVQstoreidx8", reg: gpstoreidx, asm: "MOVQ"}, // store 8 bytes in arg2 to arg0+8*arg1+auxint+aux. arg3=mem {name: "MOVXzero", reg: gpstoreconst}, // store auxint 0 bytes into arg0 using a series of MOV instructions. arg1=mem. // TODO: implement this when register clobbering works {name: "REPSTOSQ", reg: regInfo{[]regMask{buildReg("DI"), buildReg("CX")}, buildReg("DI AX CX"), nil}}, // store arg1 8-byte words containing zero into arg0 using STOSQ. arg2=mem. //TODO: set register clobber to everything? - {name: "CALLstatic", reg: regInfo{clobbers: callerSave}}, // call static function aux.(*gc.Sym). arg0=mem, returns mem - {name: "CALLclosure", reg: regInfo{[]regMask{gpsp, buildReg("DX"), 0}, callerSave, nil}}, // call function via closure. arg0=codeptr, arg1=closure, arg2=mem returns mem + {name: "CALLstatic", reg: regInfo{clobbers: callerSave}}, // call static function aux.(*gc.Sym). arg0=mem, auxint=argsize, returns mem + {name: "CALLclosure", reg: regInfo{[]regMask{gpsp, buildReg("DX"), 0}, callerSave, nil}}, // call function via closure. arg0=codeptr, arg1=closure, arg2=mem, auxint=argsize, returns mem {name: "REPMOVSB", reg: regInfo{[]regMask{buildReg("DI"), buildReg("SI"), buildReg("CX")}, buildReg("DI SI CX"), nil}}, // move arg2 bytes from arg1 to arg0. arg3=mem, returns memory diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go index 4b9430abab..f2c8972c14 100644 --- a/src/cmd/compile/internal/ssa/rewrite.go +++ b/src/cmd/compile/internal/ssa/rewrite.go @@ -122,6 +122,8 @@ func addOff(x, y int64) int64 { 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 @@ -132,6 +134,9 @@ func mergeSym(x, y interface{}) interface{} { 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) } diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 3b2b7f03a7..f9690a37db 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -3529,55 +3529,120 @@ func rewriteValueAMD64(v *Value, config *Config) bool { end781e3a47b186cf99fcb7137afd3432b9: ; case OpAMD64MOVBQSX: - // match: (MOVBQSX (MOVBload ptr mem)) + // match: (MOVBQSX (MOVBload [off] {sym} ptr mem)) // cond: - // result: (MOVBQSXload ptr mem) + // result: (MOVBQSXload [off] {sym} ptr mem) { if v.Args[0].Op != OpAMD64MOVBload { - goto enda3a5eeb5767e31f42b0b6c1db8311ebb + goto end9de452216bde3b2e2a2d01f43da1f78e } + off := v.Args[0].AuxInt + sym := v.Args[0].Aux ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] v.Op = OpAMD64MOVBQSXload v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.AuxInt = off + v.Aux = sym v.AddArg(ptr) v.AddArg(mem) return true } - goto enda3a5eeb5767e31f42b0b6c1db8311ebb - enda3a5eeb5767e31f42b0b6c1db8311ebb: + goto end9de452216bde3b2e2a2d01f43da1f78e + end9de452216bde3b2e2a2d01f43da1f78e: ; case OpAMD64MOVBQZX: - // match: (MOVBQZX (MOVBload ptr mem)) + // match: (MOVBQZX (MOVBload [off] {sym} ptr mem)) // cond: - // result: (MOVBQZXload ptr mem) + // result: (MOVBQZXload [off] {sym} ptr mem) { if v.Args[0].Op != OpAMD64MOVBload { - goto end9510a482da21d9945d53c4233b19e825 + goto end573f4e6a6fe8032338b85fddd4d1bab4 } + off := v.Args[0].AuxInt + sym := v.Args[0].Aux ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] v.Op = OpAMD64MOVBQZXload v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.AuxInt = off + v.Aux = sym v.AddArg(ptr) v.AddArg(mem) return true } - goto end9510a482da21d9945d53c4233b19e825 - end9510a482da21d9945d53c4233b19e825: + goto end573f4e6a6fe8032338b85fddd4d1bab4 + end573f4e6a6fe8032338b85fddd4d1bab4: + ; + case OpAMD64MOVBload: + // match: (MOVBload [off1] {sym} (ADDQconst [off2] ptr) mem) + // cond: + // result: (MOVBload [addOff(off1, off2)] {sym} ptr mem) + { + off1 := v.AuxInt + sym := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto end7ec9147ab863c1bd59190fed81f894b6 + } + off2 := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + mem := v.Args[1] + v.Op = OpAMD64MOVBload + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = sym + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto end7ec9147ab863c1bd59190fed81f894b6 + end7ec9147ab863c1bd59190fed81f894b6: + ; + // match: (MOVBload [off1] {sym1} (LEAQ [off2] {sym2} base) mem) + // cond: canMergeSym(sym1, sym2) + // result: (MOVBload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem) + { + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ { + goto end3771a59cf66b0df99120d76f4c358fab + } + off2 := v.Args[0].AuxInt + sym2 := v.Args[0].Aux + base := v.Args[0].Args[0] + mem := v.Args[1] + if !(canMergeSym(sym1, sym2)) { + goto end3771a59cf66b0df99120d76f4c358fab + } + v.Op = OpAMD64MOVBload + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(base) + v.AddArg(mem) + return true + } + goto end3771a59cf66b0df99120d76f4c358fab + end3771a59cf66b0df99120d76f4c358fab: ; case OpAMD64MOVBstore: - // match: (MOVBstore ptr (MOVBQSX x) mem) + // match: (MOVBstore [off] {sym} ptr (MOVBQSX x) mem) // cond: - // result: (MOVBstore ptr x mem) + // result: (MOVBstore [off] {sym} ptr x mem) { + off := v.AuxInt + sym := v.Aux ptr := v.Args[0] if v.Args[1].Op != OpAMD64MOVBQSX { - goto endc356ef104095b9217b36b594f85171c6 + goto end5b3f41f0770d566ff1647dea1d4a40e8 } x := v.Args[1].Args[0] mem := v.Args[2] @@ -3585,21 +3650,25 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.AuxInt = off + v.Aux = sym v.AddArg(ptr) v.AddArg(x) v.AddArg(mem) return true } - goto endc356ef104095b9217b36b594f85171c6 - endc356ef104095b9217b36b594f85171c6: + goto end5b3f41f0770d566ff1647dea1d4a40e8 + end5b3f41f0770d566ff1647dea1d4a40e8: ; - // match: (MOVBstore ptr (MOVBQZX x) mem) + // match: (MOVBstore [off] {sym} ptr (MOVBQZX x) mem) // cond: - // result: (MOVBstore ptr x mem) + // result: (MOVBstore [off] {sym} ptr x mem) { + off := v.AuxInt + sym := v.Aux ptr := v.Args[0] if v.Args[1].Op != OpAMD64MOVBQZX { - goto end25841a70cce7ac32c6d5e561b992d3df + goto end3a2e55db7e03920700c4875f6a55de3b } x := v.Args[1].Args[0] mem := v.Args[2] @@ -3607,22 +3676,139 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.AuxInt = off + v.Aux = sym v.AddArg(ptr) v.AddArg(x) v.AddArg(mem) return true } - goto end25841a70cce7ac32c6d5e561b992d3df - end25841a70cce7ac32c6d5e561b992d3df: + goto end3a2e55db7e03920700c4875f6a55de3b + end3a2e55db7e03920700c4875f6a55de3b: + ; + // match: (MOVBstore [off1] {sym} (ADDQconst [off2] ptr) val mem) + // cond: + // result: (MOVBstore [addOff(off1, off2)] {sym} ptr val mem) + { + off1 := v.AuxInt + sym := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto ende6347ac19d0469ee59d2e7f2e18d1070 + } + off2 := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + val := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64MOVBstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = sym + v.AddArg(ptr) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto ende6347ac19d0469ee59d2e7f2e18d1070 + ende6347ac19d0469ee59d2e7f2e18d1070: + ; + // 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) + { + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ { + goto enda7086cf7f6b8cf81972e2c3d4b12f3fc + } + 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)) { + goto enda7086cf7f6b8cf81972e2c3d4b12f3fc + } + v.Op = OpAMD64MOVBstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(base) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto enda7086cf7f6b8cf81972e2c3d4b12f3fc + enda7086cf7f6b8cf81972e2c3d4b12f3fc: + ; + case OpAMD64MOVLload: + // match: (MOVLload [off1] {sym} (ADDQconst [off2] ptr) mem) + // cond: + // result: (MOVLload [addOff(off1, off2)] {sym} ptr mem) + { + off1 := v.AuxInt + sym := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto end0c8b8a40360c5c581d92723eca04d340 + } + off2 := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + mem := v.Args[1] + v.Op = OpAMD64MOVLload + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = sym + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto end0c8b8a40360c5c581d92723eca04d340 + end0c8b8a40360c5c581d92723eca04d340: + ; + // match: (MOVLload [off1] {sym1} (LEAQ [off2] {sym2} base) mem) + // cond: canMergeSym(sym1, sym2) + // result: (MOVLload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem) + { + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ { + goto enddb9e59335876d8a565c425731438a1b3 + } + off2 := v.Args[0].AuxInt + sym2 := v.Args[0].Aux + base := v.Args[0].Args[0] + mem := v.Args[1] + if !(canMergeSym(sym1, sym2)) { + goto enddb9e59335876d8a565c425731438a1b3 + } + v.Op = OpAMD64MOVLload + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(base) + v.AddArg(mem) + return true + } + goto enddb9e59335876d8a565c425731438a1b3 + enddb9e59335876d8a565c425731438a1b3: ; case OpAMD64MOVLstore: - // match: (MOVLstore ptr (MOVLQSX x) mem) + // match: (MOVLstore [off] {sym} ptr (MOVLQSX x) mem) // cond: - // result: (MOVLstore ptr x mem) + // result: (MOVLstore [off] {sym} ptr x mem) { + off := v.AuxInt + sym := v.Aux ptr := v.Args[0] if v.Args[1].Op != OpAMD64MOVLQSX { - goto endf79c699f70cb356abb52dc28f4abf46b + goto end1fb7b2ae707c76d30927c21f85d77472 } x := v.Args[1].Args[0] mem := v.Args[2] @@ -3630,21 +3816,25 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.AuxInt = off + v.Aux = sym v.AddArg(ptr) v.AddArg(x) v.AddArg(mem) return true } - goto endf79c699f70cb356abb52dc28f4abf46b - endf79c699f70cb356abb52dc28f4abf46b: + goto end1fb7b2ae707c76d30927c21f85d77472 + end1fb7b2ae707c76d30927c21f85d77472: ; - // match: (MOVLstore ptr (MOVLQZX x) mem) + // match: (MOVLstore [off] {sym} ptr (MOVLQZX x) mem) // cond: - // result: (MOVLstore ptr x mem) + // result: (MOVLstore [off] {sym} ptr x mem) { + off := v.AuxInt + sym := v.Aux ptr := v.Args[0] if v.Args[1].Op != OpAMD64MOVLQZX { - goto end67d1549d16d373e4ad6a89298866d1bc + goto end199e8c23a5e7e99728a43d6a83b2c2cf } x := v.Args[1].Args[0] mem := v.Args[2] @@ -3652,22 +3842,83 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.AuxInt = off + v.Aux = sym v.AddArg(ptr) v.AddArg(x) v.AddArg(mem) return true } - goto end67d1549d16d373e4ad6a89298866d1bc - end67d1549d16d373e4ad6a89298866d1bc: + goto end199e8c23a5e7e99728a43d6a83b2c2cf + end199e8c23a5e7e99728a43d6a83b2c2cf: + ; + // match: (MOVLstore [off1] {sym} (ADDQconst [off2] ptr) val mem) + // cond: + // result: (MOVLstore [addOff(off1, off2)] {sym} ptr val mem) + { + off1 := v.AuxInt + sym := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto end43bffdb8d9c1fc85a95778d4911955f1 + } + off2 := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + val := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64MOVLstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = sym + v.AddArg(ptr) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto end43bffdb8d9c1fc85a95778d4911955f1 + end43bffdb8d9c1fc85a95778d4911955f1: + ; + // 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) + { + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ { + goto endd57b1e4313fc7a3331340a9af00ba116 + } + 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)) { + goto endd57b1e4313fc7a3331340a9af00ba116 + } + v.Op = OpAMD64MOVLstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(base) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto endd57b1e4313fc7a3331340a9af00ba116 + endd57b1e4313fc7a3331340a9af00ba116: ; case OpAMD64MOVQload: - // match: (MOVQload [off1] (ADDQconst [off2] ptr) mem) + // match: (MOVQload [off1] {sym} (ADDQconst [off2] ptr) mem) // cond: - // result: (MOVQload [addOff(off1, off2)] ptr mem) + // result: (MOVQload [addOff(off1, off2)] {sym} ptr mem) { off1 := v.AuxInt + sym := v.Aux if v.Args[0].Op != OpAMD64ADDQconst { - goto end843d29b538c4483b432b632e5666d6e3 + goto end0b8c50dd7faefb7d046f9a27e054df77 } off2 := v.Args[0].AuxInt ptr := v.Args[0].Args[0] @@ -3677,28 +3928,29 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = addOff(off1, off2) + v.Aux = sym v.AddArg(ptr) v.AddArg(mem) return true } - goto end843d29b538c4483b432b632e5666d6e3 - end843d29b538c4483b432b632e5666d6e3: + goto end0b8c50dd7faefb7d046f9a27e054df77 + end0b8c50dd7faefb7d046f9a27e054df77: ; - // match: (MOVQload [off1] {sym1} (LEAQ [off2] {sym2} base) mem) - // cond: (sym1 == nil || sym2 == nil) - // result: (MOVQload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem) + // match: (MOVQload [off1] {sym1} (LEAQ [off2] {sym2} base) mem) + // cond: canMergeSym(sym1, sym2) + // result: (MOVQload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem) { off1 := v.AuxInt sym1 := v.Aux if v.Args[0].Op != OpAMD64LEAQ { - goto end227426af95e74caddcf59fdcd30ca8bc + goto endd0c093adc4f05f2037005734c77d3cc4 } off2 := v.Args[0].AuxInt sym2 := v.Args[0].Aux base := v.Args[0].Args[0] mem := v.Args[1] - if !(sym1 == nil || sym2 == nil) { - goto end227426af95e74caddcf59fdcd30ca8bc + if !(canMergeSym(sym1, sym2)) { + goto endd0c093adc4f05f2037005734c77d3cc4 } v.Op = OpAMD64MOVQload v.AuxInt = 0 @@ -3710,42 +3962,49 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto end227426af95e74caddcf59fdcd30ca8bc - end227426af95e74caddcf59fdcd30ca8bc: + goto endd0c093adc4f05f2037005734c77d3cc4 + endd0c093adc4f05f2037005734c77d3cc4: ; - // match: (MOVQload [off1] (LEAQ8 [off2] ptr idx) mem) - // cond: - // result: (MOVQloadidx8 [addOff(off1, off2)] ptr idx mem) + // 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) { off1 := v.AuxInt + sym1 := v.Aux if v.Args[0].Op != OpAMD64LEAQ8 { - goto end02f5ad148292c46463e7c20d3b821735 + goto end74a50d810fb3945e809f608cd094a59c } 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)) { + goto end74a50d810fb3945e809f608cd094a59c + } v.Op = OpAMD64MOVQloadidx8 v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) v.AddArg(ptr) v.AddArg(idx) v.AddArg(mem) return true } - goto end02f5ad148292c46463e7c20d3b821735 - end02f5ad148292c46463e7c20d3b821735: + goto end74a50d810fb3945e809f608cd094a59c + end74a50d810fb3945e809f608cd094a59c: ; case OpAMD64MOVQloadidx8: - // match: (MOVQloadidx8 [off1] (ADDQconst [off2] ptr) idx mem) + // match: (MOVQloadidx8 [off1] {sym} (ADDQconst [off2] ptr) idx mem) // cond: - // result: (MOVQloadidx8 [addOff(off1, off2)] ptr idx mem) + // result: (MOVQloadidx8 [addOff(off1, off2)] {sym} ptr idx mem) { off1 := v.AuxInt + sym := v.Aux if v.Args[0].Op != OpAMD64ADDQconst { - goto ende81e44bcfb11f90916ccb440c590121f + goto endb138bf9b0b33ec824bf0aff619f8bafa } off2 := v.Args[0].AuxInt ptr := v.Args[0].Args[0] @@ -3756,22 +4015,24 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = addOff(off1, off2) + v.Aux = sym v.AddArg(ptr) v.AddArg(idx) v.AddArg(mem) return true } - goto ende81e44bcfb11f90916ccb440c590121f - ende81e44bcfb11f90916ccb440c590121f: + goto endb138bf9b0b33ec824bf0aff619f8bafa + endb138bf9b0b33ec824bf0aff619f8bafa: ; case OpAMD64MOVQstore: - // match: (MOVQstore [off1] (ADDQconst [off2] ptr) val mem) + // match: (MOVQstore [off1] {sym} (ADDQconst [off2] ptr) val mem) // cond: - // result: (MOVQstore [addOff(off1, off2)] ptr val mem) + // result: (MOVQstore [addOff(off1, off2)] {sym} ptr val mem) { off1 := v.AuxInt + sym := v.Aux if v.Args[0].Op != OpAMD64ADDQconst { - goto end2108c693a43c79aed10b9246c39c80aa + goto end0a110b5e42a4576c32fda50590092848 } off2 := v.Args[0].AuxInt ptr := v.Args[0].Args[0] @@ -3782,30 +4043,31 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = addOff(off1, off2) + v.Aux = sym v.AddArg(ptr) v.AddArg(val) v.AddArg(mem) return true } - goto end2108c693a43c79aed10b9246c39c80aa - end2108c693a43c79aed10b9246c39c80aa: + goto end0a110b5e42a4576c32fda50590092848 + end0a110b5e42a4576c32fda50590092848: ; - // match: (MOVQstore [off1] {sym1} (LEAQ [off2] {sym2} base) val mem) - // cond: (sym1 == nil || sym2 == nil) - // result: (MOVQstore [addOff(off1,off2)] {mergeSym(sym1,sym2)} base val mem) + // 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) { off1 := v.AuxInt sym1 := v.Aux if v.Args[0].Op != OpAMD64LEAQ { - goto end5061f48193268a5eb1e1740bdd23c43d + goto end9a0cfe20b3b0f587e252760907c1b5c0 } 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 !(sym1 == nil || sym2 == nil) { - goto end5061f48193268a5eb1e1740bdd23c43d + if !(canMergeSym(sym1, sym2)) { + goto end9a0cfe20b3b0f587e252760907c1b5c0 } v.Op = OpAMD64MOVQstore v.AuxInt = 0 @@ -3818,44 +4080,51 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto end5061f48193268a5eb1e1740bdd23c43d - end5061f48193268a5eb1e1740bdd23c43d: + goto end9a0cfe20b3b0f587e252760907c1b5c0 + end9a0cfe20b3b0f587e252760907c1b5c0: ; - // match: (MOVQstore [off1] (LEAQ8 [off2] ptr idx) val mem) - // cond: - // result: (MOVQstoreidx8 [addOff(off1, off2)] ptr idx val mem) + // 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) { off1 := v.AuxInt + sym1 := v.Aux if v.Args[0].Op != OpAMD64LEAQ8 { - goto endce1db8c8d37c8397c500a2068a65c215 + goto end442c322e6719e280b6be1c12858e49d7 } 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)) { + goto end442c322e6719e280b6be1c12858e49d7 + } v.Op = OpAMD64MOVQstoreidx8 v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) v.AddArg(ptr) v.AddArg(idx) v.AddArg(val) v.AddArg(mem) return true } - goto endce1db8c8d37c8397c500a2068a65c215 - endce1db8c8d37c8397c500a2068a65c215: + goto end442c322e6719e280b6be1c12858e49d7 + end442c322e6719e280b6be1c12858e49d7: ; case OpAMD64MOVQstoreidx8: - // match: (MOVQstoreidx8 [off1] (ADDQconst [off2] ptr) idx val mem) + // match: (MOVQstoreidx8 [off1] {sym} (ADDQconst [off2] ptr) idx val mem) // cond: - // result: (MOVQstoreidx8 [addOff(off1, off2)] ptr idx val mem) + // result: (MOVQstoreidx8 [addOff(off1, off2)] {sym} ptr idx val mem) { off1 := v.AuxInt + sym := v.Aux if v.Args[0].Op != OpAMD64ADDQconst { - goto end01c970657b0fdefeab82458c15022163 + goto end50671766fdab364c1edbd2072fb8e525 } off2 := v.Args[0].AuxInt ptr := v.Args[0].Args[0] @@ -3867,23 +4136,25 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = addOff(off1, off2) + v.Aux = sym v.AddArg(ptr) v.AddArg(idx) v.AddArg(val) v.AddArg(mem) return true } - goto end01c970657b0fdefeab82458c15022163 - end01c970657b0fdefeab82458c15022163: + goto end50671766fdab364c1edbd2072fb8e525 + end50671766fdab364c1edbd2072fb8e525: ; case OpAMD64MOVSDload: - // match: (MOVSDload [off1] (ADDQconst [off2] ptr) mem) + // match: (MOVSDload [off1] {sym} (ADDQconst [off2] ptr) mem) // cond: - // result: (MOVSDload [addOff(off1, off2)] ptr mem) + // result: (MOVSDload [addOff(off1, off2)] {sym} ptr mem) { off1 := v.AuxInt + sym := v.Aux if v.Args[0].Op != OpAMD64ADDQconst { - goto endb30d8b19da953bcc24db5adcaf3cd3de + goto end6dad9bf78e7368bb095eb2dfba7e244a } off2 := v.Args[0].AuxInt ptr := v.Args[0].Args[0] @@ -3893,28 +4164,29 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = addOff(off1, off2) + v.Aux = sym v.AddArg(ptr) v.AddArg(mem) return true } - goto endb30d8b19da953bcc24db5adcaf3cd3de - endb30d8b19da953bcc24db5adcaf3cd3de: + goto end6dad9bf78e7368bb095eb2dfba7e244a + end6dad9bf78e7368bb095eb2dfba7e244a: ; // match: (MOVSDload [off1] {sym1} (LEAQ [off2] {sym2} base) mem) - // cond: (sym1 == nil || sym2 == nil) + // cond: canMergeSym(sym1, sym2) // result: (MOVSDload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem) { off1 := v.AuxInt sym1 := v.Aux if v.Args[0].Op != OpAMD64LEAQ { - goto end3d7dc2a0979c214ad64f1c782b3fdeec + goto end96fa9c439e31050aa91582bc2a9f2c20 } off2 := v.Args[0].AuxInt sym2 := v.Args[0].Aux base := v.Args[0].Args[0] mem := v.Args[1] - if !(sym1 == nil || sym2 == nil) { - goto end3d7dc2a0979c214ad64f1c782b3fdeec + if !(canMergeSym(sym1, sym2)) { + goto end96fa9c439e31050aa91582bc2a9f2c20 } v.Op = OpAMD64MOVSDload v.AuxInt = 0 @@ -3926,44 +4198,54 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto end3d7dc2a0979c214ad64f1c782b3fdeec - end3d7dc2a0979c214ad64f1c782b3fdeec: + goto end96fa9c439e31050aa91582bc2a9f2c20 + end96fa9c439e31050aa91582bc2a9f2c20: ; - // match: (MOVSDload [off1] (LEAQ8 [off2] ptr idx) mem) - // cond: - // result: (MOVSDloadidx8 [addOff(off1, off2)] ptr idx mem) + // 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) { off1 := v.AuxInt + sym1 := v.Aux if v.Args[0].Op != OpAMD64LEAQ8 { - goto end290f413641e9c9b3a21dbffb8e6f51ce + goto endbcb2ce441824d0e3a4b501018cfa7f60 } 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)) { + goto endbcb2ce441824d0e3a4b501018cfa7f60 + } v.Op = OpAMD64MOVSDloadidx8 v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) v.AddArg(ptr) v.AddArg(idx) v.AddArg(mem) return true } - goto end290f413641e9c9b3a21dbffb8e6f51ce - end290f413641e9c9b3a21dbffb8e6f51ce: + goto endbcb2ce441824d0e3a4b501018cfa7f60 + endbcb2ce441824d0e3a4b501018cfa7f60: ; case OpAMD64MOVSDloadidx8: - // match: (MOVSDloadidx8 [off1] (ADDQconst [off2] ptr) idx mem) + // match: (MOVSDloadidx8 [off1] {sym} (ADDQconst [off2] {sym} ptr) idx mem) // cond: - // result: (MOVSDloadidx8 [addOff(off1, off2)] ptr idx mem) + // result: (MOVSDloadidx8 [addOff(off1, off2)] {sym} ptr idx mem) { off1 := v.AuxInt + sym := v.Aux if v.Args[0].Op != OpAMD64ADDQconst { - goto enda922ba4bafd07007398d143ff201635a + goto end84f0f457e271104a92343e3b1d2804c6 } off2 := v.Args[0].AuxInt + if v.Args[0].Aux != v.Aux { + goto end84f0f457e271104a92343e3b1d2804c6 + } ptr := v.Args[0].Args[0] idx := v.Args[1] mem := v.Args[2] @@ -3972,22 +4254,24 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = addOff(off1, off2) + v.Aux = sym v.AddArg(ptr) v.AddArg(idx) v.AddArg(mem) return true } - goto enda922ba4bafd07007398d143ff201635a - enda922ba4bafd07007398d143ff201635a: + goto end84f0f457e271104a92343e3b1d2804c6 + end84f0f457e271104a92343e3b1d2804c6: ; case OpAMD64MOVSDstore: - // match: (MOVSDstore [off1] (ADDQconst [off2] ptr) val mem) + // match: (MOVSDstore [off1] {sym} (ADDQconst [off2] ptr) val mem) // cond: - // result: (MOVSDstore [addOff(off1, off2)] ptr val mem) + // result: (MOVSDstore [addOff(off1, off2)] {sym} ptr val mem) { off1 := v.AuxInt + sym := v.Aux if v.Args[0].Op != OpAMD64ADDQconst { - goto endb8906053f3ffca146218392d4358440e + goto end6c6160664143cc66e63e67b9aa43a7ef } off2 := v.Args[0].AuxInt ptr := v.Args[0].Args[0] @@ -3998,30 +4282,31 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = addOff(off1, off2) + v.Aux = sym v.AddArg(ptr) v.AddArg(val) v.AddArg(mem) return true } - goto endb8906053f3ffca146218392d4358440e - endb8906053f3ffca146218392d4358440e: + goto end6c6160664143cc66e63e67b9aa43a7ef + end6c6160664143cc66e63e67b9aa43a7ef: ; // match: (MOVSDstore [off1] {sym1} (LEAQ [off2] {sym2} base) val mem) - // cond: (sym1 == nil || sym2 == nil) + // cond: canMergeSym(sym1, sym2) // result: (MOVSDstore [addOff(off1,off2)] {mergeSym(sym1,sym2)} base val mem) { off1 := v.AuxInt sym1 := v.Aux if v.Args[0].Op != OpAMD64LEAQ { - goto endc62528d624da256376080f662fa73cc5 + goto end415dde14f3400bec1b2756174a5d7179 } 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 !(sym1 == nil || sym2 == nil) { - goto endc62528d624da256376080f662fa73cc5 + if !(canMergeSym(sym1, sym2)) { + goto end415dde14f3400bec1b2756174a5d7179 } v.Op = OpAMD64MOVSDstore v.AuxInt = 0 @@ -4034,46 +4319,56 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto endc62528d624da256376080f662fa73cc5 - endc62528d624da256376080f662fa73cc5: + goto end415dde14f3400bec1b2756174a5d7179 + end415dde14f3400bec1b2756174a5d7179: ; - // match: (MOVSDstore [off1] (LEAQ8 [off2] ptr idx) val mem) - // cond: - // result: (MOVSDstoreidx8 [addOff(off1, off2)] ptr idx val mem) + // 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) { off1 := v.AuxInt + sym1 := v.Aux if v.Args[0].Op != OpAMD64LEAQ8 { - goto endd76d67faa7541d73e075d15443daec5f + goto end1ad6fc0c5b59610dabf7f9595a48a230 } 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)) { + goto end1ad6fc0c5b59610dabf7f9595a48a230 + } v.Op = OpAMD64MOVSDstoreidx8 v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) v.AddArg(ptr) v.AddArg(idx) v.AddArg(val) v.AddArg(mem) return true } - goto endd76d67faa7541d73e075d15443daec5f - endd76d67faa7541d73e075d15443daec5f: + goto end1ad6fc0c5b59610dabf7f9595a48a230 + end1ad6fc0c5b59610dabf7f9595a48a230: ; case OpAMD64MOVSDstoreidx8: - // match: (MOVSDstoreidx8 [off1] (ADDQconst [off2] ptr) idx val mem) + // match: (MOVSDstoreidx8 [off1] {sym} (ADDQconst [off2] {sym} ptr) idx val mem) // cond: - // result: (MOVSDstoreidx8 [addOff(off1, off2)] ptr idx val mem) + // result: (MOVSDstoreidx8 [addOff(off1, off2)] {sym} ptr idx val mem) { off1 := v.AuxInt + sym := v.Aux if v.Args[0].Op != OpAMD64ADDQconst { - goto endc0c523fd517b8432a9f946e3c3c54c83 + goto endc0e28f57697cb6038d5d09eafe26c947 } off2 := v.Args[0].AuxInt + if v.Args[0].Aux != v.Aux { + goto endc0e28f57697cb6038d5d09eafe26c947 + } ptr := v.Args[0].Args[0] idx := v.Args[1] val := v.Args[2] @@ -4083,23 +4378,25 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = addOff(off1, off2) + v.Aux = sym v.AddArg(ptr) v.AddArg(idx) v.AddArg(val) v.AddArg(mem) return true } - goto endc0c523fd517b8432a9f946e3c3c54c83 - endc0c523fd517b8432a9f946e3c3c54c83: + goto endc0e28f57697cb6038d5d09eafe26c947 + endc0e28f57697cb6038d5d09eafe26c947: ; case OpAMD64MOVSSload: - // match: (MOVSSload [off1] (ADDQconst [off2] ptr) mem) + // match: (MOVSSload [off1] {sym} (ADDQconst [off2] ptr) mem) // cond: - // result: (MOVSSload [addOff(off1, off2)] ptr mem) + // result: (MOVSSload [addOff(off1, off2)] {sym} ptr mem) { off1 := v.AuxInt + sym := v.Aux if v.Args[0].Op != OpAMD64ADDQconst { - goto endfd8ae39356d66610e8efcc54825cc022 + goto end96d63dbb64b0adfa944684c9e939c972 } off2 := v.Args[0].AuxInt ptr := v.Args[0].Args[0] @@ -4109,28 +4406,29 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = addOff(off1, off2) + v.Aux = sym v.AddArg(ptr) v.AddArg(mem) return true } - goto endfd8ae39356d66610e8efcc54825cc022 - endfd8ae39356d66610e8efcc54825cc022: + goto end96d63dbb64b0adfa944684c9e939c972 + end96d63dbb64b0adfa944684c9e939c972: ; // match: (MOVSSload [off1] {sym1} (LEAQ [off2] {sym2} base) mem) - // cond: (sym1 == nil || sym2 == nil) + // cond: canMergeSym(sym1, sym2) // result: (MOVSSload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem) { off1 := v.AuxInt sym1 := v.Aux if v.Args[0].Op != OpAMD64LEAQ { - goto end86f5c0b840432898d1e4624da1ad8918 + goto end15f2583bd72ad7fc077b3952634a1c85 } off2 := v.Args[0].AuxInt sym2 := v.Args[0].Aux base := v.Args[0].Args[0] mem := v.Args[1] - if !(sym1 == nil || sym2 == nil) { - goto end86f5c0b840432898d1e4624da1ad8918 + if !(canMergeSym(sym1, sym2)) { + goto end15f2583bd72ad7fc077b3952634a1c85 } v.Op = OpAMD64MOVSSload v.AuxInt = 0 @@ -4142,44 +4440,54 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto end86f5c0b840432898d1e4624da1ad8918 - end86f5c0b840432898d1e4624da1ad8918: + goto end15f2583bd72ad7fc077b3952634a1c85 + end15f2583bd72ad7fc077b3952634a1c85: ; - // match: (MOVSSload [off1] (LEAQ4 [off2] ptr idx) mem) - // cond: - // result: (MOVSSloadidx4 [addOff(off1, off2)] ptr idx mem) + // 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) { off1 := v.AuxInt + sym1 := v.Aux if v.Args[0].Op != OpAMD64LEAQ4 { - goto end479f98c68c30173148913157084607d2 + goto end49722f4a0adba31bb143601ce1d2aae0 } 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)) { + goto end49722f4a0adba31bb143601ce1d2aae0 + } v.Op = OpAMD64MOVSSloadidx4 v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) v.AddArg(ptr) v.AddArg(idx) v.AddArg(mem) return true } - goto end479f98c68c30173148913157084607d2 - end479f98c68c30173148913157084607d2: + goto end49722f4a0adba31bb143601ce1d2aae0 + end49722f4a0adba31bb143601ce1d2aae0: ; case OpAMD64MOVSSloadidx4: - // match: (MOVSSloadidx4 [off1] (ADDQconst [off2] ptr) idx mem) + // match: (MOVSSloadidx4 [off1] {sym} (ADDQconst [off2] {sym} ptr) idx mem) // cond: - // result: (MOVSSloadidx4 [addOff(off1, off2)] ptr idx mem) + // result: (MOVSSloadidx4 [addOff(off1, off2)] {sym} ptr idx mem) { off1 := v.AuxInt + sym := v.Aux if v.Args[0].Op != OpAMD64ADDQconst { - goto end45b6855e44d0714ef12a148d4ed57ea0 + goto end7eb5a1ab1e2508683d879ec25286754b } off2 := v.Args[0].AuxInt + if v.Args[0].Aux != v.Aux { + goto end7eb5a1ab1e2508683d879ec25286754b + } ptr := v.Args[0].Args[0] idx := v.Args[1] mem := v.Args[2] @@ -4188,22 +4496,24 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = addOff(off1, off2) + v.Aux = sym v.AddArg(ptr) v.AddArg(idx) v.AddArg(mem) return true } - goto end45b6855e44d0714ef12a148d4ed57ea0 - end45b6855e44d0714ef12a148d4ed57ea0: + goto end7eb5a1ab1e2508683d879ec25286754b + end7eb5a1ab1e2508683d879ec25286754b: ; case OpAMD64MOVSSstore: - // match: (MOVSSstore [off1] (ADDQconst [off2] ptr) val mem) + // match: (MOVSSstore [off1] {sym} (ADDQconst [off2] ptr) val mem) // cond: - // result: (MOVSSstore [addOff(off1, off2)] ptr val mem) + // result: (MOVSSstore [addOff(off1, off2)] {sym} ptr val mem) { off1 := v.AuxInt + sym := v.Aux if v.Args[0].Op != OpAMD64ADDQconst { - goto endd5dd6aabcca196087990cf227b93376a + goto endf711aa4081a9b2924b55387d4f70cfd6 } off2 := v.Args[0].AuxInt ptr := v.Args[0].Args[0] @@ -4214,30 +4524,31 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = addOff(off1, off2) + v.Aux = sym v.AddArg(ptr) v.AddArg(val) v.AddArg(mem) return true } - goto endd5dd6aabcca196087990cf227b93376a - endd5dd6aabcca196087990cf227b93376a: + goto endf711aa4081a9b2924b55387d4f70cfd6 + endf711aa4081a9b2924b55387d4f70cfd6: ; // match: (MOVSSstore [off1] {sym1} (LEAQ [off2] {sym2} base) val mem) - // cond: (sym1 == nil || sym2 == nil) + // cond: canMergeSym(sym1, sym2) // result: (MOVSSstore [addOff(off1,off2)] {mergeSym(sym1,sym2)} base val mem) { off1 := v.AuxInt sym1 := v.Aux if v.Args[0].Op != OpAMD64LEAQ { - goto endbb6c6bcd6d4f898318314e310920f8d9 + goto end70ebc170131920e515e3f416a6b952c5 } 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 !(sym1 == nil || sym2 == nil) { - goto endbb6c6bcd6d4f898318314e310920f8d9 + if !(canMergeSym(sym1, sym2)) { + goto end70ebc170131920e515e3f416a6b952c5 } v.Op = OpAMD64MOVSSstore v.AuxInt = 0 @@ -4250,46 +4561,56 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto endbb6c6bcd6d4f898318314e310920f8d9 - endbb6c6bcd6d4f898318314e310920f8d9: + goto end70ebc170131920e515e3f416a6b952c5 + end70ebc170131920e515e3f416a6b952c5: ; - // match: (MOVSSstore [off1] (LEAQ4 [off2] ptr idx) val mem) - // cond: - // result: (MOVSSstoreidx4 [addOff(off1, off2)] ptr idx val mem) + // 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) { off1 := v.AuxInt + sym1 := v.Aux if v.Args[0].Op != OpAMD64LEAQ4 { - goto end20b3a5a13e1c44d49e59eb4af0749503 + goto end1622dc435e45833eda4d29d44df7cc34 } 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)) { + goto end1622dc435e45833eda4d29d44df7cc34 + } v.Op = OpAMD64MOVSSstoreidx4 v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) v.AddArg(ptr) v.AddArg(idx) v.AddArg(val) v.AddArg(mem) return true } - goto end20b3a5a13e1c44d49e59eb4af0749503 - end20b3a5a13e1c44d49e59eb4af0749503: + goto end1622dc435e45833eda4d29d44df7cc34 + end1622dc435e45833eda4d29d44df7cc34: ; case OpAMD64MOVSSstoreidx4: - // match: (MOVSSstoreidx4 [off1] (ADDQconst [off2] ptr) idx val mem) + // match: (MOVSSstoreidx4 [off1] {sym} (ADDQconst [off2] {sym} ptr) idx val mem) // cond: - // result: (MOVSSstoreidx4 [addOff(off1, off2)] ptr idx val mem) + // result: (MOVSSstoreidx4 [addOff(off1, off2)] {sym} ptr idx val mem) { off1 := v.AuxInt + sym := v.Aux if v.Args[0].Op != OpAMD64ADDQconst { - goto end97e6b5fc52597982bc1a9e4b14561d96 + goto end66e4853026306cd46f414c22d281254f } off2 := v.Args[0].AuxInt + if v.Args[0].Aux != v.Aux { + goto end66e4853026306cd46f414c22d281254f + } ptr := v.Args[0].Args[0] idx := v.Args[1] val := v.Args[2] @@ -4299,23 +4620,81 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AuxInt = addOff(off1, off2) + v.Aux = sym v.AddArg(ptr) v.AddArg(idx) v.AddArg(val) v.AddArg(mem) return true } - goto end97e6b5fc52597982bc1a9e4b14561d96 - end97e6b5fc52597982bc1a9e4b14561d96: + goto end66e4853026306cd46f414c22d281254f + end66e4853026306cd46f414c22d281254f: + ; + case OpAMD64MOVWload: + // match: (MOVWload [off1] {sym} (ADDQconst [off2] ptr) mem) + // cond: + // result: (MOVWload [addOff(off1, off2)] {sym} ptr mem) + { + off1 := v.AuxInt + sym := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto endfcb0ce76f96e8b0c2eb19a9b827c1b73 + } + off2 := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + mem := v.Args[1] + v.Op = OpAMD64MOVWload + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = sym + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto endfcb0ce76f96e8b0c2eb19a9b827c1b73 + endfcb0ce76f96e8b0c2eb19a9b827c1b73: + ; + // match: (MOVWload [off1] {sym1} (LEAQ [off2] {sym2} base) mem) + // cond: canMergeSym(sym1, sym2) + // result: (MOVWload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem) + { + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ { + goto end7a79314cb49bf53d79c38c3077d87457 + } + off2 := v.Args[0].AuxInt + sym2 := v.Args[0].Aux + base := v.Args[0].Args[0] + mem := v.Args[1] + if !(canMergeSym(sym1, sym2)) { + goto end7a79314cb49bf53d79c38c3077d87457 + } + v.Op = OpAMD64MOVWload + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(base) + v.AddArg(mem) + return true + } + goto end7a79314cb49bf53d79c38c3077d87457 + end7a79314cb49bf53d79c38c3077d87457: ; case OpAMD64MOVWstore: - // match: (MOVWstore ptr (MOVWQSX x) mem) + // match: (MOVWstore [off] {sym} ptr (MOVWQSX x) mem) // cond: - // result: (MOVWstore ptr x mem) + // result: (MOVWstore [off] {sym} ptr x mem) { + off := v.AuxInt + sym := v.Aux ptr := v.Args[0] if v.Args[1].Op != OpAMD64MOVWQSX { - goto endcc13af07a951a61fcfec3299342f7e1f + goto endca90c534e75c7f5cb803504d119a853f } x := v.Args[1].Args[0] mem := v.Args[2] @@ -4323,21 +4702,25 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.AuxInt = off + v.Aux = sym v.AddArg(ptr) v.AddArg(x) v.AddArg(mem) return true } - goto endcc13af07a951a61fcfec3299342f7e1f - endcc13af07a951a61fcfec3299342f7e1f: + goto endca90c534e75c7f5cb803504d119a853f + endca90c534e75c7f5cb803504d119a853f: ; - // match: (MOVWstore ptr (MOVWQZX x) mem) + // match: (MOVWstore [off] {sym} ptr (MOVWQZX x) mem) // cond: - // result: (MOVWstore ptr x mem) + // result: (MOVWstore [off] {sym} ptr x mem) { + off := v.AuxInt + sym := v.Aux ptr := v.Args[0] if v.Args[1].Op != OpAMD64MOVWQZX { - goto end4e7df15ee55bdd73d8ecd61b759134d4 + goto end187fe73dfaf9cf5f4c349283b4dfd9d1 } x := v.Args[1].Args[0] mem := v.Args[2] @@ -4345,13 +4728,73 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.AuxInt = off + v.Aux = sym v.AddArg(ptr) v.AddArg(x) v.AddArg(mem) return true } - goto end4e7df15ee55bdd73d8ecd61b759134d4 - end4e7df15ee55bdd73d8ecd61b759134d4: + goto end187fe73dfaf9cf5f4c349283b4dfd9d1 + end187fe73dfaf9cf5f4c349283b4dfd9d1: + ; + // match: (MOVWstore [off1] {sym} (ADDQconst [off2] ptr) val mem) + // cond: + // result: (MOVWstore [addOff(off1, off2)] {sym} ptr val mem) + { + off1 := v.AuxInt + sym := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto endda15fdd59aa956ded0440188f38de1aa + } + off2 := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + val := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64MOVWstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = sym + v.AddArg(ptr) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto endda15fdd59aa956ded0440188f38de1aa + endda15fdd59aa956ded0440188f38de1aa: + ; + // 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) + { + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ { + goto end4cc466ede8e64e415c899ccac81c0f27 + } + 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)) { + goto end4cc466ede8e64e415c899ccac81c0f27 + } + v.Op = OpAMD64MOVWstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(base) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto end4cc466ede8e64e415c899ccac81c0f27 + end4cc466ede8e64e415c899ccac81c0f27: ; case OpAMD64MULB: // match: (MULB x (MOVBconst [c])) -- cgit v1.3 From 4282588694de58b86df17af7366a5f00903af24b Mon Sep 17 00:00:00 2001 From: David Chase Date: Thu, 20 Aug 2015 15:14:20 -0400 Subject: [dev.ssa] cmd/compile: add [u]int and FP to FP conversions Change-Id: I8c17f706a3e0f1fa2d754bfb4ccd1f7a027cb3db Reviewed-on: https://go-review.googlesource.com/13744 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 195 ++++++++++++++++++++++++- src/cmd/compile/internal/gc/testdata/fp_ssa.go | 140 ++++++++++++++++++ src/cmd/compile/internal/ssa/gen/AMD64.rules | 13 ++ src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 18 ++- src/cmd/compile/internal/ssa/gen/genericOps.go | 11 ++ src/cmd/compile/internal/ssa/opGen.go | 180 +++++++++++++++++++++++ src/cmd/compile/internal/ssa/rewriteAMD64.go | 160 ++++++++++++++++++++ 7 files changed, 708 insertions(+), 9 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 0f0610e139..8e44ede318 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1217,6 +1217,84 @@ func (s *state) expr(n *Node) *ssa.Value { } return s.newValue1(op, n.Type, x) } + + var op1, op2 ssa.Op + if ft.IsInteger() && tt.IsFloat() { + // signed 1, 2, 4, 8, unsigned 6, 7, 9, 13 + signedSize := ft.Size() + it := TINT32 // intermediate type in conversion, int32 or int64 + if !ft.IsSigned() { + signedSize += 5 + } + switch signedSize { + case 1: + op1 = ssa.OpSignExt8to32 + case 2: + op1 = ssa.OpSignExt16to32 + case 4: + op1 = ssa.OpCopy + case 8: + op1 = ssa.OpCopy + it = TINT64 + case 6: + op1 = ssa.OpZeroExt8to32 + case 7: + op1 = ssa.OpZeroExt16to32 + case 9: + // Go wide to dodge the unsignedness correction + op1 = ssa.OpZeroExt32to64 + it = TINT64 + case 13: + // unsigned 64, there is branchy correction code + // because there is only signed-integer to FP + // conversion in the (AMD64) instructions set. + // Branchy correction code *may* be amenable to + // optimization, and it can be cleanly expressed + // in SSA, so do it here. + if tt.Size() == 4 { + return s.uint64Tofloat32(n, x, ft, tt) + } + if tt.Size() == 8 { + return s.uint64Tofloat64(n, x, ft, tt) + } + + default: + s.Fatalf("weird integer to float sign extension %s -> %s", ft, tt) + + } + if tt.Size() == 4 { + if it == TINT64 { + op2 = ssa.OpCvt64to32F + } else { + op2 = ssa.OpCvt32to32F + } + } else { + if it == TINT64 { + op2 = ssa.OpCvt64to64F + } else { + op2 = ssa.OpCvt32to64F + } + } + if op1 == ssa.OpCopy { + return s.newValue1(op2, n.Type, x) + } + return s.newValue1(op2, n.Type, s.newValue1(op1, Types[it], x)) + } + if ft.IsFloat() && tt.IsFloat() { + var op ssa.Op + if ft.Size() == tt.Size() { + op = ssa.OpCopy + } else if ft.Size() == 4 && tt.Size() == 8 { + op = ssa.OpCvt32Fto64F + } else if ft.Size() == 8 && tt.Size() == 4 { + op = ssa.OpCvt64Fto32F + } else { + s.Fatalf("weird float conversion %s -> %s", ft, tt) + } + return s.newValue1(op, n.Type, x) + } + // TODO: Still lack float-to-int + s.Unimplementedf("unhandled OCONV %s -> %s", Econv(int(n.Left.Type.Etype), 0), Econv(int(n.Type.Etype), 0)) return nil @@ -1709,6 +1787,112 @@ func (s *state) boundsCheck(idx, len *ssa.Value) { s.startBlock(bNext) } +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 + // z = z + z + // } + // + // 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) + + addEdge(b, bThen) + s.startBlock(bThen) + a0 := s.newValue1(cvttab.cvt2F, tt, x) + s.vars[n] = a0 + s.endBlock() + addEdge(bThen, bAfter) + + addEdge(b, 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() + addEdge(bElse, bAfter) + + s.startBlock(bAfter) + return s.variable(n, n.Type) +} + // 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, @@ -2425,12 +2609,11 @@ func genValue(v *ssa.Value) { p.To.Scale = 4 p.To.Index = regnum(v.Args[1]) addAux(&p.To, v) - case ssa.OpAMD64MOVLQSX, ssa.OpAMD64MOVWQSX, ssa.OpAMD64MOVBQSX, ssa.OpAMD64MOVLQZX, ssa.OpAMD64MOVWQZX, ssa.OpAMD64MOVBQZX: - 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.OpAMD64MOVLQSX, ssa.OpAMD64MOVWQSX, ssa.OpAMD64MOVBQSX, ssa.OpAMD64MOVLQZX, ssa.OpAMD64MOVWQZX, ssa.OpAMD64MOVBQZX, + ssa.OpAMD64CVTSL2SS, ssa.OpAMD64CVTSL2SD, ssa.OpAMD64CVTSQ2SS, ssa.OpAMD64CVTSQ2SD, + ssa.OpAMD64CVTSS2SL, ssa.OpAMD64CVTSD2SL, ssa.OpAMD64CVTSS2SQ, ssa.OpAMD64CVTSD2SQ, + ssa.OpAMD64CVTSS2SD, ssa.OpAMD64CVTSD2SS: + opregreg(v.Op.Asm(), regnum(v), regnum(v.Args[0])) case ssa.OpAMD64MOVXzero: nb := v.AuxInt offset := int64(0) diff --git a/src/cmd/compile/internal/gc/testdata/fp_ssa.go b/src/cmd/compile/internal/gc/testdata/fp_ssa.go index 73366cdfa8..1a52100d6b 100644 --- a/src/cmd/compile/internal/gc/testdata/fp_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/fp_ssa.go @@ -31,10 +31,43 @@ func fail32(s string, f func(a, b float32) float32, a, b, e float32) int { func expect64(s string, x, expected float64) int { if x != expected { println("Expected", expected, "for", s, ", got", x) + return 1 } return 0 } +func expect32(s string, x, expected float32) int { + if x != expected { + println("Expected", expected, "for", s, ", got", 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 +} + // 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). @@ -107,6 +140,111 @@ func div32_ssa(a, b float32) float32 { return a / 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 +} + func main() { a := 3.0 @@ -157,6 +295,8 @@ func main() { fails += expect64("dc", dc, -9.0) fails += expect64("dd", dd, 44.0) + fails += integer2floatConversions() + if fails > 0 { fmt.Printf("Saw %v failures\n", fails) panic("Failed.") diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index c59da55dbf..86b443c10d 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -101,6 +101,19 @@ (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) -> (CVTSS2SL x) +(Cvt32Fto64 x) -> (CVTSS2SQ x) +(Cvt64Fto32 x) -> (CVTSD2SL x) +(Cvt64Fto64 x) -> (CVTSD2SQ 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 diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 3ee802ec9f..8b8da225d1 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -120,13 +120,14 @@ func init() { gpstoreconst = regInfo{inputs: []regMask{gpspsb, 0}} gpstoreidx = regInfo{inputs: []regMask{gpspsb, gpsp, gpsp, 0}} - // fp11 = regInfo{inputs: fponly, outputs: fponly} 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}} - // fp2flags = regInfo{inputs: []regMask{fp, fp}, outputs: flagsonly} - // fp1flags = regInfo{inputs: fponly, outputs: flagsonly} + + fpgp = regInfo{inputs: fponly, outputs: gponly} + gpfp = regInfo{inputs: gponly, outputs: fponly} + fp11 = regInfo{inputs: fponly, outputs: fponly} fpload = regInfo{inputs: []regMask{gpspsb, 0}, outputs: fponly} fploadidx = regInfo{inputs: []regMask{gpspsb, gpsp, 0}, outputs: fponly} @@ -328,6 +329,17 @@ func init() { {name: "MOVLconst", reg: gp01, asm: "MOVL"}, // 32 low bits of auxint {name: "MOVQconst", reg: gp01, asm: "MOVQ"}, // auxint + {name: "CVTSD2SL", reg: fpgp, asm: "CVTSD2SL"}, // convert float64 to int32 + {name: "CVTSD2SQ", reg: fpgp, asm: "CVTSD2SQ"}, // convert float64 to int64 + {name: "CVTSS2SL", reg: fpgp, asm: "CVTSS2SL"}, // convert float32 to int32 + {name: "CVTSS2SQ", reg: fpgp, asm: "CVTSS2SQ"}, // convert float32 to int64 + {name: "CVTSL2SS", reg: gpfp, asm: "CVTSL2SS"}, // convert int32 to float32 + {name: "CVTSL2SD", reg: gpfp, asm: "CVTSL2SD"}, // convert int32 to float64 + {name: "CVTSQ2SS", reg: gpfp, asm: "CVTSQ2SS"}, // convert int64 to float32 + {name: "CVTSQ2SD", reg: gpfp, asm: "CVTSQ2SD"}, // convert int64 to float64 + {name: "CVTSD2SS", reg: fp11, asm: "CVTSD2SS"}, // convert float64 to float32 + {name: "CVTSS2SD", reg: fp11, asm: "CVTSS2SD"}, // convert float32 to float64 + {name: "LEAQ", reg: gp11sb}, // arg0 + auxint + offset encoded in aux {name: "LEAQ1", reg: gp21sb}, // arg0 + arg1 + auxint {name: "LEAQ2", reg: gp21sb}, // arg0 + 2*arg1 + auxint diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 78524a5e6b..4a65a87ea8 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -287,6 +287,17 @@ var genericOps = []opData{ {name: "Trunc64to16"}, {name: "Trunc64to32"}, + {name: "Cvt32to32F"}, + {name: "Cvt32to64F"}, + {name: "Cvt64to32F"}, + {name: "Cvt64to64F"}, + {name: "Cvt32Fto32"}, + {name: "Cvt32Fto64"}, + {name: "Cvt64Fto32"}, + {name: "Cvt64Fto64"}, + {name: "Cvt32Fto64F"}, + {name: "Cvt64Fto32F"}, + // Automatically inserted safety checks {name: "IsNonNil"}, // arg0 != nil {name: "IsInBounds"}, // 0 <= arg0 < arg1 diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 5346f757fb..aa51cbc301 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -209,6 +209,16 @@ const ( OpAMD64MOVWconst OpAMD64MOVLconst OpAMD64MOVQconst + OpAMD64CVTSD2SL + OpAMD64CVTSD2SQ + OpAMD64CVTSS2SL + OpAMD64CVTSS2SQ + OpAMD64CVTSL2SS + OpAMD64CVTSL2SD + OpAMD64CVTSQ2SS + OpAMD64CVTSQ2SD + OpAMD64CVTSD2SS + OpAMD64CVTSS2SD OpAMD64LEAQ OpAMD64LEAQ1 OpAMD64LEAQ2 @@ -441,6 +451,16 @@ const ( OpTrunc64to8 OpTrunc64to16 OpTrunc64to32 + OpCvt32to32F + OpCvt32to64F + OpCvt64to32F + OpCvt64to64F + OpCvt32Fto32 + OpCvt32Fto64 + OpCvt64Fto32 + OpCvt64Fto64 + OpCvt32Fto64F + OpCvt64Fto32F OpIsNonNil OpIsInBounds OpPanicNilCheck @@ -2521,6 +2541,126 @@ var opcodeTable = [...]opInfo{ }, }, }, + { + name: "CVTSD2SL", + asm: x86.ACVTSD2SL, + 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: "CVTSD2SQ", + asm: x86.ACVTSD2SQ, + 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: "CVTSS2SL", + asm: x86.ACVTSS2SL, + 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: "CVTSS2SQ", + asm: x86.ACVTSS2SQ, + 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", + 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", + 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", + 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", + 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", + 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", + 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: "LEAQ", reg: regInfo{ @@ -3606,6 +3746,46 @@ var opcodeTable = [...]opInfo{ name: "Trunc64to32", generic: true, }, + { + name: "Cvt32to32F", + generic: true, + }, + { + name: "Cvt32to64F", + generic: true, + }, + { + name: "Cvt64to32F", + generic: true, + }, + { + name: "Cvt64to64F", + generic: true, + }, + { + name: "Cvt32Fto32", + generic: true, + }, + { + name: "Cvt32Fto64", + generic: true, + }, + { + name: "Cvt64Fto32", + generic: true, + }, + { + name: "Cvt64Fto64", + generic: true, + }, + { + name: "Cvt32Fto64F", + generic: true, + }, + { + name: "Cvt64Fto32F", + generic: true, + }, { name: "IsNonNil", generic: true, diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index f9690a37db..b50fecda2e 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -1688,6 +1688,166 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endc395c0a53eeccf597e225a07b53047d1 endc395c0a53eeccf597e225a07b53047d1: ; + case OpCvt32Fto32: + // match: (Cvt32Fto32 x) + // cond: + // result: (CVTSS2SL x) + { + x := v.Args[0] + v.Op = OpAMD64CVTSS2SL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto endad55e2986dea26975574ee27f4976d5e + endad55e2986dea26975574ee27f4976d5e: + ; + case OpCvt32Fto64: + // match: (Cvt32Fto64 x) + // cond: + // result: (CVTSS2SQ x) + { + x := v.Args[0] + v.Op = OpAMD64CVTSS2SQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end227800dc831e0b4ef80fa315133c0991 + end227800dc831e0b4ef80fa315133c0991: + ; + case OpCvt32Fto64F: + // match: (Cvt32Fto64F x) + // cond: + // result: (CVTSS2SD x) + { + x := v.Args[0] + v.Op = OpAMD64CVTSS2SD + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end0bf5d6f8d182ee2b3ab7d7c2f8ff7790 + end0bf5d6f8d182ee2b3ab7d7c2f8ff7790: + ; + case OpCvt32to32F: + // match: (Cvt32to32F x) + // cond: + // result: (CVTSL2SS x) + { + x := v.Args[0] + v.Op = OpAMD64CVTSL2SS + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto ende0bdea2b21aecdb8399d6fd80ddc97d6 + ende0bdea2b21aecdb8399d6fd80ddc97d6: + ; + case OpCvt32to64F: + // match: (Cvt32to64F x) + // cond: + // result: (CVTSL2SD x) + { + x := v.Args[0] + v.Op = OpAMD64CVTSL2SD + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto ende06cbe745112bcf0e6612788ef71c958 + ende06cbe745112bcf0e6612788ef71c958: + ; + case OpCvt64Fto32: + // match: (Cvt64Fto32 x) + // cond: + // result: (CVTSD2SL x) + { + x := v.Args[0] + v.Op = OpAMD64CVTSD2SL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end1ce5fd52f29d5a42d1aa08d7ac53e49e + end1ce5fd52f29d5a42d1aa08d7ac53e49e: + ; + case OpCvt64Fto32F: + // match: (Cvt64Fto32F x) + // cond: + // result: (CVTSD2SS x) + { + x := v.Args[0] + v.Op = OpAMD64CVTSD2SS + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto endfd70158a96824ced99712d606c607d94 + endfd70158a96824ced99712d606c607d94: + ; + case OpCvt64Fto64: + // match: (Cvt64Fto64 x) + // cond: + // result: (CVTSD2SQ x) + { + x := v.Args[0] + v.Op = OpAMD64CVTSD2SQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end8239c11ce860dc3b5417d4d2ae59386a + end8239c11ce860dc3b5417d4d2ae59386a: + ; + case OpCvt64to32F: + // match: (Cvt64to32F x) + // cond: + // result: (CVTSQ2SS x) + { + x := v.Args[0] + v.Op = OpAMD64CVTSQ2SS + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto endfecc08b8a8cbd2bf3be21a077c4d0d40 + endfecc08b8a8cbd2bf3be21a077c4d0d40: + ; + case OpCvt64to64F: + // match: (Cvt64to64F x) + // cond: + // result: (CVTSQ2SD x) + { + x := v.Args[0] + v.Op = OpAMD64CVTSQ2SD + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto endf74ce5df659f385f75c61187b515a5d0 + endf74ce5df659f385f75c61187b515a5d0: + ; case OpDiv16: // match: (Div16 x y) // cond: -- cgit v1.3 From 8e601b23cd77f687407a358d2baba672f5a8e4d6 Mon Sep 17 00:00:00 2001 From: David Chase Date: Tue, 18 Aug 2015 14:39:26 -0400 Subject: [dev.ssa] cmd/compile: add FP comparison ops Basic ops, no particular optimization in the pattern matching yet (e.g. x!=x for Nan detection, x cmp constant, etc.) Change-Id: I0043564081d6dc0eede876c4a9eb3c33cbd1521c Reviewed-on: https://go-review.googlesource.com/13704 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 188 ++++- src/cmd/compile/internal/gc/testdata/fp_ssa.go | 1039 ++++++++++++++++++++++-- src/cmd/compile/internal/ssa/fuse.go | 2 +- src/cmd/compile/internal/ssa/gen/AMD64.rules | 39 +- src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 30 +- src/cmd/compile/internal/ssa/gen/genericOps.go | 12 + src/cmd/compile/internal/ssa/gen/main.go | 4 +- src/cmd/compile/internal/ssa/opGen.go | 184 ++++- src/cmd/compile/internal/ssa/rewriteAMD64.go | 424 ++++++++++ 9 files changed, 1804 insertions(+), 118 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 8e44ede318..676de23115 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -848,6 +848,8 @@ var opToSSA = map[opAndType]ssa.Op{ opAndType{OEQ, TCHAN}: 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, @@ -866,42 +868,52 @@ var opToSSA = map[opAndType]ssa.Op{ opAndType{ONE, TCHAN}: ssa.OpNeqPtr, opAndType{ONE, TUINTPTR}: ssa.OpNeqPtr, opAndType{ONE, TUNSAFEPTR}: ssa.OpNeqPtr, - - 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{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{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{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{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, @@ -2198,7 +2210,7 @@ func genssa(f *ssa.Func, ptxt *obj.Prog, gcargs, gclocals *Sym) { } // opregreg emits instructions for -// dest := dest op src +// 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 { @@ -2522,11 +2534,11 @@ func genValue(v *ssa.Value) { p.To.Reg = regnum(v) case ssa.OpAMD64CMPQ, ssa.OpAMD64CMPL, ssa.OpAMD64CMPW, ssa.OpAMD64CMPB, ssa.OpAMD64TESTQ, ssa.OpAMD64TESTL, ssa.OpAMD64TESTW, ssa.OpAMD64TESTB: - 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.Args[1]) + 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, ssa.OpAMD64TESTQconst, ssa.OpAMD64TESTLconst, ssa.OpAMD64TESTWconst, ssa.OpAMD64TESTBconst: p := Prog(v.Op.Asm()) @@ -2763,11 +2775,34 @@ func genValue(v *ssa.Value) { 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 + // TODO AORQ copied from old code generator, why not AORB? + opregreg(x86.AORQ, 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 + // TODO AANDQ copied from old code generator, why not AANDB? + opregreg(x86.AANDQ, regnum(v), x86.REG_AX) + case ssa.OpAMD64InvertFlags: v.Fatalf("InvertFlags should never make it to codegen %v", v) case ssa.OpAMD64REPSTOSQ: @@ -2808,7 +2843,9 @@ func movZero(as int, width int64, nbytes int64, offset int64, regnum int16) (nle return nleft, offset } -var blockJump = [...]struct{ asm, invasm int }{ +var blockJump = [...]struct { + asm, invasm int +}{ ssa.BlockAMD64EQ: {x86.AJEQ, x86.AJNE}, ssa.BlockAMD64NE: {x86.AJNE, x86.AJEQ}, ssa.BlockAMD64LT: {x86.AJLT, x86.AJGE}, @@ -2819,6 +2856,63 @@ var blockJump = [...]struct{ asm, invasm int }{ 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(b, next *ssa.Block, jumps *[2][2]floatingEQNEJump, branches []branch) []branch { + likely := b.Likely + switch next { + case b.Succs[0]: + branches = oneFPJump(b, &jumps[0][0], likely, branches) + branches = oneFPJump(b, &jumps[0][1], likely, branches) + case b.Succs[1]: + branches = oneFPJump(b, &jumps[1][0], likely, branches) + branches = oneFPJump(b, &jumps[1][1], likely, branches) + default: + branches = oneFPJump(b, &jumps[1][0], likely, branches) + branches = oneFPJump(b, &jumps[1][1], likely, branches) + q := Prog(obj.AJMP) + q.To.Type = obj.TYPE_BRANCH + branches = append(branches, branch{q, b.Succs[1]}) + } + return branches } func genBlock(b, next *ssa.Block, branches []branch) []branch { @@ -2849,12 +2943,18 @@ func genBlock(b, next *ssa.Block, branches []branch) []branch { p.To.Type = obj.TYPE_BRANCH branches = append(branches, branch{p, b.Succs[0]}) } + + case ssa.BlockAMD64EQF: + branches = genFPJump(b, next, &eqfJumps, branches) + + case ssa.BlockAMD64NEF: + branches = genFPJump(b, next, &nefJumps, branches) + 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 diff --git a/src/cmd/compile/internal/gc/testdata/fp_ssa.go b/src/cmd/compile/internal/gc/testdata/fp_ssa.go index 1a52100d6b..95e3cf9196 100644 --- a/src/cmd/compile/internal/gc/testdata/fp_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/fp_ssa.go @@ -10,64 +10,6 @@ package main import "fmt" -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 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 expect64(s string, x, expected float64) int { - if x != expected { - println("Expected", expected, "for", s, ", got", x) - return 1 - } - return 0 -} - -func expect32(s string, x, expected float32) int { - if x != expected { - println("Expected", expected, "for", s, ", got", 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 -} - // 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). @@ -245,6 +187,952 @@ func integer2floatConversions() int { 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 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("Expected", expected, "for", s, ", got", x) + return 1 + } + return 0 +} + +func expect32(s string, x, expected float32) int { + if x != expected { + println("Expected", expected, "for", s, ", got", x) + return 1 + } + return 0 +} + +func expectUint64(s string, x, expected uint64) int { + if x != expected { + fmt.Printf("Expected 0x%016x for %s, got 0x%016x\n", expected, s, 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 main() { a := 3.0 @@ -273,6 +1161,8 @@ func main() { // 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) @@ -297,6 +1187,39 @@ func main() { 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) + } + if fails > 0 { fmt.Printf("Saw %v failures\n", fails) panic("Failed.") diff --git a/src/cmd/compile/internal/ssa/fuse.go b/src/cmd/compile/internal/ssa/fuse.go index e6bd44d573..e390fc4998 100644 --- a/src/cmd/compile/internal/ssa/fuse.go +++ b/src/cmd/compile/internal/ssa/fuse.go @@ -35,7 +35,7 @@ func fuse(f *Func) { } // trash b, just in case - b.Kind = blockInvalid + b.Kind = BlockInvalid b.Values = nil b.Preds = nil b.Succs = nil diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 86b443c10d..ff89a7e899 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -198,53 +198,67 @@ (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 ptr mem) && (is64BitInt(t) || isPtr(t)) -> (MOVQload ptr mem) (Load ptr mem) && is32BitInt(t) -> (MOVLload ptr mem) @@ -304,6 +318,12 @@ (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) -> (EQF cmp yes no) + (If cond yes no) -> (NE (TESTB cond cond) yes no) (NE (TESTB (SETL cmp)) yes no) -> (LT cmp yes no) @@ -317,6 +337,16 @@ (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 x) (SETNAN x)) +// (SETEQF x) -> (ANDQ (SETEQ x) (SETORD x)) + (StaticCall [argwid] {target} mem) -> (CALLstatic [argwid] {target} mem) (ClosureCall [argwid] entry closure mem) -> (CALLclosure [argwid] entry closure mem) @@ -519,7 +549,6 @@ (MOVSDstore [off1] {sym1} (LEAQ8 [off2] {sym2} ptr idx) val mem) && canMergeSym(sym1, sym2) -> (MOVSDstoreidx8 [addOff(off1, off2)] {mergeSym(sym1,sym2)} ptr idx val mem) - (ADDQconst [0] x) -> x // lower Zero instructions with word sizes diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 8b8da225d1..e610458c92 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -83,7 +83,6 @@ func init() { flags = buildReg("FLAGS") callerSave = gp | fp | flags ) - // Common slices of register masks var ( gponly = []regMask{gp} @@ -110,8 +109,9 @@ func init() { gp2flags = regInfo{inputs: []regMask{gpsp, gpsp}, outputs: flagsonly} gp1flags = regInfo{inputs: []regMask{gpsp}, outputs: flagsonly} - flagsgp = regInfo{inputs: flagsonly, outputs: gponly, clobbers: flags} + flagsgp = regInfo{inputs: flagsonly, outputs: gponly} readflags = regInfo{inputs: flagsonly, outputs: gponly} + flagsgpax = regInfo{inputs: flagsonly, clobbers: ax, outputs: []regMask{gp &^ ax}} gpload = regInfo{inputs: []regMask{gpspsb, 0}, outputs: gponly} gploadidx = regInfo{inputs: []regMask{gpspsb, gpsp, 0}, outputs: gponly} @@ -124,10 +124,11 @@ func init() { 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} + 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} @@ -249,6 +250,9 @@ func init() { {name: "CMPWconst", reg: gp1flags, asm: "CMPW"}, // arg0 compare to auxint {name: "CMPBconst", reg: gp1flags, asm: "CMPB"}, // arg0 compare to auxint + {name: "UCOMISS", reg: fp2flags, asm: "UCOMISS"}, // arg0 compare to arg1, f32 + {name: "UCOMISD", reg: fp2flags, asm: "UCOMISD"}, // arg0 compare to arg1, f64 + {name: "TESTQ", reg: gp2flags, asm: "TESTQ"}, // (arg0 & arg1) compare to 0 {name: "TESTL", reg: gp2flags, asm: "TESTL"}, // (arg0 & arg1) compare to 0 {name: "TESTW", reg: gp2flags, asm: "TESTW"}, // (arg0 & arg1) compare to 0 @@ -316,6 +320,16 @@ func init() { {name: "SETBE", reg: readflags, asm: "SETLS"}, // extract unsigned <= condition from arg0 {name: "SETA", reg: readflags, asm: "SETHI"}, // extract unsigned > condition from arg0 {name: "SETAE", 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", reg: flagsgpax, asm: "SETEQ"}, // extract == condition from arg0 + {name: "SETNEF", reg: flagsgpax, asm: "SETNE"}, // extract != condition from arg0 + {name: "SETORD", reg: flagsgp, asm: "SETPC"}, // extract "ordered" (No Nan present) condition from arg0 + {name: "SETNAN", reg: flagsgp, asm: "SETPS"}, // extract "unordered" (Nan present) condition from arg0 + + {name: "SETGF", reg: flagsgp, asm: "SETHI"}, // extract floating > condition from arg0 + {name: "SETGEF", reg: flagsgp, asm: "SETCC"}, // extract floating >= condition from arg0 {name: "MOVBQSX", reg: gp11nf, asm: "MOVBQSX"}, // sign extend arg0 from int8 to int64 {name: "MOVBQZX", reg: gp11nf, asm: "MOVBQZX"}, // zero extend arg0 from int8 to int64 @@ -395,6 +409,10 @@ func init() { {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/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 4a65a87ea8..a0040d3017 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -161,6 +161,8 @@ var genericOps = []opData{ {name: "Eq64"}, {name: "EqPtr"}, {name: "EqFat"}, // slice/interface; arg0 or arg1 is nil; other cases handled by frontend + {name: "Eq32F"}, + {name: "Eq64F"}, {name: "Neq8"}, // arg0 != arg1 {name: "Neq16"}, @@ -168,6 +170,8 @@ var genericOps = []opData{ {name: "Neq64"}, {name: "NeqPtr"}, {name: "NeqFat"}, // slice/interface; arg0 or arg1 is nil; other cases handled by frontend + {name: "Neq32F"}, + {name: "Neq64F"}, {name: "Less8"}, // arg0 < arg1 {name: "Less8U"}, @@ -177,6 +181,8 @@ var genericOps = []opData{ {name: "Less32U"}, {name: "Less64"}, {name: "Less64U"}, + {name: "Less32F"}, + {name: "Less64F"}, {name: "Leq8"}, // arg0 <= arg1 {name: "Leq8U"}, @@ -186,6 +192,8 @@ var genericOps = []opData{ {name: "Leq32U"}, {name: "Leq64"}, {name: "Leq64U"}, + {name: "Leq32F"}, + {name: "Leq64F"}, {name: "Greater8"}, // arg0 > arg1 {name: "Greater8U"}, @@ -195,6 +203,8 @@ var genericOps = []opData{ {name: "Greater32U"}, {name: "Greater64"}, {name: "Greater64U"}, + {name: "Greater32F"}, + {name: "Greater64F"}, {name: "Geq8"}, // arg0 <= arg1 {name: "Geq8U"}, @@ -204,6 +214,8 @@ var genericOps = []opData{ {name: "Geq32U"}, {name: "Geq64"}, {name: "Geq64U"}, + {name: "Geq32F"}, + {name: "Geq64F"}, // 1-input ops {name: "Not"}, // !arg0 diff --git a/src/cmd/compile/internal/ssa/gen/main.go b/src/cmd/compile/internal/ssa/gen/main.go index 6620c0a1d0..1383566e3a 100644 --- a/src/cmd/compile/internal/ssa/gen/main.go +++ b/src/cmd/compile/internal/ssa/gen/main.go @@ -76,7 +76,7 @@ func genOp() { // generate Block* declarations fmt.Fprintln(w, "const (") - fmt.Fprintln(w, "blockInvalid BlockKind = iota") + fmt.Fprintln(w, "BlockInvalid BlockKind = iota") for _, a := range archs { fmt.Fprintln(w) for _, d := range a.blocks { @@ -87,7 +87,7 @@ func genOp() { // generate block kind string method fmt.Fprintln(w, "var blockString = [...]string{") - fmt.Fprintln(w, "blockInvalid:\"BlockInvalid\",") + fmt.Fprintln(w, "BlockInvalid:\"BlockInvalid\",") for _, a := range archs { fmt.Fprintln(w) for _, b := range a.blocks { diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index aa51cbc301..4eccb463da 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -5,7 +5,7 @@ package ssa import "cmd/internal/obj/x86" const ( - blockInvalid BlockKind = iota + BlockInvalid BlockKind = iota BlockAMD64EQ BlockAMD64NE @@ -17,6 +17,10 @@ const ( BlockAMD64ULE BlockAMD64UGT BlockAMD64UGE + BlockAMD64EQF + BlockAMD64NEF + BlockAMD64ORD + BlockAMD64NAN BlockExit BlockDead @@ -26,7 +30,7 @@ const ( ) var blockString = [...]string{ - blockInvalid: "BlockInvalid", + BlockInvalid: "BlockInvalid", BlockAMD64EQ: "EQ", BlockAMD64NE: "NE", @@ -38,6 +42,10 @@ var blockString = [...]string{ BlockAMD64ULE: "ULE", BlockAMD64UGT: "UGT", BlockAMD64UGE: "UGE", + BlockAMD64EQF: "EQF", + BlockAMD64NEF: "NEF", + BlockAMD64ORD: "ORD", + BlockAMD64NAN: "NAN", BlockExit: "Exit", BlockDead: "Dead", @@ -143,6 +151,8 @@ const ( OpAMD64CMPLconst OpAMD64CMPWconst OpAMD64CMPBconst + OpAMD64UCOMISS + OpAMD64UCOMISD OpAMD64TESTQ OpAMD64TESTL OpAMD64TESTW @@ -199,6 +209,12 @@ const ( OpAMD64SETBE OpAMD64SETA OpAMD64SETAE + OpAMD64SETEQF + OpAMD64SETNEF + OpAMD64SETORD + OpAMD64SETNAN + OpAMD64SETGF + OpAMD64SETGEF OpAMD64MOVBQSX OpAMD64MOVBQZX OpAMD64MOVWQSX @@ -361,12 +377,16 @@ const ( OpEq64 OpEqPtr OpEqFat + OpEq32F + OpEq64F OpNeq8 OpNeq16 OpNeq32 OpNeq64 OpNeqPtr OpNeqFat + OpNeq32F + OpNeq64F OpLess8 OpLess8U OpLess16 @@ -375,6 +395,8 @@ const ( OpLess32U OpLess64 OpLess64U + OpLess32F + OpLess64F OpLeq8 OpLeq8U OpLeq16 @@ -383,6 +405,8 @@ const ( OpLeq32U OpLeq64 OpLeq64U + OpLeq32F + OpLeq64F OpGreater8 OpGreater8U OpGreater16 @@ -391,6 +415,8 @@ const ( OpGreater32U OpGreater64 OpGreater64U + OpGreater32F + OpGreater64F OpGeq8 OpGeq8U OpGeq16 @@ -399,6 +425,8 @@ const ( OpGeq32U OpGeq64 OpGeq64U + OpGeq32F + OpGeq64F OpNot OpNeg8 OpNeg16 @@ -1707,6 +1735,32 @@ var opcodeTable = [...]opInfo{ }, }, }, + { + name: "UCOMISS", + 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", + 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", asm: x86.ATESTQ, @@ -2432,6 +2486,84 @@ var opcodeTable = [...]opInfo{ }, }, }, + { + name: "SETEQF", + 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", + 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", + asm: x86.ASETPC, + reg: regInfo{ + inputs: []inputInfo{ + {0, 8589934592}, // .FLAGS + }, + clobbers: 8589934592, // .FLAGS + outputs: []regMask{ + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + }, + }, + { + name: "SETNAN", + asm: x86.ASETPS, + reg: regInfo{ + inputs: []inputInfo{ + {0, 8589934592}, // .FLAGS + }, + clobbers: 8589934592, // .FLAGS + outputs: []regMask{ + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + }, + }, + { + name: "SETGF", + asm: x86.ASETHI, + reg: regInfo{ + inputs: []inputInfo{ + {0, 8589934592}, // .FLAGS + }, + clobbers: 8589934592, // .FLAGS + outputs: []regMask{ + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + }, + }, + { + name: "SETGEF", + asm: x86.ASETCC, + reg: regInfo{ + inputs: []inputInfo{ + {0, 8589934592}, // .FLAGS + }, + clobbers: 8589934592, // .FLAGS + outputs: []regMask{ + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, + }, + }, { name: "MOVBQSX", asm: x86.AMOVBQSX, @@ -3386,6 +3518,14 @@ var opcodeTable = [...]opInfo{ name: "EqFat", generic: true, }, + { + name: "Eq32F", + generic: true, + }, + { + name: "Eq64F", + generic: true, + }, { name: "Neq8", generic: true, @@ -3410,6 +3550,14 @@ var opcodeTable = [...]opInfo{ name: "NeqFat", generic: true, }, + { + name: "Neq32F", + generic: true, + }, + { + name: "Neq64F", + generic: true, + }, { name: "Less8", generic: true, @@ -3442,6 +3590,14 @@ var opcodeTable = [...]opInfo{ name: "Less64U", generic: true, }, + { + name: "Less32F", + generic: true, + }, + { + name: "Less64F", + generic: true, + }, { name: "Leq8", generic: true, @@ -3474,6 +3630,14 @@ var opcodeTable = [...]opInfo{ name: "Leq64U", generic: true, }, + { + name: "Leq32F", + generic: true, + }, + { + name: "Leq64F", + generic: true, + }, { name: "Greater8", generic: true, @@ -3506,6 +3670,14 @@ var opcodeTable = [...]opInfo{ name: "Greater64U", generic: true, }, + { + name: "Greater32F", + generic: true, + }, + { + name: "Greater64F", + generic: true, + }, { name: "Geq8", generic: true, @@ -3538,6 +3710,14 @@ var opcodeTable = [...]opInfo{ name: "Geq64U", generic: true, }, + { + name: "Geq32F", + generic: true, + }, + { + name: "Geq64F", + generic: true, + }, { name: "Not", generic: true, diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index b50fecda2e..dc6dce995b 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -2082,6 +2082,27 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end4d77d0b016f93817fd6e5f60fa0e7ef2 end4d77d0b016f93817fd6e5f60fa0e7ef2: ; + case OpEq32F: + // match: (Eq32F x y) + // cond: + // result: (SETEQF (UCOMISS x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETEQF + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto end034925b03df528b1ffec9fafdcd56c8e + end034925b03df528b1ffec9fafdcd56c8e: + ; case OpEq64: // match: (Eq64 x y) // cond: @@ -2103,6 +2124,27 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endae6c62e4e20b4f62694b6ee40dbd9211 endae6c62e4e20b4f62694b6ee40dbd9211: ; + case OpEq64F: + // match: (Eq64F x y) + // cond: + // result: (SETEQF (UCOMISD x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETEQF + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto end62b2fb60187571e6ab0c53696ef7d030 + end62b2fb60187571e6ab0c53696ef7d030: + ; case OpEq8: // match: (Eq8 x y) // cond: @@ -2208,6 +2250,27 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end713c3dfa0f7247dcc232bcfc916fb044 end713c3dfa0f7247dcc232bcfc916fb044: ; + case OpGeq32F: + // match: (Geq32F x y) + // cond: + // result: (SETGEF (UCOMISS x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETGEF + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto end5847ac7f2e264fba4c408ebb60c1e8a5 + end5847ac7f2e264fba4c408ebb60c1e8a5: + ; case OpGeq32U: // match: (Geq32U x y) // cond: @@ -2250,6 +2313,27 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end63f44e3fec8d92723b5bde42d6d7eea0 end63f44e3fec8d92723b5bde42d6d7eea0: ; + case OpGeq64F: + // match: (Geq64F x y) + // cond: + // result: (SETGEF (UCOMISD x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETGEF + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto endb40fbc46a8fc04fef95182771e2933c2 + endb40fbc46a8fc04fef95182771e2933c2: + ; case OpGeq64U: // match: (Geq64U x y) // cond: @@ -2390,6 +2474,27 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endbf0b2b1368aadff48969a7386eee5795 endbf0b2b1368aadff48969a7386eee5795: ; + case OpGreater32F: + // match: (Greater32F x y) + // cond: + // result: (SETGF (UCOMISS x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETGF + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto endb65b042358784f18002ae59ea6f2c51a + endb65b042358784f18002ae59ea6f2c51a: + ; case OpGreater32U: // match: (Greater32U x y) // cond: @@ -2432,6 +2537,27 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endaef0cfa5e27e23cf5e527061cf251069 endaef0cfa5e27e23cf5e527061cf251069: ; + case OpGreater64F: + // match: (Greater64F x y) + // cond: + // result: (SETGF (UCOMISD x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETGF + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto end1a6ca23bbb3e885473865e3b3ea501e7 + end1a6ca23bbb3e885473865e3b3ea501e7: + ; case OpGreater64U: // match: (Greater64U x y) // cond: @@ -2728,6 +2854,27 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endf422ecc8da0033e22242de9c67112537 endf422ecc8da0033e22242de9c67112537: ; + case OpLeq32F: + // match: (Leq32F x y) + // cond: + // result: (SETGEF (UCOMISS y x)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETGEF + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(y) + v0.AddArg(x) + v.AddArg(v0) + return true + } + goto end98f7b2e6e15ce282d044c812454fe77f + end98f7b2e6e15ce282d044c812454fe77f: + ; case OpLeq32U: // match: (Leq32U x y) // cond: @@ -2770,6 +2917,27 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endf03da5e28dccdb4797671f39e824fb10 endf03da5e28dccdb4797671f39e824fb10: ; + case OpLeq64F: + // match: (Leq64F x y) + // cond: + // result: (SETGEF (UCOMISD y x)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETGEF + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(y) + v0.AddArg(x) + v.AddArg(v0) + return true + } + goto end7efa164f4e4f5a395f547b1885b7eef4 + end7efa164f4e4f5a395f547b1885b7eef4: + ; case OpLeq64U: // match: (Leq64U x y) // cond: @@ -2896,6 +3064,27 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end8da8d2030c0a323a84503c1240c566ae end8da8d2030c0a323a84503c1240c566ae: ; + case OpLess32F: + // match: (Less32F x y) + // cond: + // result: (SETGF (UCOMISS y x)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETGF + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(y) + v0.AddArg(x) + v.AddArg(v0) + return true + } + goto end54f94ce87c18a1ed2beb8d0161bea907 + end54f94ce87c18a1ed2beb8d0161bea907: + ; case OpLess32U: // match: (Less32U x y) // cond: @@ -2938,6 +3127,27 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endf8e7a24c25692045bbcfd2c9356d1a8c endf8e7a24c25692045bbcfd2c9356d1a8c: ; + case OpLess64F: + // match: (Less64F x y) + // cond: + // result: (SETGF (UCOMISD y x)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETGF + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(y) + v0.AddArg(x) + v.AddArg(v0) + return true + } + goto end92720155a95cbfae47ea469583c4d3c7 + end92720155a95cbfae47ea469583c4d3c7: + ; case OpLess64U: // match: (Less64U x y) // cond: @@ -5902,6 +6112,27 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end39c4bf6d063f8a0b6f0064c96ce25173 end39c4bf6d063f8a0b6f0064c96ce25173: ; + case OpNeq32F: + // match: (Neq32F x y) + // cond: + // result: (SETNEF (UCOMISS x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETNEF + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto end4eb0af70b64b789e55d83c15e426b0c5 + end4eb0af70b64b789e55d83c15e426b0c5: + ; case OpNeq64: // match: (Neq64 x y) // cond: @@ -5923,6 +6154,27 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end8ab0bcb910c0d3213dd8726fbcc4848e end8ab0bcb910c0d3213dd8726fbcc4848e: ; + case OpNeq64F: + // match: (Neq64F x y) + // cond: + // result: (SETNEF (UCOMISD x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETNEF + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + return true + } + goto end73beb54a015a226bc2e83bdd39e7ee46 + end73beb54a015a226bc2e83bdd39e7ee46: + ; case OpNeq8: // match: (Neq8 x y) // cond: @@ -10358,6 +10610,86 @@ func rewriteBlockAMD64(b *Block) bool { } goto end9bea9963c3c5dfb97249a5feb8287f94 end9bea9963c3c5dfb97249a5feb8287f94: + ; + // match: (If (SETGF cmp) yes no) + // cond: + // result: (UGT cmp yes no) + { + v := b.Control + if v.Op != OpAMD64SETGF { + goto enda72d68674cfa26b5982a43756bca6767 + } + 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 + } + goto enda72d68674cfa26b5982a43756bca6767 + enda72d68674cfa26b5982a43756bca6767: + ; + // match: (If (SETGEF cmp) yes no) + // cond: + // result: (UGE cmp yes no) + { + v := b.Control + if v.Op != OpAMD64SETGEF { + goto endccc171c1d66dd60ac0275d1f78259315 + } + 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 + } + goto endccc171c1d66dd60ac0275d1f78259315 + endccc171c1d66dd60ac0275d1f78259315: + ; + // match: (If (SETEQF cmp) yes no) + // cond: + // result: (EQF cmp yes no) + { + v := b.Control + if v.Op != OpAMD64SETEQF { + goto end58cb74d05266a79003ebdd733afb66fa + } + 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 + } + goto end58cb74d05266a79003ebdd733afb66fa + end58cb74d05266a79003ebdd733afb66fa: + ; + // match: (If (SETNEF cmp) yes no) + // cond: + // result: (EQF cmp yes no) + { + v := b.Control + if v.Op != OpAMD64SETNEF { + goto endfe25939ca97349543bc2d2ce4f97ba41 + } + 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 + } + goto endfe25939ca97349543bc2d2ce4f97ba41 + endfe25939ca97349543bc2d2ce4f97ba41: ; // match: (If cond yes no) // cond: @@ -10652,6 +10984,98 @@ func rewriteBlockAMD64(b *Block) bool { } goto endbd122fd599aeb9e60881a0fa735e2fde endbd122fd599aeb9e60881a0fa735e2fde: + ; + // match: (NE (TESTB (SETGF cmp)) yes no) + // cond: + // result: (UGT cmp yes no) + { + v := b.Control + if v.Op != OpAMD64TESTB { + goto endb2499521f7f351e24757f8c918c3598e + } + if v.Args[0].Op != OpAMD64SETGF { + goto endb2499521f7f351e24757f8c918c3598e + } + 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 + } + goto endb2499521f7f351e24757f8c918c3598e + endb2499521f7f351e24757f8c918c3598e: + ; + // match: (NE (TESTB (SETGEF cmp)) yes no) + // cond: + // result: (UGE cmp yes no) + { + v := b.Control + if v.Op != OpAMD64TESTB { + goto end20461774babea665c4ca7c4f790a7209 + } + if v.Args[0].Op != OpAMD64SETGEF { + goto end20461774babea665c4ca7c4f790a7209 + } + 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 + } + goto end20461774babea665c4ca7c4f790a7209 + end20461774babea665c4ca7c4f790a7209: + ; + // match: (NE (TESTB (SETEQF cmp)) yes no) + // cond: + // result: (EQF cmp yes no) + { + v := b.Control + if v.Op != OpAMD64TESTB { + goto end236616ef13d489b78736cda7bcc1d168 + } + if v.Args[0].Op != OpAMD64SETEQF { + goto end236616ef13d489b78736cda7bcc1d168 + } + 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 + } + goto end236616ef13d489b78736cda7bcc1d168 + end236616ef13d489b78736cda7bcc1d168: + ; + // match: (NE (TESTB (SETNEF cmp)) yes no) + // cond: + // result: (NEF cmp yes no) + { + v := b.Control + if v.Op != OpAMD64TESTB { + goto endc992f3c266b16cb5f6aa98faa8f55600 + } + if v.Args[0].Op != OpAMD64SETNEF { + goto endc992f3c266b16cb5f6aa98faa8f55600 + } + 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 + } + goto endc992f3c266b16cb5f6aa98faa8f55600 + endc992f3c266b16cb5f6aa98faa8f55600: ; // match: (NE (InvertFlags cmp) yes no) // cond: -- cgit v1.3 From 3526cf586be92cb4c741aed54ccfd37cf00ddfc5 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Mon, 24 Aug 2015 23:52:03 -0700 Subject: [dev.ssa] cmd/compile: implement OSLICESTR Add a new function and generic operation to handle bounds checking for slices. Unlike the index bounds checking the index can be equal to the upper bound. Do gc-friendly slicing that generates proper code for 0-length result slices. This is a takeover of Alexandru's original change, (https://go-review.googlesource.com/#/c/12764/) submittable now that the decompose phase is in. Change-Id: I17d164cf42ed7839f84ca949c6ad3289269c9160 Reviewed-on: https://go-review.googlesource.com/13903 Reviewed-by: David Chase --- src/cmd/compile/internal/gc/ssa.go | 86 +++++++++++++++++++- src/cmd/compile/internal/gc/testdata/string_ssa.go | 92 ++++++++++++++++++++++ src/cmd/compile/internal/ssa/gen/AMD64.rules | 2 + src/cmd/compile/internal/ssa/gen/genericOps.go | 7 +- src/cmd/compile/internal/ssa/opGen.go | 12 ++- src/cmd/compile/internal/ssa/rewriteAMD64.go | 39 +++++++++ 6 files changed, 234 insertions(+), 4 deletions(-) create mode 100644 src/cmd/compile/internal/gc/testdata/string_ssa.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 676de23115..ce20e7bdfd 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1465,6 +1465,71 @@ func (s *state) expr(n *Node) *ssa.Value { a := s.expr(n.Left) return s.newValue1(ssa.OpITab, n.Type, a) + case OSLICESTR: + // Evaluate the string once. + str := s.expr(n.Left) + ptr := s.newValue1(ssa.OpStringPtr, Ptrto(Types[TUINT8]), str) + len := s.newValue1(ssa.OpStringLen, Types[TINT], str) + zero := s.constInt(Types[TINT], 0) + + // Evaluate the slice indexes. + var low, high *ssa.Value + if n.Right.Left == nil { + low = zero + } else { + low = s.expr(n.Right.Left) + } + if n.Right.Right == nil { + high = len + } else { + high = s.expr(n.Right.Right) + } + + // Panic if slice indices are not in bounds. + s.sliceBoundsCheck(low, high) + s.sliceBoundsCheck(high, len) + + // Generate the following code assuming that indexes are in bounds. + // The conditional is to make sure that we don't generate a string + // that points to the next object in memory. + // rlen = (SubPtr high low) + // p = ptr + // if rlen != 0 { + // p = (AddPtr ptr low) + // } + // result = (StringMake p size) + rlen := s.newValue2(ssa.OpSubPtr, Types[TINT], high, low) + + // Use n as the "variable" for p. + s.vars[n] = ptr + + // Generate code to test the resulting slice length. + var cmp *ssa.Value + if s.config.IntSize == 8 { + cmp = s.newValue2(ssa.OpNeq64, Types[TBOOL], rlen, zero) + } else { + cmp = s.newValue2(ssa.OpNeq32, Types[TBOOL], rlen, zero) + } + + 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) + addEdge(b, nz) + s.startBlock(nz) + s.vars[n] = s.newValue2(ssa.OpAddPtr, Ptrto(Types[TUINT8]), ptr, low) + s.endBlock() + + // All done. + merge := s.f.NewBlock(ssa.BlockPlain) + addEdge(b, merge) + addEdge(nz, merge) + s.startBlock(merge) + return s.newValue2(ssa.OpStringMake, Types[TSTRING], s.variable(n, Ptrto(Types[TUINT8])), rlen) + case OCALLFUNC, OCALLMETH: left := n.Left static := left.Op == ONAME && left.Class == PFUNC @@ -1782,6 +1847,25 @@ func (s *state) boundsCheck(idx, len *ssa.Value) { // bounds check cmp := s.newValue2(ssa.OpIsInBounds, Types[TBOOL], idx, len) + s.check(cmp, ssa.OpPanicIndexCheck) +} + +// 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, ssa.OpPanicSliceCheck) +} + +// If cmp (a bool) is true, panic using the given op. +func (s *state) check(cmp *ssa.Value, panicOp ssa.Op) { b := s.endBlock() b.Kind = ssa.BlockIf b.Control = cmp @@ -1794,7 +1878,7 @@ func (s *state) boundsCheck(idx, len *ssa.Value) { s.startBlock(bPanic) // The panic check takes/returns memory to ensure that the right // memory state is observed if the panic happens. - s.vars[&memvar] = s.newValue1(ssa.OpPanicIndexCheck, ssa.TypeMem, s.mem()) + s.vars[&memvar] = s.newValue1(panicOp, ssa.TypeMem, s.mem()) s.endBlock() s.startBlock(bNext) } 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 0000000000..5987412933 --- /dev/null +++ b/src/cmd/compile/internal/gc/testdata/string_ssa.go @@ -0,0 +1,92 @@ +// string_ssa.go tests string operations. +package main + +var failed = false + +func testStringSlice1_ssa(a string, i, j int) string { + switch { // prevent inlining + } + return a[i:] +} + +func testStringSlice2_ssa(a string, i, j int) string { + switch { // prevent inlining + } + return a[:j] +} + +func testStringSlice12_ssa(a string, i, j int) string { + switch { // prevent inlining + } + 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) + } +} + +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 +} + +func main() { + testStringSlice() + testStringSlicePanic() + + if failed { + panic("failed") + } +} diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index ff89a7e899..f0b9288dd5 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -19,6 +19,7 @@ (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) @@ -279,6 +280,7 @@ // checks (IsNonNil p) -> (SETNE (TESTQ p p)) (IsInBounds idx len) -> (SETB (CMPQ idx len)) +(IsSliceInBounds idx len) -> (SETBE (CMPQ idx len)) (PanicNilCheck ptr mem) -> (LoweredPanicNilCheck ptr mem) (PanicIndexCheck mem) -> (LoweredPanicIndexCheck mem) diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index a0040d3017..66bb6596fa 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -21,9 +21,11 @@ var genericOps = []opData{ {name: "Sub16"}, {name: "Sub32"}, {name: "Sub64"}, + {name: "SubPtr"}, {name: "Sub32F"}, {name: "Sub64F"}, // TODO: Sub64C, Sub128C + // TODO: Sub32F, Sub64F, Sub64C, Sub128C {name: "Mul8"}, // arg0 * arg1 {name: "Mul16"}, @@ -311,8 +313,9 @@ var genericOps = []opData{ {name: "Cvt64Fto32F"}, // Automatically inserted safety checks - {name: "IsNonNil"}, // arg0 != nil - {name: "IsInBounds"}, // 0 <= arg0 < arg1 + {name: "IsNonNil"}, // arg0 != nil + {name: "IsInBounds"}, // 0 <= arg0 < arg1 + {name: "IsSliceInBounds"}, // 0 <= arg0 <= arg1 // Pseudo-ops {name: "PanicNilCheck"}, // trigger a dereference fault; arg0=nil ptr, arg1=mem, returns mem diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 4eccb463da..8d99d57df7 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -274,6 +274,7 @@ const ( OpSub16 OpSub32 OpSub64 + OpSubPtr OpSub32F OpSub64F OpMul8 @@ -491,6 +492,7 @@ const ( OpCvt64Fto32F OpIsNonNil OpIsInBounds + OpIsSliceInBounds OpPanicNilCheck OpPanicIndexCheck OpPanicSliceCheck @@ -2335,6 +2337,7 @@ var opcodeTable = [...]opInfo{ 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 }, @@ -2631,7 +2634,6 @@ var opcodeTable = [...]opInfo{ 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 }, @@ -3106,6 +3108,10 @@ var opcodeTable = [...]opInfo{ name: "Sub64", generic: true, }, + { + name: "SubPtr", + generic: true, + }, { name: "Sub32F", generic: true, @@ -3974,6 +3980,10 @@ var opcodeTable = [...]opInfo{ name: "IsInBounds", generic: true, }, + { + name: "IsSliceInBounds", + generic: true, + }, { name: "PanicNilCheck", generic: true, diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index dc6dce995b..c0213d8632 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -2791,6 +2791,27 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endff508c3726edfb573abc6128c177e76c endff508c3726edfb573abc6128c177e76c: ; + case OpIsSliceInBounds: + // match: (IsSliceInBounds idx len) + // cond: + // result: (SETBE (CMPQ idx len)) + { + idx := v.Args[0] + len := v.Args[1] + v.Op = OpAMD64SETBE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0.Type = TypeFlags + v0.AddArg(idx) + v0.AddArg(len) + v.AddArg(v0) + return true + } + goto end41f8211150e3a4ef36a1b5168013f96f + end41f8211150e3a4ef36a1b5168013f96f: + ; case OpLeq16: // match: (Leq16 x y) // cond: @@ -9579,6 +9600,24 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end7d33bf9bdfa505f96b930563eca7955f end7d33bf9bdfa505f96b930563eca7955f: ; + case OpSubPtr: + // match: (SubPtr x y) + // cond: + // result: (SUBQ x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SUBQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end748f63f755afe0b97a8f3cf7e4d9cbfe + end748f63f755afe0b97a8f3cf7e4d9cbfe: + ; case OpTrunc16to8: // match: (Trunc16to8 x) // cond: -- cgit v1.3 From ec39d78ddd2168d617e52086a1f5841a6cc03959 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Tue, 25 Aug 2015 10:39:23 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: update TODO and comments Change-Id: I3c598faff8af18530ae863b9e72f0cef379b4a1f Reviewed-on: https://go-review.googlesource.com/13909 Reviewed-by: Brad Fitzpatrick --- src/cmd/compile/internal/ssa/TODO | 13 ++----------- src/cmd/compile/internal/ssa/gen/genericOps.go | 1 - 2 files changed, 2 insertions(+), 12 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/TODO b/src/cmd/compile/internal/ssa/TODO index 9e52a67ed0..fbe4f56760 100644 --- a/src/cmd/compile/internal/ssa/TODO +++ b/src/cmd/compile/internal/ssa/TODO @@ -3,10 +3,7 @@ be complete soon. Coverage -------- -- Floating point numbers - Complex numbers -- Integer division (MOD) -- Fat objects (strings/slices/interfaces) vs. Phi - Defer? - Closure args - PHEAP vars @@ -16,11 +13,10 @@ Correctness - GC maps - Write barriers - Debugging info -- Handle flags register correctly (clobber/spill/restore) -- Proper panic edges from checks & calls (+deferreturn) +- Deferreturn - Can/should we move control values out of their basic block? - Anything to do for the race detector? -- Slicing details (avoid ptr to next object) +- Slicing details (avoid ptr to next object) [done for string] Optimizations (better compiled code) ------------------------------------ @@ -32,10 +28,7 @@ Optimizations (better compiled code) - Combining nil checks with subsequent load - Implement memory zeroing with REPSTOSQ and DuffZero - Implement memory copying with REPMOVSQ and DuffCopy -- Make deadstore work with zeroing -- Add branch predictions - Add a value range propagation pass (for bounds elim & bitwidth reduction) -- Stackalloc: group pointer-containing variables & spill slots together - Stackalloc: organize values to allow good packing - Regalloc: use arg slots as the home for arguments (don't copy args to locals) - Reuse stack slots for noninterfering & compatible values (but see issue 8740) @@ -55,10 +48,8 @@ Optimizations (better compiler) Regalloc -------- - Make less arch-dependent -- Don't spill everything at every basic block boundary - Allow args and return values to be ssa-able - Handle 2-address instructions -- Make calls clobber all registers - Make liveness analysis non-quadratic - Materialization of constants diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 66bb6596fa..726a62e6be 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -25,7 +25,6 @@ var genericOps = []opData{ {name: "Sub32F"}, {name: "Sub64F"}, // TODO: Sub64C, Sub128C - // TODO: Sub32F, Sub64F, Sub64C, Sub128C {name: "Mul8"}, // arg0 * arg1 {name: "Mul16"}, -- cgit v1.3 From a2f8b0d0e4f0dea41ff8dad29c249d8b204140f1 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Tue, 25 Aug 2015 14:02:30 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: add more critical edges Add blocks to remove critical edges, even when it looks like there's no phi that requires it. Regalloc still likes to have critical-edge-free graphs for other reasons. Change-Id: I69f8eaecbc5d79ab9f2a257c2e289d60b18e43c8 Reviewed-on: https://go-review.googlesource.com/13933 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/ssa/check.go | 3 --- src/cmd/compile/internal/ssa/critical.go | 13 ------------- 2 files changed, 16 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/check.go b/src/cmd/compile/internal/ssa/check.go index 2631401130..61626089a6 100644 --- a/src/cmd/compile/internal/ssa/check.go +++ b/src/cmd/compile/internal/ssa/check.go @@ -99,9 +99,6 @@ func checkFunc(f *Func) { if !b.Control.Type.IsMemory() { f.Fatalf("call block %s has non-memory control value %s", b, b.Control.LongString()) } - if b.Succs[1].Kind != BlockExit { - f.Fatalf("exception edge from call block %s does not go to exit but %s", b, b.Succs[1]) - } } 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)) diff --git a/src/cmd/compile/internal/ssa/critical.go b/src/cmd/compile/internal/ssa/critical.go index 503681ffd3..ba75450875 100644 --- a/src/cmd/compile/internal/ssa/critical.go +++ b/src/cmd/compile/internal/ssa/critical.go @@ -13,19 +13,6 @@ func critical(f *Func) { continue } - // decide if we need to split edges coming into b. - hasphi := false - for _, v := range b.Values { - if v.Op == OpPhi && v.Type != TypeMem { - hasphi = true - break - } - } - if !hasphi { - // no splitting needed - continue - } - // split input edges coming from multi-output blocks. for i, c := range b.Preds { if c.Kind == BlockPlain { -- cgit v1.3 From 752fe4dcb5c033c56dc3ab76ba912efa82df4d9e Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Tue, 25 Aug 2015 19:21:45 -0500 Subject: [dev.ssa] cmd/compile: support float zeroing Change-Id: Iacd302350cf0a8a8164d937e5c4ac55e6a07d380 Reviewed-on: https://go-review.googlesource.com/13942 Reviewed-by: David Chase --- src/cmd/compile/internal/gc/ssa.go | 9 +++++++++ 1 file changed, 9 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index ce20e7bdfd..a0ad2caeaa 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1646,6 +1646,15 @@ func (s *state) zeroVal(t *Type) *ssa.Value { 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.IsString(): return s.entryNewValue0A(ssa.OpConstString, t, "") case t.IsPtr(): -- cgit v1.3 From 7cadf23afb3c54f36758d09710b87a0a9db4b4b9 Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Tue, 25 Aug 2015 22:49:59 -0500 Subject: [dev.ssa] cmd/compile: fix phi floats The code previously always used AX causing errors. For now, just switch off the type in order to at least generate valid code. Change-Id: Iaf13120a24b62456b9b33c04ab31f2d5104b381b Reviewed-on: https://go-review.googlesource.com/13943 Reviewed-by: David Chase --- src/cmd/compile/internal/gc/testdata/fp_ssa.go | 46 ++++++++++++++++++++++++++ src/cmd/compile/internal/ssa/regalloc.go | 20 ++++++++--- 2 files changed, 62 insertions(+), 4 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/testdata/fp_ssa.go b/src/cmd/compile/internal/gc/testdata/fp_ssa.go index 95e3cf9196..5eb65035d4 100644 --- a/src/cmd/compile/internal/gc/testdata/fp_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/fp_ssa.go @@ -35,6 +35,52 @@ func manysub_ssa(a, b, c, d float64) (aa, ab, ac, ad, ba, bb, bc, bd, ca, cb, cc 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 { } diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index b62f9042b6..b098ea1a19 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -550,6 +550,16 @@ func (s *regAllocState) setState(state []regState) { } } +// compatReg returns a register compatible with the a value and is used when +// spilling/loading. +// TODO: choose a better default register (set of reg by type?). +func compatReg(v *Value) regMask { + if v.Type.IsFloat() { + return 1 << 16 // X0 + } + return 1 << 0 // AX +} + func (s *regAllocState) regalloc(f *Func) { liveset := newSparseSet(f.NumValues()) argset := newSparseSet(f.NumValues()) @@ -836,10 +846,11 @@ func (s *regAllocState) regalloc(f *Func) { if !argset.contains(v.ID) { continue } + // This stack-based phi is the argument of some other // phi in this block. We must make a copy of its // value so that we don't clobber it prematurely. - c := s.allocValToReg(v, s.values[v.ID].regs|1<<0, false) + c := s.allocValToReg(v, s.values[v.ID].regs|compatReg(v), false) d := p.NewValue1(v.Line, OpStoreReg, v.Type, c) s.values[v.ID].spill2 = d } @@ -848,9 +859,10 @@ func (s *regAllocState) regalloc(f *Func) { // we might need a register to do the assignment. for _, v := range stackPhis { // Load phi arg into a register, then store it with a StoreReg. - // If already in a register, use that. If not, use register 0. - // TODO: choose a better default register (set of reg by type?). - c := s.allocValToReg(v.Args[i], s.values[v.Args[i].ID].regs|1<<0, false) + // If already in a register, use that. If not, pick a compatible + // register. + w := v.Args[i] + c := s.allocValToReg(w, s.values[w.ID].regs|compatReg(w), false) v.Args[i] = p.NewValue1(v.Line, OpStoreReg, v.Type, c) } // Figure out what value goes in each register. -- cgit v1.3 From 35ad1fcb11c64ebd7e54f8eebf065ba118045357 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Thu, 27 Aug 2015 10:11:08 -0700 Subject: [dev.ssa] cmd/compile: fix OANDAND and OOROR type The old backend doesn't like ideal types, and we want to reuse its stackmap generation. OOROR and OANDAND expressions have ideal type. The old backend didn't care, because those expressions got rewritten away into jumps before stackmap generation. Fix the type during conversion. Change-Id: I488e7499298d9aec71da39c202f6a7235935bc8d Reviewed-on: https://go-review.googlesource.com/13980 Reviewed-by: Brad Fitzpatrick --- src/cmd/compile/internal/gc/ssa.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index a0ad2caeaa..0c0a6a36da 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1373,7 +1373,7 @@ func (s *state) expr(n *Node) *ssa.Value { addEdge(b, bResult) s.startBlock(bResult) - return s.variable(n, n.Type) + return s.variable(n, Types[TBOOL]) // unary ops case ONOT, OMINUS, OCOM: -- cgit v1.3 From 44d87035b65e9fb8fccfe9f8121276614112f629 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Thu, 27 Aug 2015 10:29:01 -0700 Subject: [dev.ssa] cmd/compile: make block kinds clickable in html Change-Id: I113c07caf504cee66a81730da8830de6de098e49 Reviewed-on: https://go-review.googlesource.com/13981 Reviewed-by: Brad Fitzpatrick --- src/cmd/compile/internal/ssa/html.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/html.go b/src/cmd/compile/internal/ssa/html.go index 5c23320680..44e4e19b77 100644 --- a/src/cmd/compile/internal/ssa/html.go +++ b/src/cmd/compile/internal/ssa/html.go @@ -379,7 +379,7 @@ func (b *Block) HTML() string { func (b *Block) LongHTML() string { // TODO: improve this for HTML? - s := b.Kind.String() + s := fmt.Sprintf("%s", html.EscapeString(b.String()), html.EscapeString(b.Kind.String())) if b.Control != nil { s += fmt.Sprintf(" %s", b.Control.HTML()) } -- cgit v1.3 From e0e4068c6e6cebb586bbffa36962c7fc6cb595e0 Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Wed, 26 Aug 2015 18:40:52 -0500 Subject: [dev.ssa] cmd/compile: implement len(map) Implement len(map) values. Change-Id: If92be96ec9a7a86aeb3ce566d6758aab01c2fa7d Reviewed-on: https://go-review.googlesource.com/13961 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 38 ++++++++++++++++- src/cmd/compile/internal/gc/testdata/map_ssa.go | 47 ++++++++++++++++++++++ src/cmd/compile/internal/gc/testdata/string_ssa.go | 4 ++ 3 files changed, 87 insertions(+), 2 deletions(-) create mode 100644 src/cmd/compile/internal/gc/testdata/map_ssa.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 0c0a6a36da..d672eb58e0 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1440,8 +1440,7 @@ func (s *state) expr(n *Node) *ssa.Value { 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(): - s.Unimplementedf("unhandled len(map)") - return nil + return s.lenMap(n, s.expr(n.Left)) case n.Left.Type.IsChan(): if n.Op == OCAP { s.Unimplementedf("unhandled cap(chan)") @@ -1998,6 +1997,41 @@ func (s *state) uintTofloat(cvttab *u2fcvtTab, n *Node, x *ssa.Value, ft, tt *Ty return s.variable(n, n.Type) } +func (s *state) lenMap(n *Node, x *ssa.Value) *ssa.Value { + // if n == nil { + // return 0 + // } else { + // return *((*int)n) + // } + lenType := n.Type + cmp := s.newValue2(ssa.OpEqPtr, Types[TBOOL], x, s.zeroVal(lenType)) + 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 of a nil map is zero + addEdge(b, bThen) + s.startBlock(bThen) + s.vars[n] = s.zeroVal(lenType) + s.endBlock() + addEdge(bThen, bAfter) + + // the length is stored in the first word + addEdge(b, bElse) + s.startBlock(bElse) + s.vars[n] = s.newValue2(ssa.OpLoad, lenType, x, s.mem()) + s.endBlock() + addEdge(bElse, bAfter) + + s.startBlock(bAfter) + return s.variable(n, lenType) +} + // 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, 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 0000000000..41c949a9f2 --- /dev/null +++ b/src/cmd/compile/internal/gc/testdata/map_ssa.go @@ -0,0 +1,47 @@ +// 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 + +func lenMap_ssa(v map[int]int) int { + switch { // prevent inlining + + } + 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/string_ssa.go b/src/cmd/compile/internal/gc/testdata/string_ssa.go index 5987412933..efc734e1a2 100644 --- a/src/cmd/compile/internal/gc/testdata/string_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/string_ssa.go @@ -1,3 +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. + // string_ssa.go tests string operations. package main -- cgit v1.3 From 525785885e42b26e6936e5d91386518218cff4d7 Mon Sep 17 00:00:00 2001 From: David Chase Date: Fri, 28 Aug 2015 14:24:10 -0400 Subject: [dev.ssa] cmd/compile: add compose/decompose for complex, phi, constants Still to do: arithmetic Change-Id: I31fd23b34980c9ed4b4e304b8597134b2ba6ca5c Reviewed-on: https://go-review.googlesource.com/14024 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 37 +++++ .../compile/internal/gc/testdata/compound_ssa.go | 54 +++++++ src/cmd/compile/internal/gc/type.go | 4 + src/cmd/compile/internal/ssa/config.go | 2 + src/cmd/compile/internal/ssa/decompose.go | 27 ++++ src/cmd/compile/internal/ssa/export_test.go | 2 + src/cmd/compile/internal/ssa/gen/generic.rules | 30 ++++ src/cmd/compile/internal/ssa/gen/genericOps.go | 5 + src/cmd/compile/internal/ssa/opGen.go | 25 ++- src/cmd/compile/internal/ssa/rewritegeneric.go | 180 +++++++++++++++++++++ src/cmd/compile/internal/ssa/type.go | 4 +- src/cmd/compile/internal/ssa/type_test.go | 26 +-- 12 files changed, 377 insertions(+), 19 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index d672eb58e0..94fdf0e489 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1113,6 +1113,29 @@ func (s *state) expr(n *Node) *ssa.Value { 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.constFloat32(pt, mpgetflt(r)), + s.constFloat32(pt, mpgetflt(i))) + } + default: + s.Fatalf("bad float size %d", n.Type.Size()) + return nil + } default: s.Unimplementedf("unhandled OLITERAL %v", n.Val().Ctype()) @@ -1654,6 +1677,18 @@ func (s *state) zeroVal(t *Type) *ssa.Value { 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.newValue2(ssa.OpComplexMake, t, z, z) + case 16: + z := s.constFloat64(Types[TFLOAT64], 0) + return s.newValue2(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(): @@ -3328,6 +3363,8 @@ 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] } diff --git a/src/cmd/compile/internal/gc/testdata/compound_ssa.go b/src/cmd/compile/internal/gc/testdata/compound_ssa.go index 9b84ce4b11..b0e4962f5e 100644 --- a/src/cmd/compile/internal/gc/testdata/compound_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/compound_ssa.go @@ -33,6 +33,58 @@ func testString() { } } +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 { @@ -85,6 +137,8 @@ func main() { testString() testSlice() testInterface() + testComplex64() + testComplex128() if failed { panic("failed") } diff --git a/src/cmd/compile/internal/gc/type.go b/src/cmd/compile/internal/gc/type.go index e2d8925839..cdd9b3f14a 100644 --- a/src/cmd/compile/internal/gc/type.go +++ b/src/cmd/compile/internal/gc/type.go @@ -59,6 +59,10 @@ 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 diff --git a/src/cmd/compile/internal/ssa/config.go b/src/cmd/compile/internal/ssa/config.go index ad6441117c..865066870d 100644 --- a/src/cmd/compile/internal/ssa/config.go +++ b/src/cmd/compile/internal/ssa/config.go @@ -27,6 +27,8 @@ type TypeSource interface { TypeUInt32() Type TypeUInt64() Type TypeInt() Type + TypeFloat32() Type + TypeFloat64() Type TypeUintptr() Type TypeString() Type TypeBytePtr() Type // TODO: use unsafe.Pointer instead? diff --git a/src/cmd/compile/internal/ssa/decompose.go b/src/cmd/compile/internal/ssa/decompose.go index 534ffc269e..a2dfdc16ab 100644 --- a/src/cmd/compile/internal/ssa/decompose.go +++ b/src/cmd/compile/internal/ssa/decompose.go @@ -14,6 +14,8 @@ func decompose(f *Func) { continue } switch { + case v.Type.IsComplex(): + decomposeComplexPhi(v) case v.Type.IsString(): decomposeStringPhi(v) case v.Type.IsSlice(): @@ -72,6 +74,31 @@ func decomposeSlicePhi(v *Value) { v.AddArg(cap) } +func decomposeComplexPhi(v *Value) { + fe := v.Block.Func.Config.fe + var partType Type + if v.Type.Size() == 8 { + partType = fe.TypeFloat32() + } else if v.Type.Size() == 16 { + partType = fe.TypeFloat64() + } else { + panic("Whoops, are sizes in bytes or bits?") + } + + 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.Op = OpComplexMake + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(real) + v.AddArg(imag) +} + func decomposeInterfacePhi(v *Value) { ptrType := v.Block.Func.Config.fe.TypeBytePtr() diff --git a/src/cmd/compile/internal/ssa/export_test.go b/src/cmd/compile/internal/ssa/export_test.go index d2e8216b5d..5b56aa5184 100644 --- a/src/cmd/compile/internal/ssa/export_test.go +++ b/src/cmd/compile/internal/ssa/export_test.go @@ -38,6 +38,8 @@ 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") } diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index 7be00569ea..f77b31501d 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -74,6 +74,36 @@ (PtrIndex ptr idx) -> (AddPtr ptr (MulPtr idx (ConstPtr [t.Elem().Size()]))) (StructSelect [idx] (Load ptr mem)) -> (Load (OffPtr [idx] ptr) mem) +// complex ops +(ComplexReal (ComplexMake real _ )) -> real +(ComplexImag (ComplexMake _ imag )) -> imag + +(Load ptr mem) && t.IsComplex() && t.Size() == 8 -> + (ComplexMake + (Load ptr mem) + (Load + (OffPtr [4] ptr) + mem) + ) +(Store [8] dst (ComplexMake real imag) mem) -> + (Store [4] + (OffPtr [4] dst) + imag + (Store [4] dst real mem)) + +(Load ptr mem) && t.IsComplex() && t.Size() == 16 -> + (ComplexMake + (Load ptr mem) + (Load + (OffPtr [8] ptr) + mem) + ) +(Store [16] dst (ComplexMake real imag) mem) -> + (Store [8] + (OffPtr [8] dst) + imag + (Store [8] dst real mem)) + // string ops (StringPtr (StringMake ptr _)) -> ptr (StringLen (StringMake _ len)) -> len diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 726a62e6be..62d34e74bb 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -334,6 +334,11 @@ var genericOps = []opData{ {name: "SliceLen"}, // len(arg0) {name: "SliceCap"}, // cap(arg0) + // Complex (part/whole) + {name: "ComplexMake"}, // arg0=real, arg1=imag + {name: "ComplexReal"}, // real_part(arg0) + {name: "ComplexImag"}, // imaginary_part(arg0) + // Strings {name: "StringMake"}, // arg0=ptr, arg1=len {name: "StringPtr"}, // ptr(arg0) diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 8d99d57df7..15689b2a85 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -505,6 +505,9 @@ const ( OpSlicePtr OpSliceLen OpSliceCap + OpComplexMake + OpComplexReal + OpComplexImag OpStringMake OpStringPtr OpStringLen @@ -2350,7 +2353,6 @@ var opcodeTable = [...]opInfo{ inputs: []inputInfo{ {0, 8589934592}, // .FLAGS }, - clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -2363,7 +2365,6 @@ var opcodeTable = [...]opInfo{ inputs: []inputInfo{ {0, 8589934592}, // .FLAGS }, - clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -2496,7 +2497,7 @@ var opcodeTable = [...]opInfo{ inputs: []inputInfo{ {0, 8589934592}, // .FLAGS }, - clobbers: 8589934593, // .AX .FLAGS + clobbers: 1, // .AX outputs: []regMask{ 65518, // .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -2509,7 +2510,7 @@ var opcodeTable = [...]opInfo{ inputs: []inputInfo{ {0, 8589934592}, // .FLAGS }, - clobbers: 8589934593, // .AX .FLAGS + clobbers: 1, // .AX outputs: []regMask{ 65518, // .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -2522,7 +2523,6 @@ var opcodeTable = [...]opInfo{ inputs: []inputInfo{ {0, 8589934592}, // .FLAGS }, - clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -2535,7 +2535,6 @@ var opcodeTable = [...]opInfo{ inputs: []inputInfo{ {0, 8589934592}, // .FLAGS }, - clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -2548,7 +2547,6 @@ var opcodeTable = [...]opInfo{ inputs: []inputInfo{ {0, 8589934592}, // .FLAGS }, - clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -2561,7 +2559,6 @@ var opcodeTable = [...]opInfo{ inputs: []inputInfo{ {0, 8589934592}, // .FLAGS }, - clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -4032,6 +4029,18 @@ var opcodeTable = [...]opInfo{ name: "SliceCap", generic: true, }, + { + name: "ComplexMake", + generic: true, + }, + { + name: "ComplexReal", + generic: true, + }, + { + name: "ComplexImag", + generic: true, + }, { name: "StringMake", generic: true, diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index bd53e05230..b14ed9c21e 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -237,6 +237,46 @@ func rewriteValuegeneric(v *Value, config *Config) bool { goto end4d92ff3ba567d9afd38fc9ca113602ad end4d92ff3ba567d9afd38fc9ca113602ad: ; + case OpComplexImag: + // match: (ComplexImag (ComplexMake _ imag )) + // cond: + // result: imag + { + if v.Args[0].Op != OpComplexMake { + goto endec3009fd8727d03002021997936e091f + } + imag := v.Args[0].Args[1] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = imag.Type + v.AddArg(imag) + return true + } + goto endec3009fd8727d03002021997936e091f + endec3009fd8727d03002021997936e091f: + ; + case OpComplexReal: + // match: (ComplexReal (ComplexMake real _ )) + // cond: + // result: real + { + if v.Args[0].Op != OpComplexMake { + goto end8db3e16bd59af1adaa4b734c8adcc71d + } + real := v.Args[0].Args[0] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = real.Type + v.AddArg(real) + return true + } + goto end8db3e16bd59af1adaa4b734c8adcc71d + end8db3e16bd59af1adaa4b734c8adcc71d: + ; case OpConstInterface: // match: (ConstInterface) // cond: @@ -569,6 +609,72 @@ func rewriteValuegeneric(v *Value, config *Config) bool { end84d6ae817944985f572ecaac51999d6c: ; case OpLoad: + // match: (Load ptr mem) + // cond: t.IsComplex() && t.Size() == 8 + // result: (ComplexMake (Load ptr mem) (Load (OffPtr [4] ptr) mem) ) + { + t := v.Type + ptr := v.Args[0] + mem := v.Args[1] + if !(t.IsComplex() && t.Size() == 8) { + goto end665854b31b828893d90b36bb462ff381 + } + v.Op = OpComplexMake + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpLoad, TypeInvalid) + v0.Type = config.fe.TypeFloat32() + v0.AddArg(ptr) + v0.AddArg(mem) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpLoad, TypeInvalid) + v1.Type = config.fe.TypeFloat32() + v2 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) + v2.Type = config.fe.TypeFloat32().PtrTo() + v2.AuxInt = 4 + v2.AddArg(ptr) + v1.AddArg(v2) + v1.AddArg(mem) + v.AddArg(v1) + return true + } + goto end665854b31b828893d90b36bb462ff381 + end665854b31b828893d90b36bb462ff381: + ; + // match: (Load ptr mem) + // cond: t.IsComplex() && t.Size() == 16 + // result: (ComplexMake (Load ptr mem) (Load (OffPtr [8] ptr) mem) ) + { + t := v.Type + ptr := v.Args[0] + mem := v.Args[1] + if !(t.IsComplex() && t.Size() == 16) { + goto end1b106f89e0e3e26c613b957a7c98d8ad + } + v.Op = OpComplexMake + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpLoad, TypeInvalid) + v0.Type = config.fe.TypeFloat64() + v0.AddArg(ptr) + v0.AddArg(mem) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpLoad, TypeInvalid) + v1.Type = config.fe.TypeFloat64() + v2 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) + v2.Type = config.fe.TypeFloat64().PtrTo() + v2.AuxInt = 8 + v2.AddArg(ptr) + v1.AddArg(v2) + v1.AddArg(mem) + v.AddArg(v1) + return true + } + goto end1b106f89e0e3e26c613b957a7c98d8ad + end1b106f89e0e3e26c613b957a7c98d8ad: + ; // match: (Load ptr mem) // cond: t.IsString() // result: (StringMake (Load ptr mem) (Load (OffPtr [config.PtrSize] ptr) mem)) @@ -1017,6 +1123,80 @@ func rewriteValuegeneric(v *Value, config *Config) bool { end526acc0a705137a5d25577499206720b: ; case OpStore: + // match: (Store [8] dst (ComplexMake real imag) mem) + // cond: + // result: (Store [4] (OffPtr [4] dst) imag (Store [4] dst real mem)) + { + if v.AuxInt != 8 { + goto endba187c049aa71488994c8a2eb3453045 + } + dst := v.Args[0] + if v.Args[1].Op != OpComplexMake { + goto endba187c049aa71488994c8a2eb3453045 + } + real := v.Args[1].Args[0] + imag := v.Args[1].Args[1] + mem := v.Args[2] + v.Op = OpStore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 4 + v0 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) + v0.Type = config.fe.TypeFloat32().PtrTo() + v0.AuxInt = 4 + v0.AddArg(dst) + v.AddArg(v0) + v.AddArg(imag) + v1 := b.NewValue0(v.Line, OpStore, TypeInvalid) + v1.Type = TypeMem + v1.AuxInt = 4 + v1.AddArg(dst) + v1.AddArg(real) + v1.AddArg(mem) + v.AddArg(v1) + return true + } + goto endba187c049aa71488994c8a2eb3453045 + endba187c049aa71488994c8a2eb3453045: + ; + // match: (Store [16] dst (ComplexMake real imag) mem) + // cond: + // result: (Store [8] (OffPtr [8] dst) imag (Store [8] dst real mem)) + { + if v.AuxInt != 16 { + goto end4df4c826201cf51af245d6b89de00589 + } + dst := v.Args[0] + if v.Args[1].Op != OpComplexMake { + goto end4df4c826201cf51af245d6b89de00589 + } + real := v.Args[1].Args[0] + imag := v.Args[1].Args[1] + mem := v.Args[2] + v.Op = OpStore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 8 + v0 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) + v0.Type = config.fe.TypeFloat64().PtrTo() + v0.AuxInt = 8 + v0.AddArg(dst) + v.AddArg(v0) + v.AddArg(imag) + v1 := b.NewValue0(v.Line, OpStore, TypeInvalid) + v1.Type = TypeMem + v1.AuxInt = 8 + v1.AddArg(dst) + v1.AddArg(real) + v1.AddArg(mem) + v.AddArg(v1) + return true + } + goto end4df4c826201cf51af245d6b89de00589 + end4df4c826201cf51af245d6b89de00589: + ; // match: (Store [2*config.PtrSize] dst (StringMake ptr len) mem) // cond: // result: (Store [config.PtrSize] (OffPtr [config.PtrSize] dst) len (Store [config.PtrSize] dst ptr mem)) diff --git a/src/cmd/compile/internal/ssa/type.go b/src/cmd/compile/internal/ssa/type.go index 15dbddd1fc..decde6889e 100644 --- a/src/cmd/compile/internal/ssa/type.go +++ b/src/cmd/compile/internal/ssa/type.go @@ -16,6 +16,7 @@ type Type interface { IsInteger() bool // ... ditto for the others IsSigned() bool IsFloat() bool + IsComplex() bool IsPtr() bool IsString() bool IsSlice() bool @@ -39,12 +40,13 @@ type CompilerType struct { Flags bool } -func (t *CompilerType) Size() int64 { return 0 } +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 } diff --git a/src/cmd/compile/internal/ssa/type_test.go b/src/cmd/compile/internal/ssa/type_test.go index 5f0413c397..b106688e84 100644 --- a/src/cmd/compile/internal/ssa/type_test.go +++ b/src/cmd/compile/internal/ssa/type_test.go @@ -12,6 +12,7 @@ type TypeImpl struct { Integer bool Signed bool Float bool + Complex bool Ptr bool string bool slice bool @@ -27,6 +28,7 @@ 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 } @@ -48,14 +50,18 @@ func (t *TypeImpl) Equal(u Type) bool { 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"} - 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"} + 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"} ) -- cgit v1.3 From f8093b8f2491171c996c4820fe7b9a2796ac1084 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Fri, 28 Aug 2015 12:53:41 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: add arg-dominating check, fix phielim Add a check to make sure value arguments dominate the value. Phi elim output used to fail this test. When eliminating redundant phis, phi elim was using one of the args and not the ultimate source. For example: b1: x = ... -> b2 b3 b2: y = Copy x b3: z = Copy x -> b4 -> b4 b4: w = phi y z Phi elim eliminates w, but it used to replace w with (Copy y). That's bad as b2 does not dominate b4. Instead we should replace w with (Copy x). Fixes #12347 Change-Id: I9f340cdabcda8e2e90359fb4f9250877b1fffe98 Reviewed-on: https://go-review.googlesource.com/13986 Reviewed-by: David Chase --- src/cmd/compile/internal/ssa/check.go | 41 +++++++++++++++++++++++++++++++++ src/cmd/compile/internal/ssa/phielim.go | 26 ++++++++------------- 2 files changed, 51 insertions(+), 16 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/check.go b/src/cmd/compile/internal/ssa/check.go index 61626089a6..ad9222f3e2 100644 --- a/src/cmd/compile/internal/ssa/check.go +++ b/src/cmd/compile/internal/ssa/check.go @@ -181,4 +181,45 @@ func checkFunc(f *Func) { f.Fatalf("used value v%d in free list", 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) + 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, idom, x, y) { + f.Fatalf("arg %d of value %s does not dominate", i, v.LongString()) + } + } + } + if b.Control != nil && !domCheck(f, idom, 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, idom []*Block, x, y *Block) bool { + if y != f.Entry && idom[y.ID] == nil { + // unreachable - ignore + return true + } + for { + if x == y { + return true + } + y = idom[y.ID] + if y == nil { + return false + } + } } diff --git a/src/cmd/compile/internal/ssa/phielim.go b/src/cmd/compile/internal/ssa/phielim.go index 19c0d077e5..be9503248b 100644 --- a/src/cmd/compile/internal/ssa/phielim.go +++ b/src/cmd/compile/internal/ssa/phielim.go @@ -11,33 +11,27 @@ package ssa // v = phi(x,x,x) // v = phi(x,v,x,v) func phielim(f *Func) { - args := newSparseSet(f.NumValues()) + argSet := newSparseSet(f.NumValues()) + var args []*Value for _, b := range f.Blocks { for _, v := range b.Values { if v.Op != OpPhi { continue } - args.clear() + argSet.clear() + args = args[:0] for _, x := range v.Args { for x.Op == OpCopy { x = x.Args[0] } - args.add(x.ID) - } - switch { - case args.size() == 1: - v.Op = OpCopy - v.SetArgs1(v.Args[0]) - case args.size() == 2 && args.contains(v.ID): - var w *Value - for _, x := range v.Args { - if x.ID != v.ID { - w = x - break - } + if x != v && !argSet.contains(x.ID) { + argSet.add(x.ID) + args = append(args, x) } + } + if len(args) == 1 { v.Op = OpCopy - v.SetArgs1(w) + v.SetArgs1(args[0]) } } } -- cgit v1.3 From 67ac8a3b22d07e9655f3909ddeffb310d12e50db Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Fri, 28 Aug 2015 15:20:54 -0500 Subject: [dev.ssa] cmd/compile: fix type of nil ptr in check Change-Id: If7a6ab6b1336dbacb006f562be7f153eb93e7253 Reviewed-on: https://go-review.googlesource.com/14025 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 94fdf0e489..a465a6fc1b 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -2039,7 +2039,8 @@ func (s *state) lenMap(n *Node, x *ssa.Value) *ssa.Value { // return *((*int)n) // } lenType := n.Type - cmp := s.newValue2(ssa.OpEqPtr, Types[TBOOL], x, s.zeroVal(lenType)) + 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 -- cgit v1.3 From a5cffb6182801f6e164089ce872a4fb622c0f0d9 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Fri, 28 Aug 2015 13:52:26 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: allocate complex zero in the entry block Fixes build. There may be no current block. Change-Id: I0da8bab133dc207124556927698e7cd682e64ef5 Reviewed-on: https://go-review.googlesource.com/13989 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index a465a6fc1b..0194a52c2b 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1681,10 +1681,10 @@ func (s *state) zeroVal(t *Type) *ssa.Value { switch t.Size() { case 8: z := s.constFloat32(Types[TFLOAT32], 0) - return s.newValue2(ssa.OpComplexMake, t, z, z) + return s.entryNewValue2(ssa.OpComplexMake, t, z, z) case 16: z := s.constFloat64(Types[TFLOAT64], 0) - return s.newValue2(ssa.OpComplexMake, t, z, z) + return s.entryNewValue2(ssa.OpComplexMake, t, z, z) default: s.Fatalf("bad sized complex type %s", t) } -- cgit v1.3 From 73151067bc7b58c56825a4cc59282aef09aaaed8 Mon Sep 17 00:00:00 2001 From: David Chase Date: Wed, 26 Aug 2015 14:25:40 -0400 Subject: [dev.ssa] cmd/compile: added floating point to [u]int conversions Change-Id: I8dee400aef07165f911750de2615b8757f826000 Reviewed-on: https://go-review.googlesource.com/13945 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 140 ++++++++++++- src/cmd/compile/internal/gc/testdata/fp_ssa.go | 260 ++++++++++++++++++++++++- 2 files changed, 395 insertions(+), 5 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 0194a52c2b..5614a6c3b9 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1253,7 +1253,6 @@ func (s *state) expr(n *Node) *ssa.Value { return s.newValue1(op, n.Type, x) } - var op1, op2 ssa.Op if ft.IsInteger() && tt.IsFloat() { // signed 1, 2, 4, 8, unsigned 6, 7, 9, 13 signedSize := ft.Size() @@ -1261,6 +1260,7 @@ func (s *state) expr(n *Node) *ssa.Value { if !ft.IsSigned() { signedSize += 5 } + var op1, op2 ssa.Op switch signedSize { case 1: op1 = ssa.OpSignExt8to32 @@ -1315,6 +1315,72 @@ func (s *state) expr(n *Node) *ssa.Value { } return s.newValue1(op2, n.Type, s.newValue1(op1, Types[it], x)) } + + if tt.IsInteger() && ft.IsFloat() { + // signed 1, 2, 4, 8, unsigned 6, 7, 9, 13 + signedSize := tt.Size() + it := TINT32 // intermediate type in conversion, int32 or int64 + if !tt.IsSigned() { + signedSize += 5 + } + var op1, op2 ssa.Op + switch signedSize { + case 1: + op2 = ssa.OpTrunc32to8 + case 2: + op2 = ssa.OpTrunc32to16 + case 4: + op2 = ssa.OpCopy + case 8: + op2 = ssa.OpCopy + it = TINT64 + case 6: + op2 = ssa.OpTrunc32to8 + case 7: + op2 = ssa.OpTrunc32to16 + case 9: + // Go wide to dodge the unsignedness correction + op2 = ssa.OpTrunc64to32 + it = TINT64 + case 13: + // unsigned 64, branchy correction code is needed + // because there is only FP to signed-integer + // conversion in the (AMD64) instructions set. + // Branchy correction code *may* be amenable to + // optimization, and it can be cleanly expressed + // in generic SSA, so do it here. + if ft.Size() == 4 { + return s.float32ToUint64(n, x, ft, tt) + } + if ft.Size() == 8 { + return s.float64ToUint64(n, x, ft, tt) + } + // unrecognized size is also "weird", hence fatal. + fallthrough + + default: + s.Fatalf("weird float to integer conversion %s -> %s", ft, tt) + + } + if ft.Size() == 4 { + if it == TINT64 { + op1 = ssa.OpCvt32Fto64 + } else { + op1 = ssa.OpCvt32Fto32 + } + } else { + if it == TINT64 { + op1 = ssa.OpCvt64Fto64 + } else { + op1 = ssa.OpCvt64Fto32 + } + } + if op2 == ssa.OpCopy { + return s.newValue1(op1, n.Type, x) + } + return s.newValue1(op2, n.Type, s.newValue1(op1, Types[it], x)) + } + if ft.IsFloat() && tt.IsFloat() { var op ssa.Op if ft.Size() == tt.Size() { @@ -1328,7 +1394,7 @@ func (s *state) expr(n *Node) *ssa.Value { } return s.newValue1(op, n.Type, x) } - // TODO: Still lack float-to-int + // TODO: Still lack complex conversions. s.Unimplementedf("unhandled OCONV %s -> %s", Econv(int(n.Left.Type.Etype), 0), Econv(int(n.Type.Etype), 0)) return nil @@ -1981,8 +2047,8 @@ func (s *state) uintTofloat(cvttab *u2fcvtTab, n *Node, x *ssa.Value, ft, tt *Ty // z = uintX(x) ; z = z >> 1 // z = z >> 1 // z = z | y - // result = (floatY) z - // z = z + z + // result = floatY(z) + // result = result + result // } // // Code borrowed from old code generator. @@ -2068,6 +2134,72 @@ func (s *state) lenMap(n *Node, x *ssa.Value) *ssa.Value { 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) + + addEdge(b, bThen) + s.startBlock(bThen) + a0 := s.newValue1(cvttab.cvt2U, tt, x) + s.vars[n] = a0 + s.endBlock() + addEdge(bThen, bAfter) + + addEdge(b, 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() + addEdge(bElse, bAfter) + + s.startBlock(bAfter) + return s.variable(n, n.Type) +} + // 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, diff --git a/src/cmd/compile/internal/gc/testdata/fp_ssa.go b/src/cmd/compile/internal/gc/testdata/fp_ssa.go index 5eb65035d4..c9eb23d371 100644 --- a/src/cmd/compile/internal/gc/testdata/fp_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/fp_ssa.go @@ -1052,6 +1052,222 @@ func gtbr32_ssa(x, y float32) float32 { 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(1.0, 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 { @@ -1106,7 +1322,47 @@ func expect32(s string, x, expected float32) int { func expectUint64(s string, x, expected uint64) int { if x != expected { - fmt.Printf("Expected 0x%016x for %s, got 0x%016x\n", expected, s, x) + fmt.Printf("%s: Expected 0x%016x, got 0x%016x\n", s, expected, 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 @@ -1266,6 +1522,8 @@ func main() { fails += expectUint64("gt", gt, 0x0000100011000000) } + fails += floatingToIntegerConversionsTest() + if fails > 0 { fmt.Printf("Saw %v failures\n", fails) panic("Failed.") -- cgit v1.3 From 707af252d9041a5a618e15d2f3683f7d57b4d34c Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Fri, 28 Aug 2015 15:56:43 -0500 Subject: [dev.ssa] cmd/compile: implement len/cap(chan) Change-Id: I1453ba226376ccd4d79780fc0686876d6dde01ee Reviewed-on: https://go-review.googlesource.com/14027 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 34 +++++++---- src/cmd/compile/internal/gc/testdata/chan_ssa.go | 76 ++++++++++++++++++++++++ 2 files changed, 97 insertions(+), 13 deletions(-) create mode 100644 src/cmd/compile/internal/gc/testdata/chan_ssa.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 5614a6c3b9..c92c82da1d 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1528,15 +1528,8 @@ func (s *state) expr(n *Node) *ssa.Value { 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(): - return s.lenMap(n, s.expr(n.Left)) - case n.Left.Type.IsChan(): - if n.Op == OCAP { - s.Unimplementedf("unhandled cap(chan)") - } else { - s.Unimplementedf("unhandled len(chan)") - } - return nil + 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) } @@ -2098,11 +2091,18 @@ func (s *state) uintTofloat(cvttab *u2fcvtTab, n *Node, x *ssa.Value, ft, tt *Ty return s.variable(n, n.Type) } -func (s *state) lenMap(n *Node, x *ssa.Value) *ssa.Value { +// 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]) @@ -2116,17 +2116,25 @@ func (s *state) lenMap(n *Node, x *ssa.Value) *ssa.Value { bElse := s.f.NewBlock(ssa.BlockPlain) bAfter := s.f.NewBlock(ssa.BlockPlain) - // length of a nil map is zero + // length/capacity of a nil map/chan is zero addEdge(b, bThen) s.startBlock(bThen) s.vars[n] = s.zeroVal(lenType) s.endBlock() addEdge(bThen, bAfter) - // the length is stored in the first word addEdge(b, bElse) s.startBlock(bElse) - s.vars[n] = s.newValue2(ssa.OpLoad, lenType, x, s.mem()) + 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() addEdge(bElse, bAfter) 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 0000000000..c527ba95be --- /dev/null +++ b/src/cmd/compile/internal/gc/testdata/chan_ssa.go @@ -0,0 +1,76 @@ +// 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 + +func lenChan_ssa(v chan int) int { + switch { // prevent inlining + + } + return len(v) +} +func capChan_ssa(v chan int) int { + switch { // prevent inlining + + } + 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") + } +} -- cgit v1.3 From 67e43c1e3b3e2470b870a9d5b5e6eedceeded5f1 Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Fri, 28 Aug 2015 21:19:40 -0500 Subject: [dev.ssa] cmd/compile: implement OFALL Frontend has already rewriten fallthrough statements, we just need to ignore them. Change-Id: Iadf89b06a9f8f9e6e2e1e87c934f31add77a19a1 Reviewed-on: https://go-review.googlesource.com/14029 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/gc/ssa.go | 2 +- src/cmd/compile/internal/gc/testdata/ctl_ssa.go | 60 +++++++++++++++++++++++++ 2 files changed, 61 insertions(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index c92c82da1d..08a3ac2635 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -430,7 +430,7 @@ func (s *state) stmt(n *Node) { s.stmtList(n.List) // No-ops - case OEMPTY, ODCLCONST, ODCLTYPE: + case OEMPTY, ODCLCONST, ODCLTYPE, OFALL: // Expression statements case OCALLFUNC, OCALLMETH, OCALLINTER: diff --git a/src/cmd/compile/internal/gc/testdata/ctl_ssa.go b/src/cmd/compile/internal/gc/testdata/ctl_ssa.go index f7c3b80799..49050110e5 100644 --- a/src/cmd/compile/internal/gc/testdata/ctl_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/ctl_ssa.go @@ -57,11 +57,71 @@ func testEmptyRange() { } } +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) + } + } +} + +func testSwitch() { + for i := 0; i < 6; i++ { + if got := switch_ssa(i); got != i { + println("switch_ssa(i) =", got, "wanted", i) + } + } +} + var failed = false func main() { testPhiControl() testEmptyRange() + + testSwitch() + testFallthrough() + if failed { panic("failed") } -- cgit v1.3 From 47d6799b0f1d51f8f749eeebfe5769ea555b5228 Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Fri, 28 Aug 2015 21:36:29 -0500 Subject: [dev.ssa] cmd/compile: move addEdge function to ssa addEdge had two identical implementations so make it an exported method on Block. Change-Id: I8c21655a9dc5074fefd7f63b2f5b51897571e608 Reviewed-on: https://go-review.googlesource.com/14040 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 96 +++++++++++++++---------------- src/cmd/compile/internal/ssa/block.go | 7 +++ src/cmd/compile/internal/ssa/func_test.go | 7 +-- 3 files changed, 53 insertions(+), 57 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 08a3ac2635..c00ab59acd 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -114,7 +114,7 @@ func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { // fallthrough to exit if b := s.endBlock(); b != nil { - addEdge(b, s.exit) + b.AddEdgeTo(s.exit) } // Finish up exit block @@ -487,7 +487,7 @@ func (s *state) stmt(n *Node) { // go to that label (we pretend "label:" is preceded by "goto label") b := s.endBlock() - addEdge(b, lab.target) + b.AddEdgeTo(lab.target) s.startBlock(lab.target) case OGOTO: @@ -508,7 +508,7 @@ func (s *state) stmt(n *Node) { } b := s.endBlock() - addEdge(b, lab.target) + b.AddEdgeTo(lab.target) case OAS, OASWB: // Check whether we can generate static data rather than code. @@ -536,25 +536,25 @@ func (s *state) stmt(n *Node) { var bElse *ssa.Block if n.Rlist == nil { - addEdge(b, bThen) - addEdge(b, bEnd) + b.AddEdgeTo(bThen) + b.AddEdgeTo(bEnd) } else { bElse = s.f.NewBlock(ssa.BlockPlain) - addEdge(b, bThen) - addEdge(b, bElse) + b.AddEdgeTo(bThen) + b.AddEdgeTo(bElse) } s.startBlock(bThen) s.stmtList(n.Nbody) if b := s.endBlock(); b != nil { - addEdge(b, bEnd) + b.AddEdgeTo(bEnd) } if n.Rlist != nil { s.startBlock(bElse) s.stmtList(n.Rlist) if b := s.endBlock(); b != nil { - addEdge(b, bEnd) + b.AddEdgeTo(bEnd) } } s.startBlock(bEnd) @@ -562,7 +562,7 @@ func (s *state) stmt(n *Node) { case ORETURN: s.stmtList(n.List) b := s.endBlock() - addEdge(b, s.exit) + b.AddEdgeTo(s.exit) case OCONTINUE, OBREAK: var op string @@ -614,7 +614,7 @@ func (s *state) stmt(n *Node) { } b := s.endBlock() - addEdge(b, to) + b.AddEdgeTo(to) case OFOR: // OFOR: for Ninit; Left; Right { Nbody } @@ -625,7 +625,7 @@ func (s *state) stmt(n *Node) { // first, jump to condition test b := s.endBlock() - addEdge(b, bCond) + b.AddEdgeTo(bCond) // generate code to test condition s.startBlock(bCond) @@ -639,8 +639,8 @@ func (s *state) stmt(n *Node) { b.Kind = ssa.BlockIf b.Control = cond b.Likely = ssa.BranchLikely - addEdge(b, bBody) - addEdge(b, bEnd) + b.AddEdgeTo(bBody) + b.AddEdgeTo(bEnd) // set up for continue/break in body prevContinue := s.continueTo @@ -668,7 +668,7 @@ func (s *state) stmt(n *Node) { // done with body, goto incr if b := s.endBlock(); b != nil { - addEdge(b, bIncr) + b.AddEdgeTo(bIncr) } // generate incr @@ -677,7 +677,7 @@ func (s *state) stmt(n *Node) { s.stmt(n.Right) } if b := s.endBlock(); b != nil { - addEdge(b, bCond) + b.AddEdgeTo(bCond) } s.startBlock(bEnd) @@ -703,7 +703,7 @@ func (s *state) stmt(n *Node) { } if b := s.endBlock(); b != nil { - addEdge(b, bEnd) + b.AddEdgeTo(bEnd) } s.startBlock(bEnd) @@ -1447,11 +1447,11 @@ func (s *state) expr(n *Node) *ssa.Value { bRight := s.f.NewBlock(ssa.BlockPlain) bResult := s.f.NewBlock(ssa.BlockPlain) if n.Op == OANDAND { - addEdge(b, bRight) - addEdge(b, bResult) + b.AddEdgeTo(bRight) + b.AddEdgeTo(bResult) } else if n.Op == OOROR { - addEdge(b, bResult) - addEdge(b, bRight) + b.AddEdgeTo(bResult) + b.AddEdgeTo(bRight) } s.startBlock(bRight) @@ -1459,7 +1459,7 @@ func (s *state) expr(n *Node) *ssa.Value { s.vars[n] = er b = s.endBlock() - addEdge(b, bResult) + b.AddEdgeTo(bResult) s.startBlock(bResult) return s.variable(n, Types[TBOOL]) @@ -1599,15 +1599,15 @@ func (s *state) expr(n *Node) *ssa.Value { // Generate code for non-zero length slice case. nz := s.f.NewBlock(ssa.BlockPlain) - addEdge(b, nz) + b.AddEdgeTo(nz) s.startBlock(nz) s.vars[n] = s.newValue2(ssa.OpAddPtr, Ptrto(Types[TUINT8]), ptr, low) s.endBlock() // All done. merge := s.f.NewBlock(ssa.BlockPlain) - addEdge(b, merge) - addEdge(nz, merge) + b.AddEdgeTo(merge) + nz.AddEdgeTo(merge) s.startBlock(merge) return s.newValue2(ssa.OpStringMake, Types[TSTRING], s.variable(n, Ptrto(Types[TUINT8])), rlen) @@ -1654,8 +1654,8 @@ func (s *state) expr(n *Node) *ssa.Value { b := s.endBlock() b.Kind = ssa.BlockCall b.Control = call - addEdge(b, bNext) - addEdge(b, s.exit) + b.AddEdgeTo(bNext) + b.AddEdgeTo(s.exit) // read result from stack at the start of the fallthrough block s.startBlock(bNext) @@ -1928,9 +1928,9 @@ func (s *state) nilCheck(ptr *ssa.Value) { b.Likely = ssa.BranchLikely bNext := s.f.NewBlock(ssa.BlockPlain) bPanic := s.f.NewBlock(ssa.BlockPlain) - addEdge(b, bNext) - addEdge(b, bPanic) - addEdge(bPanic, s.exit) + b.AddEdgeTo(bNext) + b.AddEdgeTo(bPanic) + bPanic.AddEdgeTo(s.exit) s.startBlock(bPanic) // TODO: implicit nil checks somehow? s.vars[&memvar] = s.newValue2(ssa.OpPanicNilCheck, ssa.TypeMem, ptr, s.mem()) @@ -1974,9 +1974,9 @@ func (s *state) check(cmp *ssa.Value, panicOp ssa.Op) { b.Likely = ssa.BranchLikely bNext := s.f.NewBlock(ssa.BlockPlain) bPanic := s.f.NewBlock(ssa.BlockPlain) - addEdge(b, bNext) - addEdge(b, bPanic) - addEdge(bPanic, s.exit) + b.AddEdgeTo(bNext) + b.AddEdgeTo(bPanic) + bPanic.AddEdgeTo(s.exit) s.startBlock(bPanic) // The panic check takes/returns memory to ensure that the right // memory state is observed if the panic happens. @@ -2068,14 +2068,14 @@ func (s *state) uintTofloat(cvttab *u2fcvtTab, n *Node, x *ssa.Value, ft, tt *Ty bElse := s.f.NewBlock(ssa.BlockPlain) bAfter := s.f.NewBlock(ssa.BlockPlain) - addEdge(b, bThen) + b.AddEdgeTo(bThen) s.startBlock(bThen) a0 := s.newValue1(cvttab.cvt2F, tt, x) s.vars[n] = a0 s.endBlock() - addEdge(bThen, bAfter) + bThen.AddEdgeTo(bAfter) - addEdge(b, bElse) + b.AddEdgeTo(bElse) s.startBlock(bElse) one := cvttab.one(s, ft, 1) y := s.newValue2(cvttab.and, ft, x, one) @@ -2085,7 +2085,7 @@ func (s *state) uintTofloat(cvttab *u2fcvtTab, n *Node, x *ssa.Value, ft, tt *Ty a1 := s.newValue2(cvttab.add, tt, a, a) s.vars[n] = a1 s.endBlock() - addEdge(bElse, bAfter) + bElse.AddEdgeTo(bAfter) s.startBlock(bAfter) return s.variable(n, n.Type) @@ -2117,13 +2117,13 @@ func (s *state) referenceTypeBuiltin(n *Node, x *ssa.Value) *ssa.Value { bAfter := s.f.NewBlock(ssa.BlockPlain) // length/capacity of a nil map/chan is zero - addEdge(b, bThen) + b.AddEdgeTo(bThen) s.startBlock(bThen) s.vars[n] = s.zeroVal(lenType) s.endBlock() - addEdge(bThen, bAfter) + bThen.AddEdgeTo(bAfter) - addEdge(b, bElse) + b.AddEdgeTo(bElse) s.startBlock(bElse) if n.Op == OLEN { // length is stored in the first word for map/chan @@ -2136,7 +2136,7 @@ func (s *state) referenceTypeBuiltin(n *Node, x *ssa.Value) *ssa.Value { s.Fatalf("op must be OLEN or OCAP") } s.endBlock() - addEdge(bElse, bAfter) + bElse.AddEdgeTo(bAfter) s.startBlock(bAfter) return s.variable(n, lenType) @@ -2187,14 +2187,14 @@ func (s *state) floatToUint(cvttab *f2uCvtTab, n *Node, x *ssa.Value, ft, tt *Ty bElse := s.f.NewBlock(ssa.BlockPlain) bAfter := s.f.NewBlock(ssa.BlockPlain) - addEdge(b, bThen) + b.AddEdgeTo(bThen) s.startBlock(bThen) a0 := s.newValue1(cvttab.cvt2U, tt, x) s.vars[n] = a0 s.endBlock() - addEdge(bThen, bAfter) + bThen.AddEdgeTo(bAfter) - addEdge(b, bElse) + b.AddEdgeTo(bElse) s.startBlock(bElse) y := s.newValue2(cvttab.subf, ft, x, twoToThe63) y = s.newValue1(cvttab.cvt2U, tt, y) @@ -2202,7 +2202,7 @@ func (s *state) floatToUint(cvttab *f2uCvtTab, n *Node, x *ssa.Value, ft, tt *Ty a1 := s.newValue2(ssa.OpOr64, tt, y, z) s.vars[n] = a1 s.endBlock() - addEdge(bElse, bAfter) + bElse.AddEdgeTo(bAfter) s.startBlock(bAfter) return s.variable(n, n.Type) @@ -2366,12 +2366,6 @@ func (s *state) lookupVarOutgoing(b *ssa.Block, t ssa.Type, name *Node) *ssa.Val // TODO: the above mutually recursive functions can lead to very deep stacks. Fix that. -// addEdge adds an edge from b to c. -func addEdge(b, c *ssa.Block) { - b.Succs = append(b.Succs, c) - c.Preds = append(c.Preds, b) -} - // an unresolved branch type branch struct { p *obj.Prog // branch instruction diff --git a/src/cmd/compile/internal/ssa/block.go b/src/cmd/compile/internal/ssa/block.go index a67cdb5ac6..1d5e617c55 100644 --- a/src/cmd/compile/internal/ssa/block.go +++ b/src/cmd/compile/internal/ssa/block.go @@ -83,6 +83,13 @@ func (b *Block) LongString() string { 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) Fatalf(msg string, args ...interface{}) { b.Func.Fatalf(msg, args...) } func (b *Block) Unimplementedf(msg string, args ...interface{}) { b.Func.Unimplementedf(msg, args...) } diff --git a/src/cmd/compile/internal/ssa/func_test.go b/src/cmd/compile/internal/ssa/func_test.go index 4bdc84bd4c..dc5d220db8 100644 --- a/src/cmd/compile/internal/ssa/func_test.go +++ b/src/cmd/compile/internal/ssa/func_test.go @@ -179,7 +179,7 @@ func Fun(c *Config, entry string, blocs ...bloc) fun { } // Connect to successors. for _, succ := range c.succs { - addEdge(b, blocks[succ]) + b.AddEdgeTo(blocks[succ]) } } return fun{f, blocks, values} @@ -256,11 +256,6 @@ type valu struct { args []string } -func addEdge(b, c *Block) { - b.Succs = append(b.Succs, c) - c.Preds = append(c.Preds, b) -} - func TestArgs(t *testing.T) { c := testConfig(t) fun := Fun(c, "entry", -- cgit v1.3 From 9654873a76f3234e55951b80f085e86b1ba9d754 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Fri, 28 Aug 2015 13:35:32 -0700 Subject: [dev.ssa] cmd/compile: implement PPARAMREF This also fixes the encoding/gob TestTopLevelNilPointer failure. Change-Id: I9b29a6fddffd51af305c685f3a8e2a0594bfeeab Reviewed-on: https://go-review.googlesource.com/14032 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index c00ab59acd..ca9943d81f 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1800,7 +1800,7 @@ func (s *state) addr(n *Node) *ssa.Value { s.Fatalf("addr of undeclared ONAME %v. declared: %v", n, s.decladdrs) } return v - case PAUTO | PHEAP: + case PAUTO | PHEAP, PPARAMREF: return s.expr(n.Name.Heapaddr) default: s.Unimplementedf("variable address class %v not implemented", n.Class) @@ -1864,10 +1864,8 @@ func canSSA(n *Node) bool { if n.Class&PHEAP != 0 { return false } - if n.Class == PEXTERN { - return false - } - if n.Class == PPARAMOUT { + switch n.Class { + case PEXTERN, PPARAMOUT, PPARAMREF: return false } return canSSAType(n.Type) -- cgit v1.3 From 186cf1b9ba1358344b8ce6f2fb4a62302b98ba90 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Fri, 28 Aug 2015 16:45:17 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: handle dead code a different way Instead of trying to delete dead code as soon as we find it, just mark it as dead using a PlainAndDead block kind. The deadcode pass will do the real removal. This way is somewhat more efficient because we don't need to mess with successor and predecessor lists of all the dead blocks. Fixes #12347 Change-Id: Ia42d6b5f9cdb3215a51737b3eb117c00bd439b13 Reviewed-on: https://go-review.googlesource.com/14033 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/ssa/check.go | 7 + src/cmd/compile/internal/ssa/deadcode.go | 186 +++++++++++++------------ src/cmd/compile/internal/ssa/gen/generic.rules | 6 +- src/cmd/compile/internal/ssa/gen/genericOps.go | 2 +- src/cmd/compile/internal/ssa/gen/rulegen.go | 5 +- src/cmd/compile/internal/ssa/nilcheck.go | 8 +- src/cmd/compile/internal/ssa/opGen.go | 2 + src/cmd/compile/internal/ssa/rewritegeneric.go | 49 +++---- test/fixedbugs/issue12347.go | 16 +++ 9 files changed, 154 insertions(+), 127 deletions(-) create mode 100644 test/fixedbugs/issue12347.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/check.go b/src/cmd/compile/internal/ssa/check.go index ad9222f3e2..0c2bc4c7f1 100644 --- a/src/cmd/compile/internal/ssa/check.go +++ b/src/cmd/compile/internal/ssa/check.go @@ -99,6 +99,13 @@ func checkFunc(f *Func) { if !b.Control.Type.IsMemory() { f.Fatalf("call block %s has non-memory 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)) diff --git a/src/cmd/compile/internal/ssa/deadcode.go b/src/cmd/compile/internal/ssa/deadcode.go index 5ff082baff..be25eddb47 100644 --- a/src/cmd/compile/internal/ssa/deadcode.go +++ b/src/cmd/compile/internal/ssa/deadcode.go @@ -29,7 +29,11 @@ func findlive(f *Func) (reachable []bool, live []bool) { b := p[len(p)-1] p = p[:len(p)-1] // Mark successors as reachable - for _, c := range b.Succs { + 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 @@ -103,6 +107,37 @@ func deadcode(f *Func) { b.Values = b.Values[:i] } + // 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 + + if reachable[c.ID] { + // Note: c must be reachable through some other edge. + c.removePred(b) + } + } + // Remove unreachable blocks. Return dead block ids to allocator. i := 0 for _, b := range f.Blocks { @@ -113,11 +148,10 @@ func deadcode(f *Func) { if len(b.Values) > 0 { b.Fatalf("live values in unreachable block %v: %v", b, b.Values) } - s := b.Succs + b.Preds = nil b.Succs = nil - for _, c := range s { - f.removePredecessor(b, c) - } + b.Control = nil + b.Kind = BlockDead f.bid.put(b.ID) } } @@ -132,94 +166,68 @@ func deadcode(f *Func) { // TODO: save dead Values and Blocks for reuse? Or should we just let GC handle it? } -// There was an edge b->c. c has been removed from b's successors. -// Fix up c to handle that fact. -func (f *Func) removePredecessor(b, c *Block) { - work := [][2]*Block{{b, c}} - - for len(work) > 0 { - b, c := work[0][0], work[0][1] - work = work[1:] - - // Find index of b in c's predecessor list - // TODO: This could conceivably cause O(n^2) work. Imagine a very - // wide phi in (for example) the return block. If we determine that - // lots of panics won't happen, we remove each edge at a cost of O(n) each. - var i int - found := false - for j, p := range c.Preds { - if p == b { - i = j - found = true - break - } - } - if !found { - f.Fatalf("can't find predecessor %v of %v\n", b, c) +// 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(c.Preds) - 1 - c.Preds[i] = c.Preds[n] - c.Preds[n] = nil // aid GC - c.Preds = c.Preds[:n] + 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 c.Values { - if v.Op != OpPhi { - continue - } - v.Args[i] = v.Args[n] - v.Args[n] = nil // aid GC - v.Args = v.Args[:n] - if n == 1 { - v.Op = OpCopy - // 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. So although the value graph is transiently - // bad, we'll throw away the bad part by the end of - // the next deadcode phase. - // 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. - } + // rewrite phi ops to match the new predecessor list + for _, v := range b.Values { + if v.Op != OpPhi { + continue } - if n == 0 { - // c is now dead--recycle its values - for _, v := range c.Values { - f.vid.put(v.ID) - } - c.Values = nil - // Also kill any successors of c now, to spare later processing. - for _, succ := range c.Succs { - work = append(work, [2]*Block{c, succ}) - } - c.Succs = nil - c.Kind = BlockDead - c.Control = nil + v.Args[i] = v.Args[n] + v.Args[n] = nil // aid GC + v.Args = v.Args[:n] + if n == 1 { + v.Op = OpCopy + // 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/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index f77b31501d..5d870ab1cc 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -174,8 +174,8 @@ // big-object moves (TODO: remove?) (Store [size] dst (Load src mem) mem) && size > config.IntSize -> (Move [size] dst src mem) -(If (IsNonNil (GetG)) yes no) -> (Plain nil yes) +(If (IsNonNil (GetG)) yes no) -> (First nil yes no) (If (Not cond) yes no) -> (If cond no yes) -(If (ConstBool {c}) yes no) && c.(bool) -> (Plain nil yes) -(If (ConstBool {c}) yes no) && !c.(bool) -> (Plain nil no) +(If (ConstBool {c}) yes no) && c.(bool) -> (First nil yes no) +(If (ConstBool {c}) yes no) && !c.(bool) -> (First nil no yes) diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 62d34e74bb..2e3be0c0ce 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -373,7 +373,7 @@ var genericBlocks = []blockData{ {name: "Plain"}, // a single successor {name: "If"}, // 2 successors, if control goto Succs[0] else goto Succs[1] {name: "Call"}, // 2 successors, normal return and panic - // TODO(khr): BlockPanic for the built-in panic call, has 1 edge to the exit block + {name: "First"}, // 2 successors, always takes the first one (second is dead) } func init() { diff --git a/src/cmd/compile/internal/ssa/gen/rulegen.go b/src/cmd/compile/internal/ssa/gen/rulegen.go index 057e68601b..e5c61952f1 100644 --- a/src/cmd/compile/internal/ssa/gen/rulegen.go +++ b/src/cmd/compile/internal/ssa/gen/rulegen.go @@ -236,7 +236,7 @@ func genRules(arch arch) { t := split(result[1 : len(result)-1]) // remove parens, then split newsuccs := t[2:] - // Check if newsuccs is a subset of succs. + // Check if newsuccs is the same set as succs. m := map[string]bool{} for _, succ := range succs { if m[succ] { @@ -250,6 +250,9 @@ func genRules(arch arch) { } 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 { diff --git a/src/cmd/compile/internal/ssa/nilcheck.go b/src/cmd/compile/internal/ssa/nilcheck.go index 4833ac472d..80b9e668d3 100644 --- a/src/cmd/compile/internal/ssa/nilcheck.go +++ b/src/cmd/compile/internal/ssa/nilcheck.go @@ -83,10 +83,8 @@ func nilcheckelim(f *Func) { // Eliminate the nil check. // The deadcode pass will remove vestigial values, // and the fuse pass will join this block with its successor. - node.block.Kind = BlockPlain + node.block.Kind = BlockFirst node.block.Control = nil - f.removePredecessor(node.block, node.block.Succs[1]) - node.block.Succs = node.block.Succs[:1] } else { // new nilcheck so add a ClearPtr node to clear the // ptr from the map of nil checks once we traverse @@ -173,10 +171,8 @@ func nilcheckelim0(f *Func) { // Eliminate the nil check. // The deadcode pass will remove vestigial values, // and the fuse pass will join this block with its successor. - b.Kind = BlockPlain + b.Kind = BlockFirst b.Control = nil - f.removePredecessor(b, b.Succs[1]) - b.Succs = b.Succs[:1] } } } diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 15689b2a85..51a998e352 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -27,6 +27,7 @@ const ( BlockPlain BlockIf BlockCall + BlockFirst ) var blockString = [...]string{ @@ -52,6 +53,7 @@ var blockString = [...]string{ BlockPlain: "Plain", BlockIf: "If", BlockCall: "Call", + BlockFirst: "First", } func (k BlockKind) String() string { return blockString[k] } diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index b14ed9c21e..3ec41181cc 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -1574,27 +1574,25 @@ func rewriteBlockgeneric(b *Block) bool { case BlockIf: // match: (If (IsNonNil (GetG)) yes no) // cond: - // result: (Plain nil yes) + // result: (First nil yes no) { v := b.Control if v.Op != OpIsNonNil { - goto end0f2bb0111a86be0436b44210dbd83a90 + goto endafdc4e2525f9933ab0ae7effc3559597 } if v.Args[0].Op != OpGetG { - goto end0f2bb0111a86be0436b44210dbd83a90 + goto endafdc4e2525f9933ab0ae7effc3559597 } yes := b.Succs[0] no := b.Succs[1] - b.Func.removePredecessor(b, no) - b.Kind = BlockPlain + b.Kind = BlockFirst b.Control = nil - b.Succs = b.Succs[:1] b.Succs[0] = yes - b.Likely = BranchUnknown + b.Succs[1] = no return true } - goto end0f2bb0111a86be0436b44210dbd83a90 - end0f2bb0111a86be0436b44210dbd83a90: + goto endafdc4e2525f9933ab0ae7effc3559597 + endafdc4e2525f9933ab0ae7effc3559597: ; // match: (If (Not cond) yes no) // cond: @@ -1619,53 +1617,50 @@ func rewriteBlockgeneric(b *Block) bool { ; // match: (If (ConstBool {c}) yes no) // cond: c.(bool) - // result: (Plain nil yes) + // result: (First nil yes no) { v := b.Control if v.Op != OpConstBool { - goto end9ff0273f9b1657f4afc287562ca889f0 + goto end7a20763049489cdb40bb1eaa57d113d8 } c := v.Aux yes := b.Succs[0] no := b.Succs[1] if !(c.(bool)) { - goto end9ff0273f9b1657f4afc287562ca889f0 + goto end7a20763049489cdb40bb1eaa57d113d8 } - b.Func.removePredecessor(b, no) - b.Kind = BlockPlain + b.Kind = BlockFirst b.Control = nil - b.Succs = b.Succs[:1] b.Succs[0] = yes - b.Likely = BranchUnknown + b.Succs[1] = no return true } - goto end9ff0273f9b1657f4afc287562ca889f0 - end9ff0273f9b1657f4afc287562ca889f0: + goto end7a20763049489cdb40bb1eaa57d113d8 + end7a20763049489cdb40bb1eaa57d113d8: ; // match: (If (ConstBool {c}) yes no) // cond: !c.(bool) - // result: (Plain nil no) + // result: (First nil no yes) { v := b.Control if v.Op != OpConstBool { - goto endf401a4553c3c7c6bed64801da7bba076 + goto end3ecbf5b2cc1f0a08444d8ab1871a829c } c := v.Aux yes := b.Succs[0] no := b.Succs[1] if !(!c.(bool)) { - goto endf401a4553c3c7c6bed64801da7bba076 + goto end3ecbf5b2cc1f0a08444d8ab1871a829c } - b.Func.removePredecessor(b, yes) - b.Kind = BlockPlain + b.Kind = BlockFirst b.Control = nil - b.Succs = b.Succs[:1] b.Succs[0] = no - b.Likely = BranchUnknown + b.Succs[1] = yes + b.Likely *= -1 return true } - goto endf401a4553c3c7c6bed64801da7bba076 - endf401a4553c3c7c6bed64801da7bba076: + goto end3ecbf5b2cc1f0a08444d8ab1871a829c + end3ecbf5b2cc1f0a08444d8ab1871a829c: } return false } diff --git a/test/fixedbugs/issue12347.go b/test/fixedbugs/issue12347.go new file mode 100644 index 0000000000..4bbe09c3e8 --- /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 + } + } +} -- cgit v1.3 From 5fdd4fea905923084affaeb5d2427f226db076e1 Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Sun, 30 Aug 2015 20:47:26 -0500 Subject: [dev.ssa] cmd/compile: map EQ/NE intptr to OpEqPtr/OpNeqPtr Change-Id: I8fd3727763c812297967c8069847833fc8516ff2 Reviewed-on: https://go-review.googlesource.com/14073 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/gc/ssa.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index ca9943d81f..c0bff2a5f0 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -840,12 +840,12 @@ var opToSSA = map[opAndType]ssa.Op{ opAndType{OEQ, TUINT32}: ssa.OpEq32, opAndType{OEQ, TINT64}: ssa.OpEq64, opAndType{OEQ, TUINT64}: ssa.OpEq64, - opAndType{OEQ, TPTR64}: ssa.OpEq64, opAndType{OEQ, TINTER}: ssa.OpEqFat, // e == nil only opAndType{OEQ, TARRAY}: ssa.OpEqFat, // slice only; a == nil only 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, @@ -860,12 +860,12 @@ var opToSSA = map[opAndType]ssa.Op{ opAndType{ONE, TUINT32}: ssa.OpNeq32, opAndType{ONE, TINT64}: ssa.OpNeq64, opAndType{ONE, TUINT64}: ssa.OpNeq64, - opAndType{ONE, TPTR64}: ssa.OpNeq64, opAndType{ONE, TINTER}: ssa.OpNeqFat, // e != nil only opAndType{ONE, TARRAY}: ssa.OpNeqFat, // slice only; a != nil only 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, -- cgit v1.3 From 451eca2293d7c84f5892b27462f3bab7840b11ce Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Sun, 30 Aug 2015 21:21:44 -0500 Subject: [dev.ssa] cmd/compile: make test panic on failure Change-Id: Ia5483d23fe0b5dd0b6cfe2099e9b475184742716 Reviewed-on: https://go-review.googlesource.com/14074 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/gc/testdata/ctl_ssa.go | 2 ++ 1 file changed, 2 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/testdata/ctl_ssa.go b/src/cmd/compile/internal/gc/testdata/ctl_ssa.go index 49050110e5..cc55134b96 100644 --- a/src/cmd/compile/internal/gc/testdata/ctl_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/ctl_ssa.go @@ -101,6 +101,7 @@ func testFallthrough() { for i := 0; i < 6; i++ { if got := fallthrough_ssa(i); got != i { println("fallthrough_ssa(i) =", got, "wanted", i) + failed = true } } } @@ -109,6 +110,7 @@ func testSwitch() { for i := 0; i < 6; i++ { if got := switch_ssa(i); got != i { println("switch_ssa(i) =", got, "wanted", i) + failed = true } } } -- cgit v1.3 From cff0c6ad0f353fcd484b25c525d0aa92cdf5d85c Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Sun, 30 Aug 2015 21:39:25 -0500 Subject: [dev.ssa] cmd/compile: add instrumentation to regalloc Change-Id: Ice206f7e94af4a148d9dd9a7570f5ed21722bedc Reviewed-on: https://go-review.googlesource.com/14075 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/ssa/regalloc.go | 10 ++++++++++ 1 file changed, 10 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index b098ea1a19..92b7b6c829 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -105,6 +105,7 @@ import ( ) const regDebug = false +const logSpills = false // regalloc performs register allocation on f. It sets f.RegAlloc // to the resulting allocation. @@ -402,6 +403,9 @@ func (s *regAllocState) allocValToReg(v *Value, mask regMask, nospill bool) *Val // Instead, we regenerate the flags register by issuing the same instruction again. // This requires (possibly) spilling and reloading that instruction's args. case v.Type.IsFlags(): + if logSpills { + fmt.Println("regalloc: regenerating flags") + } ns := s.nospill // Place v's arguments in registers, spilling and loading as needed args := make([]*Value, 0, len(v.Args)) @@ -429,9 +433,15 @@ func (s *regAllocState) allocValToReg(v *Value, mask regMask, nospill bool) *Val // Load v from its spill location. // TODO: rematerialize if we can. case vi.spill2 != nil: + if logSpills { + fmt.Println("regallog: load spill2") + } c = s.curBlock.NewValue1(v.Line, OpLoadReg, v.Type, vi.spill2) vi.spill2used = true case vi.spill != nil: + if logSpills { + fmt.Println("regalloc: load spill") + } c = s.curBlock.NewValue1(v.Line, OpLoadReg, v.Type, vi.spill) vi.spillUsed = true default: -- cgit v1.3 From 3b7f0c9cba109cb629d023918520f916fcbb1343 Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Sun, 30 Aug 2015 22:04:38 -0500 Subject: [dev.ssa] cmd/compile: fix typo in log Change-Id: Ic7be8fa3a89e46a93df181df3163ec1bf7e96a23 Reviewed-on: https://go-review.googlesource.com/14076 Reviewed-by: Minux Ma --- src/cmd/compile/internal/ssa/regalloc.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index 92b7b6c829..00b7ad846b 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -434,7 +434,7 @@ func (s *regAllocState) allocValToReg(v *Value, mask regMask, nospill bool) *Val // TODO: rematerialize if we can. case vi.spill2 != nil: if logSpills { - fmt.Println("regallog: load spill2") + fmt.Println("regalloc: load spill2") } c = s.curBlock.NewValue1(v.Line, OpLoadReg, v.Type, vi.spill2) vi.spill2used = true -- cgit v1.3 From 21e6a055c125022d1a10a6d57f5910cef5d2cb6d Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Sat, 29 Aug 2015 12:51:04 -0500 Subject: [dev.ssa] cmd/compile: schedule values dependent on the control later To reduce the number of spills, give any non-phi values whose argument is the control the same priority as the control. With mask.bash, this reduces regenerated flags from 603 to 240. Change-Id: I26883d69e80357c56b343428fb528102b3f26e7a Reviewed-on: https://go-review.googlesource.com/14042 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/schedule.go | 18 +++++++++++++++--- 1 file changed, 15 insertions(+), 3 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/schedule.go b/src/cmd/compile/internal/ssa/schedule.go index de0b4acbf4..cf5f872e0f 100644 --- a/src/cmd/compile/internal/ssa/schedule.go +++ b/src/cmd/compile/internal/ssa/schedule.go @@ -89,9 +89,21 @@ func schedule(f *Func) { // Force the control value to be scheduled at the end, // unless it is a phi value (which must be first). score[b.Control.ID] = 4 - // TODO: some times control values are used by other values - // in the block. So the control value will not appear at - // the very end. Decide if this is a problem or not. + + // 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] = 4 + } + } + } + } } // Initialize priority queue with schedulable values. -- cgit v1.3 From a0022d9b8ced73368e76b20b3fcbf93ead30952b Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Mon, 31 Aug 2015 20:42:04 -0500 Subject: [dev.ssa] cmd/compile: add more specific regalloc logging Change-Id: Ib0ea4b9c245f3d551e0f703826caa6b444b56a2d Reviewed-on: https://go-review.googlesource.com/14136 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/ssa/regalloc.go | 5 +++++ 1 file changed, 5 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index 00b7ad846b..3122c7a130 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -912,6 +912,8 @@ func (s *regAllocState) regalloc(f *Func) { spill2.Op = OpInvalid spill2.Type = TypeInvalid spill2.resetArgs() + } else if logSpills { + fmt.Println("regalloc: spilled phi") } s.values[v.ID].spill2 = nil s.values[v.ID].spill2used = false @@ -926,6 +928,9 @@ func (s *regAllocState) regalloc(f *Func) { for i := range s.values { vi := s.values[i] if vi.spillUsed { + if logSpills { + fmt.Println("regalloc: spilled value") + } continue } spill := vi.spill -- cgit v1.3 From 65677cabfd3a348e1a5b8deca556cf80b998efca Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Tue, 1 Sep 2015 09:16:58 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: allow ops to have a default type Specifying types in rewrites for all subexpressions gets verbose quickly. Allow opcodes to specify a default type which is used when none is supplied explicitly. Provide default types for a few easy opcodes. There are probably more we can do, but this is a good start. Change-Id: Iedc2a1a423cc3e2d4472640433982f9aa76a9f18 Reviewed-on: https://go-review.googlesource.com/14128 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/ssa/gen/AMD64.rules | 252 +++---- src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 40 +- src/cmd/compile/internal/ssa/gen/generic.rules | 26 +- src/cmd/compile/internal/ssa/gen/genericOps.go | 26 +- src/cmd/compile/internal/ssa/gen/main.go | 1 + src/cmd/compile/internal/ssa/gen/rulegen.go | 29 +- src/cmd/compile/internal/ssa/rewriteAMD64.go | 930 ++++++++++++------------- src/cmd/compile/internal/ssa/rewritegeneric.go | 112 +-- 8 files changed, 723 insertions(+), 693 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index f0b9288dd5..46fb76f1dd 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -43,8 +43,8 @@ (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)) +(Div8 x y) -> (DIVW (SignExt8to16 x) (SignExt8to16 y)) +(Div8u x y) -> (DIVWU (ZeroExt8to16 x) (ZeroExt8to16 y)) (Hmul32 x y) -> (HMULL x y) (Hmul32u x y) -> (HMULLU x y) @@ -59,8 +59,8 @@ (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)) +(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) @@ -127,139 +127,139 @@ // 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 x y) -> (ANDQ (SHLQ x y) (SBBQcarrymask (CMPQconst [64] y))) -(Lsh64x32 x y) -> (ANDQ (SHLQ x y) (SBBQcarrymask (CMPLconst [64] y))) -(Lsh64x16 x y) -> (ANDQ (SHLQ x y) (SBBQcarrymask (CMPWconst [64] y))) -(Lsh64x8 x y) -> (ANDQ (SHLQ x y) (SBBQcarrymask (CMPBconst [64] y))) - -(Lsh32x64 x y) -> (ANDL (SHLL x y) (SBBLcarrymask (CMPQconst [32] y))) -(Lsh32x32 x y) -> (ANDL (SHLL x y) (SBBLcarrymask (CMPLconst [32] y))) -(Lsh32x16 x y) -> (ANDL (SHLL x y) (SBBLcarrymask (CMPWconst [32] y))) -(Lsh32x8 x y) -> (ANDL (SHLL x y) (SBBLcarrymask (CMPBconst [32] y))) - -(Lsh16x64 x y) -> (ANDW (SHLW x y) (SBBLcarrymask (CMPQconst [16] y))) -(Lsh16x32 x y) -> (ANDW (SHLW x y) (SBBLcarrymask (CMPLconst [16] y))) -(Lsh16x16 x y) -> (ANDW (SHLW x y) (SBBLcarrymask (CMPWconst [16] y))) -(Lsh16x8 x y) -> (ANDW (SHLW x y) (SBBLcarrymask (CMPBconst [16] y))) - -(Lsh8x64 x y) -> (ANDB (SHLB x y) (SBBLcarrymask (CMPQconst [8] y))) -(Lsh8x32 x y) -> (ANDB (SHLB x y) (SBBLcarrymask (CMPLconst [8] y))) -(Lsh8x16 x y) -> (ANDB (SHLB x y) (SBBLcarrymask (CMPWconst [8] y))) -(Lsh8x8 x y) -> (ANDB (SHLB x y) (SBBLcarrymask (CMPBconst [8] y))) +(Lsh64x64 x y) -> (ANDQ (SHLQ x y) (SBBQcarrymask (CMPQconst [64] y))) +(Lsh64x32 x y) -> (ANDQ (SHLQ x y) (SBBQcarrymask (CMPLconst [64] y))) +(Lsh64x16 x y) -> (ANDQ (SHLQ x y) (SBBQcarrymask (CMPWconst [64] y))) +(Lsh64x8 x y) -> (ANDQ (SHLQ x y) (SBBQcarrymask (CMPBconst [64] y))) + +(Lsh32x64 x y) -> (ANDL (SHLL x y) (SBBLcarrymask (CMPQconst [32] y))) +(Lsh32x32 x y) -> (ANDL (SHLL x y) (SBBLcarrymask (CMPLconst [32] y))) +(Lsh32x16 x y) -> (ANDL (SHLL x y) (SBBLcarrymask (CMPWconst [32] y))) +(Lsh32x8 x y) -> (ANDL (SHLL x y) (SBBLcarrymask (CMPBconst [32] y))) + +(Lsh16x64 x y) -> (ANDW (SHLW x y) (SBBLcarrymask (CMPQconst [16] y))) +(Lsh16x32 x y) -> (ANDW (SHLW x y) (SBBLcarrymask (CMPLconst [16] y))) +(Lsh16x16 x y) -> (ANDW (SHLW x y) (SBBLcarrymask (CMPWconst [16] y))) +(Lsh16x8 x y) -> (ANDW (SHLW x y) (SBBLcarrymask (CMPBconst [16] y))) + +(Lsh8x64 x y) -> (ANDB (SHLB x y) (SBBLcarrymask (CMPQconst [8] y))) +(Lsh8x32 x y) -> (ANDB (SHLB x y) (SBBLcarrymask (CMPLconst [8] y))) +(Lsh8x16 x y) -> (ANDB (SHLB x y) (SBBLcarrymask (CMPWconst [8] y))) +(Lsh8x8 x y) -> (ANDB (SHLB x y) (SBBLcarrymask (CMPBconst [8] y))) (Lrot64 x [c]) -> (ROLQconst [c&63] x) (Lrot32 x [c]) -> (ROLLconst [c&31] x) (Lrot16 x [c]) -> (ROLWconst [c&15] x) (Lrot8 x [c]) -> (ROLBconst [c&7] x) -(Rsh64Ux64 x y) -> (ANDQ (SHRQ x y) (SBBQcarrymask (CMPQconst [64] y))) -(Rsh64Ux32 x y) -> (ANDQ (SHRQ x y) (SBBQcarrymask (CMPLconst [64] y))) -(Rsh64Ux16 x y) -> (ANDQ (SHRQ x y) (SBBQcarrymask (CMPWconst [64] y))) -(Rsh64Ux8 x y) -> (ANDQ (SHRQ x y) (SBBQcarrymask (CMPBconst [64] y))) +(Rsh64Ux64 x y) -> (ANDQ (SHRQ x y) (SBBQcarrymask (CMPQconst [64] y))) +(Rsh64Ux32 x y) -> (ANDQ (SHRQ x y) (SBBQcarrymask (CMPLconst [64] y))) +(Rsh64Ux16 x y) -> (ANDQ (SHRQ x y) (SBBQcarrymask (CMPWconst [64] y))) +(Rsh64Ux8 x y) -> (ANDQ (SHRQ x y) (SBBQcarrymask (CMPBconst [64] y))) -(Rsh32Ux64 x y) -> (ANDL (SHRL x y) (SBBLcarrymask (CMPQconst [32] y))) -(Rsh32Ux32 x y) -> (ANDL (SHRL x y) (SBBLcarrymask (CMPLconst [32] y))) -(Rsh32Ux16 x y) -> (ANDL (SHRL x y) (SBBLcarrymask (CMPWconst [32] y))) -(Rsh32Ux8 x y) -> (ANDL (SHRL x y) (SBBLcarrymask (CMPBconst [32] y))) +(Rsh32Ux64 x y) -> (ANDL (SHRL x y) (SBBLcarrymask (CMPQconst [32] y))) +(Rsh32Ux32 x y) -> (ANDL (SHRL x y) (SBBLcarrymask (CMPLconst [32] y))) +(Rsh32Ux16 x y) -> (ANDL (SHRL x y) (SBBLcarrymask (CMPWconst [32] y))) +(Rsh32Ux8 x y) -> (ANDL (SHRL x y) (SBBLcarrymask (CMPBconst [32] y))) -(Rsh16Ux64 x y) -> (ANDW (SHRW x y) (SBBLcarrymask (CMPQconst [16] y))) -(Rsh16Ux32 x y) -> (ANDW (SHRW x y) (SBBLcarrymask (CMPLconst [16] y))) -(Rsh16Ux16 x y) -> (ANDW (SHRW x y) (SBBLcarrymask (CMPWconst [16] y))) -(Rsh16Ux8 x y) -> (ANDW (SHRW x y) (SBBLcarrymask (CMPBconst [16] y))) +(Rsh16Ux64 x y) -> (ANDW (SHRW x y) (SBBLcarrymask (CMPQconst [16] y))) +(Rsh16Ux32 x y) -> (ANDW (SHRW x y) (SBBLcarrymask (CMPLconst [16] y))) +(Rsh16Ux16 x y) -> (ANDW (SHRW x y) (SBBLcarrymask (CMPWconst [16] y))) +(Rsh16Ux8 x y) -> (ANDW (SHRW x y) (SBBLcarrymask (CMPBconst [16] y))) -(Rsh8Ux64 x y) -> (ANDB (SHRB x y) (SBBLcarrymask (CMPQconst [8] y))) -(Rsh8Ux32 x y) -> (ANDB (SHRB x y) (SBBLcarrymask (CMPLconst [8] y))) -(Rsh8Ux16 x y) -> (ANDB (SHRB x y) (SBBLcarrymask (CMPWconst [8] y))) -(Rsh8Ux8 x y) -> (ANDB (SHRB x y) (SBBLcarrymask (CMPBconst [8] y))) +(Rsh8Ux64 x y) -> (ANDB (SHRB x y) (SBBLcarrymask (CMPQconst [8] y))) +(Rsh8Ux32 x y) -> (ANDB (SHRB x y) (SBBLcarrymask (CMPLconst [8] y))) +(Rsh8Ux16 x y) -> (ANDB (SHRB x y) (SBBLcarrymask (CMPWconst [8] y))) +(Rsh8Ux8 x y) -> (ANDB (SHRB x y) (SBBLcarrymask (CMPBconst [8] y))) // 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 x y) -> (SARQ x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst [64] y))))) -(Rsh64x32 x y) -> (SARQ x (ORL y (NOTL (SBBLcarrymask (CMPLconst [64] y))))) -(Rsh64x16 x y) -> (SARQ x (ORW y (NOTL (SBBLcarrymask (CMPWconst [64] y))))) -(Rsh64x8 x y) -> (SARQ x (ORB y (NOTL (SBBLcarrymask (CMPBconst [64] y))))) - -(Rsh32x64 x y) -> (SARL x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst [32] y))))) -(Rsh32x32 x y) -> (SARL x (ORL y (NOTL (SBBLcarrymask (CMPLconst [32] y))))) -(Rsh32x16 x y) -> (SARL x (ORW y (NOTL (SBBLcarrymask (CMPWconst [32] y))))) -(Rsh32x8 x y) -> (SARL x (ORB y (NOTL (SBBLcarrymask (CMPBconst [32] y))))) - -(Rsh16x64 x y) -> (SARW x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst [16] y))))) -(Rsh16x32 x y) -> (SARW x (ORL y (NOTL (SBBLcarrymask (CMPLconst [16] y))))) -(Rsh16x16 x y) -> (SARW x (ORW y (NOTL (SBBLcarrymask (CMPWconst [16] y))))) -(Rsh16x8 x y) -> (SARW x (ORB y (NOTL (SBBLcarrymask (CMPBconst [16] y))))) - -(Rsh8x64 x y) -> (SARB x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst [8] y))))) -(Rsh8x32 x y) -> (SARB x (ORL y (NOTL (SBBLcarrymask (CMPLconst [8] y))))) -(Rsh8x16 x y) -> (SARB x (ORW y (NOTL (SBBLcarrymask (CMPWconst [8] y))))) -(Rsh8x8 x y) -> (SARB x (ORB y (NOTL (SBBLcarrymask (CMPBconst [8] y))))) - -(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)) +(Rsh64x64 x y) -> (SARQ x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst [64] y))))) +(Rsh64x32 x y) -> (SARQ x (ORL y (NOTL (SBBLcarrymask (CMPLconst [64] y))))) +(Rsh64x16 x y) -> (SARQ x (ORW y (NOTL (SBBLcarrymask (CMPWconst [64] y))))) +(Rsh64x8 x y) -> (SARQ x (ORB y (NOTL (SBBLcarrymask (CMPBconst [64] y))))) + +(Rsh32x64 x y) -> (SARL x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst [32] y))))) +(Rsh32x32 x y) -> (SARL x (ORL y (NOTL (SBBLcarrymask (CMPLconst [32] y))))) +(Rsh32x16 x y) -> (SARL x (ORW y (NOTL (SBBLcarrymask (CMPWconst [32] y))))) +(Rsh32x8 x y) -> (SARL x (ORB y (NOTL (SBBLcarrymask (CMPBconst [32] y))))) + +(Rsh16x64 x y) -> (SARW x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst [16] y))))) +(Rsh16x32 x y) -> (SARW x (ORL y (NOTL (SBBLcarrymask (CMPLconst [16] y))))) +(Rsh16x16 x y) -> (SARW x (ORW y (NOTL (SBBLcarrymask (CMPWconst [16] y))))) +(Rsh16x8 x y) -> (SARW x (ORB y (NOTL (SBBLcarrymask (CMPBconst [16] y))))) + +(Rsh8x64 x y) -> (SARB x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst [8] y))))) +(Rsh8x32 x y) -> (SARB x (ORL y (NOTL (SBBLcarrymask (CMPLconst [8] y))))) +(Rsh8x16 x y) -> (SARB x (ORW y (NOTL (SBBLcarrymask (CMPWconst [8] y))))) +(Rsh8x8 x y) -> (SARB x (ORB y (NOTL (SBBLcarrymask (CMPBconst [8] y))))) + +(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)) +(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)) +(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)) +(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)) +(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 ptr mem) && (is64BitInt(t) || isPtr(t)) -> (MOVQload ptr mem) (Load ptr mem) && is32BitInt(t) -> (MOVLload ptr mem) @@ -278,9 +278,9 @@ (Store [1] ptr val mem) -> (MOVBstore ptr val mem) // checks -(IsNonNil p) -> (SETNE (TESTQ p p)) -(IsInBounds idx len) -> (SETB (CMPQ idx len)) -(IsSliceInBounds idx len) -> (SETBE (CMPQ idx len)) +(IsNonNil p) -> (SETNE (TESTQ p p)) +(IsInBounds idx len) -> (SETB (CMPQ idx len)) +(IsSliceInBounds idx len) -> (SETBE (CMPQ idx len)) (PanicNilCheck ptr mem) -> (LoweredPanicNilCheck ptr mem) (PanicIndexCheck mem) -> (LoweredPanicIndexCheck mem) @@ -326,7 +326,7 @@ (If (SETEQF cmp) yes no) -> (EQF cmp yes no) (If (SETNEF cmp) yes no) -> (EQF cmp yes no) -(If cond yes no) -> (NE (TESTB cond cond) 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) @@ -435,13 +435,13 @@ // (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])) +(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])) +(CMPL (MOVLconst [c]) x) -> (InvertFlags (CMPLconst x [c])) (CMPW x (MOVWconst [c])) -> (CMPWconst x [c]) -(CMPW (MOVWconst [c]) x) -> (InvertFlags (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])) +(CMPB (MOVBconst [c]) x) -> (InvertFlags (CMPBconst x [c])) // strength reduction (MULQconst [-1] x) -> (NEGQ x) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index e610458c92..f2c402a348 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -241,26 +241,26 @@ func init() { {name: "XORWconst", reg: gp11, asm: "XORW"}, // arg0 ^ auxint {name: "XORBconst", reg: gp11, asm: "XORB"}, // arg0 ^ auxint - {name: "CMPQ", reg: gp2flags, asm: "CMPQ"}, // arg0 compare to arg1 - {name: "CMPL", reg: gp2flags, asm: "CMPL"}, // arg0 compare to arg1 - {name: "CMPW", reg: gp2flags, asm: "CMPW"}, // arg0 compare to arg1 - {name: "CMPB", reg: gp2flags, asm: "CMPB"}, // arg0 compare to arg1 - {name: "CMPQconst", reg: gp1flags, asm: "CMPQ"}, // arg0 compare to auxint - {name: "CMPLconst", reg: gp1flags, asm: "CMPL"}, // arg0 compare to auxint - {name: "CMPWconst", reg: gp1flags, asm: "CMPW"}, // arg0 compare to auxint - {name: "CMPBconst", reg: gp1flags, asm: "CMPB"}, // arg0 compare to auxint - - {name: "UCOMISS", reg: fp2flags, asm: "UCOMISS"}, // arg0 compare to arg1, f32 - {name: "UCOMISD", reg: fp2flags, asm: "UCOMISD"}, // arg0 compare to arg1, f64 - - {name: "TESTQ", reg: gp2flags, asm: "TESTQ"}, // (arg0 & arg1) compare to 0 - {name: "TESTL", reg: gp2flags, asm: "TESTL"}, // (arg0 & arg1) compare to 0 - {name: "TESTW", reg: gp2flags, asm: "TESTW"}, // (arg0 & arg1) compare to 0 - {name: "TESTB", reg: gp2flags, asm: "TESTB"}, // (arg0 & arg1) compare to 0 - {name: "TESTQconst", reg: gp1flags, asm: "TESTQ"}, // (arg0 & auxint) compare to 0 - {name: "TESTLconst", reg: gp1flags, asm: "TESTL"}, // (arg0 & auxint) compare to 0 - {name: "TESTWconst", reg: gp1flags, asm: "TESTW"}, // (arg0 & auxint) compare to 0 - {name: "TESTBconst", reg: gp1flags, asm: "TESTB"}, // (arg0 & auxint) compare to 0 + {name: "CMPQ", reg: gp2flags, asm: "CMPQ", typ: "Flags"}, // arg0 compare to arg1 + {name: "CMPL", reg: gp2flags, asm: "CMPL", typ: "Flags"}, // arg0 compare to arg1 + {name: "CMPW", reg: gp2flags, asm: "CMPW", typ: "Flags"}, // arg0 compare to arg1 + {name: "CMPB", reg: gp2flags, asm: "CMPB", typ: "Flags"}, // arg0 compare to arg1 + {name: "CMPQconst", reg: gp1flags, asm: "CMPQ", typ: "Flags"}, // arg0 compare to auxint + {name: "CMPLconst", reg: gp1flags, asm: "CMPL", typ: "Flags"}, // arg0 compare to auxint + {name: "CMPWconst", reg: gp1flags, asm: "CMPW", typ: "Flags"}, // arg0 compare to auxint + {name: "CMPBconst", reg: gp1flags, asm: "CMPB", typ: "Flags"}, // arg0 compare to auxint + + {name: "UCOMISS", reg: fp2flags, asm: "UCOMISS", typ: "Flags"}, // arg0 compare to arg1, f32 + {name: "UCOMISD", reg: fp2flags, asm: "UCOMISD", typ: "Flags"}, // arg0 compare to arg1, f64 + + {name: "TESTQ", reg: gp2flags, asm: "TESTQ", typ: "Flags"}, // (arg0 & arg1) compare to 0 + {name: "TESTL", reg: gp2flags, asm: "TESTL", typ: "Flags"}, // (arg0 & arg1) compare to 0 + {name: "TESTW", reg: gp2flags, asm: "TESTW", typ: "Flags"}, // (arg0 & arg1) compare to 0 + {name: "TESTB", reg: gp2flags, asm: "TESTB", typ: "Flags"}, // (arg0 & arg1) compare to 0 + {name: "TESTQconst", reg: gp1flags, asm: "TESTQ", typ: "Flags"}, // (arg0 & auxint) compare to 0 + {name: "TESTLconst", reg: gp1flags, asm: "TESTL", typ: "Flags"}, // (arg0 & auxint) compare to 0 + {name: "TESTWconst", reg: gp1flags, asm: "TESTW", typ: "Flags"}, // (arg0 & auxint) compare to 0 + {name: "TESTBconst", reg: gp1flags, asm: "TESTB", typ: "Flags"}, // (arg0 & auxint) compare to 0 {name: "SHLQ", reg: gp21shift, asm: "SHLQ"}, // arg0 << arg1, shift amount is mod 64 {name: "SHLL", reg: gp21shift, asm: "SHLL"}, // arg0 << arg1, shift amount is mod 32 diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index 5d870ab1cc..e0b49180f9 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -65,13 +65,13 @@ (EqFat x y) && x.Op == OpConstNil && y.Op != OpConstNil -> (EqFat y x) (NeqFat x y) && x.Op == OpConstNil && y.Op != OpConstNil -> (NeqFat y x) // it suffices to check the first word (backing array for slices, dynamic type for interfaces) -(EqFat (Load ptr mem) (ConstNil)) -> (EqPtr (Load ptr mem) (ConstPtr [0])) -(NeqFat (Load ptr mem) (ConstNil)) -> (NeqPtr (Load ptr mem) (ConstPtr [0])) +(EqFat (Load ptr mem) (ConstNil)) -> (EqPtr (Load ptr mem) (ConstPtr [0])) +(NeqFat (Load ptr mem) (ConstNil)) -> (NeqPtr (Load ptr mem) (ConstPtr [0])) // indexing operations // Note: bounds check has already been done (ArrayIndex (Load ptr mem) idx) -> (Load (PtrIndex ptr idx) mem) -(PtrIndex ptr idx) -> (AddPtr ptr (MulPtr idx (ConstPtr [t.Elem().Size()]))) +(PtrIndex ptr idx) -> (AddPtr ptr (MulPtr idx (ConstPtr [t.Elem().Size()]))) (StructSelect [idx] (Load ptr mem)) -> (Load (OffPtr [idx] ptr) mem) // complex ops @@ -89,7 +89,7 @@ (Store [4] (OffPtr [4] dst) imag - (Store [4] dst real mem)) + (Store [4] dst real mem)) (Load ptr mem) && t.IsComplex() && t.Size() == 16 -> (ComplexMake @@ -102,7 +102,7 @@ (Store [8] (OffPtr [8] dst) imag - (Store [8] dst real mem)) + (Store [8] dst real mem)) // string ops (StringPtr (StringMake ptr _)) -> ptr @@ -110,8 +110,8 @@ (ConstString {s}) -> (StringMake (Addr {config.fe.StringData(s.(string))} - (SB )) - (ConstPtr [int64(len(s.(string)))])) + (SB)) + (ConstPtr [int64(len(s.(string)))])) (Load ptr mem) && t.IsString() -> (StringMake (Load ptr mem) @@ -122,7 +122,7 @@ (Store [config.PtrSize] (OffPtr [config.PtrSize] dst) len - (Store [config.PtrSize] dst ptr mem)) + (Store [config.PtrSize] dst ptr mem)) // slice ops (SlicePtr (SliceMake ptr _ _ )) -> ptr @@ -131,8 +131,8 @@ (ConstSlice) -> (SliceMake (ConstNil ) - (ConstPtr ) - (ConstPtr )) + (ConstPtr [0]) + (ConstPtr [0])) (Load ptr mem) && t.IsSlice() -> (SliceMake @@ -147,10 +147,10 @@ (Store [config.PtrSize] (OffPtr [2*config.PtrSize] dst) cap - (Store [config.PtrSize] + (Store [config.PtrSize] (OffPtr [config.PtrSize] dst) len - (Store [config.PtrSize] dst ptr mem))) + (Store [config.PtrSize] dst ptr mem))) // interface ops (ITab (IMake itab _)) -> itab @@ -169,7 +169,7 @@ (Store [config.PtrSize] (OffPtr [config.PtrSize] dst) data - (Store [config.PtrSize] dst itab mem)) + (Store [config.PtrSize] dst itab mem)) // big-object moves (TODO: remove?) (Store [size] dst (Load src mem) mem) && size > config.IntSize -> (Move [size] dst src mem) diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 2e3be0c0ce..8f6a858e43 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -30,7 +30,7 @@ var genericOps = []opData{ {name: "Mul16"}, {name: "Mul32"}, {name: "Mul64"}, - {name: "MulPtr"}, // MulPtr is used for address calculations + {name: "MulPtr", typ: "Uintptr"}, // MulPtr is used for address calculations {name: "Mul32F"}, {name: "Mul64F"}, @@ -250,9 +250,9 @@ var genericOps = []opData{ {name: "Const64"}, {name: "Const32F"}, {name: "Const64F"}, - {name: "ConstPtr"}, // pointer-sized integer constant - {name: "ConstInterface"}, // nil interface - {name: "ConstSlice"}, // nil slice + {name: "ConstPtr", typ: "Uintptr"}, // pointer-sized integer constant + {name: "ConstInterface"}, // nil interface + {name: "ConstSlice"}, // nil slice // TODO: Const32F, ... // Constant-like things @@ -264,15 +264,15 @@ var genericOps = []opData{ // or *AutoSymbol (arg0=SP). {name: "Addr"}, // Address of a variable. Arg0=SP or SB. Aux identifies the variable. - {name: "SP"}, // stack pointer - {name: "SB"}, // static base pointer (a.k.a. globals pointer) - {name: "Func"}, // entry address of a function + {name: "SP"}, // stack pointer + {name: "SB", typ: "Uintptr"}, // static base pointer (a.k.a. globals pointer) + {name: "Func"}, // entry address of a function // Memory operations - {name: "Load"}, // Load from arg0. arg1=memory - {name: "Store"}, // Store arg1 to arg0. arg2=memory, auxint=size. Returns memory. - {name: "Move"}, // arg0=destptr, arg1=srcptr, arg2=mem, auxint=size. Returns memory. - {name: "Zero"}, // arg0=destptr, arg1=mem, auxint=size. Returns memory. + {name: "Load"}, // Load from arg0. arg1=memory + {name: "Store", typ: "Mem"}, // Store arg1 to arg0. arg2=memory, auxint=size. Returns memory. + {name: "Move"}, // arg0=destptr, arg1=srcptr, arg2=mem, auxint=size. Returns memory. + {name: "Zero"}, // 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 @@ -281,13 +281,13 @@ var genericOps = []opData{ {name: "StaticCall"}, // call function aux.(*gc.Sym), arg0=memory. Returns memory. // Conversions: signed extensions, zero (unsigned) extensions, truncations - {name: "SignExt8to16"}, + {name: "SignExt8to16", typ: "Int16"}, {name: "SignExt8to32"}, {name: "SignExt8to64"}, {name: "SignExt16to32"}, {name: "SignExt16to64"}, {name: "SignExt32to64"}, - {name: "ZeroExt8to16"}, + {name: "ZeroExt8to16", typ: "UInt16"}, {name: "ZeroExt8to32"}, {name: "ZeroExt8to64"}, {name: "ZeroExt16to32"}, diff --git a/src/cmd/compile/internal/ssa/gen/main.go b/src/cmd/compile/internal/ssa/gen/main.go index 1383566e3a..c869de82e7 100644 --- a/src/cmd/compile/internal/ssa/gen/main.go +++ b/src/cmd/compile/internal/ssa/gen/main.go @@ -29,6 +29,7 @@ type opData struct { name string reg regInfo asm string + typ string // default result type } type blockData struct { diff --git a/src/cmd/compile/internal/ssa/gen/rulegen.go b/src/cmd/compile/internal/ssa/gen/rulegen.go index e5c61952f1..d98ad2587f 100644 --- a/src/cmd/compile/internal/ssa/gen/rulegen.go +++ b/src/cmd/compile/internal/ssa/gen/rulegen.go @@ -459,7 +459,24 @@ func genResult0(w io.Writer, arch arch, result string, alloc *int, top bool) str } } if !hasType { - log.Fatalf("sub-expression %s must have a type", result) + // find default type, if any + for _, op := range arch.ops { + if op.name != s[0] || op.typ == "" || hasType { + continue + } + fmt.Fprintf(w, "%s.Type = %s\n", v, typeName(op.typ)) + hasType = true + } + for _, op := range genericOps { + if op.name != s[0] || op.typ == "" || hasType { + continue + } + fmt.Fprintf(w, "%s.Type = %s\n", v, typeName(op.typ)) + hasType = true + } + } + if !hasType { + log.Fatalf("sub-expression %s (op=%s) must have a type", result, s[0]) } return v } @@ -547,6 +564,16 @@ func blockName(name string, arch arch) string { 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": + 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 diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index c0213d8632..e089028258 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -1279,10 +1279,10 @@ func rewriteValueAMD64(v *Value, config *Config) bool { ; // match: (CMPB (MOVBconst [c]) x) // cond: - // result: (InvertFlags (CMPBconst x [c])) + // result: (InvertFlags (CMPBconst x [c])) { if v.Args[0].Op != OpAMD64MOVBconst { - goto end6798593f4f9a27e90de089b3248187fd + goto end25ab646f9eb8749ea58c8fbbb4bf6bcd } c := v.Args[0].AuxInt x := v.Args[1] @@ -1291,14 +1291,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AuxInt = c + v0.Type = TypeFlags v.AddArg(v0) return true } - goto end6798593f4f9a27e90de089b3248187fd - end6798593f4f9a27e90de089b3248187fd: + goto end25ab646f9eb8749ea58c8fbbb4bf6bcd + end25ab646f9eb8749ea58c8fbbb4bf6bcd: ; case OpAMD64CMPL: // match: (CMPL x (MOVLconst [c])) @@ -1323,10 +1323,10 @@ func rewriteValueAMD64(v *Value, config *Config) bool { ; // match: (CMPL (MOVLconst [c]) x) // cond: - // result: (InvertFlags (CMPLconst x [c])) + // result: (InvertFlags (CMPLconst x [c])) { if v.Args[0].Op != OpAMD64MOVLconst { - goto end3c04e861f07a442be9e2f5e0e0d07cce + goto end7d89230086678ab4ed5cc96a3ae358d6 } c := v.Args[0].AuxInt x := v.Args[1] @@ -1335,14 +1335,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AuxInt = c + v0.Type = TypeFlags v.AddArg(v0) return true } - goto end3c04e861f07a442be9e2f5e0e0d07cce - end3c04e861f07a442be9e2f5e0e0d07cce: + goto end7d89230086678ab4ed5cc96a3ae358d6 + end7d89230086678ab4ed5cc96a3ae358d6: ; case OpAMD64CMPQ: // match: (CMPQ x (MOVQconst [c])) @@ -1370,29 +1370,29 @@ func rewriteValueAMD64(v *Value, config *Config) bool { ; // match: (CMPQ (MOVQconst [c]) x) // cond: is32Bit(c) - // result: (InvertFlags (CMPQconst x [c])) + // result: (InvertFlags (CMPQconst x [c])) { if v.Args[0].Op != OpAMD64MOVQconst { - goto end5edbe48a495a51ecabd3b2c0ed44a3d3 + goto end153e951c4d9890ee40bf6f189ff6280e } c := v.Args[0].AuxInt x := v.Args[1] if !(is32Bit(c)) { - goto end5edbe48a495a51ecabd3b2c0ed44a3d3 + goto end153e951c4d9890ee40bf6f189ff6280e } v.Op = OpAMD64InvertFlags v.AuxInt = 0 v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AuxInt = c + v0.Type = TypeFlags v.AddArg(v0) return true } - goto end5edbe48a495a51ecabd3b2c0ed44a3d3 - end5edbe48a495a51ecabd3b2c0ed44a3d3: + goto end153e951c4d9890ee40bf6f189ff6280e + end153e951c4d9890ee40bf6f189ff6280e: ; case OpAMD64CMPW: // match: (CMPW x (MOVWconst [c])) @@ -1417,10 +1417,10 @@ func rewriteValueAMD64(v *Value, config *Config) bool { ; // match: (CMPW (MOVWconst [c]) x) // cond: - // result: (InvertFlags (CMPWconst x [c])) + // result: (InvertFlags (CMPWconst x [c])) { if v.Args[0].Op != OpAMD64MOVWconst { - goto end1ce191aaab0f4dd3b98dafdfbfac13ce + goto end3c52d0ae6e3d186bf131b41276c21889 } c := v.Args[0].AuxInt x := v.Args[1] @@ -1429,14 +1429,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AuxInt = c + v0.Type = TypeFlags v.AddArg(v0) return true } - goto end1ce191aaab0f4dd3b98dafdfbfac13ce - end1ce191aaab0f4dd3b98dafdfbfac13ce: + goto end3c52d0ae6e3d186bf131b41276c21889 + end3c52d0ae6e3d186bf131b41276c21889: ; case OpClosureCall: // match: (ClosureCall [argwid] entry closure mem) @@ -1995,7 +1995,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { case OpDiv8: // match: (Div8 x y) // cond: - // result: (DIVW (SignExt8to16 x) (SignExt8to16 y)) + // result: (DIVW (SignExt8to16 x) (SignExt8to16 y)) { x := v.Args[0] y := v.Args[1] @@ -2004,22 +2004,22 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpSignExt8to16, TypeInvalid) - v0.Type = config.Frontend().TypeInt16() v0.AddArg(x) + v0.Type = config.fe.TypeInt16() v.AddArg(v0) v1 := b.NewValue0(v.Line, OpSignExt8to16, TypeInvalid) - v1.Type = config.Frontend().TypeInt16() v1.AddArg(y) + v1.Type = config.fe.TypeInt16() v.AddArg(v1) return true } - goto ende25a7899b9c7a869f74226b4b6033084 - ende25a7899b9c7a869f74226b4b6033084: + goto endeee2bc780a73ec2ccb1a66c527816ee0 + endeee2bc780a73ec2ccb1a66c527816ee0: ; case OpDiv8u: // match: (Div8u x y) // cond: - // result: (DIVWU (ZeroExt8to16 x) (ZeroExt8to16 y)) + // result: (DIVWU (ZeroExt8to16 x) (ZeroExt8to16 y)) { x := v.Args[0] y := v.Args[1] @@ -2028,22 +2028,22 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpZeroExt8to16, TypeInvalid) - v0.Type = config.Frontend().TypeUInt16() v0.AddArg(x) + v0.Type = config.fe.TypeUInt16() v.AddArg(v0) v1 := b.NewValue0(v.Line, OpZeroExt8to16, TypeInvalid) - v1.Type = config.Frontend().TypeUInt16() v1.AddArg(y) + v1.Type = config.fe.TypeUInt16() v.AddArg(v1) return true } - goto ende655b41d48feafc4d139b815a3b7b55c - ende655b41d48feafc4d139b815a3b7b55c: + goto end39da6664d6434d844303f6924cc875dd + end39da6664d6434d844303f6924cc875dd: ; case OpEq16: // match: (Eq16 x y) // cond: - // result: (SETEQ (CMPW x y)) + // result: (SETEQ (CMPW x y)) { x := v.Args[0] y := v.Args[1] @@ -2052,19 +2052,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto end66a03470b5b3e8457ba205ccfcaccea6 - end66a03470b5b3e8457ba205ccfcaccea6: + goto endd7f668b1d23603b0949953ee8dec8107 + endd7f668b1d23603b0949953ee8dec8107: ; case OpEq32: // match: (Eq32 x y) // cond: - // result: (SETEQ (CMPL x y)) + // result: (SETEQ (CMPL x y)) { x := v.Args[0] y := v.Args[1] @@ -2073,19 +2073,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto end4d77d0b016f93817fd6e5f60fa0e7ef2 - end4d77d0b016f93817fd6e5f60fa0e7ef2: + goto endf28041ae0c73fb341cc0d2f4903fb2fb + endf28041ae0c73fb341cc0d2f4903fb2fb: ; case OpEq32F: // match: (Eq32F x y) // cond: - // result: (SETEQF (UCOMISS x y)) + // result: (SETEQF (UCOMISS x y)) { x := v.Args[0] y := v.Args[1] @@ -2094,19 +2094,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto end034925b03df528b1ffec9fafdcd56c8e - end034925b03df528b1ffec9fafdcd56c8e: + goto endb2c12933769e5faa8fc238048e113dee + endb2c12933769e5faa8fc238048e113dee: ; case OpEq64: // match: (Eq64 x y) // cond: - // result: (SETEQ (CMPQ x y)) + // result: (SETEQ (CMPQ x y)) { x := v.Args[0] y := v.Args[1] @@ -2115,19 +2115,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto endae6c62e4e20b4f62694b6ee40dbd9211 - endae6c62e4e20b4f62694b6ee40dbd9211: + goto ende07a380487b710b51bcd5aa6d3144b8c + ende07a380487b710b51bcd5aa6d3144b8c: ; case OpEq64F: // match: (Eq64F x y) // cond: - // result: (SETEQF (UCOMISD x y)) + // result: (SETEQF (UCOMISD x y)) { x := v.Args[0] y := v.Args[1] @@ -2136,19 +2136,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto end62b2fb60187571e6ab0c53696ef7d030 - end62b2fb60187571e6ab0c53696ef7d030: + goto end68e20c0c1b3ee62fbd17af07ac100704 + end68e20c0c1b3ee62fbd17af07ac100704: ; case OpEq8: // match: (Eq8 x y) // cond: - // result: (SETEQ (CMPB x y)) + // result: (SETEQ (CMPB x y)) { x := v.Args[0] y := v.Args[1] @@ -2157,19 +2157,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto end84a692e769900e3adbfe00718d2169e0 - end84a692e769900e3adbfe00718d2169e0: + goto end359e5a51d2ab928a455f0ae5adb42ab0 + end359e5a51d2ab928a455f0ae5adb42ab0: ; case OpEqPtr: // match: (EqPtr x y) // cond: - // result: (SETEQ (CMPQ x y)) + // result: (SETEQ (CMPQ x y)) { x := v.Args[0] y := v.Args[1] @@ -2178,19 +2178,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto end6de1d39c9d151e5e503d643bd835356e - end6de1d39c9d151e5e503d643bd835356e: + goto endf19bd3c0eb99d15718bef4066d62560c + endf19bd3c0eb99d15718bef4066d62560c: ; case OpGeq16: // match: (Geq16 x y) // cond: - // result: (SETGE (CMPW x y)) + // result: (SETGE (CMPW x y)) { x := v.Args[0] y := v.Args[1] @@ -2199,19 +2199,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto end26084bf821f9e418934fee812632b774 - end26084bf821f9e418934fee812632b774: + goto end0a3f723d5c0b877c473b0043d814867b + end0a3f723d5c0b877c473b0043d814867b: ; case OpGeq16U: // match: (Geq16U x y) // cond: - // result: (SETAE (CMPW x y)) + // result: (SETAE (CMPW x y)) { x := v.Args[0] y := v.Args[1] @@ -2220,19 +2220,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto end20b00f850ca834cb2013414645c19ad9 - end20b00f850ca834cb2013414645c19ad9: + goto end79d754a28ee34eff95140635b26f0248 + end79d754a28ee34eff95140635b26f0248: ; case OpGeq32: // match: (Geq32 x y) // cond: - // result: (SETGE (CMPL x y)) + // result: (SETGE (CMPL x y)) { x := v.Args[0] y := v.Args[1] @@ -2241,19 +2241,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto end713c3dfa0f7247dcc232bcfc916fb044 - end713c3dfa0f7247dcc232bcfc916fb044: + goto endfb1f6286a1b153b2a3f5b8548a782c8c + endfb1f6286a1b153b2a3f5b8548a782c8c: ; case OpGeq32F: // match: (Geq32F x y) // cond: - // result: (SETGEF (UCOMISS x y)) + // result: (SETGEF (UCOMISS x y)) { x := v.Args[0] y := v.Args[1] @@ -2262,19 +2262,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto end5847ac7f2e264fba4c408ebb60c1e8a5 - end5847ac7f2e264fba4c408ebb60c1e8a5: + goto end7a8d6107a945410e64db06669a61da97 + end7a8d6107a945410e64db06669a61da97: ; case OpGeq32U: // match: (Geq32U x y) // cond: - // result: (SETAE (CMPL x y)) + // result: (SETAE (CMPL x y)) { x := v.Args[0] y := v.Args[1] @@ -2283,19 +2283,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto endac2cde17ec6ab0107eabbda6407d1004 - endac2cde17ec6ab0107eabbda6407d1004: + goto endc5d3478a626df01ede063564f4cb80d0 + endc5d3478a626df01ede063564f4cb80d0: ; case OpGeq64: // match: (Geq64 x y) // cond: - // result: (SETGE (CMPQ x y)) + // result: (SETGE (CMPQ x y)) { x := v.Args[0] y := v.Args[1] @@ -2304,19 +2304,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto end63f44e3fec8d92723b5bde42d6d7eea0 - end63f44e3fec8d92723b5bde42d6d7eea0: + goto end74bddb7905ab865de5b041e7e4789911 + end74bddb7905ab865de5b041e7e4789911: ; case OpGeq64F: // match: (Geq64F x y) // cond: - // result: (SETGEF (UCOMISD x y)) + // result: (SETGEF (UCOMISD x y)) { x := v.Args[0] y := v.Args[1] @@ -2325,19 +2325,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto endb40fbc46a8fc04fef95182771e2933c2 - endb40fbc46a8fc04fef95182771e2933c2: + goto end9fac9bd98ef58b7fbbe1a31f84bdcccf + end9fac9bd98ef58b7fbbe1a31f84bdcccf: ; case OpGeq64U: // match: (Geq64U x y) // cond: - // result: (SETAE (CMPQ x y)) + // result: (SETAE (CMPQ x y)) { x := v.Args[0] y := v.Args[1] @@ -2346,19 +2346,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto endd8d2d9faa19457f6a7b0635a756d234f - endd8d2d9faa19457f6a7b0635a756d234f: + goto end95101721fc8f5be9969e50e364143e7f + end95101721fc8f5be9969e50e364143e7f: ; case OpGeq8: // match: (Geq8 x y) // cond: - // result: (SETGE (CMPB x y)) + // result: (SETGE (CMPB x y)) { x := v.Args[0] y := v.Args[1] @@ -2367,19 +2367,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto endb5f40ee158007e675b2113c3ce962382 - endb5f40ee158007e675b2113c3ce962382: + goto end983070a3db317bdb64b5a0fb104d267c + end983070a3db317bdb64b5a0fb104d267c: ; case OpGeq8U: // match: (Geq8U x y) // cond: - // result: (SETAE (CMPB x y)) + // result: (SETAE (CMPB x y)) { x := v.Args[0] y := v.Args[1] @@ -2388,14 +2388,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto endd30ee67afc0284c419cef70261f61452 - endd30ee67afc0284c419cef70261f61452: + goto enda617119faaccc0f0c2d23548116cf331 + enda617119faaccc0f0c2d23548116cf331: ; case OpGetG: // match: (GetG) @@ -2414,7 +2414,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { case OpGreater16: // match: (Greater16 x y) // cond: - // result: (SETG (CMPW x y)) + // result: (SETG (CMPW x y)) { x := v.Args[0] y := v.Args[1] @@ -2423,19 +2423,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto end5bc9fdb7e563a6b949e42d721903cb58 - end5bc9fdb7e563a6b949e42d721903cb58: + goto end4e4a1307c61240af9a86d8fe4f834ee8 + end4e4a1307c61240af9a86d8fe4f834ee8: ; case OpGreater16U: // match: (Greater16U x y) // cond: - // result: (SETA (CMPW x y)) + // result: (SETA (CMPW x y)) { x := v.Args[0] y := v.Args[1] @@ -2444,19 +2444,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto endd5b646f04fd839d11082a9ff6adb4a3f - endd5b646f04fd839d11082a9ff6adb4a3f: + goto end7c66c75f4b8ec1db593f3e60cfba9592 + end7c66c75f4b8ec1db593f3e60cfba9592: ; case OpGreater32: // match: (Greater32 x y) // cond: - // result: (SETG (CMPL x y)) + // result: (SETG (CMPL x y)) { x := v.Args[0] y := v.Args[1] @@ -2465,19 +2465,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto endbf0b2b1368aadff48969a7386eee5795 - endbf0b2b1368aadff48969a7386eee5795: + goto end6fb0eae4a0e0e81b4afb085d398d873b + end6fb0eae4a0e0e81b4afb085d398d873b: ; case OpGreater32F: // match: (Greater32F x y) // cond: - // result: (SETGF (UCOMISS x y)) + // result: (SETGF (UCOMISS x y)) { x := v.Args[0] y := v.Args[1] @@ -2486,19 +2486,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto endb65b042358784f18002ae59ea6f2c51a - endb65b042358784f18002ae59ea6f2c51a: + goto end94df0bd5cedad8ce8021df1b24da40c6 + end94df0bd5cedad8ce8021df1b24da40c6: ; case OpGreater32U: // match: (Greater32U x y) // cond: - // result: (SETA (CMPL x y)) + // result: (SETA (CMPL x y)) { x := v.Args[0] y := v.Args[1] @@ -2507,19 +2507,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto end033c944272dc0af6fafe33f667cf7485 - end033c944272dc0af6fafe33f667cf7485: + goto end18da022a28eae8bd0771e0c948aadaf8 + end18da022a28eae8bd0771e0c948aadaf8: ; case OpGreater64: // match: (Greater64 x y) // cond: - // result: (SETG (CMPQ x y)) + // result: (SETG (CMPQ x y)) { x := v.Args[0] y := v.Args[1] @@ -2528,19 +2528,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto endaef0cfa5e27e23cf5e527061cf251069 - endaef0cfa5e27e23cf5e527061cf251069: + goto endc025c908708f939780fba0da0c1148b4 + endc025c908708f939780fba0da0c1148b4: ; case OpGreater64F: // match: (Greater64F x y) // cond: - // result: (SETGF (UCOMISD x y)) + // result: (SETGF (UCOMISD x y)) { x := v.Args[0] y := v.Args[1] @@ -2549,19 +2549,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto end1a6ca23bbb3e885473865e3b3ea501e7 - end1a6ca23bbb3e885473865e3b3ea501e7: + goto end033ca5181b18376e7215c02812ef5a6b + end033ca5181b18376e7215c02812ef5a6b: ; case OpGreater64U: // match: (Greater64U x y) // cond: - // result: (SETA (CMPQ x y)) + // result: (SETA (CMPQ x y)) { x := v.Args[0] y := v.Args[1] @@ -2570,19 +2570,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto end2afc16a19fe1073dfa86770a78eba2b4 - end2afc16a19fe1073dfa86770a78eba2b4: + goto endb3e25347041760a04d3fc8321c3f3d00 + endb3e25347041760a04d3fc8321c3f3d00: ; case OpGreater8: // match: (Greater8 x y) // cond: - // result: (SETG (CMPB x y)) + // result: (SETG (CMPB x y)) { x := v.Args[0] y := v.Args[1] @@ -2591,19 +2591,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto endbdb1e5f6b760cf02e0fc2f474622e6be - endbdb1e5f6b760cf02e0fc2f474622e6be: + goto enda3eeb5da2e69cb54a1515601d4b360d4 + enda3eeb5da2e69cb54a1515601d4b360d4: ; case OpGreater8U: // match: (Greater8U x y) // cond: - // result: (SETA (CMPB x y)) + // result: (SETA (CMPB x y)) { x := v.Args[0] y := v.Args[1] @@ -2612,14 +2612,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto end22eaafbcfe70447f79d9b3e6cc395bbd - end22eaafbcfe70447f79d9b3e6cc395bbd: + goto endd2027f3b6471262f42b90c8cc0413667 + endd2027f3b6471262f42b90c8cc0413667: ; case OpHmul16: // match: (Hmul16 x y) @@ -2753,7 +2753,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { case OpIsInBounds: // match: (IsInBounds idx len) // cond: - // result: (SETB (CMPQ idx len)) + // result: (SETB (CMPQ idx len)) { idx := v.Args[0] len := v.Args[1] @@ -2762,19 +2762,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(idx) v0.AddArg(len) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto endb51d371171154c0f1613b687757e0576 - endb51d371171154c0f1613b687757e0576: + goto endfff988d5f1912886d73be3bb563c37d9 + endfff988d5f1912886d73be3bb563c37d9: ; case OpIsNonNil: // match: (IsNonNil p) // cond: - // result: (SETNE (TESTQ p p)) + // result: (SETNE (TESTQ p p)) { p := v.Args[0] v.Op = OpAMD64SETNE @@ -2782,19 +2782,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64TESTQ, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(p) v0.AddArg(p) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto endff508c3726edfb573abc6128c177e76c - endff508c3726edfb573abc6128c177e76c: + goto end0af5ec868ede9ea73fb0602d54b863e9 + end0af5ec868ede9ea73fb0602d54b863e9: ; case OpIsSliceInBounds: // match: (IsSliceInBounds idx len) // cond: - // result: (SETBE (CMPQ idx len)) + // result: (SETBE (CMPQ idx len)) { idx := v.Args[0] len := v.Args[1] @@ -2803,19 +2803,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(idx) v0.AddArg(len) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto end41f8211150e3a4ef36a1b5168013f96f - end41f8211150e3a4ef36a1b5168013f96f: + goto end02799ad95fe7fb5ce3c2c8ab313b737c + end02799ad95fe7fb5ce3c2c8ab313b737c: ; case OpLeq16: // match: (Leq16 x y) // cond: - // result: (SETLE (CMPW x y)) + // result: (SETLE (CMPW x y)) { x := v.Args[0] y := v.Args[1] @@ -2824,19 +2824,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto endc1916dfcb3eae58ab237e40a57e1ff16 - endc1916dfcb3eae58ab237e40a57e1ff16: + goto end586c647ca6bb8ec725eea917c743d1ea + end586c647ca6bb8ec725eea917c743d1ea: ; case OpLeq16U: // match: (Leq16U x y) // cond: - // result: (SETBE (CMPW x y)) + // result: (SETBE (CMPW x y)) { x := v.Args[0] y := v.Args[1] @@ -2845,19 +2845,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto end627e261aea217b5d17177b52711b8c82 - end627e261aea217b5d17177b52711b8c82: + goto end9c24a81bc6a4a92267bd6638362dfbfc + end9c24a81bc6a4a92267bd6638362dfbfc: ; case OpLeq32: // match: (Leq32 x y) // cond: - // result: (SETLE (CMPL x y)) + // result: (SETLE (CMPL x y)) { x := v.Args[0] y := v.Args[1] @@ -2866,19 +2866,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto endf422ecc8da0033e22242de9c67112537 - endf422ecc8da0033e22242de9c67112537: + goto end595ee99a9fc3460b2748b9129b139f88 + end595ee99a9fc3460b2748b9129b139f88: ; case OpLeq32F: // match: (Leq32F x y) // cond: - // result: (SETGEF (UCOMISS y x)) + // result: (SETGEF (UCOMISS y x)) { x := v.Args[0] y := v.Args[1] @@ -2887,19 +2887,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(y) v0.AddArg(x) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto end98f7b2e6e15ce282d044c812454fe77f - end98f7b2e6e15ce282d044c812454fe77f: + goto endfee4b989a80cc43328b24f7017e80a17 + endfee4b989a80cc43328b24f7017e80a17: ; case OpLeq32U: // match: (Leq32U x y) // cond: - // result: (SETBE (CMPL x y)) + // result: (SETBE (CMPL x y)) { x := v.Args[0] y := v.Args[1] @@ -2908,19 +2908,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto end1b39c9661896abdff8a29de509311b96 - end1b39c9661896abdff8a29de509311b96: + goto end1a59850aad6cb17c295d0dc359013420 + end1a59850aad6cb17c295d0dc359013420: ; case OpLeq64: // match: (Leq64 x y) // cond: - // result: (SETLE (CMPQ x y)) + // result: (SETLE (CMPQ x y)) { x := v.Args[0] y := v.Args[1] @@ -2929,19 +2929,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto endf03da5e28dccdb4797671f39e824fb10 - endf03da5e28dccdb4797671f39e824fb10: + goto end406def83fcbf29cd8fa306170b512de2 + end406def83fcbf29cd8fa306170b512de2: ; case OpLeq64F: // match: (Leq64F x y) // cond: - // result: (SETGEF (UCOMISD y x)) + // result: (SETGEF (UCOMISD y x)) { x := v.Args[0] y := v.Args[1] @@ -2950,19 +2950,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(y) v0.AddArg(x) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto end7efa164f4e4f5a395f547b1885b7eef4 - end7efa164f4e4f5a395f547b1885b7eef4: + goto end6e3de6d4b5668f673e3822d5947edbd0 + end6e3de6d4b5668f673e3822d5947edbd0: ; case OpLeq64U: // match: (Leq64U x y) // cond: - // result: (SETBE (CMPQ x y)) + // result: (SETBE (CMPQ x y)) { x := v.Args[0] y := v.Args[1] @@ -2971,19 +2971,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto end37302777dd91a5d0c6f410a5444ccb38 - end37302777dd91a5d0c6f410a5444ccb38: + goto end52f23c145b80639c8d60420ad4057bc7 + end52f23c145b80639c8d60420ad4057bc7: ; case OpLeq8: // match: (Leq8 x y) // cond: - // result: (SETLE (CMPB x y)) + // result: (SETLE (CMPB x y)) { x := v.Args[0] y := v.Args[1] @@ -2992,19 +2992,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto end03be536eea60fdd98d48b17681acaf5a - end03be536eea60fdd98d48b17681acaf5a: + goto end72ecba6f2a7062cb266923dfec811f79 + end72ecba6f2a7062cb266923dfec811f79: ; case OpLeq8U: // match: (Leq8U x y) // cond: - // result: (SETBE (CMPB x y)) + // result: (SETBE (CMPB x y)) { x := v.Args[0] y := v.Args[1] @@ -3013,19 +3013,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto end661377f6745450bb1fa7fd0608ef0a86 - end661377f6745450bb1fa7fd0608ef0a86: + goto endb043b338cced4f15400d8d6e584ebea7 + endb043b338cced4f15400d8d6e584ebea7: ; case OpLess16: // match: (Less16 x y) // cond: - // result: (SETL (CMPW x y)) + // result: (SETL (CMPW x y)) { x := v.Args[0] y := v.Args[1] @@ -3034,19 +3034,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto endeb09704ef62ba2695a967b6fcb42e562 - endeb09704ef62ba2695a967b6fcb42e562: + goto end2f6c6ba80eda8d68e77a58cba13d3f16 + end2f6c6ba80eda8d68e77a58cba13d3f16: ; case OpLess16U: // match: (Less16U x y) // cond: - // result: (SETB (CMPW x y)) + // result: (SETB (CMPW x y)) { x := v.Args[0] y := v.Args[1] @@ -3055,19 +3055,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto end2209a57bd887f68ad732aa7da2bc7286 - end2209a57bd887f68ad732aa7da2bc7286: + goto end9f65eefe7b83a3c436b5c16664c93703 + end9f65eefe7b83a3c436b5c16664c93703: ; case OpLess32: // match: (Less32 x y) // cond: - // result: (SETL (CMPL x y)) + // result: (SETL (CMPL x y)) { x := v.Args[0] y := v.Args[1] @@ -3076,19 +3076,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto end8da8d2030c0a323a84503c1240c566ae - end8da8d2030c0a323a84503c1240c566ae: + goto end6632ff4ee994eb5b14cdf60c99ac3798 + end6632ff4ee994eb5b14cdf60c99ac3798: ; case OpLess32F: // match: (Less32F x y) // cond: - // result: (SETGF (UCOMISS y x)) + // result: (SETGF (UCOMISS y x)) { x := v.Args[0] y := v.Args[1] @@ -3097,19 +3097,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(y) v0.AddArg(x) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto end54f94ce87c18a1ed2beb8d0161bea907 - end54f94ce87c18a1ed2beb8d0161bea907: + goto end5b3b0c96a7fc2ede81bc89c9abaac9d0 + end5b3b0c96a7fc2ede81bc89c9abaac9d0: ; case OpLess32U: // match: (Less32U x y) // cond: - // result: (SETB (CMPL x y)) + // result: (SETB (CMPL x y)) { x := v.Args[0] y := v.Args[1] @@ -3118,19 +3118,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto enddcfbbb482eb194146f4f7c8f12029a7a - enddcfbbb482eb194146f4f7c8f12029a7a: + goto end39e5a513c7fb0a42817a6cf9c6143b60 + end39e5a513c7fb0a42817a6cf9c6143b60: ; case OpLess64: // match: (Less64 x y) // cond: - // result: (SETL (CMPQ x y)) + // result: (SETL (CMPQ x y)) { x := v.Args[0] y := v.Args[1] @@ -3139,19 +3139,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto endf8e7a24c25692045bbcfd2c9356d1a8c - endf8e7a24c25692045bbcfd2c9356d1a8c: + goto enddce827d3e922e8487b61a88c2b1510f2 + enddce827d3e922e8487b61a88c2b1510f2: ; case OpLess64F: // match: (Less64F x y) // cond: - // result: (SETGF (UCOMISD y x)) + // result: (SETGF (UCOMISD y x)) { x := v.Args[0] y := v.Args[1] @@ -3160,19 +3160,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(y) v0.AddArg(x) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto end92720155a95cbfae47ea469583c4d3c7 - end92720155a95cbfae47ea469583c4d3c7: + goto endf2be3d2dcb6543d2159e7fff5ccbbb55 + endf2be3d2dcb6543d2159e7fff5ccbbb55: ; case OpLess64U: // match: (Less64U x y) // cond: - // result: (SETB (CMPQ x y)) + // result: (SETB (CMPQ x y)) { x := v.Args[0] y := v.Args[1] @@ -3181,19 +3181,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto end2fac0a2c2e972b5e04b5062d5786b87d - end2fac0a2c2e972b5e04b5062d5786b87d: + goto endb76d7768f175a44baf6d63d12ab6e81d + endb76d7768f175a44baf6d63d12ab6e81d: ; case OpLess8: // match: (Less8 x y) // cond: - // result: (SETL (CMPB x y)) + // result: (SETL (CMPB x y)) { x := v.Args[0] y := v.Args[1] @@ -3202,19 +3202,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto end445ad05f8d23dfecf246ce083f1ea167 - end445ad05f8d23dfecf246ce083f1ea167: + goto end314fbffe99f3bd4b07857a80c0b914cd + end314fbffe99f3bd4b07857a80c0b914cd: ; case OpLess8U: // match: (Less8U x y) // cond: - // result: (SETB (CMPB x y)) + // result: (SETB (CMPB x y)) { x := v.Args[0] y := v.Args[1] @@ -3223,14 +3223,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto end816d1dff858c45836dfa337262e04649 - end816d1dff858c45836dfa337262e04649: + goto endadccc5d80fd053a33004ed0759f64d93 + endadccc5d80fd053a33004ed0759f64d93: ; case OpLoad: // match: (Load ptr mem) @@ -3442,7 +3442,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { case OpLsh16x16: // match: (Lsh16x16 x y) // cond: - // result: (ANDW (SHLW x y) (SBBLcarrymask (CMPWconst [16] y))) + // result: (ANDW (SHLW x y) (SBBLcarrymask (CMPWconst [16] y))) { t := v.Type x := v.Args[0] @@ -3459,20 +3459,20 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) - v2.Type = TypeFlags v2.AuxInt = 16 v2.AddArg(y) + v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end5b63495f0e75ac68c4ce9d4afa1472d4 - end5b63495f0e75ac68c4ce9d4afa1472d4: + goto end7ffc4f31c526f7fcb2283215b458f589 + end7ffc4f31c526f7fcb2283215b458f589: ; case OpLsh16x32: // match: (Lsh16x32 x y) // cond: - // result: (ANDW (SHLW x y) (SBBLcarrymask (CMPLconst [16] y))) + // result: (ANDW (SHLW x y) (SBBLcarrymask (CMPLconst [16] y))) { t := v.Type x := v.Args[0] @@ -3489,20 +3489,20 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) - v2.Type = TypeFlags v2.AuxInt = 16 v2.AddArg(y) + v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end6384dd9bdcec3046732d7347250d49f6 - end6384dd9bdcec3046732d7347250d49f6: + goto enddcc0e751d315967423c99518c0cc065e + enddcc0e751d315967423c99518c0cc065e: ; case OpLsh16x64: // match: (Lsh16x64 x y) // cond: - // result: (ANDW (SHLW x y) (SBBLcarrymask (CMPQconst [16] y))) + // result: (ANDW (SHLW x y) (SBBLcarrymask (CMPQconst [16] y))) { t := v.Type x := v.Args[0] @@ -3519,20 +3519,20 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) - v2.Type = TypeFlags v2.AuxInt = 16 v2.AddArg(y) + v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end0975ca28988350db0ad556c925d8af07 - end0975ca28988350db0ad556c925d8af07: + goto endf6368b59d046ca83050cd75fbe8715d2 + endf6368b59d046ca83050cd75fbe8715d2: ; case OpLsh16x8: // match: (Lsh16x8 x y) // cond: - // result: (ANDW (SHLW x y) (SBBLcarrymask (CMPBconst [16] y))) + // result: (ANDW (SHLW x y) (SBBLcarrymask (CMPBconst [16] y))) { t := v.Type x := v.Args[0] @@ -3549,20 +3549,20 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) - v2.Type = TypeFlags v2.AuxInt = 16 v2.AddArg(y) + v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto endd17c913707f29d59cfcb5d57d5f5c6ff - endd17c913707f29d59cfcb5d57d5f5c6ff: + goto end8730d944c8fb358001ba2d165755bdc4 + end8730d944c8fb358001ba2d165755bdc4: ; case OpLsh32x16: // match: (Lsh32x16 x y) // cond: - // result: (ANDL (SHLL x y) (SBBLcarrymask (CMPWconst [32] y))) + // result: (ANDL (SHLL x y) (SBBLcarrymask (CMPWconst [32] y))) { t := v.Type x := v.Args[0] @@ -3579,20 +3579,20 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) - v2.Type = TypeFlags v2.AuxInt = 32 v2.AddArg(y) + v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end027b6f888054cc1dd8911fe16a6315a1 - end027b6f888054cc1dd8911fe16a6315a1: + goto end5a43b7e9b0780e62f622bac0a68524d2 + end5a43b7e9b0780e62f622bac0a68524d2: ; case OpLsh32x32: // match: (Lsh32x32 x y) // cond: - // result: (ANDL (SHLL x y) (SBBLcarrymask (CMPLconst [32] y))) + // result: (ANDL (SHLL x y) (SBBLcarrymask (CMPLconst [32] y))) { t := v.Type x := v.Args[0] @@ -3609,20 +3609,20 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) - v2.Type = TypeFlags v2.AuxInt = 32 v2.AddArg(y) + v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto endbcc31e2bd8800d5ddb27c09d37f867b9 - endbcc31e2bd8800d5ddb27c09d37f867b9: + goto end9ce0ab6f9095c24ea46ca8fe2d7e5507 + end9ce0ab6f9095c24ea46ca8fe2d7e5507: ; case OpLsh32x64: // match: (Lsh32x64 x y) // cond: - // result: (ANDL (SHLL x y) (SBBLcarrymask (CMPQconst [32] y))) + // result: (ANDL (SHLL x y) (SBBLcarrymask (CMPQconst [32] y))) { t := v.Type x := v.Args[0] @@ -3639,20 +3639,20 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) - v2.Type = TypeFlags v2.AuxInt = 32 v2.AddArg(y) + v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end6797e3a3bbb0fe7eda819fe19a4d4b49 - end6797e3a3bbb0fe7eda819fe19a4d4b49: + goto end646b5471b709d5ea6c21f49a2815236f + end646b5471b709d5ea6c21f49a2815236f: ; case OpLsh32x8: // match: (Lsh32x8 x y) // cond: - // result: (ANDL (SHLL x y) (SBBLcarrymask (CMPBconst [32] y))) + // result: (ANDL (SHLL x y) (SBBLcarrymask (CMPBconst [32] y))) { t := v.Type x := v.Args[0] @@ -3669,20 +3669,20 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) - v2.Type = TypeFlags v2.AuxInt = 32 v2.AddArg(y) + v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end7dd2c717933f46750e8a0871aab6fc63 - end7dd2c717933f46750e8a0871aab6fc63: + goto end96a677c71370e7c9179125f92cbdfda8 + end96a677c71370e7c9179125f92cbdfda8: ; case OpLsh64x16: // match: (Lsh64x16 x y) // cond: - // result: (ANDQ (SHLQ x y) (SBBQcarrymask (CMPWconst [64] y))) + // result: (ANDQ (SHLQ x y) (SBBQcarrymask (CMPWconst [64] y))) { t := v.Type x := v.Args[0] @@ -3699,20 +3699,20 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) - v2.Type = TypeFlags v2.AuxInt = 64 v2.AddArg(y) + v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end3a2fda1dddb29e49f46ccde6f5397222 - end3a2fda1dddb29e49f46ccde6f5397222: + goto end5f88f241d68d38954222d81559cd7f9f + end5f88f241d68d38954222d81559cd7f9f: ; case OpLsh64x32: // match: (Lsh64x32 x y) // cond: - // result: (ANDQ (SHLQ x y) (SBBQcarrymask (CMPLconst [64] y))) + // result: (ANDQ (SHLQ x y) (SBBQcarrymask (CMPLconst [64] y))) { t := v.Type x := v.Args[0] @@ -3729,20 +3729,20 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) - v2.Type = TypeFlags v2.AuxInt = 64 v2.AddArg(y) + v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end147322aba732027ac2290fd8173d806a - end147322aba732027ac2290fd8173d806a: + goto endae1705f03ed3d6f43cd63b53496a910a + endae1705f03ed3d6f43cd63b53496a910a: ; case OpLsh64x64: // match: (Lsh64x64 x y) // cond: - // result: (ANDQ (SHLQ x y) (SBBQcarrymask (CMPQconst [64] y))) + // result: (ANDQ (SHLQ x y) (SBBQcarrymask (CMPQconst [64] y))) { t := v.Type x := v.Args[0] @@ -3759,20 +3759,20 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) - v2.Type = TypeFlags v2.AuxInt = 64 v2.AddArg(y) + v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto endeb8e78c9c960fa12e29ea07a8519649b - endeb8e78c9c960fa12e29ea07a8519649b: + goto end1f6f5f510c5c68e4ce4a78643e6d85a1 + end1f6f5f510c5c68e4ce4a78643e6d85a1: ; case OpLsh64x8: // match: (Lsh64x8 x y) // cond: - // result: (ANDQ (SHLQ x y) (SBBQcarrymask (CMPBconst [64] y))) + // result: (ANDQ (SHLQ x y) (SBBQcarrymask (CMPBconst [64] y))) { t := v.Type x := v.Args[0] @@ -3789,20 +3789,20 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) - v2.Type = TypeFlags v2.AuxInt = 64 v2.AddArg(y) + v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end42cdc11c34c81bbd5e8b4ad19ceec1ef - end42cdc11c34c81bbd5e8b4ad19ceec1ef: + goto endd14f5c89e3496b0e425aa1ae366f4b53 + endd14f5c89e3496b0e425aa1ae366f4b53: ; case OpLsh8x16: // match: (Lsh8x16 x y) // cond: - // result: (ANDB (SHLB x y) (SBBLcarrymask (CMPWconst [8] y))) + // result: (ANDB (SHLB x y) (SBBLcarrymask (CMPWconst [8] y))) { t := v.Type x := v.Args[0] @@ -3819,20 +3819,20 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) - v2.Type = TypeFlags v2.AuxInt = 8 v2.AddArg(y) + v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end60bf962bf5256e20b547e18e3c886aa5 - end60bf962bf5256e20b547e18e3c886aa5: + goto end0926c3d8b9a0776ba5058946f6e1a4b7 + end0926c3d8b9a0776ba5058946f6e1a4b7: ; case OpLsh8x32: // match: (Lsh8x32 x y) // cond: - // result: (ANDB (SHLB x y) (SBBLcarrymask (CMPLconst [8] y))) + // result: (ANDB (SHLB x y) (SBBLcarrymask (CMPLconst [8] y))) { t := v.Type x := v.Args[0] @@ -3849,20 +3849,20 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) - v2.Type = TypeFlags v2.AuxInt = 8 v2.AddArg(y) + v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end8ed3445f6dbba1a87c80b140371445ce - end8ed3445f6dbba1a87c80b140371445ce: + goto end5987682d77f197ef0fd95251f413535a + end5987682d77f197ef0fd95251f413535a: ; case OpLsh8x64: // match: (Lsh8x64 x y) // cond: - // result: (ANDB (SHLB x y) (SBBLcarrymask (CMPQconst [8] y))) + // result: (ANDB (SHLB x y) (SBBLcarrymask (CMPQconst [8] y))) { t := v.Type x := v.Args[0] @@ -3879,20 +3879,20 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) - v2.Type = TypeFlags v2.AuxInt = 8 v2.AddArg(y) + v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end0a03c9cc48ef1bfd74973de5f5fb02b0 - end0a03c9cc48ef1bfd74973de5f5fb02b0: + goto end9ffe6731d7d6514b8c0482f1645eee18 + end9ffe6731d7d6514b8c0482f1645eee18: ; case OpLsh8x8: // match: (Lsh8x8 x y) // cond: - // result: (ANDB (SHLB x y) (SBBLcarrymask (CMPBconst [8] y))) + // result: (ANDB (SHLB x y) (SBBLcarrymask (CMPBconst [8] y))) { t := v.Type x := v.Args[0] @@ -3909,15 +3909,15 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) - v2.Type = TypeFlags v2.AuxInt = 8 v2.AddArg(y) + v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end781e3a47b186cf99fcb7137afd3432b9 - end781e3a47b186cf99fcb7137afd3432b9: + goto end2b75242a31c3713ffbfdd8f0288b1c12 + end2b75242a31c3713ffbfdd8f0288b1c12: ; case OpAMD64MOVBQSX: // match: (MOVBQSX (MOVBload [off] {sym} ptr mem)) @@ -5679,7 +5679,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { case OpMod8: // match: (Mod8 x y) // cond: - // result: (MODW (SignExt8to16 x) (SignExt8to16 y)) + // result: (MODW (SignExt8to16 x) (SignExt8to16 y)) { x := v.Args[0] y := v.Args[1] @@ -5688,22 +5688,22 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpSignExt8to16, TypeInvalid) - v0.Type = config.Frontend().TypeInt16() v0.AddArg(x) + v0.Type = config.fe.TypeInt16() v.AddArg(v0) v1 := b.NewValue0(v.Line, OpSignExt8to16, TypeInvalid) - v1.Type = config.Frontend().TypeInt16() v1.AddArg(y) + v1.Type = config.fe.TypeInt16() v.AddArg(v1) return true } - goto end13bfd4e75ea363f7b6926fa05136e193 - end13bfd4e75ea363f7b6926fa05136e193: + goto endf959fc16e72bc6dc47ab7c9ee3778901 + endf959fc16e72bc6dc47ab7c9ee3778901: ; case OpMod8u: // match: (Mod8u x y) // cond: - // result: (MODWU (ZeroExt8to16 x) (ZeroExt8to16 y)) + // result: (MODWU (ZeroExt8to16 x) (ZeroExt8to16 y)) { x := v.Args[0] y := v.Args[1] @@ -5712,17 +5712,17 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpZeroExt8to16, TypeInvalid) - v0.Type = config.Frontend().TypeUInt16() v0.AddArg(x) + v0.Type = config.fe.TypeUInt16() v.AddArg(v0) v1 := b.NewValue0(v.Line, OpZeroExt8to16, TypeInvalid) - v1.Type = config.Frontend().TypeUInt16() v1.AddArg(y) + v1.Type = config.fe.TypeUInt16() v.AddArg(v1) return true } - goto end4c0e16e55b5f8f6d19811fc8d07eacf2 - end4c0e16e55b5f8f6d19811fc8d07eacf2: + goto end9b3274d9dd7f1e91c75ce5e7b548fe97 + end9b3274d9dd7f1e91c75ce5e7b548fe97: ; case OpMove: // match: (Move [size] dst src mem) @@ -6094,7 +6094,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { case OpNeq16: // match: (Neq16 x y) // cond: - // result: (SETNE (CMPW x y)) + // result: (SETNE (CMPW x y)) { x := v.Args[0] y := v.Args[1] @@ -6103,19 +6103,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto endf177c3b3868606824e43e11da7804572 - endf177c3b3868606824e43e11da7804572: + goto end6413ee42d523a005cce9e3372ff2c8e9 + end6413ee42d523a005cce9e3372ff2c8e9: ; case OpNeq32: // match: (Neq32 x y) // cond: - // result: (SETNE (CMPL x y)) + // result: (SETNE (CMPL x y)) { x := v.Args[0] y := v.Args[1] @@ -6124,19 +6124,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto end39c4bf6d063f8a0b6f0064c96ce25173 - end39c4bf6d063f8a0b6f0064c96ce25173: + goto endb1a3ad499a09d8262952e6cbc47a23a8 + endb1a3ad499a09d8262952e6cbc47a23a8: ; case OpNeq32F: // match: (Neq32F x y) // cond: - // result: (SETNEF (UCOMISS x y)) + // result: (SETNEF (UCOMISS x y)) { x := v.Args[0] y := v.Args[1] @@ -6145,19 +6145,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto end4eb0af70b64b789e55d83c15e426b0c5 - end4eb0af70b64b789e55d83c15e426b0c5: + goto end2a001b2774f58aaf8c1e9efce6ae59e7 + end2a001b2774f58aaf8c1e9efce6ae59e7: ; case OpNeq64: // match: (Neq64 x y) // cond: - // result: (SETNE (CMPQ x y)) + // result: (SETNE (CMPQ x y)) { x := v.Args[0] y := v.Args[1] @@ -6166,19 +6166,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto end8ab0bcb910c0d3213dd8726fbcc4848e - end8ab0bcb910c0d3213dd8726fbcc4848e: + goto end092b9159bce08d2ef7896f7d3da5a595 + end092b9159bce08d2ef7896f7d3da5a595: ; case OpNeq64F: // match: (Neq64F x y) // cond: - // result: (SETNEF (UCOMISD x y)) + // result: (SETNEF (UCOMISD x y)) { x := v.Args[0] y := v.Args[1] @@ -6187,19 +6187,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto end73beb54a015a226bc2e83bdd39e7ee46 - end73beb54a015a226bc2e83bdd39e7ee46: + goto endb9c010023c38bd2fee7800fbefc85d98 + endb9c010023c38bd2fee7800fbefc85d98: ; case OpNeq8: // match: (Neq8 x y) // cond: - // result: (SETNE (CMPB x y)) + // result: (SETNE (CMPB x y)) { x := v.Args[0] y := v.Args[1] @@ -6208,19 +6208,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto end4aaff28af59a65b3684f4f1897299932 - end4aaff28af59a65b3684f4f1897299932: + goto end89e59f45e068c89458cc4db1692bf3bb + end89e59f45e068c89458cc4db1692bf3bb: ; case OpNeqPtr: // match: (NeqPtr x y) // cond: - // result: (SETNE (CMPQ x y)) + // result: (SETNE (CMPQ x y)) { x := v.Args[0] y := v.Args[1] @@ -6229,14 +6229,14 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(x) v0.AddArg(y) + v0.Type = TypeFlags v.AddArg(v0) return true } - goto end6e180ffd9583cd55361ed3e465158a4c - end6e180ffd9583cd55361ed3e465158a4c: + goto end3b8bb3b4952011d1d40f993d8717cf16 + end3b8bb3b4952011d1d40f993d8717cf16: ; case OpNot: // match: (Not x) @@ -6874,7 +6874,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { case OpRsh16Ux16: // match: (Rsh16Ux16 x y) // cond: - // result: (ANDW (SHRW x y) (SBBLcarrymask (CMPWconst [16] y))) + // result: (ANDW (SHRW x y) (SBBLcarrymask (CMPWconst [16] y))) { t := v.Type x := v.Args[0] @@ -6891,20 +6891,20 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) - v2.Type = TypeFlags v2.AuxInt = 16 v2.AddArg(y) + v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end73239750a306668023d2c49875ac442f - end73239750a306668023d2c49875ac442f: + goto end4d5e000764dcea396f2d86472c2af6eb + end4d5e000764dcea396f2d86472c2af6eb: ; case OpRsh16Ux32: // match: (Rsh16Ux32 x y) // cond: - // result: (ANDW (SHRW x y) (SBBLcarrymask (CMPLconst [16] y))) + // result: (ANDW (SHRW x y) (SBBLcarrymask (CMPLconst [16] y))) { t := v.Type x := v.Args[0] @@ -6921,20 +6921,20 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) - v2.Type = TypeFlags v2.AuxInt = 16 v2.AddArg(y) + v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end9951e3b2e92c892256feece722b32219 - end9951e3b2e92c892256feece722b32219: + goto end9ef4fe2ea4565865cd4b3aa9c7596c00 + end9ef4fe2ea4565865cd4b3aa9c7596c00: ; case OpRsh16Ux64: // match: (Rsh16Ux64 x y) // cond: - // result: (ANDW (SHRW x y) (SBBLcarrymask (CMPQconst [16] y))) + // result: (ANDW (SHRW x y) (SBBLcarrymask (CMPQconst [16] y))) { t := v.Type x := v.Args[0] @@ -6951,20 +6951,20 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) - v2.Type = TypeFlags v2.AuxInt = 16 v2.AddArg(y) + v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end610d56d808c204abfa40d653447b2c17 - end610d56d808c204abfa40d653447b2c17: + goto end48bc94b9a68aad454eaabc42b2e1d646 + end48bc94b9a68aad454eaabc42b2e1d646: ; case OpRsh16Ux8: // match: (Rsh16Ux8 x y) // cond: - // result: (ANDW (SHRW x y) (SBBLcarrymask (CMPBconst [16] y))) + // result: (ANDW (SHRW x y) (SBBLcarrymask (CMPBconst [16] y))) { t := v.Type x := v.Args[0] @@ -6981,20 +6981,20 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) - v2.Type = TypeFlags v2.AuxInt = 16 v2.AddArg(y) + v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end45e76a8d2b004e6802d53cf12b4757b3 - end45e76a8d2b004e6802d53cf12b4757b3: + goto ende98f618fa53b1f1d5d3f79781d5cb2cc + ende98f618fa53b1f1d5d3f79781d5cb2cc: ; case OpRsh16x16: // match: (Rsh16x16 x y) // cond: - // result: (SARW x (ORW y (NOTL (SBBLcarrymask (CMPWconst [16] y))))) + // result: (SARW x (ORW y (NOTL (SBBLcarrymask (CMPWconst [16] y))))) { t := v.Type x := v.Args[0] @@ -7013,22 +7013,22 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v2.Type = y.Type v3 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) - v3.Type = TypeFlags v3.AuxInt = 16 v3.AddArg(y) + v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) return true } - goto endbcd8fd69ada08517f6f94f35da91e1c3 - endbcd8fd69ada08517f6f94f35da91e1c3: + goto end1de548dcf8d7c7222c7a739809597526 + end1de548dcf8d7c7222c7a739809597526: ; case OpRsh16x32: // match: (Rsh16x32 x y) // cond: - // result: (SARW x (ORL y (NOTL (SBBLcarrymask (CMPLconst [16] y))))) + // result: (SARW x (ORL y (NOTL (SBBLcarrymask (CMPLconst [16] y))))) { t := v.Type x := v.Args[0] @@ -7047,22 +7047,22 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v2.Type = y.Type v3 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) - v3.Type = TypeFlags v3.AuxInt = 16 v3.AddArg(y) + v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) return true } - goto endec3994083e7f82857ecec05906c29aa6 - endec3994083e7f82857ecec05906c29aa6: + goto end74419e1036ea7e0c3a09d05b1eabad22 + end74419e1036ea7e0c3a09d05b1eabad22: ; case OpRsh16x64: // match: (Rsh16x64 x y) // cond: - // result: (SARW x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst [16] y))))) + // result: (SARW x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst [16] y))))) { t := v.Type x := v.Args[0] @@ -7081,22 +7081,22 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) v2.Type = y.Type v3 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) - v3.Type = TypeFlags v3.AuxInt = 16 v3.AddArg(y) + v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) return true } - goto end19da3883e21ffa3a45d7fc648ef38b66 - end19da3883e21ffa3a45d7fc648ef38b66: + goto ende35d1c2918196fae04fca22e80936bab + ende35d1c2918196fae04fca22e80936bab: ; case OpRsh16x8: // match: (Rsh16x8 x y) // cond: - // result: (SARW x (ORB y (NOTL (SBBLcarrymask (CMPBconst [16] y))))) + // result: (SARW x (ORB y (NOTL (SBBLcarrymask (CMPBconst [16] y))))) { t := v.Type x := v.Args[0] @@ -7115,22 +7115,22 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v2.Type = y.Type v3 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) - v3.Type = TypeFlags v3.AuxInt = 16 v3.AddArg(y) + v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) return true } - goto end3c989f6931d059ea04e4ba93601b6c51 - end3c989f6931d059ea04e4ba93601b6c51: + goto endaa6a45afc4c6552c1a90a13160578fba + endaa6a45afc4c6552c1a90a13160578fba: ; case OpRsh32Ux16: // match: (Rsh32Ux16 x y) // cond: - // result: (ANDL (SHRL x y) (SBBLcarrymask (CMPWconst [32] y))) + // result: (ANDL (SHRL x y) (SBBLcarrymask (CMPWconst [32] y))) { t := v.Type x := v.Args[0] @@ -7147,20 +7147,20 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) - v2.Type = TypeFlags v2.AuxInt = 32 v2.AddArg(y) + v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end056ede9885a9fc2f32615a2a03b35388 - end056ede9885a9fc2f32615a2a03b35388: + goto end74495683df77023ed619b4ecee98d94a + end74495683df77023ed619b4ecee98d94a: ; case OpRsh32Ux32: // match: (Rsh32Ux32 x y) // cond: - // result: (ANDL (SHRL x y) (SBBLcarrymask (CMPLconst [32] y))) + // result: (ANDL (SHRL x y) (SBBLcarrymask (CMPLconst [32] y))) { t := v.Type x := v.Args[0] @@ -7177,20 +7177,20 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) - v2.Type = TypeFlags v2.AuxInt = 32 v2.AddArg(y) + v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end30439bdc3517479ea25ae7f54408ba7f - end30439bdc3517479ea25ae7f54408ba7f: + goto enda7d6c92ab2d7467102db447d6b431b28 + enda7d6c92ab2d7467102db447d6b431b28: ; case OpRsh32Ux64: // match: (Rsh32Ux64 x y) // cond: - // result: (ANDL (SHRL x y) (SBBLcarrymask (CMPQconst [32] y))) + // result: (ANDL (SHRL x y) (SBBLcarrymask (CMPQconst [32] y))) { t := v.Type x := v.Args[0] @@ -7207,20 +7207,20 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) - v2.Type = TypeFlags v2.AuxInt = 32 v2.AddArg(y) + v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end49b47fd18b54461d8eea51f6e5889cd2 - end49b47fd18b54461d8eea51f6e5889cd2: + goto end7c0829166a6219a15de2c0aa688a9bb3 + end7c0829166a6219a15de2c0aa688a9bb3: ; case OpRsh32Ux8: // match: (Rsh32Ux8 x y) // cond: - // result: (ANDL (SHRL x y) (SBBLcarrymask (CMPBconst [32] y))) + // result: (ANDL (SHRL x y) (SBBLcarrymask (CMPBconst [32] y))) { t := v.Type x := v.Args[0] @@ -7237,20 +7237,20 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) - v2.Type = TypeFlags v2.AuxInt = 32 v2.AddArg(y) + v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end46e045970a8b1afb9035605fc0e50c69 - end46e045970a8b1afb9035605fc0e50c69: + goto end221315aa8a09c9d8d2f243bf445446ea + end221315aa8a09c9d8d2f243bf445446ea: ; case OpRsh32x16: // match: (Rsh32x16 x y) // cond: - // result: (SARL x (ORW y (NOTL (SBBLcarrymask (CMPWconst [32] y))))) + // result: (SARL x (ORW y (NOTL (SBBLcarrymask (CMPWconst [32] y))))) { t := v.Type x := v.Args[0] @@ -7269,22 +7269,22 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v2.Type = y.Type v3 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) - v3.Type = TypeFlags v3.AuxInt = 32 v3.AddArg(y) + v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) return true } - goto end5d1b8d7e1d1e53e621d13bb0eafc9102 - end5d1b8d7e1d1e53e621d13bb0eafc9102: + goto end521b60d91648f07fe1be359f1cdbde29 + end521b60d91648f07fe1be359f1cdbde29: ; case OpRsh32x32: // match: (Rsh32x32 x y) // cond: - // result: (SARL x (ORL y (NOTL (SBBLcarrymask (CMPLconst [32] y))))) + // result: (SARL x (ORL y (NOTL (SBBLcarrymask (CMPLconst [32] y))))) { t := v.Type x := v.Args[0] @@ -7303,22 +7303,22 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v2.Type = y.Type v3 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) - v3.Type = TypeFlags v3.AuxInt = 32 v3.AddArg(y) + v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) return true } - goto end9c27383961c2161a9955012fce808cab - end9c27383961c2161a9955012fce808cab: + goto end0fc03188975afbca2139e28c38b7cd17 + end0fc03188975afbca2139e28c38b7cd17: ; case OpRsh32x64: // match: (Rsh32x64 x y) // cond: - // result: (SARL x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst [32] y))))) + // result: (SARL x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst [32] y))))) { t := v.Type x := v.Args[0] @@ -7337,22 +7337,22 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) v2.Type = y.Type v3 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) - v3.Type = TypeFlags v3.AuxInt = 32 v3.AddArg(y) + v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) return true } - goto end75dc7144497705c800e0c60dcd4a2828 - end75dc7144497705c800e0c60dcd4a2828: + goto endf36790cc7ba330d448b403a450a7c1d4 + endf36790cc7ba330d448b403a450a7c1d4: ; case OpRsh32x8: // match: (Rsh32x8 x y) // cond: - // result: (SARL x (ORB y (NOTL (SBBLcarrymask (CMPBconst [32] y))))) + // result: (SARL x (ORB y (NOTL (SBBLcarrymask (CMPBconst [32] y))))) { t := v.Type x := v.Args[0] @@ -7371,22 +7371,22 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v2.Type = y.Type v3 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) - v3.Type = TypeFlags v3.AuxInt = 32 v3.AddArg(y) + v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) return true } - goto enda7b94b2fd5cbcd12bb2dcd576bdca481 - enda7b94b2fd5cbcd12bb2dcd576bdca481: + goto end1242709228488be2f2505ead8eabb871 + end1242709228488be2f2505ead8eabb871: ; case OpRsh64Ux16: // match: (Rsh64Ux16 x y) // cond: - // result: (ANDQ (SHRQ x y) (SBBQcarrymask (CMPWconst [64] y))) + // result: (ANDQ (SHRQ x y) (SBBQcarrymask (CMPWconst [64] y))) { t := v.Type x := v.Args[0] @@ -7403,20 +7403,20 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) - v2.Type = TypeFlags v2.AuxInt = 64 v2.AddArg(y) + v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto endc4bdfdc375a5c94978d936bd0db89cc5 - endc4bdfdc375a5c94978d936bd0db89cc5: + goto end0bc6c36a57ebaf0b90fc418f976fe210 + end0bc6c36a57ebaf0b90fc418f976fe210: ; case OpRsh64Ux32: // match: (Rsh64Ux32 x y) // cond: - // result: (ANDQ (SHRQ x y) (SBBQcarrymask (CMPLconst [64] y))) + // result: (ANDQ (SHRQ x y) (SBBQcarrymask (CMPLconst [64] y))) { t := v.Type x := v.Args[0] @@ -7433,20 +7433,20 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) - v2.Type = TypeFlags v2.AuxInt = 64 v2.AddArg(y) + v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end217f32bca5f6744b9a7de052f4fae13e - end217f32bca5f6744b9a7de052f4fae13e: + goto ende3f52062f53bc3b5aa0461a644e38a1b + ende3f52062f53bc3b5aa0461a644e38a1b: ; case OpRsh64Ux64: // match: (Rsh64Ux64 x y) // cond: - // result: (ANDQ (SHRQ x y) (SBBQcarrymask (CMPQconst [64] y))) + // result: (ANDQ (SHRQ x y) (SBBQcarrymask (CMPQconst [64] y))) { t := v.Type x := v.Args[0] @@ -7463,20 +7463,20 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) - v2.Type = TypeFlags v2.AuxInt = 64 v2.AddArg(y) + v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end530dee0bcadf1cf5d092894b6210ffcd - end530dee0bcadf1cf5d092894b6210ffcd: + goto endaec410d0544f817303c79bad739c50fd + endaec410d0544f817303c79bad739c50fd: ; case OpRsh64Ux8: // match: (Rsh64Ux8 x y) // cond: - // result: (ANDQ (SHRQ x y) (SBBQcarrymask (CMPBconst [64] y))) + // result: (ANDQ (SHRQ x y) (SBBQcarrymask (CMPBconst [64] y))) { t := v.Type x := v.Args[0] @@ -7493,20 +7493,20 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) - v2.Type = TypeFlags v2.AuxInt = 64 v2.AddArg(y) + v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto endf09baf4e0005c5eb4905f71ce4c8b306 - endf09baf4e0005c5eb4905f71ce4c8b306: + goto end0318851ecb02e4ad8a2669034adf7862 + end0318851ecb02e4ad8a2669034adf7862: ; case OpRsh64x16: // match: (Rsh64x16 x y) // cond: - // result: (SARQ x (ORW y (NOTL (SBBLcarrymask (CMPWconst [64] y))))) + // result: (SARQ x (ORW y (NOTL (SBBLcarrymask (CMPWconst [64] y))))) { t := v.Type x := v.Args[0] @@ -7525,22 +7525,22 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v2.Type = y.Type v3 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) - v3.Type = TypeFlags v3.AuxInt = 64 v3.AddArg(y) + v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) return true } - goto endb370ee74ca256a604138321ddca9d543 - endb370ee74ca256a604138321ddca9d543: + goto endcf8bbca9a7a848fbebaaaa8b699cd086 + endcf8bbca9a7a848fbebaaaa8b699cd086: ; case OpRsh64x32: // match: (Rsh64x32 x y) // cond: - // result: (SARQ x (ORL y (NOTL (SBBLcarrymask (CMPLconst [64] y))))) + // result: (SARQ x (ORL y (NOTL (SBBLcarrymask (CMPLconst [64] y))))) { t := v.Type x := v.Args[0] @@ -7559,22 +7559,22 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v2.Type = y.Type v3 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) - v3.Type = TypeFlags v3.AuxInt = 64 v3.AddArg(y) + v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) return true } - goto end3cc6edf5b286a449332757ea12d2d601 - end3cc6edf5b286a449332757ea12d2d601: + goto end7604d45b06ee69bf2feddf88b2f33cb6 + end7604d45b06ee69bf2feddf88b2f33cb6: ; case OpRsh64x64: // match: (Rsh64x64 x y) // cond: - // result: (SARQ x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst [64] y))))) + // result: (SARQ x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst [64] y))))) { t := v.Type x := v.Args[0] @@ -7593,22 +7593,22 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) v2.Type = y.Type v3 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) - v3.Type = TypeFlags v3.AuxInt = 64 v3.AddArg(y) + v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) return true } - goto end45de7b33396d9fd2ba377bd095f1d7a6 - end45de7b33396d9fd2ba377bd095f1d7a6: + goto end12a3b44af604b515ad5530502336486f + end12a3b44af604b515ad5530502336486f: ; case OpRsh64x8: // match: (Rsh64x8 x y) // cond: - // result: (SARQ x (ORB y (NOTL (SBBLcarrymask (CMPBconst [64] y))))) + // result: (SARQ x (ORB y (NOTL (SBBLcarrymask (CMPBconst [64] y))))) { t := v.Type x := v.Args[0] @@ -7627,22 +7627,22 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v2.Type = y.Type v3 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) - v3.Type = TypeFlags v3.AuxInt = 64 v3.AddArg(y) + v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) return true } - goto ende03fa68104fd18bb9b2bb94370e0c8b3 - ende03fa68104fd18bb9b2bb94370e0c8b3: + goto end4e2a83809914aad301a2f74d3c38fbbb + end4e2a83809914aad301a2f74d3c38fbbb: ; case OpRsh8Ux16: // match: (Rsh8Ux16 x y) // cond: - // result: (ANDB (SHRB x y) (SBBLcarrymask (CMPWconst [8] y))) + // result: (ANDB (SHRB x y) (SBBLcarrymask (CMPWconst [8] y))) { t := v.Type x := v.Args[0] @@ -7659,20 +7659,20 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) - v2.Type = TypeFlags v2.AuxInt = 8 v2.AddArg(y) + v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto enda1adfc560334e10d5e83fbff27a8752f - enda1adfc560334e10d5e83fbff27a8752f: + goto end724175a51b6efac60c6bb9d83d81215a + end724175a51b6efac60c6bb9d83d81215a: ; case OpRsh8Ux32: // match: (Rsh8Ux32 x y) // cond: - // result: (ANDB (SHRB x y) (SBBLcarrymask (CMPLconst [8] y))) + // result: (ANDB (SHRB x y) (SBBLcarrymask (CMPLconst [8] y))) { t := v.Type x := v.Args[0] @@ -7689,20 +7689,20 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) - v2.Type = TypeFlags v2.AuxInt = 8 v2.AddArg(y) + v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end17f63b4b712e715a33ac780193b59c2e - end17f63b4b712e715a33ac780193b59c2e: + goto end9d973431bed6682c1d557a535cf440ed + end9d973431bed6682c1d557a535cf440ed: ; case OpRsh8Ux64: // match: (Rsh8Ux64 x y) // cond: - // result: (ANDB (SHRB x y) (SBBLcarrymask (CMPQconst [8] y))) + // result: (ANDB (SHRB x y) (SBBLcarrymask (CMPQconst [8] y))) { t := v.Type x := v.Args[0] @@ -7719,20 +7719,20 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) - v2.Type = TypeFlags v2.AuxInt = 8 v2.AddArg(y) + v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end77d5c3ef9982ebd27c135d3461b7430b - end77d5c3ef9982ebd27c135d3461b7430b: + goto end9586937cdeb7946c337d46cd30cb9a11 + end9586937cdeb7946c337d46cd30cb9a11: ; case OpRsh8Ux8: // match: (Rsh8Ux8 x y) // cond: - // result: (ANDB (SHRB x y) (SBBLcarrymask (CMPBconst [8] y))) + // result: (ANDB (SHRB x y) (SBBLcarrymask (CMPBconst [8] y))) { t := v.Type x := v.Args[0] @@ -7749,20 +7749,20 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) - v2.Type = TypeFlags v2.AuxInt = 8 v2.AddArg(y) + v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end206712ffbda924142afbf384aeb8f09e - end206712ffbda924142afbf384aeb8f09e: + goto endc5a55ef63d86e6b8d4d366a947bf563d + endc5a55ef63d86e6b8d4d366a947bf563d: ; case OpRsh8x16: // match: (Rsh8x16 x y) // cond: - // result: (SARB x (ORW y (NOTL (SBBLcarrymask (CMPWconst [8] y))))) + // result: (SARB x (ORW y (NOTL (SBBLcarrymask (CMPWconst [8] y))))) { t := v.Type x := v.Args[0] @@ -7781,22 +7781,22 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v2.Type = y.Type v3 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) - v3.Type = TypeFlags v3.AuxInt = 8 v3.AddArg(y) + v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) return true } - goto endd303f390b49d9716dc783d5c4d57ddd1 - endd303f390b49d9716dc783d5c4d57ddd1: + goto endfa967d6583c1bb9644514c2013b919f8 + endfa967d6583c1bb9644514c2013b919f8: ; case OpRsh8x32: // match: (Rsh8x32 x y) // cond: - // result: (SARB x (ORL y (NOTL (SBBLcarrymask (CMPLconst [8] y))))) + // result: (SARB x (ORL y (NOTL (SBBLcarrymask (CMPLconst [8] y))))) { t := v.Type x := v.Args[0] @@ -7815,22 +7815,22 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v2.Type = y.Type v3 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) - v3.Type = TypeFlags v3.AuxInt = 8 v3.AddArg(y) + v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) return true } - goto ende12a524a6fc68eb245140c6919034337 - ende12a524a6fc68eb245140c6919034337: + goto ende5a630810624a1bd3677618c2cbc8619 + ende5a630810624a1bd3677618c2cbc8619: ; case OpRsh8x64: // match: (Rsh8x64 x y) // cond: - // result: (SARB x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst [8] y))))) + // result: (SARB x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst [8] y))))) { t := v.Type x := v.Args[0] @@ -7849,22 +7849,22 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) v2.Type = y.Type v3 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) - v3.Type = TypeFlags v3.AuxInt = 8 v3.AddArg(y) + v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) return true } - goto end6ee53459daa5458d163c86ea02dd2f31 - end6ee53459daa5458d163c86ea02dd2f31: + goto end23c55e49d8bc44afc680b2a4eade5af6 + end23c55e49d8bc44afc680b2a4eade5af6: ; case OpRsh8x8: // match: (Rsh8x8 x y) // cond: - // result: (SARB x (ORB y (NOTL (SBBLcarrymask (CMPBconst [8] y))))) + // result: (SARB x (ORB y (NOTL (SBBLcarrymask (CMPBconst [8] y))))) { t := v.Type x := v.Args[0] @@ -7883,17 +7883,17 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v2.Type = y.Type v3 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) - v3.Type = TypeFlags v3.AuxInt = 8 v3.AddArg(y) + v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) v0.AddArg(v1) v.AddArg(v0) return true } - goto end07f447a7e25b048c41d412c242330ec0 - end07f447a7e25b048c41d412c242330ec0: + goto enddab0c33c56e2e9434b880e1718621979 + enddab0c33c56e2e9434b880e1718621979: ; case OpAMD64SARB: // match: (SARB x (MOVBconst [c])) @@ -10732,7 +10732,7 @@ func rewriteBlockAMD64(b *Block) bool { ; // match: (If cond yes no) // cond: - // result: (NE (TESTB cond cond) yes no) + // result: (NE (TESTB cond cond) yes no) { v := b.Control cond := v @@ -10740,16 +10740,16 @@ func rewriteBlockAMD64(b *Block) bool { no := b.Succs[1] b.Kind = BlockAMD64NE v0 := b.NewValue0(v.Line, OpAMD64TESTB, TypeInvalid) - v0.Type = TypeFlags v0.AddArg(cond) v0.AddArg(cond) + v0.Type = TypeFlags b.Control = v0 b.Succs[0] = yes b.Succs[1] = no return true } - goto end012351592edfc708bd3181d7e53f3993 - end012351592edfc708bd3181d7e53f3993: + goto end5bdbb8d5ea62ff2a76dccf3f9e89d94d + end5bdbb8d5ea62ff2a76dccf3f9e89d94d: ; case BlockAMD64LE: // match: (LE (InvertFlags cmp) yes no) diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index 3ec41181cc..09f03f985f 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -300,7 +300,7 @@ func rewriteValuegeneric(v *Value, config *Config) bool { case OpConstSlice: // match: (ConstSlice) // cond: - // result: (SliceMake (ConstNil ) (ConstPtr ) (ConstPtr )) + // result: (SliceMake (ConstNil ) (ConstPtr [0]) (ConstPtr [0])) { v.Op = OpSliceMake v.AuxInt = 0 @@ -310,20 +310,22 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v0.Type = config.fe.TypeBytePtr() v.AddArg(v0) v1 := b.NewValue0(v.Line, OpConstPtr, TypeInvalid) + v1.AuxInt = 0 v1.Type = config.fe.TypeUintptr() v.AddArg(v1) v2 := b.NewValue0(v.Line, OpConstPtr, TypeInvalid) + v2.AuxInt = 0 v2.Type = config.fe.TypeUintptr() v.AddArg(v2) return true } - goto endfd2d8ffcd55eaf8a5092a20c3ae61ba3 - endfd2d8ffcd55eaf8a5092a20c3ae61ba3: + goto endc587abac76a5fd9b1284ba891a178e63 + endc587abac76a5fd9b1284ba891a178e63: ; case OpConstString: // match: (ConstString {s}) // cond: - // result: (StringMake (Addr {config.fe.StringData(s.(string))} (SB )) (ConstPtr [int64(len(s.(string)))])) + // result: (StringMake (Addr {config.fe.StringData(s.(string))} (SB)) (ConstPtr [int64(len(s.(string)))])) { s := v.Aux v.Op = OpStringMake @@ -338,13 +340,13 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v0.AddArg(v1) v.AddArg(v0) v2 := b.NewValue0(v.Line, OpConstPtr, TypeInvalid) - v2.Type = config.fe.TypeUintptr() v2.AuxInt = int64(len(s.(string))) + v2.Type = config.fe.TypeUintptr() v.AddArg(v2) return true } - goto end51a3d96f2d304db9a52f36ee6b29c14e - end51a3d96f2d304db9a52f36ee6b29c14e: + goto end2eb756398dd4c6b6d126012a26284c89 + end2eb756398dd4c6b6d126012a26284c89: ; case OpEq16: // match: (Eq16 x x) @@ -445,15 +447,15 @@ func rewriteValuegeneric(v *Value, config *Config) bool { ; // match: (EqFat (Load ptr mem) (ConstNil)) // cond: - // result: (EqPtr (Load ptr mem) (ConstPtr [0])) + // result: (EqPtr (Load ptr mem) (ConstPtr [0])) { if v.Args[0].Op != OpLoad { - goto ende10070e5ddd3dc059674d25ccc6a63b5 + goto end6f10fb57a906a2c23667c770acb6abf9 } ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] if v.Args[1].Op != OpConstNil { - goto ende10070e5ddd3dc059674d25ccc6a63b5 + goto end6f10fb57a906a2c23667c770acb6abf9 } v.Op = OpEqPtr v.AuxInt = 0 @@ -465,13 +467,13 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v0.AddArg(mem) v.AddArg(v0) v1 := b.NewValue0(v.Line, OpConstPtr, TypeInvalid) - v1.Type = config.fe.TypeUintptr() v1.AuxInt = 0 + v1.Type = config.fe.TypeUintptr() v.AddArg(v1) return true } - goto ende10070e5ddd3dc059674d25ccc6a63b5 - ende10070e5ddd3dc059674d25ccc6a63b5: + goto end6f10fb57a906a2c23667c770acb6abf9 + end6f10fb57a906a2c23667c770acb6abf9: ; case OpIData: // match: (IData (IMake _ data)) @@ -928,15 +930,15 @@ func rewriteValuegeneric(v *Value, config *Config) bool { ; // match: (NeqFat (Load ptr mem) (ConstNil)) // cond: - // result: (NeqPtr (Load ptr mem) (ConstPtr [0])) + // result: (NeqPtr (Load ptr mem) (ConstPtr [0])) { if v.Args[0].Op != OpLoad { - goto end423eea941d60473e73140e25f5818bfb + goto end3ffd7685735a83eaee8dc2577ae89d79 } ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] if v.Args[1].Op != OpConstNil { - goto end423eea941d60473e73140e25f5818bfb + goto end3ffd7685735a83eaee8dc2577ae89d79 } v.Op = OpNeqPtr v.AuxInt = 0 @@ -948,13 +950,13 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v0.AddArg(mem) v.AddArg(v0) v1 := b.NewValue0(v.Line, OpConstPtr, TypeInvalid) - v1.Type = config.fe.TypeUintptr() v1.AuxInt = 0 + v1.Type = config.fe.TypeUintptr() v.AddArg(v1) return true } - goto end423eea941d60473e73140e25f5818bfb - end423eea941d60473e73140e25f5818bfb: + goto end3ffd7685735a83eaee8dc2577ae89d79 + end3ffd7685735a83eaee8dc2577ae89d79: ; case OpOr16: // match: (Or16 x x) @@ -1039,7 +1041,7 @@ func rewriteValuegeneric(v *Value, config *Config) bool { case OpPtrIndex: // match: (PtrIndex ptr idx) // cond: - // result: (AddPtr ptr (MulPtr idx (ConstPtr [t.Elem().Size()]))) + // result: (AddPtr ptr (MulPtr idx (ConstPtr [t.Elem().Size()]))) { t := v.Type ptr := v.Args[0] @@ -1050,17 +1052,17 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.resetArgs() v.AddArg(ptr) v0 := b.NewValue0(v.Line, OpMulPtr, TypeInvalid) - v0.Type = config.fe.TypeUintptr() v0.AddArg(idx) v1 := b.NewValue0(v.Line, OpConstPtr, TypeInvalid) - v1.Type = config.fe.TypeUintptr() v1.AuxInt = t.Elem().Size() + v1.Type = config.fe.TypeUintptr() v0.AddArg(v1) + v0.Type = config.fe.TypeUintptr() v.AddArg(v0) return true } - goto end1e1c5ef80c11231f89a5439cdda98359 - end1e1c5ef80c11231f89a5439cdda98359: + goto end502555083d57a877982955070cda7530 + end502555083d57a877982955070cda7530: ; case OpSliceCap: // match: (SliceCap (SliceMake _ _ cap)) @@ -1125,14 +1127,14 @@ func rewriteValuegeneric(v *Value, config *Config) bool { case OpStore: // match: (Store [8] dst (ComplexMake real imag) mem) // cond: - // result: (Store [4] (OffPtr [4] dst) imag (Store [4] dst real mem)) + // result: (Store [4] (OffPtr [4] dst) imag (Store [4] dst real mem)) { if v.AuxInt != 8 { - goto endba187c049aa71488994c8a2eb3453045 + goto endced898cb0a165662afe48ea44ad3318a } dst := v.Args[0] if v.Args[1].Op != OpComplexMake { - goto endba187c049aa71488994c8a2eb3453045 + goto endced898cb0a165662afe48ea44ad3318a } real := v.Args[1].Args[0] imag := v.Args[1].Args[1] @@ -1149,27 +1151,27 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.AddArg(v0) v.AddArg(imag) v1 := b.NewValue0(v.Line, OpStore, TypeInvalid) - v1.Type = TypeMem v1.AuxInt = 4 v1.AddArg(dst) v1.AddArg(real) v1.AddArg(mem) + v1.Type = TypeMem v.AddArg(v1) return true } - goto endba187c049aa71488994c8a2eb3453045 - endba187c049aa71488994c8a2eb3453045: + goto endced898cb0a165662afe48ea44ad3318a + endced898cb0a165662afe48ea44ad3318a: ; // match: (Store [16] dst (ComplexMake real imag) mem) // cond: - // result: (Store [8] (OffPtr [8] dst) imag (Store [8] dst real mem)) + // result: (Store [8] (OffPtr [8] dst) imag (Store [8] dst real mem)) { if v.AuxInt != 16 { - goto end4df4c826201cf51af245d6b89de00589 + goto end3851a482d7bd37a93c4d81581e85b3ab } dst := v.Args[0] if v.Args[1].Op != OpComplexMake { - goto end4df4c826201cf51af245d6b89de00589 + goto end3851a482d7bd37a93c4d81581e85b3ab } real := v.Args[1].Args[0] imag := v.Args[1].Args[1] @@ -1186,27 +1188,27 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.AddArg(v0) v.AddArg(imag) v1 := b.NewValue0(v.Line, OpStore, TypeInvalid) - v1.Type = TypeMem v1.AuxInt = 8 v1.AddArg(dst) v1.AddArg(real) v1.AddArg(mem) + v1.Type = TypeMem v.AddArg(v1) return true } - goto end4df4c826201cf51af245d6b89de00589 - end4df4c826201cf51af245d6b89de00589: + goto end3851a482d7bd37a93c4d81581e85b3ab + end3851a482d7bd37a93c4d81581e85b3ab: ; // match: (Store [2*config.PtrSize] dst (StringMake ptr len) mem) // cond: - // result: (Store [config.PtrSize] (OffPtr [config.PtrSize] dst) len (Store [config.PtrSize] dst ptr mem)) + // result: (Store [config.PtrSize] (OffPtr [config.PtrSize] dst) len (Store [config.PtrSize] dst ptr mem)) { if v.AuxInt != 2*config.PtrSize { - goto end25ae4fc3dc01583a4adc45067d49940a + goto end12abe4021d24e76ed56d64b18730bffb } dst := v.Args[0] if v.Args[1].Op != OpStringMake { - goto end25ae4fc3dc01583a4adc45067d49940a + goto end12abe4021d24e76ed56d64b18730bffb } ptr := v.Args[1].Args[0] len := v.Args[1].Args[1] @@ -1223,27 +1225,27 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.AddArg(v0) v.AddArg(len) v1 := b.NewValue0(v.Line, OpStore, TypeInvalid) - v1.Type = TypeMem v1.AuxInt = config.PtrSize v1.AddArg(dst) v1.AddArg(ptr) v1.AddArg(mem) + v1.Type = TypeMem v.AddArg(v1) return true } - goto end25ae4fc3dc01583a4adc45067d49940a - end25ae4fc3dc01583a4adc45067d49940a: + goto end12abe4021d24e76ed56d64b18730bffb + end12abe4021d24e76ed56d64b18730bffb: ; // match: (Store [3*config.PtrSize] dst (SliceMake ptr len cap) mem) // cond: - // result: (Store [config.PtrSize] (OffPtr [2*config.PtrSize] dst) cap (Store [config.PtrSize] (OffPtr [config.PtrSize] dst) len (Store [config.PtrSize] dst ptr mem))) + // result: (Store [config.PtrSize] (OffPtr [2*config.PtrSize] dst) cap (Store [config.PtrSize] (OffPtr [config.PtrSize] dst) len (Store [config.PtrSize] dst ptr mem))) { if v.AuxInt != 3*config.PtrSize { - goto end39ab85d51c8cd7f5d54e3eea4fb79a96 + goto end7498d25e17db5398cf073a8590e35cc2 } dst := v.Args[0] if v.Args[1].Op != OpSliceMake { - goto end39ab85d51c8cd7f5d54e3eea4fb79a96 + goto end7498d25e17db5398cf073a8590e35cc2 } ptr := v.Args[1].Args[0] len := v.Args[1].Args[1] @@ -1261,7 +1263,6 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.AddArg(v0) v.AddArg(cap) v1 := b.NewValue0(v.Line, OpStore, TypeInvalid) - v1.Type = TypeMem v1.AuxInt = config.PtrSize v2 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) v2.Type = config.fe.TypeUintptr().PtrTo() @@ -1270,28 +1271,29 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v1.AddArg(v2) v1.AddArg(len) v3 := b.NewValue0(v.Line, OpStore, TypeInvalid) - v3.Type = TypeMem v3.AuxInt = config.PtrSize v3.AddArg(dst) v3.AddArg(ptr) v3.AddArg(mem) + v3.Type = TypeMem v1.AddArg(v3) + v1.Type = TypeMem v.AddArg(v1) return true } - goto end39ab85d51c8cd7f5d54e3eea4fb79a96 - end39ab85d51c8cd7f5d54e3eea4fb79a96: + goto end7498d25e17db5398cf073a8590e35cc2 + end7498d25e17db5398cf073a8590e35cc2: ; // match: (Store [2*config.PtrSize] dst (IMake itab data) mem) // cond: - // result: (Store [config.PtrSize] (OffPtr [config.PtrSize] dst) data (Store [config.PtrSize] dst itab mem)) + // result: (Store [config.PtrSize] (OffPtr [config.PtrSize] dst) data (Store [config.PtrSize] dst itab mem)) { if v.AuxInt != 2*config.PtrSize { - goto end63b77ae78d92c05d496202e8b6b96ff3 + goto endaa801a871178ae3256b3f6f5d9f13514 } dst := v.Args[0] if v.Args[1].Op != OpIMake { - goto end63b77ae78d92c05d496202e8b6b96ff3 + goto endaa801a871178ae3256b3f6f5d9f13514 } itab := v.Args[1].Args[0] data := v.Args[1].Args[1] @@ -1308,16 +1310,16 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.AddArg(v0) v.AddArg(data) v1 := b.NewValue0(v.Line, OpStore, TypeInvalid) - v1.Type = TypeMem v1.AuxInt = config.PtrSize v1.AddArg(dst) v1.AddArg(itab) v1.AddArg(mem) + v1.Type = TypeMem v.AddArg(v1) return true } - goto end63b77ae78d92c05d496202e8b6b96ff3 - end63b77ae78d92c05d496202e8b6b96ff3: + goto endaa801a871178ae3256b3f6f5d9f13514 + endaa801a871178ae3256b3f6f5d9f13514: ; // match: (Store [size] dst (Load src mem) mem) // cond: size > config.IntSize -- cgit v1.3 From 3a9d0ac3c807de9c6b91a91fa1e37f75da1941a8 Mon Sep 17 00:00:00 2001 From: David Chase Date: Fri, 28 Aug 2015 14:24:10 -0400 Subject: [dev.ssa] cmd/compile: add complex arithmetic Still to do: details, more testing corner cases. (e.g. negative zero) Includes small cleanups for previous CL. Note: complex division is currently done in the runtime, so the division code here is apparently not yet necessary and also not tested. Seems likely better to open code division and expose the widening/narrowing to optimization. Complex64 multiplication and division is done in wide format to avoid cancellation errors; for division, this also happens to be compatible with pre-SSA practice (which uses a single complex128 division function). It would-be-nice to widen for complex128 multiplication intermediates as well, but that is trickier to implement without a handy wider-precision format. Change-Id: I595a4300f68868fb7641852a54674c6b2b78855e Reviewed-on: https://go-review.googlesource.com/14028 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 153 ++++++++++++++++++++++--- src/cmd/compile/internal/gc/testdata/fp_ssa.go | 102 ++++++++++++++++- src/cmd/compile/internal/ssa/decompose.go | 9 +- src/cmd/compile/internal/ssa/gen/AMD64.rules | 2 + src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 2 + src/cmd/compile/internal/ssa/gen/genericOps.go | 7 +- src/cmd/compile/internal/ssa/gen/rulegen.go | 3 + src/cmd/compile/internal/ssa/opGen.go | 24 ++++ src/cmd/compile/internal/ssa/rewriteAMD64.go | 43 +++++++ src/cmd/compile/internal/ssa/rewritegeneric.go | 3 + 10 files changed, 325 insertions(+), 23 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index c0bff2a5f0..17288c3156 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -747,14 +747,16 @@ var opToSSA = map[opAndType]ssa.Op{ 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, 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, @@ -953,6 +955,14 @@ func (s *state) ssaOp(op uint8, t *Type) ssa.Op { return x } +func floatForComplex(t *Type) *Type { + if t.Size() == 8 { + return Types[TFLOAT32] + } else { + return Types[TFLOAT64] + } +} + type opAndTwoTypes struct { op uint8 etype1 uint8 @@ -1394,7 +1404,24 @@ func (s *state) expr(n *Node) *ssa.Value { } return s.newValue1(op, n.Type, x) } - // TODO: Still lack complex conversions. + + 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(int(n.Left.Type.Etype), 0), Econv(int(n.Type.Etype), 0)) return nil @@ -1404,7 +1431,97 @@ func (s *state) expr(n *Node) *ssa.Value { a := s.expr(n.Left) b := s.expr(n.Right) return s.newValue2(s.ssaOp(n.Op, n.Left.Type), Types[TBOOL], a, b) - case OADD, OAND, OMUL, OOR, OSUB, ODIV, OMOD, OHMUL, OXOR: + 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) + } + 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, OMOD, 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) @@ -1464,8 +1581,18 @@ func (s *state) expr(n *Node) *ssa.Value { s.startBlock(bResult) return s.variable(n, Types[TBOOL]) - // unary ops - case ONOT, OMINUS, OCOM: + // 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: a := s.expr(n.Left) return s.newValue1(s.ssaOp(n.Op, n.Type), a.Type, a) @@ -2551,7 +2678,7 @@ func genValue(v *ssa.Value) { 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.OpAMD64MULSS, ssa.OpAMD64MULSD, ssa.OpAMD64PXOR: r := regnum(v) x := regnum(v.Args[0]) y := regnum(v.Args[1]) diff --git a/src/cmd/compile/internal/gc/testdata/fp_ssa.go b/src/cmd/compile/internal/gc/testdata/fp_ssa.go index c9eb23d371..2cbf00bab0 100644 --- a/src/cmd/compile/internal/gc/testdata/fp_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/fp_ssa.go @@ -1306,7 +1306,7 @@ func fail32bool(s string, f func(a, b float32) bool, a, b float32, e bool) int { func expect64(s string, x, expected float64) int { if x != expected { - println("Expected", expected, "for", s, ", got", x) + println("F64 Expected", expected, "for", s, ", got", x) return 1 } return 0 @@ -1314,7 +1314,7 @@ func expect64(s string, x, expected float64) int { func expect32(s string, x, expected float32) int { if x != expected { - println("Expected", expected, "for", s, ", got", x) + println("F32 Expected", expected, "for", s, ", got", x) return 1 } return 0 @@ -1322,7 +1322,7 @@ func expect32(s string, x, expected float32) int { func expectUint64(s string, x, expected uint64) int { if x != expected { - fmt.Printf("%s: Expected 0x%016x, got 0x%016x\n", s, expected, x) + fmt.Printf("U64 Expected 0x%016x for %s, got 0x%016x\n", expected, s, x) return 1 } return 0 @@ -1435,6 +1435,100 @@ func cmpOpTest(s string, 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 +} + +func cx128sum_ssa(a, b complex128) complex128 { + return a + b +} + +func cx128diff_ssa(a, b complex128) complex128 { + return a - b +} + +func cx128prod_ssa(a, b complex128) complex128 { + return a * b +} + +func cx128quot_ssa(a, b complex128) complex128 { + return a / b +} + +func cx128neg_ssa(a complex128) complex128 { + return -a +} + +func cx64sum_ssa(a, b complex64) complex64 { + return a + b +} + +func cx64diff_ssa(a, b complex64) complex64 { + return a - b +} + +func cx64prod_ssa(a, b complex64) complex64 { + return a * b +} + +func cx64quot_ssa(a, b complex64) complex64 { + return a / b +} + +func cx64neg_ssa(a complex64) complex64 { + return -a +} + +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) + + 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) + + 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) + + 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) + + return fails +} + func main() { a := 3.0 @@ -1523,6 +1617,8 @@ func main() { } fails += floatingToIntegerConversionsTest() + fails += complexTest128() + fails += complexTest64() if fails > 0 { fmt.Printf("Saw %v failures\n", fails) diff --git a/src/cmd/compile/internal/ssa/decompose.go b/src/cmd/compile/internal/ssa/decompose.go index a2dfdc16ab..3ef20ef34f 100644 --- a/src/cmd/compile/internal/ssa/decompose.go +++ b/src/cmd/compile/internal/ssa/decompose.go @@ -77,12 +77,13 @@ func decomposeSlicePhi(v *Value) { func decomposeComplexPhi(v *Value) { fe := v.Block.Func.Config.fe var partType Type - if v.Type.Size() == 8 { + switch z := v.Type.Size(); z { + case 8: partType = fe.TypeFloat32() - } else if v.Type.Size() == 16 { + case 16: partType = fe.TypeFloat64() - } else { - panic("Whoops, are sizes in bytes or bits?") + default: + v.Fatalf("decomposeComplexPhi: bad complex size %d", z) } real := v.Block.NewValue0(v.Line, OpPhi, partType) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 46fb76f1dd..28ae88ff24 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -81,6 +81,8 @@ (Neg32 x) -> (NEGL x) (Neg16 x) -> (NEGW x) (Neg8 x) -> (NEGB x) +(Neg32F x) -> (PXOR x (MOVSSconst {math.Copysign(0, -1)})) +(Neg64F x) -> (PXOR x (MOVSDconst {math.Copysign(0, -1)})) (Com64 x) -> (NOTQ x) (Com32 x) -> (NOTL x) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index f2c402a348..555a5149a7 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -354,6 +354,8 @@ func init() { {name: "CVTSD2SS", reg: fp11, asm: "CVTSD2SS"}, // convert float64 to float32 {name: "CVTSS2SD", reg: fp11, asm: "CVTSS2SD"}, // convert float32 to float64 + {name: "PXOR", reg: fp21, asm: "PXOR"}, // exclusive or, applied to X regs for float negation. + {name: "LEAQ", reg: gp11sb}, // arg0 + auxint + offset encoded in aux {name: "LEAQ1", reg: gp21sb}, // arg0 + arg1 + auxint {name: "LEAQ2", reg: gp21sb}, // arg0 + 2*arg1 + auxint diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 8f6a858e43..d17f207a80 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -24,7 +24,6 @@ var genericOps = []opData{ {name: "SubPtr"}, {name: "Sub32F"}, {name: "Sub64F"}, - // TODO: Sub64C, Sub128C {name: "Mul8"}, // arg0 * arg1 {name: "Mul16"}, @@ -225,6 +224,8 @@ var genericOps = []opData{ {name: "Neg16"}, {name: "Neg32"}, {name: "Neg64"}, + {name: "Neg32F"}, + {name: "Neg64F"}, {name: "Com8"}, // ^arg0 {name: "Com16"}, @@ -336,8 +337,8 @@ var genericOps = []opData{ // Complex (part/whole) {name: "ComplexMake"}, // arg0=real, arg1=imag - {name: "ComplexReal"}, // real_part(arg0) - {name: "ComplexImag"}, // imaginary_part(arg0) + {name: "ComplexReal"}, // real(arg0) + {name: "ComplexImag"}, // imag(arg0) // Strings {name: "StringMake"}, // arg0=ptr, arg1=len diff --git a/src/cmd/compile/internal/ssa/gen/rulegen.go b/src/cmd/compile/internal/ssa/gen/rulegen.go index d98ad2587f..5dcbf1ee1c 100644 --- a/src/cmd/compile/internal/ssa/gen/rulegen.go +++ b/src/cmd/compile/internal/ssa/gen/rulegen.go @@ -142,6 +142,9 @@ func genRules(arch arch) { if *genLog { fmt.Fprintln(w, "import \"fmt\"") } + fmt.Fprintln(w, "import \"math\"") + fmt.Fprintln(w, "var _ = math.MinInt8 // in case not otherwise used") + fmt.Fprintf(w, "func rewriteValue%s(v *Value, config *Config) bool {\n", arch.name) fmt.Fprintln(w, "b := v.Block") diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 51a998e352..a41b04b29f 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -237,6 +237,7 @@ const ( OpAMD64CVTSQ2SD OpAMD64CVTSD2SS OpAMD64CVTSS2SD + OpAMD64PXOR OpAMD64LEAQ OpAMD64LEAQ1 OpAMD64LEAQ2 @@ -435,6 +436,8 @@ const ( OpNeg16 OpNeg32 OpNeg64 + OpNeg32F + OpNeg64F OpCom8 OpCom16 OpCom32 @@ -2794,6 +2797,19 @@ var opcodeTable = [...]opInfo{ }, }, }, + { + name: "PXOR", + 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", reg: regInfo{ @@ -3743,6 +3759,14 @@ var opcodeTable = [...]opInfo{ name: "Neg64", generic: true, }, + { + name: "Neg32F", + generic: true, + }, + { + name: "Neg64F", + generic: true, + }, { name: "Com8", generic: true, diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index e089028258..67ec747e20 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -2,6 +2,9 @@ // 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 { b := v.Block switch v.Op { @@ -6059,6 +6062,26 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endce1f7e17fc193f6c076e47d5e401e126 endce1f7e17fc193f6c076e47d5e401e126: ; + case OpNeg32F: + // match: (Neg32F x) + // cond: + // result: (PXOR x (MOVSSconst {math.Copysign(0, -1)})) + { + x := v.Args[0] + v.Op = OpAMD64PXOR + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpAMD64MOVSSconst, TypeInvalid) + v0.Type = config.Frontend().TypeFloat32() + v0.Aux = math.Copysign(0, -1) + v.AddArg(v0) + return true + } + goto end47074133a76e069317ceca46372cafc3 + end47074133a76e069317ceca46372cafc3: + ; case OpNeg64: // match: (Neg64 x) // cond: @@ -6075,6 +6098,26 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto enda06c5b1718f2b96aba10bf5a5c437c6c enda06c5b1718f2b96aba10bf5a5c437c6c: ; + case OpNeg64F: + // match: (Neg64F x) + // cond: + // result: (PXOR x (MOVSDconst {math.Copysign(0, -1)})) + { + x := v.Args[0] + v.Op = OpAMD64PXOR + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpAMD64MOVSDconst, TypeInvalid) + v0.Type = config.Frontend().TypeFloat64() + v0.Aux = math.Copysign(0, -1) + v.AddArg(v0) + return true + } + goto end9240202f5753ebd23f11f982ece3e06e + end9240202f5753ebd23f11f982ece3e06e: + ; case OpNeg8: // match: (Neg8 x) // cond: diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index 09f03f985f..ca771d75ae 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -2,6 +2,9 @@ // 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 { b := v.Block switch v.Op { -- cgit v1.3 From 6411533ebf98d898a888b0195e8c4d4039864896 Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Sat, 29 Aug 2015 15:41:57 -0500 Subject: [dev.ssa] cmd/compile: fix rare issue caused by liblink rewrite liblink rewrites MOV $0, reg into XOR reg, reg. Make MOVxconst clobber flags so we don't generate invalid code in the unlikely case that it matters. In testing, this change leads to no additional regenerated flags due to a scheduling fix in CL14042. Change-Id: I7bc1cfee94ef83beb2f97c31ec6a97e19872fb89 Reviewed-on: https://go-review.googlesource.com/14043 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/testdata/ctl_ssa.go | 31 +++++++++++++++++++++++++ src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 11 +++++---- src/cmd/compile/internal/ssa/opGen.go | 4 ++++ 3 files changed, 42 insertions(+), 4 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/testdata/ctl_ssa.go b/src/cmd/compile/internal/gc/testdata/ctl_ssa.go index cc55134b96..09880ef94f 100644 --- a/src/cmd/compile/internal/gc/testdata/ctl_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/ctl_ssa.go @@ -115,6 +115,35 @@ func testSwitch() { } } +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() { @@ -124,6 +153,8 @@ func main() { testSwitch() testFallthrough() + testFlagOverwrite() + if failed { panic("failed") } diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 555a5149a7..09ffd4526f 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -93,6 +93,7 @@ func init() { // Common regInfo var ( gp01 = regInfo{inputs: []regMask{}, outputs: gponly} + gp01flags = regInfo{inputs: []regMask{}, outputs: gponly, clobbers: flags} 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} @@ -338,10 +339,12 @@ func init() { {name: "MOVLQSX", reg: gp11nf, asm: "MOVLQSX"}, // sign extend arg0 from int32 to int64 {name: "MOVLQZX", reg: gp11nf, asm: "MOVLQZX"}, // zero extend arg0 from int32 to int64 - {name: "MOVBconst", reg: gp01, asm: "MOVB"}, // 8 low bits of auxint - {name: "MOVWconst", reg: gp01, asm: "MOVW"}, // 16 low bits of auxint - {name: "MOVLconst", reg: gp01, asm: "MOVL"}, // 32 low bits of auxint - {name: "MOVQconst", reg: gp01, asm: "MOVQ"}, // auxint + // clobbers flags as liblink will rewrite these to XOR reg, reg if the constant is zero + // TODO: revisit when issue 12405 is fixed + {name: "MOVBconst", reg: gp01flags, asm: "MOVB"}, // 8 low bits of auxint + {name: "MOVWconst", reg: gp01flags, asm: "MOVW"}, // 16 low bits of auxint + {name: "MOVLconst", reg: gp01flags, asm: "MOVL"}, // 32 low bits of auxint + {name: "MOVQconst", reg: gp01flags, asm: "MOVQ"}, // auxint {name: "CVTSD2SL", reg: fpgp, asm: "CVTSD2SL"}, // convert float64 to int32 {name: "CVTSD2SQ", reg: fpgp, asm: "CVTSD2SQ"}, // convert float64 to int64 diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index a41b04b29f..8263268019 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -2645,6 +2645,7 @@ var opcodeTable = [...]opInfo{ name: "MOVBconst", asm: x86.AMOVB, reg: regInfo{ + clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -2654,6 +2655,7 @@ var opcodeTable = [...]opInfo{ name: "MOVWconst", asm: x86.AMOVW, reg: regInfo{ + clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -2663,6 +2665,7 @@ var opcodeTable = [...]opInfo{ name: "MOVLconst", asm: x86.AMOVL, reg: regInfo{ + clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -2672,6 +2675,7 @@ var opcodeTable = [...]opInfo{ name: "MOVQconst", asm: x86.AMOVQ, reg: regInfo{ + clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, -- cgit v1.3 From 2511cf03b9c2d5c0e9dcf78533f24f2baaf97d74 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Tue, 1 Sep 2015 15:18:01 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: make SETEQF and SETNEF clobber flags They do an AND or an OR internally, so they clobber flags. Fixes #12441 Change-Id: I6c843bd268496bc13fc7e3c561d76619e961e8ad Reviewed-on: https://go-review.googlesource.com/14180 Reviewed-by: Todd Neal --- src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 2 +- src/cmd/compile/internal/ssa/opGen.go | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 09ffd4526f..da5c506064 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -112,7 +112,7 @@ func init() { 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, outputs: []regMask{gp &^ ax}} + 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} diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 8263268019..82ba4a5449 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -2502,7 +2502,7 @@ var opcodeTable = [...]opInfo{ inputs: []inputInfo{ {0, 8589934592}, // .FLAGS }, - clobbers: 1, // .AX + clobbers: 8589934593, // .AX .FLAGS outputs: []regMask{ 65518, // .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -2515,7 +2515,7 @@ var opcodeTable = [...]opInfo{ inputs: []inputInfo{ {0, 8589934592}, // .FLAGS }, - clobbers: 1, // .AX + clobbers: 8589934593, // .AX .FLAGS outputs: []regMask{ 65518, // .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, -- cgit v1.3 From 4219aba5dbbc94d82a4b80c1f6ecc97d7eb3a62d Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Tue, 1 Sep 2015 17:56:37 -0500 Subject: [dev.ssa] cmd/compile: make REPSTOSQ clobber flags It does a XOR internally and clobbers flags. Change-Id: Id6ef9219c4e6c3a2b5fc79c8d52bcfa30c148617 Reviewed-on: https://go-review.googlesource.com/14165 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 4 ++-- src/cmd/compile/internal/ssa/opGen.go | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index da5c506064..d8d7703594 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -380,8 +380,8 @@ func init() { {name: "MOVQstoreidx8", reg: gpstoreidx, asm: "MOVQ"}, // store 8 bytes in arg2 to arg0+8*arg1+auxint+aux. arg3=mem {name: "MOVXzero", reg: gpstoreconst}, // store auxint 0 bytes into arg0 using a series of MOV instructions. arg1=mem. - // TODO: implement this when register clobbering works - {name: "REPSTOSQ", reg: regInfo{[]regMask{buildReg("DI"), buildReg("CX")}, buildReg("DI AX CX"), nil}}, // store arg1 8-byte words containing zero into arg0 using STOSQ. arg2=mem. + + {name: "REPSTOSQ", reg: regInfo{[]regMask{buildReg("DI"), buildReg("CX")}, buildReg("DI AX CX FLAGS"), nil}}, // store arg1 8-byte words containing zero into arg0 using STOSQ. arg2=mem. //TODO: set register clobber to everything? {name: "CALLstatic", reg: regInfo{clobbers: callerSave}}, // call static function aux.(*gc.Sym). arg0=mem, auxint=argsize, returns mem diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 82ba4a5449..d663535940 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -3024,7 +3024,7 @@ var opcodeTable = [...]opInfo{ {0, 128}, // .DI {1, 2}, // .CX }, - clobbers: 131, // .AX .CX .DI + clobbers: 8589934723, // .AX .CX .DI .FLAGS }, }, { -- cgit v1.3 From 634b50c6e138669d5518c0c02d3bfba79e1278ab Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Tue, 1 Sep 2015 19:05:44 -0500 Subject: [dev.ssa] cmd/compile: truncate when converting floats to ints Modified to use the truncating conversion. Fixes reflect. Change-Id: I47bf3200abc2d2c662939a2a2351e2ff84168f4a Reviewed-on: https://go-review.googlesource.com/14167 Reviewed-by: David Chase --- src/cmd/compile/internal/gc/ssa.go | 2 +- src/cmd/compile/internal/gc/testdata/fp_ssa.go | 3 +++ src/cmd/compile/internal/ssa/gen/AMD64.rules | 8 +++---- src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 20 ++++++++-------- src/cmd/compile/internal/ssa/opGen.go | 24 +++++++++---------- src/cmd/compile/internal/ssa/rewriteAMD64.go | 32 +++++++++++++------------- 6 files changed, 46 insertions(+), 43 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 17288c3156..61e17ee68b 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -3045,7 +3045,7 @@ func genValue(v *ssa.Value) { addAux(&p.To, v) case ssa.OpAMD64MOVLQSX, ssa.OpAMD64MOVWQSX, ssa.OpAMD64MOVBQSX, ssa.OpAMD64MOVLQZX, ssa.OpAMD64MOVWQZX, ssa.OpAMD64MOVBQZX, ssa.OpAMD64CVTSL2SS, ssa.OpAMD64CVTSL2SD, ssa.OpAMD64CVTSQ2SS, ssa.OpAMD64CVTSQ2SD, - ssa.OpAMD64CVTSS2SL, ssa.OpAMD64CVTSD2SL, ssa.OpAMD64CVTSS2SQ, ssa.OpAMD64CVTSD2SQ, + ssa.OpAMD64CVTTSS2SL, ssa.OpAMD64CVTTSD2SL, ssa.OpAMD64CVTTSS2SQ, ssa.OpAMD64CVTTSD2SQ, ssa.OpAMD64CVTSS2SD, ssa.OpAMD64CVTSD2SS: opregreg(v.Op.Asm(), regnum(v), regnum(v.Args[0])) case ssa.OpAMD64MOVXzero: diff --git a/src/cmd/compile/internal/gc/testdata/fp_ssa.go b/src/cmd/compile/internal/gc/testdata/fp_ssa.go index 2cbf00bab0..6193983e4c 100644 --- a/src/cmd/compile/internal/gc/testdata/fp_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/fp_ssa.go @@ -1179,7 +1179,10 @@ func floatsToUints(x float64, expected uint64) int { 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) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 28ae88ff24..e8dc5cee72 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -109,10 +109,10 @@ (Cvt64to32F x) -> (CVTSQ2SS x) (Cvt64to64F x) -> (CVTSQ2SD x) -(Cvt32Fto32 x) -> (CVTSS2SL x) -(Cvt32Fto64 x) -> (CVTSS2SQ x) -(Cvt64Fto32 x) -> (CVTSD2SL x) -(Cvt64Fto64 x) -> (CVTSD2SQ 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) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index d8d7703594..37cd096d63 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -346,16 +346,16 @@ func init() { {name: "MOVLconst", reg: gp01flags, asm: "MOVL"}, // 32 low bits of auxint {name: "MOVQconst", reg: gp01flags, asm: "MOVQ"}, // auxint - {name: "CVTSD2SL", reg: fpgp, asm: "CVTSD2SL"}, // convert float64 to int32 - {name: "CVTSD2SQ", reg: fpgp, asm: "CVTSD2SQ"}, // convert float64 to int64 - {name: "CVTSS2SL", reg: fpgp, asm: "CVTSS2SL"}, // convert float32 to int32 - {name: "CVTSS2SQ", reg: fpgp, asm: "CVTSS2SQ"}, // convert float32 to int64 - {name: "CVTSL2SS", reg: gpfp, asm: "CVTSL2SS"}, // convert int32 to float32 - {name: "CVTSL2SD", reg: gpfp, asm: "CVTSL2SD"}, // convert int32 to float64 - {name: "CVTSQ2SS", reg: gpfp, asm: "CVTSQ2SS"}, // convert int64 to float32 - {name: "CVTSQ2SD", reg: gpfp, asm: "CVTSQ2SD"}, // convert int64 to float64 - {name: "CVTSD2SS", reg: fp11, asm: "CVTSD2SS"}, // convert float64 to float32 - {name: "CVTSS2SD", reg: fp11, asm: "CVTSS2SD"}, // convert float32 to float64 + {name: "CVTTSD2SL", reg: fpgp, asm: "CVTTSD2SL"}, // convert float64 to int32 + {name: "CVTTSD2SQ", reg: fpgp, asm: "CVTTSD2SQ"}, // convert float64 to int64 + {name: "CVTTSS2SL", reg: fpgp, asm: "CVTTSS2SL"}, // convert float32 to int32 + {name: "CVTTSS2SQ", reg: fpgp, asm: "CVTTSS2SQ"}, // convert float32 to int64 + {name: "CVTSL2SS", reg: gpfp, asm: "CVTSL2SS"}, // convert int32 to float32 + {name: "CVTSL2SD", reg: gpfp, asm: "CVTSL2SD"}, // convert int32 to float64 + {name: "CVTSQ2SS", reg: gpfp, asm: "CVTSQ2SS"}, // convert int64 to float32 + {name: "CVTSQ2SD", reg: gpfp, asm: "CVTSQ2SD"}, // convert int64 to float64 + {name: "CVTSD2SS", reg: fp11, asm: "CVTSD2SS"}, // convert float64 to float32 + {name: "CVTSS2SD", reg: fp11, asm: "CVTSS2SD"}, // convert float32 to float64 {name: "PXOR", reg: fp21, asm: "PXOR"}, // exclusive or, applied to X regs for float negation. diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index d663535940..f4c74fe340 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -227,10 +227,10 @@ const ( OpAMD64MOVWconst OpAMD64MOVLconst OpAMD64MOVQconst - OpAMD64CVTSD2SL - OpAMD64CVTSD2SQ - OpAMD64CVTSS2SL - OpAMD64CVTSS2SQ + OpAMD64CVTTSD2SL + OpAMD64CVTTSD2SQ + OpAMD64CVTTSS2SL + OpAMD64CVTTSS2SQ OpAMD64CVTSL2SS OpAMD64CVTSL2SD OpAMD64CVTSQ2SS @@ -2682,8 +2682,8 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "CVTSD2SL", - asm: x86.ACVTSD2SL, + name: "CVTTSD2SL", + 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 @@ -2694,8 +2694,8 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "CVTSD2SQ", - asm: x86.ACVTSD2SQ, + name: "CVTTSD2SQ", + 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 @@ -2706,8 +2706,8 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "CVTSS2SL", - asm: x86.ACVTSS2SL, + name: "CVTTSS2SL", + 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 @@ -2718,8 +2718,8 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "CVTSS2SQ", - asm: x86.ACVTSS2SQ, + name: "CVTTSS2SQ", + 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 diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 67ec747e20..366a195a3d 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -1694,34 +1694,34 @@ func rewriteValueAMD64(v *Value, config *Config) bool { case OpCvt32Fto32: // match: (Cvt32Fto32 x) // cond: - // result: (CVTSS2SL x) + // result: (CVTTSS2SL x) { x := v.Args[0] - v.Op = OpAMD64CVTSS2SL + v.Op = OpAMD64CVTTSS2SL v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AddArg(x) return true } - goto endad55e2986dea26975574ee27f4976d5e - endad55e2986dea26975574ee27f4976d5e: + goto enda410209d31804e1bce7bdc235fc62342 + enda410209d31804e1bce7bdc235fc62342: ; case OpCvt32Fto64: // match: (Cvt32Fto64 x) // cond: - // result: (CVTSS2SQ x) + // result: (CVTTSS2SQ x) { x := v.Args[0] - v.Op = OpAMD64CVTSS2SQ + v.Op = OpAMD64CVTTSS2SQ v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AddArg(x) return true } - goto end227800dc831e0b4ef80fa315133c0991 - end227800dc831e0b4ef80fa315133c0991: + goto enddb02fa4f3230a14d557d6c90cdadd523 + enddb02fa4f3230a14d557d6c90cdadd523: ; case OpCvt32Fto64F: // match: (Cvt32Fto64F x) @@ -1774,18 +1774,18 @@ func rewriteValueAMD64(v *Value, config *Config) bool { case OpCvt64Fto32: // match: (Cvt64Fto32 x) // cond: - // result: (CVTSD2SL x) + // result: (CVTTSD2SL x) { x := v.Args[0] - v.Op = OpAMD64CVTSD2SL + v.Op = OpAMD64CVTTSD2SL v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AddArg(x) return true } - goto end1ce5fd52f29d5a42d1aa08d7ac53e49e - end1ce5fd52f29d5a42d1aa08d7ac53e49e: + goto endc213dd690dfe568607dec717b2c385b7 + endc213dd690dfe568607dec717b2c385b7: ; case OpCvt64Fto32F: // match: (Cvt64Fto32F x) @@ -1806,18 +1806,18 @@ func rewriteValueAMD64(v *Value, config *Config) bool { case OpCvt64Fto64: // match: (Cvt64Fto64 x) // cond: - // result: (CVTSD2SQ x) + // result: (CVTTSD2SQ x) { x := v.Args[0] - v.Op = OpAMD64CVTSD2SQ + v.Op = OpAMD64CVTTSD2SQ v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AddArg(x) return true } - goto end8239c11ce860dc3b5417d4d2ae59386a - end8239c11ce860dc3b5417d4d2ae59386a: + goto end0bf3e4468047fd20714266ff05797454 + end0bf3e4468047fd20714266ff05797454: ; case OpCvt64to32F: // match: (Cvt64to32F x) -- cgit v1.3 From 5cb352edeba36e862995dd82fe7312368e6e8571 Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Tue, 1 Sep 2015 21:25:24 -0500 Subject: [dev.ssa] cmd/compile: fix liblink rewrite of -0.0 liblink was rewriting xor by a negative zero (used by SSA for negation) as XORPS reg,reg. Fixes strconv. Change-Id: I627a0a7366618e6b07ba8f0ad0db0e102340c5e3 Reviewed-on: https://go-review.googlesource.com/14200 Reviewed-by: Josh Bleecher Snyder Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/testdata/fp_ssa.go | 14 ++++++++++++++ src/cmd/internal/obj/x86/obj6.go | 6 ++++-- 2 files changed, 18 insertions(+), 2 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/testdata/fp_ssa.go b/src/cmd/compile/internal/gc/testdata/fp_ssa.go index 6193983e4c..ee3163abb3 100644 --- a/src/cmd/compile/internal/gc/testdata/fp_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/fp_ssa.go @@ -105,6 +105,12 @@ func div64_ssa(a, b float64) float64 { return a / b } +func neg64_ssa(a, b float64) float64 { + switch { + } + return -a + -1*b +} + func add32_ssa(a, b float32) float32 { switch { } @@ -128,6 +134,12 @@ func div32_ssa(a, b float32) float32 { 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 { @@ -1548,11 +1560,13 @@ func main() { 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) diff --git a/src/cmd/internal/obj/x86/obj6.go b/src/cmd/internal/obj/x86/obj6.go index d0efffbc0a..d55dcc7cac 100644 --- a/src/cmd/internal/obj/x86/obj6.go +++ b/src/cmd/internal/obj/x86/obj6.go @@ -221,7 +221,8 @@ func progedit(ctxt *obj.Link, p *obj.Prog) { // 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 @@ -261,7 +262,8 @@ func progedit(ctxt *obj.Link, p *obj.Prog) { 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 -- cgit v1.3 From 19285efaed7b08535e1b3ba921f584ed8bde6e49 Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Wed, 2 Sep 2015 21:11:32 -0500 Subject: [dev.ssa] cmd/compile: fix complex128 complex128 was being treated as a complex64 Fixes math/cmplx. Change-Id: I2996915b4cb6b94198d41cf08a30bd8531b9fec5 Reviewed-on: https://go-review.googlesource.com/14206 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 4 ++-- src/cmd/compile/internal/gc/testdata/fp_ssa.go | 29 ++++++++++++++++++++++++++ 2 files changed, 31 insertions(+), 2 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 61e17ee68b..77c822787d 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1139,8 +1139,8 @@ func (s *state) expr(n *Node) *ssa.Value { { pt := Types[TFLOAT64] return s.newValue2(ssa.OpComplexMake, n.Type, - s.constFloat32(pt, mpgetflt(r)), - s.constFloat32(pt, mpgetflt(i))) + s.constFloat64(pt, mpgetflt(r)), + s.constFloat64(pt, mpgetflt(i))) } default: s.Fatalf("bad float size %d", n.Type.Size()) diff --git a/src/cmd/compile/internal/gc/testdata/fp_ssa.go b/src/cmd/compile/internal/gc/testdata/fp_ssa.go index ee3163abb3..9bd545f878 100644 --- a/src/cmd/compile/internal/gc/testdata/fp_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/fp_ssa.go @@ -1467,42 +1467,69 @@ func expectCx64(s string, x, expected complex64) int { } func cx128sum_ssa(a, b complex128) complex128 { + switch { // prevent inlining + } return a + b } func cx128diff_ssa(a, b complex128) complex128 { + switch { // prevent inlining + } return a - b } func cx128prod_ssa(a, b complex128) complex128 { + switch { // prevent inlining + } return a * b } func cx128quot_ssa(a, b complex128) complex128 { + switch { // prevent inlining + } return a / b } func cx128neg_ssa(a complex128) complex128 { + switch { // prevent inlining + } return -a } +func cx128cnst_ssa(a complex128) complex128 { + switch { // prevent inlining + } + b := 2 + 3i + return a * b +} + func cx64sum_ssa(a, b complex64) complex64 { + switch { // prevent inlining + } return a + b } func cx64diff_ssa(a, b complex64) complex64 { + switch { // prevent inlining + } return a - b } func cx64prod_ssa(a, b complex64) complex64 { + switch { // prevent inlining + } return a * b } func cx64quot_ssa(a, b complex64) complex64 { + switch { // prevent inlining + } return a / b } func cx64neg_ssa(a complex64) complex64 { + switch { // prevent inlining + } return -a } @@ -1515,12 +1542,14 @@ func complexTest128() int { prod := cx128prod_ssa(b, a) quot := cx128quot_ssa(b, a) neg := cx128neg_ssa(a) + cnst := cx128cnst_ssa(a) 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 += expectCx128("cnst", cnst, -4+7i) return fails } -- cgit v1.3 From ce4317266c160953aacf46cbe9d8341f86158776 Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Wed, 2 Sep 2015 20:17:47 -0500 Subject: [dev.ssa] cmd/compile: cse should treat -0.0 and 0.0 as different cse was incorrectly classifying -0.0 and 0.0 as equivalent. This lead to invalid code as ssa uses PXOR -0.0, reg to negate a floating point. Fixes math. Change-Id: Id7eb10c71749eaed897f29b02c33891cf5820acf Reviewed-on: https://go-review.googlesource.com/14205 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/TODO | 1 + src/cmd/compile/internal/ssa/cse.go | 19 +++++++++++++++++-- 2 files changed, 18 insertions(+), 2 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/TODO b/src/cmd/compile/internal/ssa/TODO index fbe4f56760..8feb1053ae 100644 --- a/src/cmd/compile/internal/ssa/TODO +++ b/src/cmd/compile/internal/ssa/TODO @@ -44,6 +44,7 @@ Optimizations (better compiler) - Reuseable slices (e.g. []int of size NumValues()) cached in Func - Handle signed division overflow and sign extension earlier - Implement 64 bit const division with high multiply, maybe in the frontend? +- Store bool and float32/float64 in auxInt Regalloc -------- diff --git a/src/cmd/compile/internal/ssa/cse.go b/src/cmd/compile/internal/ssa/cse.go index 6851ca9f40..6469ecd72b 100644 --- a/src/cmd/compile/internal/ssa/cse.go +++ b/src/cmd/compile/internal/ssa/cse.go @@ -4,7 +4,10 @@ package ssa -import "sort" +import ( + "math" + "sort" +) // cse does common-subexpression elimination on the Function. // Values are just relinked, nothing is deleted. A subsequent deadcode @@ -51,7 +54,19 @@ func cse(f *Func) { if len(v.Args) > 1 { arg1op = v.Args[1].Op } - k := key{v.Op, v.Type.String(), v.Aux, v.AuxInt, len(v.Args), bid, arg0op, arg1op} + + aux := v.Aux + auxInt := v.AuxInt + // -0 == 0, but aren't equivalent values so we use + // Float64bits to distinguish + if f, ok := aux.(float64); ok { + aux = nil + if auxInt != 0 { + v.Fatalf("float would clobber v.auxInt") + } + auxInt = int64(math.Float64bits(f)) + } + k := key{v.Op, v.Type.String(), aux, auxInt, len(v.Args), bid, arg0op, arg1op} m[k] = append(m[k], v) } } -- cgit v1.3 From 73024083b08509414e98061d894239386ddd8ba0 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Wed, 2 Sep 2015 20:36:47 -0700 Subject: [dev.ssa] cmd/compile: add pxor to list of instructions analyzeable by liveness analysis Change-Id: I6ea0a3482d8813b8555b16fe6c377cad33554619 Reviewed-on: https://go-review.googlesource.com/14247 Reviewed-by: David Chase --- src/cmd/compile/internal/amd64/prog.go | 1 + src/cmd/compile/internal/x86/prog.go | 1 + 2 files changed, 2 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/amd64/prog.go b/src/cmd/compile/internal/amd64/prog.go index 5f4fe1c5ab..6c46f20a3b 100644 --- a/src/cmd/compile/internal/amd64/prog.go +++ b/src/cmd/compile/internal/amd64/prog.go @@ -165,6 +165,7 @@ var progtable = [x86.ALAST]obj.ProgInfo{ 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/x86/prog.go b/src/cmd/compile/internal/x86/prog.go index ce432c17f3..8e1b7573b5 100644 --- a/src/cmd/compile/internal/x86/prog.go +++ b/src/cmd/compile/internal/x86/prog.go @@ -187,6 +187,7 @@ var progtable = [x86.ALAST]obj.ProgInfo{ 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}, -- cgit v1.3 From 10f38f51ef51467b5df1fb8f744a5597f87efb1e Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Thu, 3 Sep 2015 09:09:59 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: distinguish exit and return blocks It is confusing to have exceptional edges jump back into real code. Distinguish return blocks, which execute acutal code, and the exit block, which is a merge point for the regular and exceptional return flow. Prevent critical edge insertion from adding blocks on edges into the exit block. These added blocks serve no purpose and add a bunch of dead jumps to the assembly output. Furthermore, live variable analysis is confused by these jumps. Change-Id: Ifd69e6c00e90338ed147e7cb351b5100dc0364df Reviewed-on: https://go-review.googlesource.com/14254 Reviewed-by: David Chase --- src/cmd/compile/internal/gc/ssa.go | 2 ++ src/cmd/compile/internal/ssa/check.go | 10 ++++++++++ src/cmd/compile/internal/ssa/critical.go | 2 +- src/cmd/compile/internal/ssa/gen/genericOps.go | 1 + src/cmd/compile/internal/ssa/opGen.go | 2 ++ 5 files changed, 16 insertions(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 77c822787d..f0cad90d40 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -562,6 +562,7 @@ func (s *state) stmt(n *Node) { case ORETURN: s.stmtList(n.List) b := s.endBlock() + b.Kind = ssa.BlockRet b.AddEdgeTo(s.exit) case OCONTINUE, OBREAK: @@ -3358,6 +3359,7 @@ func genBlock(b, next *ssa.Block, branches []branch) []branch { branches = append(branches, branch{p, b.Succs[0]}) } case ssa.BlockExit: + case ssa.BlockRet: Prog(obj.ARET) case ssa.BlockCall: if b.Succs[0] != next { diff --git a/src/cmd/compile/internal/ssa/check.go b/src/cmd/compile/internal/ssa/check.go index 0c2bc4c7f1..68ba25a272 100644 --- a/src/cmd/compile/internal/ssa/check.go +++ b/src/cmd/compile/internal/ssa/check.go @@ -59,6 +59,16 @@ func checkFunc(f *Func) { 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) != 1 { + f.Fatalf("ret block %s len(Succs)==%d, want 1", b, len(b.Succs)) + } + if b.Control != nil { + f.Fatalf("ret block %s has non-nil control %s", b, b.Control.LongString()) + } + if b.Succs[0].Kind != BlockExit { + f.Fatalf("ret block %s has successor %s, not Exit", b, b.Succs[0].Kind) + } case BlockDead: if len(b.Succs) != 0 { f.Fatalf("dead block %s has successors", b) diff --git a/src/cmd/compile/internal/ssa/critical.go b/src/cmd/compile/internal/ssa/critical.go index ba75450875..439d4823e5 100644 --- a/src/cmd/compile/internal/ssa/critical.go +++ b/src/cmd/compile/internal/ssa/critical.go @@ -9,7 +9,7 @@ package ssa // 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 { + if len(b.Preds) <= 1 || b.Kind == BlockExit { continue } diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index d17f207a80..59b90adfe5 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -375,6 +375,7 @@ var genericBlocks = []blockData{ {name: "If"}, // 2 successors, if control goto Succs[0] else goto Succs[1] {name: "Call"}, // 2 successors, normal return and panic {name: "First"}, // 2 successors, always takes the first one (second is dead) + {name: "Ret"}, // 1 successor, branches to exit } func init() { diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index f4c74fe340..a61c31ad5a 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -28,6 +28,7 @@ const ( BlockIf BlockCall BlockFirst + BlockRet ) var blockString = [...]string{ @@ -54,6 +55,7 @@ var blockString = [...]string{ BlockIf: "If", BlockCall: "Call", BlockFirst: "First", + BlockRet: "Ret", } func (k BlockKind) String() string { return blockString[k] } -- cgit v1.3 From d9f2cafb5050fd264777f175ceb2576d734b7360 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Thu, 3 Sep 2015 14:28:52 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: fix fallthrough return Fallthrough return needs to be a return block before jumping to the exit block. Change-Id: I994de2064da5c326c9cade2c33cbb15bdbce5acb Reviewed-on: https://go-review.googlesource.com/14256 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/gc/ssa.go | 1 + 1 file changed, 1 insertion(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index f0cad90d40..c2ad49e954 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -114,6 +114,7 @@ func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { // fallthrough to exit if b := s.endBlock(); b != nil { + b.Kind = ssa.BlockRet b.AddEdgeTo(s.exit) } -- cgit v1.3 From 991036aef38cea57c2a7ef02220754d93799c489 Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Thu, 3 Sep 2015 18:24:22 -0500 Subject: [dev.ssa] cmd/compile: store bools in AuxInt Store bools in AuxInt to reduce allocations. Change-Id: Ibd26db67fca5e1e2803f53d7ef094897968b704b Reviewed-on: https://go-review.googlesource.com/14276 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 24 +++- src/cmd/compile/internal/ssa/check.go | 5 + src/cmd/compile/internal/ssa/deadcode_test.go | 6 +- src/cmd/compile/internal/ssa/deadstore_test.go | 6 +- src/cmd/compile/internal/ssa/dom_test.go | 28 ++--- src/cmd/compile/internal/ssa/gen/AMD64.rules | 3 +- src/cmd/compile/internal/ssa/gen/generic.rules | 28 ++--- src/cmd/compile/internal/ssa/rewrite.go | 8 ++ src/cmd/compile/internal/ssa/rewriteAMD64.go | 35 ++---- src/cmd/compile/internal/ssa/rewritegeneric.go | 164 ++++++++++++------------- 10 files changed, 156 insertions(+), 151 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index c2ad49e954..340b7daa52 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -302,6 +302,11 @@ 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) @@ -337,16 +342,21 @@ func (s *state) newValue3I(op ssa.Op, t ssa.Type, aux int64, arg0, arg1, arg2 *s return s.curBlock.NewValue3I(s.peekLine(), op, t, aux, arg0, arg1, arg2) } -// entryNewValue adds a new value with no arguments to the entry block. +// 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) } -// entryNewValue adds a new value with no arguments and an aux value to the entry block. +// 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) @@ -635,7 +645,7 @@ func (s *state) stmt(n *Node) { if n.Left != nil { cond = s.expr(n.Left) } else { - cond = s.entryNewValue0A(ssa.OpConstBool, Types[TBOOL], true) + cond = s.entryNewValue0I(ssa.OpConstBool, Types[TBOOL], 1) // 1 = true } b = s.endBlock() b.Kind = ssa.BlockIf @@ -1103,7 +1113,11 @@ func (s *state) expr(n *Node) *ssa.Value { case CTSTR: return s.entryNewValue0A(ssa.OpConstString, n.Type, n.Val().U) case CTBOOL: - return s.entryNewValue0A(ssa.OpConstBool, n.Type, n.Val().U) + if n.Val().U.(bool) { + return s.entryNewValue0I(ssa.OpConstBool, n.Type, 1) // 1 = true + } else { + return s.entryNewValue0I(ssa.OpConstBool, n.Type, 0) // 0 = false + } case CTNIL: t := n.Type switch { @@ -1882,7 +1896,7 @@ func (s *state) zeroVal(t *Type) *ssa.Value { case t.IsPtr(): return s.entryNewValue0(ssa.OpConstNil, t) case t.IsBoolean(): - return s.entryNewValue0A(ssa.OpConstBool, t, false) // TODO: store bools as 0/1 in AuxInt? + return s.entryNewValue0I(ssa.OpConstBool, t, 0) // 0 = false case t.IsInterface(): return s.entryNewValue0(ssa.OpConstInterface, t) case t.IsSlice(): diff --git a/src/cmd/compile/internal/ssa/check.go b/src/cmd/compile/internal/ssa/check.go index 68ba25a272..a7249a4c54 100644 --- a/src/cmd/compile/internal/ssa/check.go +++ b/src/cmd/compile/internal/ssa/check.go @@ -122,6 +122,11 @@ func checkFunc(f *Func) { } for _, v := range b.Values { + + if _, ok := v.Aux.(bool); ok { + f.Fatalf("value %v has a bool Aux value, should be AuxInt", v.LongString()) + } + for _, arg := range v.Args { if arg == nil { f.Fatalf("value %v has nil arg", v.LongString()) diff --git a/src/cmd/compile/internal/ssa/deadcode_test.go b/src/cmd/compile/internal/ssa/deadcode_test.go index ef42d74f4d..7f491c77f9 100644 --- a/src/cmd/compile/internal/ssa/deadcode_test.go +++ b/src/cmd/compile/internal/ssa/deadcode_test.go @@ -17,7 +17,7 @@ func TestDeadLoop(t *testing.T) { // dead loop Bloc("deadblock", // dead value in dead block - Valu("deadval", OpConstBool, TypeBool, 0, true), + Valu("deadval", OpConstBool, TypeBool, 1, nil), If("deadval", "deadblock", "exit"))) CheckFunc(fun.f) @@ -63,7 +63,7 @@ func TestNeverTaken(t *testing.T) { c := testConfig(t) fun := Fun(c, "entry", Bloc("entry", - Valu("cond", OpConstBool, TypeBool, 0, false), + Valu("cond", OpConstBool, TypeBool, 0, nil), Valu("mem", OpArg, TypeMem, 0, ".mem"), If("cond", "then", "else")), Bloc("then", @@ -99,7 +99,7 @@ func TestNestedDeadBlocks(t *testing.T) { fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), - Valu("cond", OpConstBool, TypeBool, 0, false), + Valu("cond", OpConstBool, TypeBool, 0, nil), If("cond", "b2", "b4")), Bloc("b2", If("cond", "b3", "b4")), diff --git a/src/cmd/compile/internal/ssa/deadstore_test.go b/src/cmd/compile/internal/ssa/deadstore_test.go index 0f295296bd..159ac4e439 100644 --- a/src/cmd/compile/internal/ssa/deadstore_test.go +++ b/src/cmd/compile/internal/ssa/deadstore_test.go @@ -14,7 +14,7 @@ func TestDeadStore(t *testing.T) { Bloc("entry", Valu("start", OpArg, TypeMem, 0, ".mem"), Valu("sb", OpSB, TypeInvalid, 0, nil), - Valu("v", OpConstBool, TypeBool, 0, true), + 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"), @@ -49,7 +49,7 @@ func TestDeadStorePhi(t *testing.T) { Bloc("entry", Valu("start", OpArg, TypeMem, 0, ".mem"), Valu("sb", OpSB, TypeInvalid, 0, nil), - Valu("v", OpConstBool, TypeBool, 0, true), + Valu("v", OpConstBool, TypeBool, 1, nil), Valu("addr", OpAddr, ptrType, 0, nil, "sb"), Goto("loop")), Bloc("loop", @@ -76,7 +76,7 @@ func TestDeadStoreTypes(t *testing.T) { Bloc("entry", Valu("start", OpArg, TypeMem, 0, ".mem"), Valu("sb", OpSB, TypeInvalid, 0, nil), - Valu("v", OpConstBool, TypeBool, 0, true), + 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"), diff --git a/src/cmd/compile/internal/ssa/dom_test.go b/src/cmd/compile/internal/ssa/dom_test.go index e125907929..b46dcebc72 100644 --- a/src/cmd/compile/internal/ssa/dom_test.go +++ b/src/cmd/compile/internal/ssa/dom_test.go @@ -44,7 +44,7 @@ func genFwdBack(size int) []bloc { blocs = append(blocs, Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), - Valu("p", OpConstBool, TypeBool, 0, true), + Valu("p", OpConstBool, TypeBool, 1, nil), Goto(blockn(0)), ), ) @@ -74,7 +74,7 @@ func genManyPred(size int) []bloc { blocs = append(blocs, Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), - Valu("p", OpConstBool, TypeBool, 0, true), + Valu("p", OpConstBool, TypeBool, 1, nil), Goto(blockn(0)), ), ) @@ -85,15 +85,15 @@ func genManyPred(size int) []bloc { switch i % 3 { case 0: blocs = append(blocs, Bloc(blockn(i), - Valu("a", OpConstBool, TypeBool, 0, true), + Valu("a", OpConstBool, TypeBool, 1, nil), Goto(blockn(i+1)))) case 1: blocs = append(blocs, Bloc(blockn(i), - Valu("a", OpConstBool, TypeBool, 0, true), + 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, 0, true), + Valu("a", OpConstBool, TypeBool, 1, nil), If("p", blockn(i+1), blockn(size)))) } } @@ -112,7 +112,7 @@ func genMaxPred(size int) []bloc { blocs = append(blocs, Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), - Valu("p", OpConstBool, TypeBool, 0, true), + Valu("p", OpConstBool, TypeBool, 1, nil), Goto(blockn(0)), ), ) @@ -137,14 +137,14 @@ func genMaxPredValue(size int) []bloc { blocs = append(blocs, Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), - Valu("p", OpConstBool, TypeBool, 0, true), + 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, 0, true), + Valu("a", OpConstBool, TypeBool, 1, nil), If("p", blockn(i+1), "exit"))) } @@ -267,7 +267,7 @@ func TestDominatorsMultPredFwd(t *testing.T) { fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), - Valu("p", OpConstBool, TypeBool, 0, true), + Valu("p", OpConstBool, TypeBool, 1, nil), If("p", "a", "c")), Bloc("a", If("p", "b", "c")), @@ -295,7 +295,7 @@ func TestDominatorsDeadCode(t *testing.T) { fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), - Valu("p", OpConstBool, TypeBool, 0, false), + Valu("p", OpConstBool, TypeBool, 0, nil), If("p", "b3", "b5")), Bloc("b2", Exit("mem")), Bloc("b3", Goto("b2")), @@ -320,7 +320,7 @@ func TestDominatorsMultPredRev(t *testing.T) { Goto("first")), Bloc("first", Valu("mem", OpArg, TypeMem, 0, ".mem"), - Valu("p", OpConstBool, TypeBool, 0, true), + Valu("p", OpConstBool, TypeBool, 1, nil), Goto("a")), Bloc("a", If("p", "b", "first")), @@ -349,7 +349,7 @@ func TestDominatorsMultPred(t *testing.T) { fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), - Valu("p", OpConstBool, TypeBool, 0, true), + Valu("p", OpConstBool, TypeBool, 1, nil), If("p", "a", "c")), Bloc("a", If("p", "b", "c")), @@ -377,7 +377,7 @@ func TestPostDominators(t *testing.T) { fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), - Valu("p", OpConstBool, TypeBool, 0, true), + Valu("p", OpConstBool, TypeBool, 1, nil), If("p", "a", "c")), Bloc("a", If("p", "b", "c")), @@ -404,7 +404,7 @@ func TestInfiniteLoop(t *testing.T) { fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), - Valu("p", OpConstBool, TypeBool, 0, true), + Valu("p", OpConstBool, TypeBool, 1, nil), Goto("a")), Bloc("a", Goto("b")), diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index e8dc5cee72..8e1a8a09b1 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -303,8 +303,7 @@ (Const64F {val}) -> (MOVSDconst {val}) (ConstPtr [val]) -> (MOVQconst [val]) (ConstNil) -> (MOVQconst [0]) -(ConstBool {b}) && !b.(bool) -> (MOVBconst [0]) -(ConstBool {b}) && b.(bool) -> (MOVBconst [1]) +(ConstBool [b]) -> (MOVBconst [b]) (Addr {sym} base) -> (LEAQ {sym} base) diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index e0b49180f9..8d7b069c67 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -24,18 +24,18 @@ (AddPtr (ConstPtr [c]) (ConstPtr [d])) -> (ConstPtr [c+d]) (Mul64 (Const64 [c]) (Const64 [d])) -> (Const64 [c*d]) (MulPtr (ConstPtr [c]) (ConstPtr [d])) -> (ConstPtr [c*d]) -(IsInBounds (Const32 [c]) (Const32 [d])) -> (ConstBool {inBounds32(c,d)}) -(IsInBounds (Const64 [c]) (Const64 [d])) -> (ConstBool {inBounds64(c,d)}) -(IsInBounds (ConstPtr [c]) (ConstPtr [d])) && config.PtrSize == 4 -> (ConstBool {inBounds32(c,d)}) -(IsInBounds (ConstPtr [c]) (ConstPtr [d])) && config.PtrSize == 8 -> (ConstBool {inBounds64(c,d)}) -(Eq64 x x) -> (ConstBool {true}) -(Eq32 x x) -> (ConstBool {true}) -(Eq16 x x) -> (ConstBool {true}) -(Eq8 x x) -> (ConstBool {true}) -(Neq64 x x) -> (ConstBool {false}) -(Neq32 x x) -> (ConstBool {false}) -(Neq16 x x) -> (ConstBool {false}) -(Neq8 x x) -> (ConstBool {false}) +(IsInBounds (Const32 [c]) (Const32 [d])) -> (ConstBool [b2i(inBounds32(c,d))]) +(IsInBounds (Const64 [c]) (Const64 [d])) -> (ConstBool [b2i(inBounds64(c,d))]) +(IsInBounds (ConstPtr [c]) (ConstPtr [d])) && config.PtrSize == 4 -> (ConstBool [b2i(inBounds32(c,d))]) +(IsInBounds (ConstPtr [c]) (ConstPtr [d])) && config.PtrSize == 8 -> (ConstBool [b2i(inBounds64(c,d))]) +(Eq64 x x) -> (ConstBool [1]) +(Eq32 x x) -> (ConstBool [1]) +(Eq16 x x) -> (ConstBool [1]) +(Eq8 x x) -> (ConstBool [1]) +(Neq64 x x) -> (ConstBool [0]) +(Neq32 x x) -> (ConstBool [0]) +(Neq16 x x) -> (ConstBool [0]) +(Neq8 x x) -> (ConstBool [0]) // simplifications (Or64 x x) -> x @@ -177,5 +177,5 @@ (If (IsNonNil (GetG)) yes no) -> (First nil yes no) (If (Not cond) yes no) -> (If cond no yes) -(If (ConstBool {c}) yes no) && c.(bool) -> (First nil yes no) -(If (ConstBool {c}) yes no) && !c.(bool) -> (First nil no yes) +(If (ConstBool [c]) yes no) && c == 1 -> (First nil yes no) +(If (ConstBool [c]) yes no) && c == 0 -> (First nil no yes) diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go index f2c8972c14..2742a5cc3b 100644 --- a/src/cmd/compile/internal/ssa/rewrite.go +++ b/src/cmd/compile/internal/ssa/rewrite.go @@ -162,3 +162,11 @@ func isPowerOfTwo(n int64) bool { 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 +} diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 366a195a3d..f449892a8a 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -1624,41 +1624,20 @@ func rewriteValueAMD64(v *Value, config *Config) bool { end200524c722ed14ca935ba47f8f30327d: ; case OpConstBool: - // match: (ConstBool {b}) - // cond: !b.(bool) - // result: (MOVBconst [0]) - { - b := v.Aux - if !(!b.(bool)) { - goto end876159ea073d2dcefcc251667c1a7780 - } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 0 - return true - } - goto end876159ea073d2dcefcc251667c1a7780 - end876159ea073d2dcefcc251667c1a7780: - ; - // match: (ConstBool {b}) - // cond: b.(bool) - // result: (MOVBconst [1]) + // match: (ConstBool [b]) + // cond: + // result: (MOVBconst [b]) { - b := v.Aux - if !(b.(bool)) { - goto end0dacad3f7cad53905aad5303391447f6 - } + b := v.AuxInt v.Op = OpAMD64MOVBconst v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = 1 + v.AuxInt = b return true } - goto end0dacad3f7cad53905aad5303391447f6 - end0dacad3f7cad53905aad5303391447f6: + goto end6d919011283330dcbcb3826f0adc6793 + end6d919011283330dcbcb3826f0adc6793: ; case OpConstNil: // match: (ConstNil) diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index ca771d75ae..3a068058ee 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -354,78 +354,78 @@ func rewriteValuegeneric(v *Value, config *Config) bool { case OpEq16: // match: (Eq16 x x) // cond: - // result: (ConstBool {true}) + // result: (ConstBool [1]) { x := v.Args[0] if v.Args[1] != x { - goto enda503589f9b617e708a5ad3ddb047809f + goto end0c0fe5fdfba3821add3448fd3f1fc6b7 } v.Op = OpConstBool v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = true + v.AuxInt = 1 return true } - goto enda503589f9b617e708a5ad3ddb047809f - enda503589f9b617e708a5ad3ddb047809f: + goto end0c0fe5fdfba3821add3448fd3f1fc6b7 + end0c0fe5fdfba3821add3448fd3f1fc6b7: ; case OpEq32: // match: (Eq32 x x) // cond: - // result: (ConstBool {true}) + // result: (ConstBool [1]) { x := v.Args[0] if v.Args[1] != x { - goto endc94ae3b97d0090257b02152e437b3e17 + goto end6da547ec4ee93d787434f3bda873e4a0 } v.Op = OpConstBool v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = true + v.AuxInt = 1 return true } - goto endc94ae3b97d0090257b02152e437b3e17 - endc94ae3b97d0090257b02152e437b3e17: + goto end6da547ec4ee93d787434f3bda873e4a0 + end6da547ec4ee93d787434f3bda873e4a0: ; case OpEq64: // match: (Eq64 x x) // cond: - // result: (ConstBool {true}) + // result: (ConstBool [1]) { x := v.Args[0] if v.Args[1] != x { - goto end4d21cead60174989467a9c8202dbb91d + goto endb1d471cc503ba8bb05440f01dbf33d81 } v.Op = OpConstBool v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = true + v.AuxInt = 1 return true } - goto end4d21cead60174989467a9c8202dbb91d - end4d21cead60174989467a9c8202dbb91d: + goto endb1d471cc503ba8bb05440f01dbf33d81 + endb1d471cc503ba8bb05440f01dbf33d81: ; case OpEq8: // match: (Eq8 x x) // cond: - // result: (ConstBool {true}) + // result: (ConstBool [1]) { x := v.Args[0] if v.Args[1] != x { - goto end73dce8bba164e4f4a1dd701bf8cfb362 + goto enda66da0d3e7e51624ee46527727c48a9a } v.Op = OpConstBool v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = true + v.AuxInt = 1 return true } - goto end73dce8bba164e4f4a1dd701bf8cfb362 - end73dce8bba164e4f4a1dd701bf8cfb362: + goto enda66da0d3e7e51624ee46527727c48a9a + enda66da0d3e7e51624ee46527727c48a9a: ; case OpEqFat: // match: (EqFat x y) @@ -521,97 +521,97 @@ func rewriteValuegeneric(v *Value, config *Config) bool { case OpIsInBounds: // match: (IsInBounds (Const32 [c]) (Const32 [d])) // cond: - // result: (ConstBool {inBounds32(c,d)}) + // result: (ConstBool [b2i(inBounds32(c,d))]) { if v.Args[0].Op != OpConst32 { - goto endc3396bf88b56276e1691abe62811dba5 + goto endf0a2ecfe84b293de6ff0919e45d19d9d } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst32 { - goto endc3396bf88b56276e1691abe62811dba5 + goto endf0a2ecfe84b293de6ff0919e45d19d9d } d := v.Args[1].AuxInt v.Op = OpConstBool v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = inBounds32(c, d) + v.AuxInt = b2i(inBounds32(c, d)) return true } - goto endc3396bf88b56276e1691abe62811dba5 - endc3396bf88b56276e1691abe62811dba5: + goto endf0a2ecfe84b293de6ff0919e45d19d9d + endf0a2ecfe84b293de6ff0919e45d19d9d: ; // match: (IsInBounds (Const64 [c]) (Const64 [d])) // cond: - // result: (ConstBool {inBounds64(c,d)}) + // result: (ConstBool [b2i(inBounds64(c,d))]) { if v.Args[0].Op != OpConst64 { - goto end0b4b8178a54662835b00bfa503cf879a + goto end4b406f402c135f50f71effcc904ecb2b } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst64 { - goto end0b4b8178a54662835b00bfa503cf879a + goto end4b406f402c135f50f71effcc904ecb2b } d := v.Args[1].AuxInt v.Op = OpConstBool v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = inBounds64(c, d) + v.AuxInt = b2i(inBounds64(c, d)) return true } - goto end0b4b8178a54662835b00bfa503cf879a - end0b4b8178a54662835b00bfa503cf879a: + goto end4b406f402c135f50f71effcc904ecb2b + end4b406f402c135f50f71effcc904ecb2b: ; // match: (IsInBounds (ConstPtr [c]) (ConstPtr [d])) // cond: config.PtrSize == 4 - // result: (ConstBool {inBounds32(c,d)}) + // result: (ConstBool [b2i(inBounds32(c,d))]) { if v.Args[0].Op != OpConstPtr { - goto end2c6938f68a67e08dbd96edb1e693e549 + goto end4323278ec7a053034fcf7033697d7b3b } c := v.Args[0].AuxInt if v.Args[1].Op != OpConstPtr { - goto end2c6938f68a67e08dbd96edb1e693e549 + goto end4323278ec7a053034fcf7033697d7b3b } d := v.Args[1].AuxInt if !(config.PtrSize == 4) { - goto end2c6938f68a67e08dbd96edb1e693e549 + goto end4323278ec7a053034fcf7033697d7b3b } v.Op = OpConstBool v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = inBounds32(c, d) + v.AuxInt = b2i(inBounds32(c, d)) return true } - goto end2c6938f68a67e08dbd96edb1e693e549 - end2c6938f68a67e08dbd96edb1e693e549: + goto end4323278ec7a053034fcf7033697d7b3b + end4323278ec7a053034fcf7033697d7b3b: ; // match: (IsInBounds (ConstPtr [c]) (ConstPtr [d])) // cond: config.PtrSize == 8 - // result: (ConstBool {inBounds64(c,d)}) + // result: (ConstBool [b2i(inBounds64(c,d))]) { if v.Args[0].Op != OpConstPtr { - goto end84d6ae817944985f572ecaac51999d6c + goto endb550b8814df20b5eeda4f43cc94e902b } c := v.Args[0].AuxInt if v.Args[1].Op != OpConstPtr { - goto end84d6ae817944985f572ecaac51999d6c + goto endb550b8814df20b5eeda4f43cc94e902b } d := v.Args[1].AuxInt if !(config.PtrSize == 8) { - goto end84d6ae817944985f572ecaac51999d6c + goto endb550b8814df20b5eeda4f43cc94e902b } v.Op = OpConstBool v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = inBounds64(c, d) + v.AuxInt = b2i(inBounds64(c, d)) return true } - goto end84d6ae817944985f572ecaac51999d6c - end84d6ae817944985f572ecaac51999d6c: + goto endb550b8814df20b5eeda4f43cc94e902b + endb550b8814df20b5eeda4f43cc94e902b: ; case OpLoad: // match: (Load ptr mem) @@ -837,78 +837,78 @@ func rewriteValuegeneric(v *Value, config *Config) bool { case OpNeq16: // match: (Neq16 x x) // cond: - // result: (ConstBool {false}) + // result: (ConstBool [0]) { x := v.Args[0] if v.Args[1] != x { - goto end192755dd3c2be992e9d3deb53794a8d2 + goto ende76a50b524aeb16c7aeccf5f5cc60c06 } v.Op = OpConstBool v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = false + v.AuxInt = 0 return true } - goto end192755dd3c2be992e9d3deb53794a8d2 - end192755dd3c2be992e9d3deb53794a8d2: + goto ende76a50b524aeb16c7aeccf5f5cc60c06 + ende76a50b524aeb16c7aeccf5f5cc60c06: ; case OpNeq32: // match: (Neq32 x x) // cond: - // result: (ConstBool {false}) + // result: (ConstBool [0]) { x := v.Args[0] if v.Args[1] != x { - goto endeb23619fc85950a8df7b31126252c4dd + goto end3713a608cffd29b40ff7c3b3f2585cbb } v.Op = OpConstBool v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = false + v.AuxInt = 0 return true } - goto endeb23619fc85950a8df7b31126252c4dd - endeb23619fc85950a8df7b31126252c4dd: + goto end3713a608cffd29b40ff7c3b3f2585cbb + end3713a608cffd29b40ff7c3b3f2585cbb: ; case OpNeq64: // match: (Neq64 x x) // cond: - // result: (ConstBool {false}) + // result: (ConstBool [0]) { x := v.Args[0] if v.Args[1] != x { - goto endfc6eea780fb4056afb9e4287076da60c + goto end3601ad382705ea12b79d2008c1e5725c } v.Op = OpConstBool v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = false + v.AuxInt = 0 return true } - goto endfc6eea780fb4056afb9e4287076da60c - endfc6eea780fb4056afb9e4287076da60c: + goto end3601ad382705ea12b79d2008c1e5725c + end3601ad382705ea12b79d2008c1e5725c: ; case OpNeq8: // match: (Neq8 x x) // cond: - // result: (ConstBool {false}) + // result: (ConstBool [0]) { x := v.Args[0] if v.Args[1] != x { - goto endcccf700d93c6d57765b80f92f7b3fa81 + goto end09a0deaf3c42627d0d2d3efa96e30745 } v.Op = OpConstBool v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = false + v.AuxInt = 0 return true } - goto endcccf700d93c6d57765b80f92f7b3fa81 - endcccf700d93c6d57765b80f92f7b3fa81: + goto end09a0deaf3c42627d0d2d3efa96e30745 + end09a0deaf3c42627d0d2d3efa96e30745: ; case OpNeqFat: // match: (NeqFat x y) @@ -1620,19 +1620,19 @@ func rewriteBlockgeneric(b *Block) bool { goto endebe19c1c3c3bec068cdb2dd29ef57f96 endebe19c1c3c3bec068cdb2dd29ef57f96: ; - // match: (If (ConstBool {c}) yes no) - // cond: c.(bool) + // match: (If (ConstBool [c]) yes no) + // cond: c == 1 // result: (First nil yes no) { v := b.Control if v.Op != OpConstBool { - goto end7a20763049489cdb40bb1eaa57d113d8 + goto endc58ecbb85af78c0d58bb232ca86b67a4 } - c := v.Aux + c := v.AuxInt yes := b.Succs[0] no := b.Succs[1] - if !(c.(bool)) { - goto end7a20763049489cdb40bb1eaa57d113d8 + if !(c == 1) { + goto endc58ecbb85af78c0d58bb232ca86b67a4 } b.Kind = BlockFirst b.Control = nil @@ -1640,22 +1640,22 @@ func rewriteBlockgeneric(b *Block) bool { b.Succs[1] = no return true } - goto end7a20763049489cdb40bb1eaa57d113d8 - end7a20763049489cdb40bb1eaa57d113d8: + goto endc58ecbb85af78c0d58bb232ca86b67a4 + endc58ecbb85af78c0d58bb232ca86b67a4: ; - // match: (If (ConstBool {c}) yes no) - // cond: !c.(bool) + // match: (If (ConstBool [c]) yes no) + // cond: c == 0 // result: (First nil no yes) { v := b.Control if v.Op != OpConstBool { - goto end3ecbf5b2cc1f0a08444d8ab1871a829c + goto end4c3e297e275dd7e2e67f8ccd348c4bb5 } - c := v.Aux + c := v.AuxInt yes := b.Succs[0] no := b.Succs[1] - if !(!c.(bool)) { - goto end3ecbf5b2cc1f0a08444d8ab1871a829c + if !(c == 0) { + goto end4c3e297e275dd7e2e67f8ccd348c4bb5 } b.Kind = BlockFirst b.Control = nil @@ -1664,8 +1664,8 @@ func rewriteBlockgeneric(b *Block) bool { b.Likely *= -1 return true } - goto end3ecbf5b2cc1f0a08444d8ab1871a829c - end3ecbf5b2cc1f0a08444d8ab1871a829c: + goto end4c3e297e275dd7e2e67f8ccd348c4bb5 + end4c3e297e275dd7e2e67f8ccd348c4bb5: } return false } -- cgit v1.3 From 19447a66d663cf51f5c02c4d9d0c74894714067a Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Fri, 4 Sep 2015 06:33:56 -0500 Subject: [dev.ssa] cmd/compile: store floats in AuxInt Store floats in AuxInt to reduce allocations. Change-Id: I101e6322530b4a0b2ea3591593ad022c992e8df8 Reviewed-on: https://go-review.googlesource.com/14320 Reviewed-by: David Chase Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 3 ++- src/cmd/compile/internal/ssa/TODO | 1 - src/cmd/compile/internal/ssa/check.go | 7 +++++ src/cmd/compile/internal/ssa/cse.go | 22 +++++---------- src/cmd/compile/internal/ssa/func.go | 11 ++++---- src/cmd/compile/internal/ssa/gen/AMD64.rules | 8 +++--- src/cmd/compile/internal/ssa/rewrite.go | 10 ++++++- src/cmd/compile/internal/ssa/rewriteAMD64.go | 40 ++++++++++++++-------------- src/cmd/compile/internal/ssa/value.go | 14 +++++++++- 9 files changed, 67 insertions(+), 49 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 340b7daa52..ac8888e14d 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -8,6 +8,7 @@ import ( "bytes" "fmt" "html" + "math" "os" "strings" @@ -3006,7 +3007,7 @@ func genValue(v *ssa.Value) { x := regnum(v) p := Prog(v.Op.Asm()) p.From.Type = obj.TYPE_FCONST - p.From.Val = v.Aux.(float64) + 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: diff --git a/src/cmd/compile/internal/ssa/TODO b/src/cmd/compile/internal/ssa/TODO index 8feb1053ae..fbe4f56760 100644 --- a/src/cmd/compile/internal/ssa/TODO +++ b/src/cmd/compile/internal/ssa/TODO @@ -44,7 +44,6 @@ Optimizations (better compiler) - Reuseable slices (e.g. []int of size NumValues()) cached in Func - Handle signed division overflow and sign extension earlier - Implement 64 bit const division with high multiply, maybe in the frontend? -- Store bool and float32/float64 in auxInt Regalloc -------- diff --git a/src/cmd/compile/internal/ssa/check.go b/src/cmd/compile/internal/ssa/check.go index a7249a4c54..710b7609c6 100644 --- a/src/cmd/compile/internal/ssa/check.go +++ b/src/cmd/compile/internal/ssa/check.go @@ -126,6 +126,13 @@ func checkFunc(f *Func) { if _, ok := v.Aux.(bool); ok { f.Fatalf("value %v has a bool Aux value, should be AuxInt", v.LongString()) } + if _, ok := v.Aux.(float32); ok { + f.Fatalf("value %v has a float32 Aux value, should be AuxInt", v.LongString()) + } + + if _, ok := v.Aux.(float64); ok { + f.Fatalf("value %v has a float64 Aux value, should be AuxInt", v.LongString()) + } for _, arg := range v.Args { if arg == nil { diff --git a/src/cmd/compile/internal/ssa/cse.go b/src/cmd/compile/internal/ssa/cse.go index 6469ecd72b..836a7803ac 100644 --- a/src/cmd/compile/internal/ssa/cse.go +++ b/src/cmd/compile/internal/ssa/cse.go @@ -4,10 +4,7 @@ package ssa -import ( - "math" - "sort" -) +import "sort" // cse does common-subexpression elimination on the Function. // Values are just relinked, nothing is deleted. A subsequent deadcode @@ -55,18 +52,11 @@ func cse(f *Func) { arg1op = v.Args[1].Op } - aux := v.Aux - auxInt := v.AuxInt - // -0 == 0, but aren't equivalent values so we use - // Float64bits to distinguish - if f, ok := aux.(float64); ok { - aux = nil - if auxInt != 0 { - v.Fatalf("float would clobber v.auxInt") - } - auxInt = int64(math.Float64bits(f)) - } - k := key{v.Op, v.Type.String(), aux, auxInt, len(v.Args), bid, arg0op, arg1op} + // This assumes that floats are stored in AuxInt + // instead of Aux. If not, then we need to use the + // float bits as part of the key, otherwise since 0.0 == -0.0 + // this would incorrectly treat 0.0 and -0.0 as identical values + k := key{v.Op, v.Type.String(), v.Aux, v.AuxInt, len(v.Args), bid, arg0op, arg1op} m[k] = append(m[k], v) } } diff --git a/src/cmd/compile/internal/ssa/func.go b/src/cmd/compile/internal/ssa/func.go index 09bfff2bfc..747a5c7f03 100644 --- a/src/cmd/compile/internal/ssa/func.go +++ b/src/cmd/compile/internal/ssa/func.go @@ -4,7 +4,10 @@ package ssa -import "sync" +import ( + "math" + "sync" +) // A Func represents a Go func declaration (or function literal) and // its body. This package compiles each Func independently. @@ -287,13 +290,11 @@ func (f *Func) ConstIntPtr(line int32, t Type, c int64) *Value { } func (f *Func) ConstFloat32(line int32, t Type, c float64) *Value { // TODO: cache? - // For now stuff FP values into aux interface - return f.Entry.NewValue0A(line, OpConst32F, t, c) + return f.Entry.NewValue0I(line, OpConst32F, t, int64(math.Float64bits(c))) } func (f *Func) ConstFloat64(line int32, t Type, c float64) *Value { // TODO: cache? - // For now stuff FP values into aux interface - return f.Entry.NewValue0A(line, OpConst64F, t, c) + return f.Entry.NewValue0I(line, OpConst64F, t, int64(math.Float64bits(c))) } func (f *Func) Logf(msg string, args ...interface{}) { f.Config.Logf(msg, args...) } diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 8e1a8a09b1..16bd1df84b 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -81,8 +81,8 @@ (Neg32 x) -> (NEGL x) (Neg16 x) -> (NEGW x) (Neg8 x) -> (NEGB x) -(Neg32F x) -> (PXOR x (MOVSSconst {math.Copysign(0, -1)})) -(Neg64F x) -> (PXOR x (MOVSDconst {math.Copysign(0, -1)})) +(Neg32F x) -> (PXOR x (MOVSSconst [f2i(math.Copysign(0, -1))])) +(Neg64F x) -> (PXOR x (MOVSDconst [f2i(math.Copysign(0, -1))])) (Com64 x) -> (NOTQ x) (Com32 x) -> (NOTL x) @@ -299,8 +299,8 @@ (Const16 [val]) -> (MOVWconst [val]) (Const32 [val]) -> (MOVLconst [val]) (Const64 [val]) -> (MOVQconst [val]) -(Const32F {val}) -> (MOVSSconst {val}) -(Const64F {val}) -> (MOVSDconst {val}) +(Const32F [val]) -> (MOVSSconst [val]) +(Const64F [val]) -> (MOVSDconst [val]) (ConstPtr [val]) -> (MOVQconst [val]) (ConstNil) -> (MOVQconst [0]) (ConstBool [b]) -> (MOVBconst [b]) diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go index 2742a5cc3b..5c47ec6660 100644 --- a/src/cmd/compile/internal/ssa/rewrite.go +++ b/src/cmd/compile/internal/ssa/rewrite.go @@ -4,7 +4,10 @@ package ssa -import "fmt" +import ( + "fmt" + "math" +) func applyRewrite(f *Func, rb func(*Block) bool, rv func(*Value, *Config) bool) { // repeat rewrites until we find no more rewrites @@ -170,3 +173,8 @@ func b2i(b bool) int64 { } return 0 } + +// f2i is used in the rules for storing a float in AuxInt. +func f2i(f float64) int64 { + return int64(math.Float64bits(f)) +} diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index f449892a8a..8ad939ead9 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -1560,20 +1560,20 @@ func rewriteValueAMD64(v *Value, config *Config) bool { enddae5807662af67143a3ac3ad9c63bae5: ; case OpConst32F: - // match: (Const32F {val}) + // match: (Const32F [val]) // cond: - // result: (MOVSSconst {val}) + // result: (MOVSSconst [val]) { - val := v.Aux + val := v.AuxInt v.Op = OpAMD64MOVSSconst v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = val + v.AuxInt = val return true } - goto end30a68b43982e55971cc58f893ae2c04a - end30a68b43982e55971cc58f893ae2c04a: + goto endfabcef2d57a8f36eaa6041de6f112b89 + endfabcef2d57a8f36eaa6041de6f112b89: ; case OpConst64: // match: (Const64 [val]) @@ -1592,20 +1592,20 @@ func rewriteValueAMD64(v *Value, config *Config) bool { endc630434ae7f143ab69d5f482a9b52b5f: ; case OpConst64F: - // match: (Const64F {val}) + // match: (Const64F [val]) // cond: - // result: (MOVSDconst {val}) + // result: (MOVSDconst [val]) { - val := v.Aux + val := v.AuxInt v.Op = OpAMD64MOVSDconst v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Aux = val + v.AuxInt = val return true } - goto end958041a44a2ee8fc571cbc0832fad285 - end958041a44a2ee8fc571cbc0832fad285: + goto endae6cf7189e464bbde17b98635a20f0ff + endae6cf7189e464bbde17b98635a20f0ff: ; case OpConst8: // match: (Const8 [val]) @@ -6044,7 +6044,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { case OpNeg32F: // match: (Neg32F x) // cond: - // result: (PXOR x (MOVSSconst {math.Copysign(0, -1)})) + // result: (PXOR x (MOVSSconst [f2i(math.Copysign(0, -1))])) { x := v.Args[0] v.Op = OpAMD64PXOR @@ -6054,12 +6054,12 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(x) v0 := b.NewValue0(v.Line, OpAMD64MOVSSconst, TypeInvalid) v0.Type = config.Frontend().TypeFloat32() - v0.Aux = math.Copysign(0, -1) + v0.AuxInt = f2i(math.Copysign(0, -1)) v.AddArg(v0) return true } - goto end47074133a76e069317ceca46372cafc3 - end47074133a76e069317ceca46372cafc3: + goto end685a5fc899e195b9091afbe2a7146051 + end685a5fc899e195b9091afbe2a7146051: ; case OpNeg64: // match: (Neg64 x) @@ -6080,7 +6080,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { case OpNeg64F: // match: (Neg64F x) // cond: - // result: (PXOR x (MOVSDconst {math.Copysign(0, -1)})) + // result: (PXOR x (MOVSDconst [f2i(math.Copysign(0, -1))])) { x := v.Args[0] v.Op = OpAMD64PXOR @@ -6090,12 +6090,12 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(x) v0 := b.NewValue0(v.Line, OpAMD64MOVSDconst, TypeInvalid) v0.Type = config.Frontend().TypeFloat64() - v0.Aux = math.Copysign(0, -1) + v0.AuxInt = f2i(math.Copysign(0, -1)) v.AddArg(v0) return true } - goto end9240202f5753ebd23f11f982ece3e06e - end9240202f5753ebd23f11f982ece3e06e: + goto ende85ae82b7a51e75000eb9158d584acb2 + ende85ae82b7a51e75000eb9158d584acb2: ; case OpNeg8: // match: (Neg8 x) diff --git a/src/cmd/compile/internal/ssa/value.go b/src/cmd/compile/internal/ssa/value.go index 04ea17cce9..d213b72df3 100644 --- a/src/cmd/compile/internal/ssa/value.go +++ b/src/cmd/compile/internal/ssa/value.go @@ -4,7 +4,10 @@ package ssa -import "fmt" +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 @@ -60,6 +63,15 @@ func (v *Value) LongString() string { s += " <" + v.Type.String() + ">" if v.AuxInt != 0 { s += fmt.Sprintf(" [%d]", v.AuxInt) + + switch { + case v.Op == OpConst32F || v.Op == OpConst64F: + s += fmt.Sprintf("(%g)", math.Float64frombits(uint64(v.AuxInt))) + case v.Op == OpConstBool && v.AuxInt == 0: + s += " (false)" + case v.Op == OpConstBool && v.AuxInt == 1: + s += " (true)" + } } if v.Aux != nil { if _, ok := v.Aux.(string); ok { -- cgit v1.3 From 24dcede1c0c0338a06da4d0b4b3d2996b90bf7d6 Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Mon, 10 Aug 2015 19:00:34 -0500 Subject: [dev.ssa] cmd/compile/ssa: add timing to compiler passes Add timing/allocation information to each compiler pass for both the console and html output. Change-Id: I75833003b806a09b4fb1bbf63983258612cdb7b0 Reviewed-on: https://go-review.googlesource.com/14277 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/compile.go | 26 ++++++++++++++++++++++++-- 1 file changed, 24 insertions(+), 2 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/compile.go b/src/cmd/compile/internal/ssa/compile.go index 7413e721fe..bff1a8103b 100644 --- a/src/cmd/compile/internal/ssa/compile.go +++ b/src/cmd/compile/internal/ssa/compile.go @@ -5,8 +5,10 @@ package ssa import ( + "fmt" "log" "runtime" + "time" ) // Compile is the main entry point for this package. @@ -36,14 +38,34 @@ func Compile(f *Func) { printFunc(f) f.Config.HTML.WriteFunc("start", f) checkFunc(f) + const logMemStats = false for _, p := range passes { phaseName = p.name 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 { + runtime.ReadMemStats(&mStart) + } + + tStart := time.Now() p.fn(f) - f.Logf(" pass %s end\n", p.name) + tEnd := time.Now() + + time := tEnd.Sub(tStart).Nanoseconds() + var stats string + if logMemStats { + var mEnd runtime.MemStats + runtime.ReadMemStats(&mEnd) + nAllocs := mEnd.TotalAlloc - mStart.TotalAlloc + stats = fmt.Sprintf("[%d ns %d bytes]", time, nAllocs) + } else { + stats = fmt.Sprintf("[%d ns]", time) + } + + f.Logf(" pass %s end %s\n", p.name, stats) printFunc(f) - f.Config.HTML.WriteFunc("after "+phaseName, f) + f.Config.HTML.WriteFunc(fmt.Sprintf("after %s %s", phaseName, stats), f) checkFunc(f) } -- cgit v1.3 From 617e892b87fd2f74317a9ebf5d8b90bb9144957b Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Fri, 4 Sep 2015 13:16:07 -0700 Subject: [dev.ssa] cmd/compile: teach live variable analysis about LEAW SSA uses this opcode, the old compiler doesn't. Change-Id: Ic3dde6216496b4b89d570584d34cb0971fdf379d Reviewed-on: https://go-review.googlesource.com/14330 Reviewed-by: Minux Ma --- src/cmd/compile/internal/amd64/prog.go | 1 + src/cmd/compile/internal/x86/prog.go | 1 + 2 files changed, 2 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/amd64/prog.go b/src/cmd/compile/internal/amd64/prog.go index 6c46f20a3b..56d402a638 100644 --- a/src/cmd/compile/internal/amd64/prog.go +++ b/src/cmd/compile/internal/amd64/prog.go @@ -116,6 +116,7 @@ var progtable = [x86.ALAST]obj.ProgInfo{ 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}, diff --git a/src/cmd/compile/internal/x86/prog.go b/src/cmd/compile/internal/x86/prog.go index 8e1b7573b5..ef38ad119b 100644 --- a/src/cmd/compile/internal/x86/prog.go +++ b/src/cmd/compile/internal/x86/prog.go @@ -152,6 +152,7 @@ var progtable = [x86.ALAST]obj.ProgInfo{ 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}, -- cgit v1.3 From ec8a597cd24e72d9213f439f7c9ee51567c0621d Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Sun, 30 Aug 2015 21:19:20 -0500 Subject: [dev.ssa] cmd/compile: rewrite user nil check as OpIsNonNil Rewite user nil checks as OpIsNonNil so our nil check elimination pass can take advantage and remove redundant checks. With make.bash this removes 10% more nilchecks (34110 vs 31088). Change-Id: Ifb01d1b6d2d759f5e2a5aaa0470e1d5a2a680212 Reviewed-on: https://go-review.googlesource.com/14321 Reviewed-by: Keith Randall Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/ssa/compile.go | 2 + src/cmd/compile/internal/ssa/gen/generic.rules | 6 ++ src/cmd/compile/internal/ssa/gen/genericOps.go | 6 +- src/cmd/compile/internal/ssa/nilcheck.go | 11 ++-- src/cmd/compile/internal/ssa/nilcheck_test.go | 40 +++++++++++++ src/cmd/compile/internal/ssa/rewritegeneric.go | 80 ++++++++++++++++++++++++++ 6 files changed, 136 insertions(+), 9 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/compile.go b/src/cmd/compile/internal/ssa/compile.go index bff1a8103b..a9365e91e1 100644 --- a/src/cmd/compile/internal/ssa/compile.go +++ b/src/cmd/compile/internal/ssa/compile.go @@ -121,6 +121,8 @@ var passOrder = [...]constraint{ {"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 diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index 8d7b069c67..d2ab9f5421 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -59,6 +59,12 @@ (Com32 (Com32 x)) -> x (Com64 (Com64 x)) -> x +// 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 // start by putting nil on the right to simplify the other rules diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 59b90adfe5..8cd8165028 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -313,9 +313,9 @@ var genericOps = []opData{ {name: "Cvt64Fto32F"}, // Automatically inserted safety checks - {name: "IsNonNil"}, // arg0 != nil - {name: "IsInBounds"}, // 0 <= arg0 < arg1 - {name: "IsSliceInBounds"}, // 0 <= arg0 <= arg1 + {name: "IsNonNil", typ: "Bool"}, // arg0 != nil + {name: "IsInBounds", typ: "Bool"}, // 0 <= arg0 < arg1 + {name: "IsSliceInBounds", typ: "Bool"}, // 0 <= arg0 <= arg1 // Pseudo-ops {name: "PanicNilCheck"}, // trigger a dereference fault; arg0=nil ptr, arg1=mem, returns mem diff --git a/src/cmd/compile/internal/ssa/nilcheck.go b/src/cmd/compile/internal/ssa/nilcheck.go index 80b9e668d3..16cb04df98 100644 --- a/src/cmd/compile/internal/ssa/nilcheck.go +++ b/src/cmd/compile/internal/ssa/nilcheck.go @@ -105,12 +105,11 @@ func nilcheckelim(f *Func) { var nilBranch *Block for _, w := range domTree[node.block.ID] { - // TODO: Since we handle the false side of OpIsNonNil - // correctly, look into rewriting user nil checks into - // OpIsNonNil so they can be eliminated also - - // we are about to traverse down the 'ptr is nil' side - // of a nilcheck block, so save it for later + // We are about to traverse down the 'ptr is nil' side + // of a nilcheck block, so save it for later. This doesn't + // remove nil checks on the false side of the OpIsNonNil branch. + // This is important otherwise we would remove nil checks that + // are not redundant. if node.block.Kind == BlockIf && node.block.Control.Op == OpIsNonNil && w == node.block.Succs[1] { nilBranch = w diff --git a/src/cmd/compile/internal/ssa/nilcheck_test.go b/src/cmd/compile/internal/ssa/nilcheck_test.go index c54f86a7b4..1d048fbb34 100644 --- a/src/cmd/compile/internal/ssa/nilcheck_test.go +++ b/src/cmd/compile/internal/ssa/nilcheck_test.go @@ -342,3 +342,43 @@ func TestNilcheckInFalseBranch(t *testing.T) { 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}) + fun := Fun(c, "entry", + Bloc("entry", + Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("sb", OpSB, TypeInvalid, 0, nil), + Goto("checkPtr")), + Bloc("checkPtr", + Valu("ptr1", OpConstPtr, ptrType, 0, nil, "sb"), + Valu("nilptr", OpConstNil, ptrType, 0, nil, "sb"), + 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") + } + } +} diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index 3a068058ee..dc6604fe38 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -478,6 +478,49 @@ func rewriteValuegeneric(v *Value, config *Config) bool { goto end6f10fb57a906a2c23667c770acb6abf9 end6f10fb57a906a2c23667c770acb6abf9: ; + case OpEqPtr: + // match: (EqPtr p (ConstNil)) + // cond: + // result: (Not (IsNonNil p)) + { + p := v.Args[0] + if v.Args[1].Op != OpConstNil { + goto ende701cdb6a2c1fff4d4b283b7f8f6178b + } + v.Op = OpNot + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpIsNonNil, TypeInvalid) + v0.AddArg(p) + v0.Type = config.fe.TypeBool() + v.AddArg(v0) + return true + } + goto ende701cdb6a2c1fff4d4b283b7f8f6178b + ende701cdb6a2c1fff4d4b283b7f8f6178b: + ; + // match: (EqPtr (ConstNil) p) + // cond: + // result: (Not (IsNonNil p)) + { + if v.Args[0].Op != OpConstNil { + goto end7cdc0d5c38fbffe6287c8928803b038e + } + p := v.Args[1] + v.Op = OpNot + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpIsNonNil, TypeInvalid) + v0.AddArg(p) + v0.Type = config.fe.TypeBool() + v.AddArg(v0) + return true + } + goto end7cdc0d5c38fbffe6287c8928803b038e + end7cdc0d5c38fbffe6287c8928803b038e: + ; case OpIData: // match: (IData (IMake _ data)) // cond: @@ -961,6 +1004,43 @@ func rewriteValuegeneric(v *Value, config *Config) bool { goto end3ffd7685735a83eaee8dc2577ae89d79 end3ffd7685735a83eaee8dc2577ae89d79: ; + case OpNeqPtr: + // match: (NeqPtr p (ConstNil)) + // cond: + // result: (IsNonNil p) + { + p := v.Args[0] + if v.Args[1].Op != OpConstNil { + goto endba798520b4d41172b110347158c44791 + } + v.Op = OpIsNonNil + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(p) + return true + } + goto endba798520b4d41172b110347158c44791 + endba798520b4d41172b110347158c44791: + ; + // match: (NeqPtr (ConstNil) p) + // cond: + // result: (IsNonNil p) + { + if v.Args[0].Op != OpConstNil { + goto enddd95e9c3606d9fd48034f1a703561e45 + } + p := v.Args[1] + v.Op = OpIsNonNil + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(p) + return true + } + goto enddd95e9c3606d9fd48034f1a703561e45 + enddd95e9c3606d9fd48034f1a703561e45: + ; case OpOr16: // match: (Or16 x x) // cond: -- cgit v1.3 From 1b5ffda01e94a44ec8a4dee02db024f1959e7f01 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Fri, 4 Sep 2015 17:33:32 -0700 Subject: [dev.ssa] cmd/compile: minor code cleanup Change-Id: I9c84f5ca18745fb2358494c6944bf7ddd05cf8f0 Reviewed-on: https://go-review.googlesource.com/14332 Reviewed-by: Todd Neal --- src/cmd/compile/internal/ssa/check.go | 13 +++---------- 1 file changed, 3 insertions(+), 10 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/check.go b/src/cmd/compile/internal/ssa/check.go index 710b7609c6..4b38bec99e 100644 --- a/src/cmd/compile/internal/ssa/check.go +++ b/src/cmd/compile/internal/ssa/check.go @@ -122,16 +122,9 @@ func checkFunc(f *Func) { } for _, v := range b.Values { - - if _, ok := v.Aux.(bool); ok { - f.Fatalf("value %v has a bool Aux value, should be AuxInt", v.LongString()) - } - if _, ok := v.Aux.(float32); ok { - f.Fatalf("value %v has a float32 Aux value, should be AuxInt", v.LongString()) - } - - if _, ok := v.Aux.(float64); ok { - f.Fatalf("value %v has a float64 Aux value, should be AuxInt", v.LongString()) + switch v.Aux.(type) { + case bool, float32, float64: + f.Fatalf("value %v has an Aux value of type %T, should be AuxInt", v.LongString(), v.Aux) } for _, arg := range v.Args { -- cgit v1.3 From a3f72956f1f8fde81930c0f8261cfa19bc114345 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Fri, 4 Sep 2015 17:33:56 -0700 Subject: [dev.ssa] cmd/compile: add allocs to pass stats Also, improve HTML formatting. Change-Id: I07e2482a30862e2091707f260a2c43d6e9a85d97 Reviewed-on: https://go-review.googlesource.com/14333 Reviewed-by: Todd Neal --- src/cmd/compile/internal/ssa/compile.go | 7 ++++--- src/cmd/compile/internal/ssa/html.go | 4 ++++ 2 files changed, 8 insertions(+), 3 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/compile.go b/src/cmd/compile/internal/ssa/compile.go index a9365e91e1..1c2b7ac2a8 100644 --- a/src/cmd/compile/internal/ssa/compile.go +++ b/src/cmd/compile/internal/ssa/compile.go @@ -57,15 +57,16 @@ func Compile(f *Func) { if logMemStats { var mEnd runtime.MemStats runtime.ReadMemStats(&mEnd) - nAllocs := mEnd.TotalAlloc - mStart.TotalAlloc - stats = fmt.Sprintf("[%d ns %d bytes]", time, nAllocs) + 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 %s", phaseName, stats), f) + f.Config.HTML.WriteFunc(fmt.Sprintf("after %s %s", phaseName, stats), f) checkFunc(f) } diff --git a/src/cmd/compile/internal/ssa/html.go b/src/cmd/compile/internal/ssa/html.go index 44e4e19b77..c84dccf793 100644 --- a/src/cmd/compile/internal/ssa/html.go +++ b/src/cmd/compile/internal/ssa/html.go @@ -45,6 +45,10 @@ func (w *HTMLWriter) start(name string) { display: none; } +.stats { + font-size: 60%; +} + table { border: 1px solid black; table-layout: fixed; -- cgit v1.3 From d052bbd051a76dcfcbc0a0f471072166a9d07d20 Mon Sep 17 00:00:00 2001 From: David Chase Date: Tue, 1 Sep 2015 17:09:00 -0400 Subject: [dev.ssa] cmd/compile: cleanup fp conversions in ssa.go Change to table-driven instead of branchy code; leads to net reduction in lines, easier to understand what happens, easier to modify code if we want option to exclude generation of branchy cases. Doesn't appear to scale for 8x8 case of integer types. Change-Id: Ib40104b149d30bb329c5782f6cac45c75743e768 Reviewed-on: https://go-review.googlesource.com/14163 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 218 +++++++++++++++---------------------- 1 file changed, 89 insertions(+), 129 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index ac8888e14d..9bd3655e52 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -982,6 +982,66 @@ type opAndTwoTypes struct { etype2 uint8 } +type twoTypes struct { + etype1 uint8 + etype2 uint8 +} + +type twoOpsAndType struct { + op1 ssa.Op + op2 ssa.Op + intermediateType uint8 +} + +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, @@ -1280,146 +1340,46 @@ func (s *state) expr(n *Node) *ssa.Value { return s.newValue1(op, n.Type, x) } - if ft.IsInteger() && tt.IsFloat() { - // signed 1, 2, 4, 8, unsigned 6, 7, 9, 13 - signedSize := ft.Size() - it := TINT32 // intermediate type in conversion, int32 or int64 - if !ft.IsSigned() { - signedSize += 5 + 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) } - var op1, op2 ssa.Op - switch signedSize { - case 1: - op1 = ssa.OpSignExt8to32 - case 2: - op1 = ssa.OpSignExt16to32 - case 4: - op1 = ssa.OpCopy - case 8: - op1 = ssa.OpCopy - it = TINT64 - case 6: - op1 = ssa.OpZeroExt8to32 - case 7: - op1 = ssa.OpZeroExt16to32 - case 9: - // Go wide to dodge the unsignedness correction - op1 = ssa.OpZeroExt32to64 - it = TINT64 - case 13: - // unsigned 64, there is branchy correction code - // because there is only signed-integer to FP - // conversion in the (AMD64) instructions set. - // Branchy correction code *may* be amenable to - // optimization, and it can be cleanly expressed - // in SSA, so do it here. + 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) } - - default: - s.Fatalf("weird integer to float sign extension %s -> %s", ft, tt) - - } - if tt.Size() == 4 { - if it == TINT64 { - op2 = ssa.OpCvt64to32F - } else { - op2 = ssa.OpCvt32to32F - } - } else { - if it == TINT64 { - op2 = ssa.OpCvt64to64F - } else { - op2 = ssa.OpCvt32to64F - } - } - if op1 == ssa.OpCopy { - return s.newValue1(op2, n.Type, x) - } - return s.newValue1(op2, n.Type, s.newValue1(op1, Types[it], x)) - } - - if tt.IsInteger() && ft.IsFloat() { - // signed 1, 2, 4, 8, unsigned 6, 7, 9, 13 - signedSize := tt.Size() - it := TINT32 // intermediate type in conversion, int32 or int64 - if !tt.IsSigned() { - signedSize += 5 - } - var op1, op2 ssa.Op - switch signedSize { - case 1: - op2 = ssa.OpTrunc32to8 - case 2: - op2 = ssa.OpTrunc32to16 - case 4: - op2 = ssa.OpCopy - case 8: - op2 = ssa.OpCopy - it = TINT64 - case 6: - op2 = ssa.OpTrunc32to8 - case 7: - op2 = ssa.OpTrunc32to16 - case 9: - // Go wide to dodge the unsignedness correction - op2 = ssa.OpTrunc64to32 - it = TINT64 - case 13: - // unsigned 64, branchy correction code is needed - // because there is only FP to signed-integer - // conversion in the (AMD64) instructions set. - // Branchy correction code *may* be amenable to - // optimization, and it can be cleanly expressed - // in generic SSA, so do it here. - if ft.Size() == 4 { - return s.float32ToUint64(n, x, ft, tt) - } - if ft.Size() == 8 { - return s.float64ToUint64(n, x, ft, tt) - } - // unrecognized size is also "weird", hence fatal. - fallthrough - - default: - s.Fatalf("weird float to integer conversion %s -> %s", 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 { - if it == TINT64 { - op1 = ssa.OpCvt32Fto64 - } else { - op1 = ssa.OpCvt32Fto32 - } - } else { - if it == TINT64 { - op1 = ssa.OpCvt64Fto64 - } else { - op1 = ssa.OpCvt64Fto32 - } + return s.float32ToUint64(n, x, ft, tt) } - if op2 == ssa.OpCopy { - return s.newValue1(op1, n.Type, x) + if ft.Size() == 8 { + return s.float64ToUint64(n, x, ft, tt) } - return s.newValue1(op2, n.Type, s.newValue1(op1, Types[it], x)) - } - - if ft.IsFloat() && tt.IsFloat() { - var op ssa.Op - if ft.Size() == tt.Size() { - op = ssa.OpCopy - } else if ft.Size() == 4 && tt.Size() == 8 { - op = ssa.OpCvt32Fto64F - } else if ft.Size() == 8 && tt.Size() == 4 { - op = ssa.OpCvt64Fto32F - } else { - s.Fatalf("weird float conversion %s -> %s", ft, tt) - } - return s.newValue1(op, n.Type, x) + s.Fatalf("weird float to unsigned integer conversion %s -> %s", ft, tt) + return nil } if ft.IsComplex() && tt.IsComplex() { -- cgit v1.3 From d2107fc98724662c7aa343d8004ed9d391fdeb59 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Mon, 24 Aug 2015 02:16:19 -0700 Subject: [dev.ssa] cmd/runtime: generate gc bitmaps for SSA-compiled code This change is all about leveraging the gc bitmap generation that is already done by the current compiler. We rearrange how stack allocation is done so that we generate a variable declaration for each spill. We also reorganize how args/locals are recorded during SSA. Then we can use the existing allocauto/defframe to allocate the stack frame and liveness to make the gc bitmaps. With this change, stack copying works correctly and we no longer need hacks in runtime/stack*.go to make tests work. GC is close to working, it just needs write barriers. Change-Id: I990fb4e3fbe98850c6be35c3185a1c85d9e1a6ba Reviewed-on: https://go-review.googlesource.com/13894 Reviewed-by: David Chase Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/gc/ssa.go | 140 +++++++++++++++---------- src/cmd/compile/internal/ssa/config.go | 6 ++ src/cmd/compile/internal/ssa/export_test.go | 8 +- src/cmd/compile/internal/ssa/func.go | 2 - src/cmd/compile/internal/ssa/gen/genericOps.go | 7 +- src/cmd/compile/internal/ssa/location.go | 4 +- src/cmd/compile/internal/ssa/lower.go | 2 +- src/cmd/compile/internal/ssa/opGen.go | 10 ++ src/cmd/compile/internal/ssa/schedule.go | 3 +- src/cmd/compile/internal/ssa/stackalloc.go | 46 +------- src/cmd/compile/internal/ssa/value.go | 14 ++- 11 files changed, 128 insertions(+), 114 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 9bd3655e52..407b143809 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -91,11 +91,11 @@ func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { n := d.N switch n.Class { case PPARAM, PPARAMOUT: - aux := &ssa.ArgSymbol{Typ: n.Type, Offset: n.Xoffset, Sym: n.Sym} + aux := &ssa.ArgSymbol{Typ: n.Type, Node: n} s.decladdrs[n] = s.entryNewValue1A(ssa.OpAddr, Ptrto(n.Type), aux, s.sp) case PAUTO: - aux := &ssa.AutoSymbol{Typ: n.Type, Offset: -1, Sym: n.Sym} // offset TBD by SSA pass - s.decladdrs[n] = s.entryNewValue1A(ssa.OpAddr, Ptrto(n.Type), aux, s.sp) + // processed at each use, to prevent Addr coming + // before the decl. default: str := "" if n.Class&PHEAP != 0 { @@ -105,7 +105,7 @@ func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { } } // nodfp is a special argument which is the function's FP. - aux := &ssa.ArgSymbol{Typ: Types[TUINTPTR], Offset: 0, Sym: nodfp.Sym} + aux := &ssa.ArgSymbol{Typ: Types[TUINTPTR], Node: nodfp} s.decladdrs[nodfp] = s.entryNewValue1A(ssa.OpAddr, Types[TUINTPTR], aux, s.sp) // Convert the AST-based IR to the SSA-based IR @@ -200,7 +200,7 @@ type state struct { // all defined variables at the end of each block. Indexed by block ID. defvars []map[*Node]*ssa.Value - // addresses of PPARAM, PPARAMOUT, and PAUTO variables. + // addresses of PPARAM and PPARAMOUT variables. decladdrs map[*Node]*ssa.Value // starting values. Memory, frame pointer, and stack pointer @@ -721,8 +721,11 @@ func (s *state) stmt(n *Node) { s.startBlock(bEnd) case OVARKILL: - // TODO(khr): ??? anything to do here? Only for addrtaken variables? - // Maybe just link it in the store chain? + // 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. + s.vars[&memvar] = s.newValue1A(ssa.OpVarKill, ssa.TypeMem, n.Left, s.mem()) default: s.Unimplementedf("unhandled stmt %s", opnames[n.Op]) } @@ -1175,9 +1178,9 @@ func (s *state) expr(n *Node) *ssa.Value { return s.entryNewValue0A(ssa.OpConstString, n.Type, n.Val().U) case CTBOOL: if n.Val().U.(bool) { - return s.entryNewValue0I(ssa.OpConstBool, n.Type, 1) // 1 = true + return s.entryNewValue0I(ssa.OpConstBool, Types[TBOOL], 1) // 1 = true } else { - return s.entryNewValue0I(ssa.OpConstBool, n.Type, 0) // 0 = false + return s.entryNewValue0I(ssa.OpConstBool, Types[TBOOL], 0) // 0 = false } case CTNIL: t := n.Type @@ -1798,6 +1801,9 @@ func (s *state) assign(op uint8, left *Node, right *Node) { if !canSSA(left) { // if we can't ssa this memory, treat it as just zeroing out the backing memory addr := s.addr(left) + if left.Op == ONAME { + s.vars[&memvar] = s.newValue1A(ssa.OpVarDef, ssa.TypeMem, left, s.mem()) + } s.vars[&memvar] = s.newValue2I(ssa.OpZero, ssa.TypeMem, t.Size(), addr, s.mem()) return } @@ -1812,6 +1818,9 @@ func (s *state) assign(op uint8, left *Node, right *Node) { } // not ssa-able. Treat as a store. addr := s.addr(left) + if left.Op == ONAME { + s.vars[&memvar] = s.newValue1A(ssa.OpVarDef, ssa.TypeMem, left, s.mem()) + } s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, t.Size(), addr, val, s.mem()) } @@ -1857,7 +1866,7 @@ func (s *state) zeroVal(t *Type) *ssa.Value { case t.IsPtr(): return s.entryNewValue0(ssa.OpConstNil, t) case t.IsBoolean(): - return s.entryNewValue0I(ssa.OpConstBool, t, 0) // 0 = false + return s.entryNewValue0I(ssa.OpConstBool, Types[TBOOL], 0) // 0 = false case t.IsInterface(): return s.entryNewValue0(ssa.OpConstInterface, t) case t.IsSlice(): @@ -1894,7 +1903,7 @@ func (s *state) addr(n *Node) *ssa.Value { v = s.entryNewValue1I(ssa.OpOffPtr, v.Type, n.Xoffset, v) } return v - case PPARAM, PPARAMOUT, PAUTO: + case PPARAM, PPARAMOUT: // parameter/result slot or local variable v := s.decladdrs[n] if v == nil { @@ -1904,6 +1913,17 @@ func (s *state) addr(n *Node) *ssa.Value { s.Fatalf("addr of undeclared ONAME %v. declared: %v", n, s.decladdrs) } return v + 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, Ptrto(n.Type), aux, s.sp) case PAUTO | PHEAP, PPARAMREF: return s.expr(n.Name.Heapaddr) default: @@ -2477,23 +2497,12 @@ type branch struct { // 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) { - // TODO: line numbers - - if f.FrameSize > 1<<31 { - Yyerror("stack frame too large (>2GB)") - return - } - 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 - ptxt.To.Type = obj.TYPE_TEXTSIZE - ptxt.To.Val = int32(Rnd(Curfn.Type.Argwid, int64(Widthptr))) // arg size - ptxt.To.Offset = f.FrameSize - 8 // TODO: arch-dependent - // Remember where each block starts. bstart := make([]*obj.Prog, f.NumBlocks()) @@ -2592,18 +2601,22 @@ func genssa(f *ssa.Func, ptxt *obj.Prog, gcargs, gclocals *Sym) { } } - // TODO: liveness - // TODO: gcargs - // TODO: gclocals + // Allocate stack frame + allocauto(ptxt) + + // Generate gc bitmaps. + liveness(Curfn, ptxt, gcargs, gclocals) + gcsymdup(gcargs) + gcsymdup(gclocals) - // TODO: dump frame if -f + // Add frame prologue. Zero ambiguously live variables. + Thearch.Defframe(ptxt) + if Debug['f'] != 0 { + frame(0) + } - // Emit garbage collection symbols. TODO: put something in them - //liveness(Curfn, ptxt, gcargs, gclocals) - duint32(gcargs, 0, 0) - ggloblsym(gcargs, 4, obj.RODATA|obj.DUPOK) - duint32(gclocals, 0, 0) - ggloblsym(gclocals, 4, obj.RODATA|obj.DUPOK) + // Remove leftover instrumentation from the instruction stream. + removevardef(ptxt) f.Config.HTML.Close() } @@ -3056,9 +3069,11 @@ func genValue(v *ssa.Value) { return } p := Prog(movSizeByType(v.Type)) + n := autoVar(v.Args[0]) p.From.Type = obj.TYPE_MEM - p.From.Reg = x86.REG_SP - p.From.Offset = localOffset(v.Args[0]) + p.From.Name = obj.NAME_AUTO + p.From.Node = n + p.From.Sym = Linksym(n.Sym) p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v) @@ -3070,9 +3085,11 @@ func genValue(v *ssa.Value) { p := Prog(movSizeByType(v.Type)) p.From.Type = obj.TYPE_REG p.From.Reg = regnum(v.Args[0]) + n := autoVar(v) p.To.Type = obj.TYPE_MEM - p.To.Reg = x86.REG_SP - p.To.Offset = localOffset(v) + p.To.Name = obj.NAME_AUTO + p.To.Node = n + p.To.Sym = Linksym(n.Sym) case ssa.OpPhi: // just check to make sure regalloc and stackalloc did it right if v.Type.IsMemory() { @@ -3106,19 +3123,19 @@ func genValue(v *ssa.Value) { q.From.Reg = x86.REG_AX q.To.Type = obj.TYPE_MEM q.To.Reg = r - // TODO: need AUNDEF here? + Prog(obj.AUNDEF) // tell plive.go that we never reach here case ssa.OpAMD64LoweredPanicIndexCheck: p := Prog(obj.ACALL) p.To.Type = obj.TYPE_MEM p.To.Name = obj.NAME_EXTERN p.To.Sym = Linksym(Panicindex.Sym) - // TODO: need AUNDEF here? + Prog(obj.AUNDEF) case ssa.OpAMD64LoweredPanicSliceCheck: p := Prog(obj.ACALL) p.To.Type = obj.TYPE_MEM p.To.Name = obj.NAME_EXTERN p.To.Sym = Linksym(panicslice.Sym) - // TODO: need AUNDEF here? + Prog(obj.AUNDEF) case ssa.OpAMD64LoweredGetG: r := regnum(v) // See the comments in cmd/internal/obj/x86/obj6.go @@ -3151,10 +3168,16 @@ func genValue(v *ssa.Value) { 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.OpAMD64NEGQ, ssa.OpAMD64NEGL, ssa.OpAMD64NEGW, ssa.OpAMD64NEGB, ssa.OpAMD64NOTQ, ssa.OpAMD64NOTL, ssa.OpAMD64NOTW, ssa.OpAMD64NOTB: x := regnum(v.Args[0]) @@ -3215,6 +3238,10 @@ func genValue(v *ssa.Value) { case ssa.OpAMD64REPMOVSB: Prog(x86.AREP) Prog(x86.AMOVSB) + case ssa.OpVarDef: + Gvardef(v.Aux.(*Node)) + case ssa.OpVarKill: + gvarkill(v.Aux.(*Node)) default: v.Unimplementedf("genValue not implemented: %s", v.LongString()) } @@ -3414,12 +3441,16 @@ func addAux(a *obj.Addr, v *ssa.Value) { a.Name = obj.NAME_EXTERN a.Sym = Linksym(sym.Sym.(*Sym)) case *ssa.ArgSymbol: - a.Offset += v.Block.Func.FrameSize + sym.Offset + 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: - if sym.Offset == -1 { - v.Fatalf("auto symbol %s offset not calculated", sym.Sym) - } - a.Offset += sym.Offset + 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) } @@ -3571,18 +3602,9 @@ func regnum(v *ssa.Value) int16 { return ssaRegToReg[reg.(*ssa.Register).Num] } -// localOffset returns the offset below the frame pointer where -// a stack-allocated local has been allocated. Panics if v -// is not assigned to a local slot. -// TODO: Make this panic again once it stops happening routinely. -func localOffset(v *ssa.Value) int64 { - reg := v.Block.Func.RegAlloc[v.ID] - slot, ok := reg.(*ssa.LocalSlot) - if !ok { - v.Unimplementedf("localOffset of non-LocalSlot value: %s\n%s\n", v.LongString(), v.Block.Func) - return 0 - } - return slot.Idx +// autoVar returns a *Node representing the auto variable assigned to v. +func autoVar(v *ssa.Value) *Node { + return v.Block.Func.RegAlloc[v.ID].(*ssa.LocalSlot).N.(*Node) } // ssaExport exports a bunch of compiler services for the ssa backend. @@ -3616,6 +3638,12 @@ func (*ssaExport) StringData(s string) interface{} { return &ssa.ExternSymbol{Typ: idealstring, Sym: data} } +func (e *ssaExport) Auto(t ssa.Type) fmt.Stringer { + 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 +} + // 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. diff --git a/src/cmd/compile/internal/ssa/config.go b/src/cmd/compile/internal/ssa/config.go index 865066870d..8ae74d0b2f 100644 --- a/src/cmd/compile/internal/ssa/config.go +++ b/src/cmd/compile/internal/ssa/config.go @@ -4,6 +4,8 @@ package ssa +import "fmt" + type Config struct { arch string // "amd64", etc. IntSize int64 // 4 or 8 @@ -52,6 +54,10 @@ type Frontend interface { // 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) fmt.Stringer // returns *gc.Node } // NewConfig returns a new configuration object for the given architecture. diff --git a/src/cmd/compile/internal/ssa/export_test.go b/src/cmd/compile/internal/ssa/export_test.go index 5b56aa5184..7c314c2630 100644 --- a/src/cmd/compile/internal/ssa/export_test.go +++ b/src/cmd/compile/internal/ssa/export_test.go @@ -4,7 +4,10 @@ package ssa -import "testing" +import ( + "fmt" + "testing" +) var CheckFunc = checkFunc var PrintFunc = printFunc @@ -24,6 +27,9 @@ type DummyFrontend struct { func (DummyFrontend) StringData(s string) interface{} { return nil } +func (DummyFrontend) Auto(t Type) fmt.Stringer { + return nil +} func (d DummyFrontend) Logf(msg string, args ...interface{}) { d.t.Logf(msg, args...) } func (d DummyFrontend) Fatalf(msg string, args ...interface{}) { d.t.Fatalf(msg, args...) } diff --git a/src/cmd/compile/internal/ssa/func.go b/src/cmd/compile/internal/ssa/func.go index 747a5c7f03..b6956a459f 100644 --- a/src/cmd/compile/internal/ssa/func.go +++ b/src/cmd/compile/internal/ssa/func.go @@ -25,8 +25,6 @@ type Func struct { // when register allocation is done, maps value ids to locations RegAlloc []Location - // when stackalloc is done, the size of the stack frame - FrameSize int64 } // NumBlocks returns an integer larger than the id of any Block in the Func. diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 8cd8165028..81fe20547e 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -278,8 +278,8 @@ var genericOps = []opData{ // 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"}, // arg0=code pointer, arg1=context ptr, arg2=memory. Returns memory. - {name: "StaticCall"}, // call function aux.(*gc.Sym), arg0=memory. Returns memory. + {name: "ClosureCall"}, // arg0=code pointer, arg1=context ptr, arg2=memory. auxint=arg size. Returns memory. + {name: "StaticCall"}, // call function aux.(*gc.Sym), arg0=memory. auxint=arg size. Returns memory. // Conversions: signed extensions, zero (unsigned) extensions, truncations {name: "SignExt8to16", typ: "Int16"}, @@ -359,6 +359,9 @@ var genericOps = []opData{ // Used during ssa construction. Like Copy, but the arg has not been specified yet. {name: "FwdRef"}, + + {name: "VarDef"}, // aux is a *gc.Node of a variable that is about to be initialized. arg0=mem, returns mem + {name: "VarKill"}, // aux is a *gc.Node of a variable that is known to be dead. arg0=mem, returns mem } // kind control successors diff --git a/src/cmd/compile/internal/ssa/location.go b/src/cmd/compile/internal/ssa/location.go index 1b6f6d66c1..9f445e5b5a 100644 --- a/src/cmd/compile/internal/ssa/location.go +++ b/src/cmd/compile/internal/ssa/location.go @@ -26,9 +26,9 @@ func (r *Register) Name() string { // A LocalSlot is a location in the stack frame. type LocalSlot struct { - Idx int64 // offset in locals area (distance up from SP) + N fmt.Stringer // a *gc.Node for an auto variable } func (s *LocalSlot) Name() string { - return fmt.Sprintf("%d(SP)", s.Idx) + return s.N.String() } diff --git a/src/cmd/compile/internal/ssa/lower.go b/src/cmd/compile/internal/ssa/lower.go index 3dac264fac..9c28bd10a5 100644 --- a/src/cmd/compile/internal/ssa/lower.go +++ b/src/cmd/compile/internal/ssa/lower.go @@ -21,7 +21,7 @@ func checkLower(f *Func) { continue // lowered } switch v.Op { - case OpSP, OpSB, OpArg, OpCopy, OpPhi: + case OpSP, OpSB, OpArg, OpCopy, OpPhi, OpVarDef, OpVarKill: continue // ok not to lower } s := "not lowered: " + v.Op.String() + " " + v.Type.SimpleString() diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index a61c31ad5a..087a0e75b8 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -524,6 +524,8 @@ const ( OpStoreReg OpLoadReg OpFwdRef + OpVarDef + OpVarKill ) var opcodeTable = [...]opInfo{ @@ -4109,6 +4111,14 @@ var opcodeTable = [...]opInfo{ name: "FwdRef", generic: true, }, + { + name: "VarDef", + generic: true, + }, + { + name: "VarKill", + generic: true, + }, } func (o Op) Asm() int { return opcodeTable[o].asm } diff --git a/src/cmd/compile/internal/ssa/schedule.go b/src/cmd/compile/internal/ssa/schedule.go index cf5f872e0f..e551a6375c 100644 --- a/src/cmd/compile/internal/ssa/schedule.go +++ b/src/cmd/compile/internal/ssa/schedule.go @@ -74,7 +74,8 @@ func schedule(f *Func) { score[v.ID] = 0 case v.Type.IsMemory(): // Schedule stores as early as possible. This tends to - // reduce register pressure. + // reduce register pressure. It also helps make sure + // VARDEF ops are scheduled before the corresponding LEA. score[v.ID] = 1 case v.Type.IsFlags(): // Schedule flag register generation as late as possible. diff --git a/src/cmd/compile/internal/ssa/stackalloc.go b/src/cmd/compile/internal/ssa/stackalloc.go index 626fb8f369..d60f8d1df2 100644 --- a/src/cmd/compile/internal/ssa/stackalloc.go +++ b/src/cmd/compile/internal/ssa/stackalloc.go @@ -18,22 +18,6 @@ func setloc(home []Location, v *Value, loc Location) []Location { func stackalloc(f *Func) { home := f.RegAlloc - // Start with space for callee arguments/returns. - var n int64 - for _, b := range f.Blocks { - if b.Kind != BlockCall { - continue - } - v := b.Control - if n < v.AuxInt { - n = v.AuxInt - } - } - f.Logf("stackalloc: 0-%d for callee arguments/returns\n", n) - - // TODO: group variables by ptr/nonptr, size, etc. Emit ptr vars last - // so stackmap is smaller. - // Assign stack locations to phis first, because we // must also assign the same locations to the phi stores // introduced during regalloc. @@ -49,10 +33,9 @@ func stackalloc(f *Func) { continue // register-based phi } // stack-based phi - n = align(n, v.Type.Alignment()) - f.Logf("stackalloc: %d-%d for %v\n", n, n+v.Type.Size(), v) + n := f.Config.fe.Auto(v.Type) + f.Logf("stackalloc: %s: for %v <%v>\n", n, v, v.Type) loc := &LocalSlot{n} - n += v.Type.Size() home = setloc(home, v, loc) for _, w := range v.Args { if w.Op != OpStoreReg { @@ -79,34 +62,15 @@ func stackalloc(f *Func) { if len(v.Args) == 1 && (v.Args[0].Op == OpSP || v.Args[0].Op == OpSB) { continue } - n = align(n, v.Type.Alignment()) - f.Logf("stackalloc: %d-%d for %v\n", n, n+v.Type.Size(), v) + + n := f.Config.fe.Auto(v.Type) + f.Logf("stackalloc: %s for %v\n", n, v) loc := &LocalSlot{n} - n += v.Type.Size() home = setloc(home, v, loc) } } - // Finally, allocate space for all autos that we used - for _, b := range f.Blocks { - for _, v := range b.Values { - s, ok := v.Aux.(*AutoSymbol) - if !ok || s.Offset >= 0 { - continue - } - t := s.Typ - n = align(n, t.Alignment()) - f.Logf("stackalloc: %d-%d for auto %v\n", n, n+t.Size(), v) - s.Offset = n - n += t.Size() - } - } - - n = align(n, f.Config.PtrSize) - f.Logf("stackalloc: %d-%d for return address\n", n, n+f.Config.PtrSize) - n += f.Config.PtrSize // space for return address. TODO: arch-dependent f.RegAlloc = home - f.FrameSize = n // TODO: share stack slots among noninterfering (& gc type compatible) values } diff --git a/src/cmd/compile/internal/ssa/value.go b/src/cmd/compile/internal/ssa/value.go index d213b72df3..a5915da025 100644 --- a/src/cmd/compile/internal/ssa/value.go +++ b/src/cmd/compile/internal/ssa/value.go @@ -142,17 +142,15 @@ type ExternSymbol struct { // 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 - Offset int64 // Distance above frame pointer - Sym fmt.Stringer // A *gc.Sym referring to the argument/result variable. + Typ Type // Go type + Node fmt.Stringer // 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 - Offset int64 // Distance above stack pointer. Set by stackalloc in SSA. - Sym fmt.Stringer // A *gc.Sym referring to a local (auto) variable. + Typ Type // Go type + Node fmt.Stringer // A *gc.Node referring to a local (auto) variable. } func (s *ExternSymbol) String() string { @@ -160,9 +158,9 @@ func (s *ExternSymbol) String() string { } func (s *ArgSymbol) String() string { - return s.Sym.String() + return s.Node.String() } func (s *AutoSymbol) String() string { - return s.Sym.String() + return s.Node.String() } -- cgit v1.3 From 6b9b618787156dea53d14dde924b71639548da33 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Fri, 4 Sep 2015 08:50:28 -0700 Subject: [dev.ssa] cmd/compile: run std tests with SSA codegen as part of all.bash Todd Neal has made all the stdlib tests pass. Now the trybots and build dashboard can help us keep them passing. All of this code will be unwound bit by bit as SSA matures and then becomes the default. Change-Id: I52ac7e72a87d329ccce974d6671c054374828d11 Reviewed-on: https://go-review.googlesource.com/14294 Reviewed-by: Brad Fitzpatrick TryBot-Result: Gobot Gobot --- src/cmd/dist/test.go | 42 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 42 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/dist/test.go b/src/cmd/dist/test.go index d0e634640c..4cc181f610 100755 --- a/src/cmd/dist/test.go +++ b/src/cmd/dist/test.go @@ -12,6 +12,7 @@ import ( "log" "os" "os/exec" + "path" "path/filepath" "regexp" "strconv" @@ -274,6 +275,39 @@ func (t *tester) registerStdTest(pkg string) { }) } +// TODO: Remove when SSA codegen is used by default. +func (t *tester) registerSSATest(pkg string) { + switch pkg { + // known failures due to GOGC=off + case "runtime", "runtime/pprof", "runtime/trace", "sync": + return + // TODO: fix these failures + case "math/big", "cmd/compile/internal/big": + return + } + t.tests = append(t.tests, distTest{ + name: "go_test_ssa:" + pkg, + heading: "Testing packages with SSA codegen.", + fn: func() error { + args := []string{ + "test", + "-short", + t.timeout(180 * 3), // SSA generates slower code right now + "-gcflags=" + os.Getenv("GO_GCFLAGS"), + } + if t.race { + args = append(args, "-race") + } + args = append(args, pkg) + cmd := exec.Command("go", args...) + cmd.Env = mergeEnvLists([]string{"GOSSAPKG=" + path.Base(pkg), "GOGC=off"}, os.Environ()) + cmd.Stdout = os.Stdout + cmd.Stderr = os.Stderr + return cmd.Run() + }, + }) +} + func (t *tester) registerRaceBenchTest(pkg string) { testName := "go_test_bench:" + pkg if t.runRx == nil || t.runRx.MatchString(testName) { @@ -317,6 +351,9 @@ func (t *tester) registerTests() { if strings.HasPrefix(name, "go_test_bench:") { t.registerRaceBenchTest(strings.TrimPrefix(name, "go_test_bench:")) } + if t.goarch == "amd64" && strings.HasPrefix(name, "go_test_ssa:") { + t.registerSSATest(strings.TrimPrefix(name, "go_test_ssa:")) + } } } else { // Use a format string to only list packages and commands that have tests. @@ -333,6 +370,11 @@ func (t *tester) registerTests() { for _, pkg := range pkgs { t.registerStdTest(pkg) } + if t.goarch == "amd64" { + for _, pkg := range pkgs { + t.registerSSATest(pkg) + } + } if t.race { for _, pkg := range pkgs { t.registerRaceBenchTest(pkg) -- cgit v1.3 From 9569b957cba47310bbdaf6f19732dcb0ebbb373b Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Fri, 28 Aug 2015 22:51:01 -0700 Subject: [dev.ssa] cmd/compile/internal/gc: implement go and defer TODO: for now, just function calls. Do method and interface calls. Change-Id: Ib262dfa31cb753996cde899beaad4dc2e66705ac Reviewed-on: https://go-review.googlesource.com/14035 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/gc/ssa.go | 157 ++++++++++++++++++++----- src/cmd/compile/internal/ssa/gen/AMD64.rules | 2 + src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 2 + src/cmd/compile/internal/ssa/gen/genericOps.go | 2 + src/cmd/compile/internal/ssa/opGen.go | 24 ++++ src/cmd/compile/internal/ssa/rewriteAMD64.go | 36 ++++++ 6 files changed, 192 insertions(+), 31 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 407b143809..8df86b890c 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -726,6 +726,44 @@ func (s *state) stmt(n *Node) { // varkill in the store chain is enough to keep it correctly ordered // with respect to call ops. s.vars[&memvar] = s.newValue1A(ssa.OpVarKill, ssa.TypeMem, n.Left, s.mem()) + + case OPROC, ODEFER: + call := n.Left + fn := call.Left + if call.Op != OCALLFUNC { + s.Unimplementedf("defer/go of %s", opnames[call.Op]) + } + + // Write argsize and closure (args to Newproc/Deferproc) + argsize := s.constInt32(Types[TUINT32], int32(fn.Type.Argwid)) + s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, 4, s.sp, argsize, s.mem()) + closure := s.expr(fn) + 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()) + + // Run all argument assignments. The arg slots have already + // been offset by 2*widthptr. + s.stmtList(call.List) + + // Call deferproc or newproc + bNext := s.f.NewBlock(ssa.BlockPlain) + var op ssa.Op + switch n.Op { + case ODEFER: + op = ssa.OpDeferCall + case OPROC: + op = ssa.OpGoCall + } + r := s.newValue1(op, ssa.TypeMem, s.mem()) + r.AuxInt = fn.Type.Argwid + 2*int64(Widthptr) // total stack space used + s.vars[&memvar] = r + b := s.endBlock() + b.Kind = ssa.BlockCall + b.Control = r + b.AddEdgeTo(bNext) + b.AddEdgeTo(s.exit) + s.startBlock(bNext) + default: s.Unimplementedf("unhandled stmt %s", opnames[n.Op]) } @@ -2494,9 +2532,26 @@ type branch struct { 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, @@ -2504,11 +2559,7 @@ func genssa(f *ssa.Func, ptxt *obj.Prog, gcargs, gclocals *Sym) { e.mustImplement = true // Remember where each block starts. - bstart := make([]*obj.Prog, f.NumBlocks()) - - // Remember all the branch instructions we've seen - // and where they would like to go - var branches []branch + s.bstart = make([]*obj.Prog, f.NumBlocks()) var valueProgs map[*obj.Prog]*ssa.Value var blockProgs map[*obj.Prog]*ssa.Block @@ -2522,11 +2573,11 @@ func genssa(f *ssa.Func, ptxt *obj.Prog, gcargs, gclocals *Sym) { // Emit basic blocks for i, b := range f.Blocks { - bstart[b.ID] = Pc + s.bstart[b.ID] = Pc // Emit values in block for _, v := range b.Values { x := Pc - genValue(v) + s.genValue(v) if logProgs { for ; x != Pc; x = x.Link { valueProgs[x] = v @@ -2539,7 +2590,7 @@ func genssa(f *ssa.Func, ptxt *obj.Prog, gcargs, gclocals *Sym) { next = f.Blocks[i+1] } x := Pc - branches = genBlock(b, next, branches) + s.genBlock(b, next) if logProgs { for ; x != Pc; x = x.Link { blockProgs[x] = b @@ -2548,8 +2599,11 @@ func genssa(f *ssa.Func, ptxt *obj.Prog, gcargs, gclocals *Sym) { } // Resolve branches - for _, br := range branches { - br.p.To.Val = bstart[br.b.ID] + for _, br := range s.branches { + br.p.To.Val = s.bstart[br.b.ID] + } + for _, p := range s.deferBranches { + p.To.Val = s.deferTarget } Pc.As = obj.ARET // overwrite AEND @@ -2634,7 +2688,7 @@ func opregreg(op int, dest, src int16) *obj.Prog { return p } -func genValue(v *ssa.Value) { +func (s *genState) genValue(v *ssa.Value) { lineno = v.Line switch v.Op { case ssa.OpAMD64ADDQ: @@ -3178,6 +3232,33 @@ func genValue(v *ssa.Value) { 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.OpAMD64NEGQ, ssa.OpAMD64NEGL, ssa.OpAMD64NEGW, ssa.OpAMD64NEGB, ssa.OpAMD64NOTQ, ssa.OpAMD64NOTL, ssa.OpAMD64NOTW, ssa.OpAMD64NOTB: x := regnum(v.Args[0]) @@ -3322,26 +3403,25 @@ func oneFPJump(b *ssa.Block, jumps *floatingEQNEJump, likely ssa.BranchPredictio return branches } -func genFPJump(b, next *ssa.Block, jumps *[2][2]floatingEQNEJump, branches []branch) []branch { +func genFPJump(s *genState, b, next *ssa.Block, jumps *[2][2]floatingEQNEJump) { likely := b.Likely switch next { case b.Succs[0]: - branches = oneFPJump(b, &jumps[0][0], likely, branches) - branches = oneFPJump(b, &jumps[0][1], likely, branches) + s.branches = oneFPJump(b, &jumps[0][0], likely, s.branches) + s.branches = oneFPJump(b, &jumps[0][1], likely, s.branches) case b.Succs[1]: - branches = oneFPJump(b, &jumps[1][0], likely, branches) - branches = oneFPJump(b, &jumps[1][1], likely, branches) + s.branches = oneFPJump(b, &jumps[1][0], likely, s.branches) + s.branches = oneFPJump(b, &jumps[1][1], likely, s.branches) default: - branches = oneFPJump(b, &jumps[1][0], likely, branches) - branches = oneFPJump(b, &jumps[1][1], likely, branches) + 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 - branches = append(branches, branch{q, b.Succs[1]}) + s.branches = append(s.branches, branch{q, b.Succs[1]}) } - return branches } -func genBlock(b, next *ssa.Block, branches []branch) []branch { +func (s *genState) genBlock(b, next *ssa.Block) { lineno = b.Line // after a panic call, don't emit any branch code @@ -3350,7 +3430,7 @@ func genBlock(b, next *ssa.Block, branches []branch) []branch { case ssa.OpAMD64LoweredPanicNilCheck, ssa.OpAMD64LoweredPanicIndexCheck, ssa.OpAMD64LoweredPanicSliceCheck: - return branches + return } } @@ -3359,23 +3439,39 @@ func genBlock(b, next *ssa.Block, branches []branch) []branch { if b.Succs[0] != next { p := Prog(obj.AJMP) p.To.Type = obj.TYPE_BRANCH - branches = append(branches, branch{p, b.Succs[0]}) + s.branches = append(s.branches, branch{p, b.Succs[0]}) } case ssa.BlockExit: case ssa.BlockRet: + if Hasdefer != 0 { + // 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) + } Prog(obj.ARET) case ssa.BlockCall: if b.Succs[0] != next { p := Prog(obj.AJMP) p.To.Type = obj.TYPE_BRANCH - branches = append(branches, branch{p, b.Succs[0]}) + s.branches = append(s.branches, branch{p, b.Succs[0]}) } case ssa.BlockAMD64EQF: - branches = genFPJump(b, next, &eqfJumps, branches) + genFPJump(s, b, next, &eqfJumps) case ssa.BlockAMD64NEF: - branches = genFPJump(b, next, &nefJumps, branches) + genFPJump(s, b, next, &nefJumps) case ssa.BlockAMD64EQ, ssa.BlockAMD64NE, ssa.BlockAMD64LT, ssa.BlockAMD64GE, @@ -3390,18 +3486,18 @@ func genBlock(b, next *ssa.Block, branches []branch) []branch { p = Prog(jmp.invasm) likely *= -1 p.To.Type = obj.TYPE_BRANCH - branches = append(branches, branch{p, b.Succs[1]}) + s.branches = append(s.branches, branch{p, b.Succs[1]}) case b.Succs[1]: p = Prog(jmp.asm) p.To.Type = obj.TYPE_BRANCH - branches = append(branches, branch{p, b.Succs[0]}) + s.branches = append(s.branches, branch{p, b.Succs[0]}) default: p = Prog(jmp.asm) p.To.Type = obj.TYPE_BRANCH - branches = append(branches, branch{p, b.Succs[0]}) + s.branches = append(s.branches, branch{p, b.Succs[0]}) q := Prog(obj.AJMP) q.To.Type = obj.TYPE_BRANCH - branches = append(branches, branch{q, b.Succs[1]}) + s.branches = append(s.branches, branch{q, b.Succs[1]}) } // liblink reorders the instruction stream as it sees fit. @@ -3420,7 +3516,6 @@ func genBlock(b, next *ssa.Block, branches []branch) []branch { default: b.Unimplementedf("branch not implemented: %s. Control: %s", b.LongString(), b.Control.LongString()) } - return branches } // addAux adds the offset in the aux fields (AuxInt and Aux) of v to a. diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 16bd1df84b..cba16eadc7 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -352,6 +352,8 @@ (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) // Rules below here apply some simple optimizations after lowering. // TODO: Should this be a separate pass? diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 37cd096d63..0eee551f32 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -386,6 +386,8 @@ func init() { //TODO: set register clobber to everything? {name: "CALLstatic", reg: regInfo{clobbers: callerSave}}, // call static function aux.(*gc.Sym). arg0=mem, auxint=argsize, returns mem {name: "CALLclosure", reg: regInfo{[]regMask{gpsp, buildReg("DX"), 0}, callerSave, nil}}, // call function via closure. arg0=codeptr, arg1=closure, arg2=mem, auxint=argsize, returns mem + {name: "CALLdefer", reg: regInfo{clobbers: callerSave}}, // call deferproc. arg0=mem, auxint=argsize, returns mem + {name: "CALLgo", reg: regInfo{clobbers: callerSave}}, // call newproc. arg0=mem, auxint=argsize, returns mem {name: "REPMOVSB", reg: regInfo{[]regMask{buildReg("DI"), buildReg("SI"), buildReg("CX")}, buildReg("DI SI CX"), nil}}, // move arg2 bytes from arg1 to arg0. arg3=mem, returns memory diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 81fe20547e..b52bd1fecc 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -280,6 +280,8 @@ var genericOps = []opData{ // as a phantom first argument. {name: "ClosureCall"}, // arg0=code pointer, arg1=context ptr, arg2=memory. auxint=arg size. Returns memory. {name: "StaticCall"}, // call function aux.(*gc.Sym), arg0=memory. auxint=arg size. Returns memory. + {name: "DeferCall"}, // defer call. arg0=memory, auxint=arg size. Returns memory. + {name: "GoCall"}, // go call. arg0=memory, auxint=arg size. Returns memory. // Conversions: signed extensions, zero (unsigned) extensions, truncations {name: "SignExt8to16", typ: "Int16"}, diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 087a0e75b8..0d7343c8aa 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -261,6 +261,8 @@ const ( OpAMD64REPSTOSQ OpAMD64CALLstatic OpAMD64CALLclosure + OpAMD64CALLdefer + OpAMD64CALLgo OpAMD64REPMOVSB OpAMD64InvertFlags OpAMD64LoweredPanicNilCheck @@ -469,6 +471,8 @@ const ( OpZero OpClosureCall OpStaticCall + OpDeferCall + OpGoCall OpSignExt8to16 OpSignExt8to32 OpSignExt8to64 @@ -3047,6 +3051,18 @@ var opcodeTable = [...]opInfo{ 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", + 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", + 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: "REPMOVSB", reg: regInfo{ @@ -3891,6 +3907,14 @@ var opcodeTable = [...]opInfo{ name: "StaticCall", generic: true, }, + { + name: "DeferCall", + generic: true, + }, + { + name: "GoCall", + generic: true, + }, { name: "SignExt8to16", generic: true, diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 8ad939ead9..7917d8d971 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -1830,6 +1830,24 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endf74ce5df659f385f75c61187b515a5d0 endf74ce5df659f385f75c61187b515a5d0: ; + case OpDeferCall: + // match: (DeferCall [argwid] mem) + // cond: + // result: (CALLdefer [argwid] mem) + { + argwid := v.AuxInt + mem := v.Args[0] + v.Op = OpAMD64CALLdefer + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = argwid + v.AddArg(mem) + return true + } + goto end1c408581037450df959dd1fb7554a022 + end1c408581037450df959dd1fb7554a022: + ; case OpDiv16: // match: (Div16 x y) // cond: @@ -2393,6 +2411,24 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endb17140e71dd641aa4d89e14479160260 endb17140e71dd641aa4d89e14479160260: ; + case OpGoCall: + // match: (GoCall [argwid] mem) + // cond: + // result: (CALLgo [argwid] mem) + { + argwid := v.AuxInt + mem := v.Args[0] + v.Op = OpAMD64CALLgo + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = argwid + v.AddArg(mem) + return true + } + goto end1cef0f92c46e6aaa2c7abdf5f2794baf + end1cef0f92c46e6aaa2c7abdf5f2794baf: + ; case OpGreater16: // match: (Greater16 x y) // cond: -- cgit v1.3 From 4178f207763374c798c56a868b04d1aeacc21cd9 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Sat, 5 Sep 2015 19:28:00 -0700 Subject: [dev.ssa] cmd/compile: implement OPLUS Change-Id: Iaf282211a717e38b05e5d2661d400d465decad50 Reviewed-on: https://go-review.googlesource.com/14337 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 8df86b890c..01db547736 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1599,7 +1599,7 @@ func (s *state) expr(n *Node) *ssa.Value { s.startBlock(bResult) return s.variable(n, Types[TBOOL]) - // unary ops + // unary ops case OMINUS: a := s.expr(n.Left) if n.Type.IsComplex() { @@ -1613,6 +1613,8 @@ func (s *state) expr(n *Node) *ssa.Value { case ONOT, OCOM: a := s.expr(n.Left) return s.newValue1(s.ssaOp(n.Op, n.Type), a.Type, a) + case OPLUS: + return s.expr(n.Left) case OADDR: return s.addr(n.Left) -- cgit v1.3 From 95bb89f6dd4d92747bed1fe451379cd2b99ec5b7 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Sun, 6 Sep 2015 15:04:46 -0700 Subject: [dev.ssa] cmd/compile: fix build CL 14337 made SSA support fixedbugs/issue9604b.go. That test contains > 40k blocks. This made the O(n^2) dom algorithm fail to terminate in a reasonable length of time, breaking the build. For the moment, cap the number of blocks to fix the build. This will be reverted when a more efficient dom algorithm is put in place, which will be soon. Change-Id: Ia66c2629481d29d06655ec54d1deff076b0422c6 Reviewed-on: https://go-review.googlesource.com/14342 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/ssa/cse.go | 5 +++++ 1 file changed, 5 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/cse.go b/src/cmd/compile/internal/ssa/cse.go index 836a7803ac..003530a9d3 100644 --- a/src/cmd/compile/internal/ssa/cse.go +++ b/src/cmd/compile/internal/ssa/cse.go @@ -10,6 +10,11 @@ import "sort" // Values are just relinked, nothing is deleted. A subsequent deadcode // pass is required to actually remove duplicate expressions. func cse(f *Func) { + if f.NumBlocks() > 10000 { + f.Unimplementedf("too many blocks: %d", f.NumBlocks()) + return + } + // Two values are equivalent if they satisfy the following definition: // equivalent(v, w): // v.op == w.op -- cgit v1.3 From c3eb1a7e8a191c0d0be3a3cc3e835010560e4b5a Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Sun, 6 Sep 2015 13:42:26 -0700 Subject: [dev.ssa] cmd/compile/internal/gc: handle local function declarations They are already handled by the frontend, we just need to skip them when we see them in ssa. Change-Id: I309d91552f96a761f8d429a2cab3a47d200ca9e5 Reviewed-on: https://go-review.googlesource.com/14341 Reviewed-by: Brad Fitzpatrick --- src/cmd/compile/internal/gc/ssa.go | 2 ++ 1 file changed, 2 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 01db547736..9a9834f3e1 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -96,6 +96,8 @@ func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { 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 { -- cgit v1.3 From e22ae879d391e8814b697c79ec7ba2bdc825f25f Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Sat, 5 Sep 2015 19:28:15 -0700 Subject: [dev.ssa] cmd/compile: implement OCHECKNIL Change-Id: Ifb6b2ad6078ad084b73c0e785e748e92139684e2 Reviewed-on: https://go-review.googlesource.com/14338 Reviewed-by: Keith Randall Run-TryBot: Josh Bleecher Snyder TryBot-Result: Gobot Gobot --- src/cmd/compile/internal/gc/ssa.go | 5 +++++ 1 file changed, 5 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 9a9834f3e1..fef3e61301 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1621,6 +1621,11 @@ func (s *state) expr(n *Node) *ssa.Value { case OADDR: return s.addr(n.Left) + case OCHECKNIL: + p := s.expr(n.Left) + s.nilCheck(p) + return p + 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) -- cgit v1.3 From 1792b363101143efadc71f75c6f27056ab03b0f4 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Sat, 5 Sep 2015 19:28:27 -0700 Subject: [dev.ssa] cmd/compile: implement OEFACE Change-Id: I32953c4e1d82795bacba9eb94d65cd2e26bfeb87 Reviewed-on: https://go-review.googlesource.com/14339 Reviewed-by: Keith Randall Run-TryBot: Josh Bleecher Snyder --- src/cmd/compile/internal/gc/ssa.go | 5 +++++ 1 file changed, 5 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index fef3e61301..f92238b4a6 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1700,6 +1700,11 @@ func (s *state) expr(n *Node) *ssa.Value { 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) + return s.newValue2(ssa.OpIMake, n.Type, tab, data) + case OSLICESTR: // Evaluate the string once. str := s.expr(n.Left) -- cgit v1.3 From fa5fe191371e87596637000a99e5b281b49e8f3f Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Sun, 6 Sep 2015 19:24:59 -0700 Subject: [dev.ssa] cmd/compile: implement OIMAG and OREAL Change-Id: I17c83f6552367d42d48c1ec62fbb494f010fd866 Reviewed-on: https://go-review.googlesource.com/14343 Run-TryBot: Josh Bleecher Snyder Reviewed-by: David Chase TryBot-Result: Gobot Gobot --- src/cmd/compile/internal/gc/ssa.go | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index f92238b4a6..098a1e15f6 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -823,6 +823,11 @@ var opToSSA = map[opAndType]ssa.Op{ 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, @@ -1612,7 +1617,7 @@ func (s *state) expr(n *Node) *ssa.Value { 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: + case ONOT, OCOM, OIMAG, OREAL: a := s.expr(n.Left) return s.newValue1(s.ssaOp(n.Op, n.Type), a.Type, a) case OPLUS: -- cgit v1.3 From ad5ceafa2cc71380e2b1d4ecd9ddd5ff458c3010 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Mon, 7 Sep 2015 09:03:58 -0700 Subject: [dev.ssa] cmd/compile: update SSA todos Change-Id: I1271c015e602cd7ec92bf24f019dd8839b3180fc Reviewed-on: https://go-review.googlesource.com/14346 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/TODO | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/TODO b/src/cmd/compile/internal/ssa/TODO index fbe4f56760..3644bf3abd 100644 --- a/src/cmd/compile/internal/ssa/TODO +++ b/src/cmd/compile/internal/ssa/TODO @@ -3,17 +3,13 @@ be complete soon. Coverage -------- -- Complex numbers -- Defer? - Closure args - PHEAP vars Correctness ----------- -- GC maps - Write barriers - Debugging info -- Deferreturn - Can/should we move control values out of their basic block? - Anything to do for the race detector? - Slicing details (avoid ptr to next object) [done for string] @@ -24,11 +20,10 @@ Optimizations (better compiled code) - More strength reduction: multiply -> shift/add combos (Worth doing?) - Strength reduction: constant divides -> multiply - Expand current optimizations to all bit widths -- Nil/bounds check removal +- Add a value range propagation pass (for bounds elim & bitwidth reduction) - Combining nil checks with subsequent load - Implement memory zeroing with REPSTOSQ and DuffZero - Implement memory copying with REPMOVSQ and DuffCopy -- Add a value range propagation pass (for bounds elim & bitwidth reduction) - Stackalloc: organize values to allow good packing - Regalloc: use arg slots as the home for arguments (don't copy args to locals) - Reuse stack slots for noninterfering & compatible values (but see issue 8740) @@ -44,6 +39,7 @@ Optimizations (better compiler) - Reuseable slices (e.g. []int of size NumValues()) cached in Func - 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 -------- -- cgit v1.3 From 6bf383c7b31c990231c2a6c148b98e035b3b1b53 Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Sun, 6 Sep 2015 16:00:01 -0400 Subject: [dev.ssa] cmd/compile: clean up nilcheck logic Be more clear about the two conditions that we care about: 1) a block that performs a nil check (OpIsNonNil), which may be removed 2) a block that is the non-nil sucessor for an OpIsNonNil block Now we only care about removing nilchecks for two scenarios: - a type 1 block is dominated by a type 2 block for the same value - a block is both type 1 and type 2 for the same value Fixes math/big. Change-Id: I50018a4014830461ddfe2a2daf588468e4a8f0b4 Reviewed-on: https://go-review.googlesource.com/14325 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/nilcheck.go | 122 ++++++++------------------ src/cmd/compile/internal/ssa/nilcheck_test.go | 45 ++++++++++ src/cmd/dist/test.go | 3 - 3 files changed, 83 insertions(+), 87 deletions(-) mode change 100755 => 100644 src/cmd/dist/test.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/nilcheck.go b/src/cmd/compile/internal/ssa/nilcheck.go index 16cb04df98..0c3cb3e294 100644 --- a/src/cmd/compile/internal/ssa/nilcheck.go +++ b/src/cmd/compile/internal/ssa/nilcheck.go @@ -38,7 +38,7 @@ func nilcheckelim(f *Func) { } work := make([]bp, 0, 256) - work = append(work, bp{block: f.Entry, ptr: checkedptr(f.Entry)}) + 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 @@ -74,27 +74,38 @@ func nilcheckelim(f *Func) { node := work[len(work)-1] work = work[:len(work)-1] - var pushRecPtr bool switch node.op { case Work: - if node.ptr != nil { - // already have a nilcheck in the dominator path - if nonNilValues[node.ptr.ID] { + 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. node.block.Kind = BlockFirst node.block.Control = nil - } else { - // 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: node.ptr}) - // and cause a new setPtr to be appended after the - // block's dominees - pushRecPtr = true } } + + 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 @@ -102,77 +113,6 @@ func nilcheckelim(f *Func) { nonNilValues[node.ptr.ID] = false continue } - - var nilBranch *Block - for _, w := range domTree[node.block.ID] { - // We are about to traverse down the 'ptr is nil' side - // of a nilcheck block, so save it for later. This doesn't - // remove nil checks on the false side of the OpIsNonNil branch. - // This is important otherwise we would remove nil checks that - // are not redundant. - if node.block.Kind == BlockIf && node.block.Control.Op == OpIsNonNil && - w == node.block.Succs[1] { - nilBranch = w - continue - } - work = append(work, bp{block: w, ptr: checkedptr(w)}) - } - - if nilBranch != nil { - // we pop from the back of the work slice, so this sets - // up the false branch to be operated on before the - // node.ptr is recorded - work = append(work, bp{op: RecPtr, ptr: node.ptr}) - work = append(work, bp{block: nilBranch, ptr: checkedptr(nilBranch)}) - } else if pushRecPtr { - work = append(work, bp{op: RecPtr, ptr: node.ptr}) - } - } -} - -// nilcheckelim0 is the original redundant nilcheck elimination algorithm. -func nilcheckelim0(f *Func) { - // Exit early if there are no nil checks to eliminate. - var found bool - for _, b := range f.Blocks { - if checkedptr(b) != nil { - found = true - break - } - } - if !found { - return - } - - // Eliminate redundant nil checks. - // A nil check is redundant if the same - // nil check has been performed by a - // dominating block. - // The efficacy of this pass depends - // heavily on the efficacy of the cse pass. - idom := dominators(f) // TODO: cache the dominator tree in the function, clearing when the CFG changes? - for _, b := range f.Blocks { - ptr := checkedptr(b) - if ptr == nil { - continue - } - var elim bool - // Walk up the dominator tree, - // looking for identical nil checks. - // TODO: This loop is O(n^2). See BenchmarkNilCheckDeep*. - for c := idom[b.ID]; c != nil; c = idom[c.ID] { - if checkedptr(c) == ptr { - elim = true - break - } - } - if elim { - // Eliminate the nil check. - // The deadcode pass will remove vestigial values, - // and the fuse pass will join this block with its successor. - b.Kind = BlockFirst - b.Control = nil - } } } @@ -184,3 +124,17 @@ func checkedptr(b *Block) *Value { } return nil } + +// nonnilptr returns the Value, if any, +// that is non-nil due to b being the success block +// of an OpIsNonNil 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 == 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 index 1d048fbb34..cbd17e0093 100644 --- a/src/cmd/compile/internal/ssa/nilcheck_test.go +++ b/src/cmd/compile/internal/ssa/nilcheck_test.go @@ -382,3 +382,48 @@ func TestNilcheckUser(t *testing.T) { } } } + +// 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}) + fun := Fun(c, "entry", + Bloc("entry", + Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("sb", OpSB, TypeInvalid, 0, nil), + Goto("checkPtr")), + Bloc("checkPtr", + Valu("ptr1", OpConstPtr, ptrType, 0, nil, "sb"), + Valu("nilptr", OpConstNil, ptrType, 0, nil, "sb"), + 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", + 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) + 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/dist/test.go b/src/cmd/dist/test.go old mode 100755 new mode 100644 index 4cc181f610..d80547ed1c --- a/src/cmd/dist/test.go +++ b/src/cmd/dist/test.go @@ -281,9 +281,6 @@ func (t *tester) registerSSATest(pkg string) { // known failures due to GOGC=off case "runtime", "runtime/pprof", "runtime/trace", "sync": return - // TODO: fix these failures - case "math/big", "cmd/compile/internal/big": - return } t.tests = append(t.tests, distTest{ name: "go_test_ssa:" + pkg, -- cgit v1.3 From 3fa0a75a02f8c54fe4b3436a343271ce1d6682f4 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Mon, 7 Sep 2015 13:55:49 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: large object load/store vs. vardef VarDef declarations are getting in the way of rewriting load/store pairs into moves. This change fixes that, albeit in a really hacky way. Better options would be appreciated. Increases coverage during make.bash from 67% to 71%. Change-Id: I336e967687e2238c7d0d64e3b37132a731ad15c3 Reviewed-on: https://go-review.googlesource.com/14347 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/ssa/gen/generic.rules | 1 + src/cmd/compile/internal/ssa/gen/genericOps.go | 4 +-- src/cmd/compile/internal/ssa/rewritegeneric.go | 38 ++++++++++++++++++++++++++ 3 files changed, 41 insertions(+), 2 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index d2ab9f5421..b704014287 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -179,6 +179,7 @@ // big-object moves (TODO: remove?) (Store [size] dst (Load src mem) mem) && size > config.IntSize -> (Move [size] dst src mem) +(Store [size] dst (Load src mem) (VarDef {x} mem)) && size > config.IntSize -> (Move [size] dst src (VarDef {x} mem)) (If (IsNonNil (GetG)) yes no) -> (First nil yes no) diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index b52bd1fecc..042d34ea85 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -362,8 +362,8 @@ var genericOps = []opData{ // Used during ssa construction. Like Copy, but the arg has not been specified yet. {name: "FwdRef"}, - {name: "VarDef"}, // aux is a *gc.Node of a variable that is about to be initialized. arg0=mem, returns mem - {name: "VarKill"}, // aux is a *gc.Node of a variable that is known to be dead. arg0=mem, returns mem + {name: "VarDef", typ: "Mem"}, // aux is a *gc.Node of a variable that is about to be initialized. arg0=mem, returns mem + {name: "VarKill"}, // aux is a *gc.Node of a variable that is known to be dead. arg0=mem, returns mem } // kind control successors diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index dc6604fe38..0334c0cd95 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -1434,6 +1434,44 @@ func rewriteValuegeneric(v *Value, config *Config) bool { goto enda18a7163888e2f4fca9f38bae56cef42 enda18a7163888e2f4fca9f38bae56cef42: ; + // match: (Store [size] dst (Load src mem) (VarDef {x} mem)) + // cond: size > config.IntSize + // result: (Move [size] dst src (VarDef {x} mem)) + { + size := v.AuxInt + dst := v.Args[0] + if v.Args[1].Op != OpLoad { + goto endc671c9b1be99e3125fe81e29018bc0e6 + } + src := v.Args[1].Args[0] + mem := v.Args[1].Args[1] + if v.Args[2].Op != OpVarDef { + goto endc671c9b1be99e3125fe81e29018bc0e6 + } + x := v.Args[2].Aux + if v.Args[2].Args[0] != mem { + goto endc671c9b1be99e3125fe81e29018bc0e6 + } + if !(size > config.IntSize) { + goto endc671c9b1be99e3125fe81e29018bc0e6 + } + v.Op = OpMove + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = size + v.AddArg(dst) + v.AddArg(src) + v0 := b.NewValue0(v.Line, OpVarDef, TypeInvalid) + v0.Aux = x + v0.AddArg(mem) + v0.Type = TypeMem + v.AddArg(v0) + return true + } + goto endc671c9b1be99e3125fe81e29018bc0e6 + endc671c9b1be99e3125fe81e29018bc0e6: + ; case OpStringLen: // match: (StringLen (StringMake _ len)) // cond: -- cgit v1.3 From 8d081679d5e72637ec724df7d6ec5f9e1f6a78e6 Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Mon, 7 Sep 2015 19:29:26 -0500 Subject: [dev.ssa] test: ensure that all current tests run Some of the test files were missing, so add them. Change-Id: Ifac248edf33e1e4ccd82355f596d74eab4ff01a2 Reviewed-on: https://go-review.googlesource.com/14328 Run-TryBot: Todd Neal TryBot-Result: Gobot Gobot Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/gc/ssa_test.go | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa_test.go b/src/cmd/compile/internal/gc/ssa_test.go index 071522bc2f..e4f5bcd1fd 100644 --- a/src/cmd/compile/internal/gc/ssa_test.go +++ b/src/cmd/compile/internal/gc/ssa_test.go @@ -54,3 +54,19 @@ 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") } -- cgit v1.3 From ca9e450bed8e0884e88731526adfb2b4080b548e Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Tue, 8 Sep 2015 08:59:57 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: fix defer in functions with no return The after-defer test jumps to a deferreturn site. Some functions (those with infinite loops) have no deferreturn site. Add one so we have one to jump to. Change-Id: I505e7f3f888f5e7d03ca49a3477b41cf1f78eb8a Reviewed-on: https://go-review.googlesource.com/14349 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/gc/ssa.go | 38 ++++++++++++++-------- src/cmd/compile/internal/gc/ssa_test.go | 10 +++++- .../internal/gc/testdata/deferNoReturn_ssa.go | 21 ++++++++++++ 3 files changed, 54 insertions(+), 15 deletions(-) create mode 100644 src/cmd/compile/internal/gc/testdata/deferNoReturn_ssa.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 098a1e15f6..70990bbd18 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -2621,6 +2621,12 @@ func genssa(f *ssa.Func, ptxt *obj.Prog, gcargs, gclocals *Sym) { 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 } @@ -3463,20 +3469,7 @@ func (s *genState) genBlock(b, next *ssa.Block) { case ssa.BlockExit: case ssa.BlockRet: if Hasdefer != 0 { - // 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) + s.deferReturn() } Prog(obj.ARET) case ssa.BlockCall: @@ -3537,6 +3530,23 @@ func (s *genState) genBlock(b, next *ssa.Block) { } } +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) { if a.Type != obj.TYPE_MEM { diff --git a/src/cmd/compile/internal/gc/ssa_test.go b/src/cmd/compile/internal/gc/ssa_test.go index e4f5bcd1fd..0bce902982 100644 --- a/src/cmd/compile/internal/gc/ssa_test.go +++ b/src/cmd/compile/internal/gc/ssa_test.go @@ -17,12 +17,18 @@ import ( // 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", "run", filepath.Join("testdata", filename)) + cmd := exec.Command("go", kind, filepath.Join("testdata", filename)) cmd.Stdout = &stdout cmd.Stderr = &stderr // TODO: set GOGC=off until we have stackmaps @@ -70,3 +76,5 @@ 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") } 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 0000000000..171f5837bc --- /dev/null +++ b/src/cmd/compile/internal/gc/testdata/deferNoReturn_ssa.go @@ -0,0 +1,21 @@ +// 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 main + +func deferNoReturn_ssa() { + defer func() { println("returned") }() + for { + println("loop") + } +} + +func main() { + deferNoReturn_ssa() +} -- cgit v1.3 From c684d4d26c3197039ac2c2f53a862f25dc7d1112 Mon Sep 17 00:00:00 2001 From: Alexandru Moșoi Date: Tue, 8 Sep 2015 18:18:59 +0200 Subject: [dev.ssa] cmd/compile/internal/ssa: fix string slice types. Change-Id: I28bc6373bb42d9abf4f179664dbaab8d514a6ab9 Reviewed-on: https://go-review.googlesource.com/14376 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 4 +-- src/cmd/compile/internal/gc/testdata/string_ssa.go | 30 ++++++++++++++++++++++ 2 files changed, 32 insertions(+), 2 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 70990bbd18..a554a1dfd9 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1722,12 +1722,12 @@ func (s *state) expr(n *Node) *ssa.Value { if n.Right.Left == nil { low = zero } else { - low = s.expr(n.Right.Left) + low = s.extendIndex(s.expr(n.Right.Left)) } if n.Right.Right == nil { high = len } else { - high = s.expr(n.Right.Right) + high = s.extendIndex(s.expr(n.Right.Right)) } // Panic if slice indices are not in bounds. diff --git a/src/cmd/compile/internal/gc/testdata/string_ssa.go b/src/cmd/compile/internal/gc/testdata/string_ssa.go index efc734e1a2..448433acd3 100644 --- a/src/cmd/compile/internal/gc/testdata/string_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/string_ssa.go @@ -86,9 +86,39 @@ func testStringSlicePanic() { failed = true } +const _Accuracy_name = "BelowExactAbove" + +var _Accuracy_index = [...]uint8{0, 5, 10, 15} + +func testSmallIndexType_ssa(i int) string { + switch { // prevent inlining + } + 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 + } + } +} + func main() { testStringSlice() testStringSlicePanic() + testStructSlice() + testSmallIndexType() if failed { panic("failed") -- cgit v1.3 From 1c2975c305b2b2c32f2673c93ab51204c5a5bff5 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Tue, 8 Sep 2015 16:23:50 -0700 Subject: [dev.ssa] cmd/compile/internal/gc: avoid generating test binary file Using the main package causes a binary to be generated. That binary clutters up git listings. Use a non-main package instead, so the results of a successful compilation are thrown away. Change-Id: I3ac91fd69ad297a5c0fe035c22fdef290b7dfbc4 Reviewed-on: https://go-review.googlesource.com/14399 Reviewed-by: Josh Bleecher Snyder Run-TryBot: Josh Bleecher Snyder TryBot-Result: Gobot Gobot --- src/cmd/compile/internal/gc/testdata/deferNoReturn_ssa.go | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/testdata/deferNoReturn_ssa.go b/src/cmd/compile/internal/gc/testdata/deferNoReturn_ssa.go index 171f5837bc..7578dd56f2 100644 --- a/src/cmd/compile/internal/gc/testdata/deferNoReturn_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/deferNoReturn_ssa.go @@ -7,7 +7,7 @@ // Test that a defer in a function with no return // statement will compile correctly. -package main +package foo func deferNoReturn_ssa() { defer func() { println("returned") }() @@ -15,7 +15,3 @@ func deferNoReturn_ssa() { println("loop") } } - -func main() { - deferNoReturn_ssa() -} -- cgit v1.3 From a7cfc759f2b03cb1155477d99384578f2910139c Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Tue, 8 Sep 2015 16:04:37 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: handle returns correctly Make sure that return blocks take a store as their control. Without this, code was getting inserted between the return and exit blocks. Use AEND to mark the end of code. The live variable analysis gets confused when routines end like: JMP earlier RET because the RET is unreachable. The RET was incorrectly added to the last basic block, rendering the JMP invisible to the CFG builder. Change-Id: I91b32c8b37075347243ff039b4e4385856fba7cd Reviewed-on: https://go-review.googlesource.com/14398 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/gc/plive.go | 6 ++++-- src/cmd/compile/internal/gc/ssa.go | 9 ++++++--- src/cmd/compile/internal/ssa/check.go | 7 +++++-- src/cmd/compile/internal/ssa/gen/genericOps.go | 4 +++- 4 files changed, 18 insertions(+), 8 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/plive.go b/src/cmd/compile/internal/gc/plive.go index fa8bc20f14..2ac639629c 100644 --- a/src/cmd/compile/internal/gc/plive.go +++ b/src/cmd/compile/internal/gc/plive.go @@ -425,7 +425,7 @@ func newcfg(firstp *obj.Prog) []*BasicBlock { 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 { @@ -453,7 +453,7 @@ func newcfg(firstp *obj.Prog) []*BasicBlock { // 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 } @@ -462,6 +462,8 @@ func newcfg(firstp *obj.Prog) []*BasicBlock { // 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 } diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 96d62041d6..9791967677 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -116,8 +116,11 @@ func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { s.stmtList(fn.Nbody) // fallthrough to exit - if b := s.endBlock(); b != nil { + if s.curBlock != nil { + m := s.mem() + b := s.endBlock() b.Kind = ssa.BlockRet + b.Control = m b.AddEdgeTo(s.exit) } @@ -575,8 +578,10 @@ func (s *state) stmt(n *Node) { case ORETURN: s.stmtList(n.List) + m := s.mem() b := s.endBlock() b.Kind = ssa.BlockRet + b.Control = m b.AddEdgeTo(s.exit) case OCONTINUE, OBREAK: @@ -2631,8 +2636,6 @@ func genssa(f *ssa.Func, ptxt *obj.Prog, gcargs, gclocals *Sym) { p.To.Val = s.deferTarget } - Pc.As = obj.ARET // overwrite AEND - if logProgs { for p := ptxt; p != nil; p = p.Link { var s string diff --git a/src/cmd/compile/internal/ssa/check.go b/src/cmd/compile/internal/ssa/check.go index 4b38bec99e..b860f633ef 100644 --- a/src/cmd/compile/internal/ssa/check.go +++ b/src/cmd/compile/internal/ssa/check.go @@ -63,8 +63,11 @@ func checkFunc(f *Func) { if len(b.Succs) != 1 { f.Fatalf("ret block %s len(Succs)==%d, want 1", b, len(b.Succs)) } - if b.Control != nil { - f.Fatalf("ret block %s has non-nil control %s", b, b.Control.LongString()) + 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()) } if b.Succs[0].Kind != BlockExit { f.Fatalf("ret block %s has successor %s, not Exit", b, b.Succs[0].Kind) diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 042d34ea85..9bc77909b5 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -369,9 +369,11 @@ var genericOps = []opData{ // kind control successors // ------------------------------------------ // Exit return mem [] +// Ret return mem [exit] // Plain nil [next] // If a boolean Value [then, else] -// Call mem [nopanic, panic] (control opcode should be OpCall or OpStaticCall) +// Call mem [nopanic, exit] (control opcode should be OpCall or OpStaticCall) +// First nil [always,never] var genericBlocks = []blockData{ {name: "Exit"}, // no successors. There should only be 1 of these. -- cgit v1.3 From fd8c71be865386b5545571c9ff3b5c604809e133 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Tue, 8 Sep 2015 21:37:37 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: eval defer args before setting argsize and func Evaluating args can overwrite arg area, so we can't write argsize and func until args are evaluated. Fixes test/recover.go, test/recover1.go, and test/fixedbugs/issue4066.go Change-Id: I862e4934ccdb8661431bcc3e1e93817ea834ea3f Reviewed-on: https://go-review.googlesource.com/14405 Reviewed-by: David Chase --- src/cmd/compile/internal/gc/ssa.go | 8 ++++---- test/run.go | 4 ++-- 2 files changed, 6 insertions(+), 6 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 9791967677..e3a71a9f3f 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -741,6 +741,10 @@ func (s *state) stmt(n *Node) { s.Unimplementedf("defer/go of %s", opnames[call.Op]) } + // Run all argument assignments. The arg slots have already + // been offset by 2*widthptr. + s.stmtList(call.List) + // Write argsize and closure (args to Newproc/Deferproc) argsize := s.constInt32(Types[TUINT32], int32(fn.Type.Argwid)) s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, 4, s.sp, argsize, s.mem()) @@ -748,10 +752,6 @@ func (s *state) stmt(n *Node) { 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()) - // Run all argument assignments. The arg slots have already - // been offset by 2*widthptr. - s.stmtList(call.List) - // Call deferproc or newproc bNext := s.f.NewBlock(ssa.BlockPlain) var op ssa.Op diff --git a/test/run.go b/test/run.go index f2618e027b..1f9b905ea3 100644 --- a/test/run.go +++ b/test/run.go @@ -638,8 +638,8 @@ func (t *test) run() { case "run": useTmp = false switch t.gofile { - case "bug434.go", "recover.go", "recover1.go", "issue4066.go": - // TODO fix these failures + case "bug434.go": + // TODO fix this failure default: ssaMain = true } -- cgit v1.3 From 8a1f6217c57316808e8f23f5f2fa251de3c18a26 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Tue, 8 Sep 2015 21:28:44 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: implement ORETJMP Change-Id: I352c7b9aab053959bc74c15861339e1dbe545ddc Reviewed-on: https://go-review.googlesource.com/14404 Reviewed-by: David Chase --- src/cmd/compile/internal/gc/ssa.go | 18 ++++++++++++++++++ src/cmd/compile/internal/ssa/block.go | 6 ++++++ src/cmd/compile/internal/ssa/check.go | 16 ++++++++++++++++ src/cmd/compile/internal/ssa/gen/genericOps.go | 15 ++++++++------- src/cmd/compile/internal/ssa/html.go | 3 +++ src/cmd/compile/internal/ssa/opGen.go | 16 +++++++++------- 6 files changed, 60 insertions(+), 14 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index e3a71a9f3f..9d87f38ea1 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -583,6 +583,14 @@ func (s *state) stmt(n *Node) { b.Kind = ssa.BlockRet b.Control = m b.AddEdgeTo(s.exit) + case ORETJMP: + s.stmtList(n.List) + m := s.mem() + b := s.endBlock() + b.Kind = ssa.BlockRetJmp + b.Aux = n.Left.Sym + b.Control = m + b.AddEdgeTo(s.exit) case OCONTINUE, OBREAK: var op string @@ -2054,6 +2062,11 @@ func canSSA(n *Node) bool { case PEXTERN, PPARAMOUT, PPARAMREF: return false } + if n.Class == PPARAM && n.String() == ".this" { + // wrappers generated by genwrapper need to update + // the .this pointer in place. + return false + } return canSSAType(n.Type) // TODO: try to make more variables SSAable? } @@ -3475,6 +3488,11 @@ func (s *genState) genBlock(b, next *ssa.Block) { 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.BlockCall: if b.Succs[0] != next { p := Prog(obj.AJMP) diff --git a/src/cmd/compile/internal/ssa/block.go b/src/cmd/compile/internal/ssa/block.go index 1d5e617c55..5fb93cd5a7 100644 --- a/src/cmd/compile/internal/ssa/block.go +++ b/src/cmd/compile/internal/ssa/block.go @@ -30,6 +30,9 @@ type Block struct { // 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. @@ -65,6 +68,9 @@ func (b *Block) String() string { // 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) } diff --git a/src/cmd/compile/internal/ssa/check.go b/src/cmd/compile/internal/ssa/check.go index b860f633ef..9747585f4a 100644 --- a/src/cmd/compile/internal/ssa/check.go +++ b/src/cmd/compile/internal/ssa/check.go @@ -72,6 +72,22 @@ func checkFunc(f *Func) { if b.Succs[0].Kind != BlockExit { f.Fatalf("ret block %s has successor %s, not Exit", b, b.Succs[0].Kind) } + case BlockRetJmp: + if len(b.Succs) != 1 { + f.Fatalf("retjmp block %s len(Succs)==%d, want 1", 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.Succs[0].Kind != BlockExit { + f.Fatalf("retjmp block %s has successor %s, not Exit", b, b.Succs[0].Kind) + } + 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) diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 9bc77909b5..1c26946781 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -376,13 +376,14 @@ var genericOps = []opData{ // First nil [always,never] var genericBlocks = []blockData{ - {name: "Exit"}, // no successors. There should only be 1 of these. - {name: "Dead"}, // no successors; determined to be dead but not yet removed - {name: "Plain"}, // a single successor - {name: "If"}, // 2 successors, if control goto Succs[0] else goto Succs[1] - {name: "Call"}, // 2 successors, normal return and panic - {name: "First"}, // 2 successors, always takes the first one (second is dead) - {name: "Ret"}, // 1 successor, branches to exit + {name: "Exit"}, // no successors. There should only be 1 of these. + {name: "Dead"}, // no successors; determined to be dead but not yet removed + {name: "Plain"}, // a single successor + {name: "If"}, // 2 successors, if control goto Succs[0] else goto Succs[1] + {name: "Call"}, // 2 successors, normal return and panic + {name: "First"}, // 2 successors, always takes the first one (second is dead) + {name: "Ret"}, // 1 successor, branches to exit + {name: "RetJmp"}, // 1 successor, branches to exit. Jumps to b.Aux.(*gc.Sym) } func init() { diff --git a/src/cmd/compile/internal/ssa/html.go b/src/cmd/compile/internal/ssa/html.go index c84dccf793..68a432c676 100644 --- a/src/cmd/compile/internal/ssa/html.go +++ b/src/cmd/compile/internal/ssa/html.go @@ -384,6 +384,9 @@ func (b *Block) HTML() string { func (b *Block) LongHTML() string { // TODO: improve this for HTML? s := fmt.Sprintf("%s", 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()) } diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 0d7343c8aa..bca6654158 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -29,6 +29,7 @@ const ( BlockCall BlockFirst BlockRet + BlockRetJmp ) var blockString = [...]string{ @@ -49,13 +50,14 @@ var blockString = [...]string{ BlockAMD64ORD: "ORD", BlockAMD64NAN: "NAN", - BlockExit: "Exit", - BlockDead: "Dead", - BlockPlain: "Plain", - BlockIf: "If", - BlockCall: "Call", - BlockFirst: "First", - BlockRet: "Ret", + BlockExit: "Exit", + BlockDead: "Dead", + BlockPlain: "Plain", + BlockIf: "If", + BlockCall: "Call", + BlockFirst: "First", + BlockRet: "Ret", + BlockRetJmp: "RetJmp", } func (k BlockKind) String() string { return blockString[k] } -- cgit v1.3 From 2a2957656270cf409d11eb2df1d316e97cef2b62 Mon Sep 17 00:00:00 2001 From: David Chase Date: Sun, 6 Sep 2015 21:32:24 -0400 Subject: [dev.ssa] cmd/compile: fix N^2 dominator queries in CSE Added tree numbering data structure. Changed dominator query in CSE. Removed skip-for-too-big patch in CSE. Passes all.bash. Change-Id: I98d7c61b6015c81f5edab553615db17bc7a58d68 Reviewed-on: https://go-review.googlesource.com/14326 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/cse.go | 12 +-- src/cmd/compile/internal/ssa/sparsetree.go | 113 +++++++++++++++++++++++++++++ 2 files changed, 117 insertions(+), 8 deletions(-) create mode 100644 src/cmd/compile/internal/ssa/sparsetree.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/cse.go b/src/cmd/compile/internal/ssa/cse.go index 003530a9d3..3b007c6192 100644 --- a/src/cmd/compile/internal/ssa/cse.go +++ b/src/cmd/compile/internal/ssa/cse.go @@ -10,11 +10,6 @@ import "sort" // Values are just relinked, nothing is deleted. A subsequent deadcode // pass is required to actually remove duplicate expressions. func cse(f *Func) { - if f.NumBlocks() > 10000 { - f.Unimplementedf("too many blocks: %d", f.NumBlocks()) - return - } - // Two values are equivalent if they satisfy the following definition: // equivalent(v, w): // v.op == w.op @@ -132,6 +127,7 @@ func cse(f *Func) { // 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. @@ -142,7 +138,7 @@ func cse(f *Func) { // Find a maximal dominant element in e v := e[0] for _, w := range e[1:] { - if dom(w.Block, v.Block, idom) { + if sdom.isAncestorEq(w.Block, v.Block) { v = w } } @@ -152,7 +148,7 @@ func cse(f *Func) { w := e[i] if w == v { e, e[i] = e[:len(e)-1], e[len(e)-1] - } else if dom(v.Block, w.Block, idom) { + } else if sdom.isAncestorEq(v.Block, w.Block) { rewrite[w.ID] = v e, e[i] = e[:len(e)-1], e[len(e)-1] } else { @@ -176,7 +172,7 @@ func cse(f *Func) { } // returns true if b dominates c. -// TODO(khr): faster +// simple and iterative, has O(depth) complexity in tall trees. func dom(b, c *Block, idom []*Block) bool { // Walk up from c in the dominator tree looking for b. for c != nil { diff --git a/src/cmd/compile/internal/ssa/sparsetree.go b/src/cmd/compile/internal/ssa/sparsetree.go new file mode 100644 index 0000000000..14bcb44b1b --- /dev/null +++ b/src/cmd/compile/internal/ssa/sparsetree.go @@ -0,0 +1,113 @@ +// 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 { + block *Block + 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] + n.block = b + 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 +} + +// 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 +} -- cgit v1.3 From adba6c4fdf8c9d2078a88a016924e80fd23cb39c Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Tue, 8 Sep 2015 07:50:25 -0400 Subject: [dev.ssa] cmd/compile/internal/ssa: treat -0.0 literal as 0.0 This matches existing behavior, see issue #2196 Change-Id: Ifa9359b7c821115389f337a57de355c5ec23be8f Reviewed-on: https://go-review.googlesource.com/14261 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 16 ++++++++++------ test/run.go | 8 +------- 2 files changed, 11 insertions(+), 13 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 9d87f38ea1..386420f26b 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1254,9 +1254,11 @@ func (s *state) expr(n *Node) *ssa.Value { f := n.Val().U.(*Mpflt) switch n.Type.Size() { case 4: - return s.constFloat32(n.Type, mpgetflt32(f)) + // -0.0 literals need to be treated as if they were 0.0, adding 0.0 here + // accomplishes this while not affecting other values. + return s.constFloat32(n.Type, mpgetflt32(f)+0.0) case 8: - return s.constFloat64(n.Type, mpgetflt(f)) + return s.constFloat64(n.Type, mpgetflt(f)+0.0) default: s.Fatalf("bad float size %d", n.Type.Size()) return nil @@ -1269,16 +1271,18 @@ func (s *state) expr(n *Node) *ssa.Value { case 8: { pt := Types[TFLOAT32] + // -0.0 literals need to be treated as if they were 0.0, adding 0.0 here + // accomplishes this while not affecting other values. return s.newValue2(ssa.OpComplexMake, n.Type, - s.constFloat32(pt, mpgetflt32(r)), - s.constFloat32(pt, mpgetflt32(i))) + s.constFloat32(pt, mpgetflt32(r)+0.0), + s.constFloat32(pt, mpgetflt32(i)+0.0)) } case 16: { pt := Types[TFLOAT64] return s.newValue2(ssa.OpComplexMake, n.Type, - s.constFloat64(pt, mpgetflt(r)), - s.constFloat64(pt, mpgetflt(i))) + s.constFloat64(pt, mpgetflt(r)+0.0), + s.constFloat64(pt, mpgetflt(i)+0.0)) } default: s.Fatalf("bad float size %d", n.Type.Size()) diff --git a/test/run.go b/test/run.go index 1f9b905ea3..de2044704c 100644 --- a/test/run.go +++ b/test/run.go @@ -636,13 +636,7 @@ func (t *test) run() { } case "run": - useTmp = false - switch t.gofile { - case "bug434.go": - // TODO fix this failure - default: - ssaMain = true - } + ssaMain = true out, err := runcmd(append([]string{"go", "run", t.goFileName()}, args...)...) if err != nil { t.err = err -- cgit v1.3 From def7c65b7062f5c087c4e348768ee4c464b79b91 Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Mon, 7 Sep 2015 19:07:02 -0500 Subject: [dev.ssa] cmd/compile/internal/ssa: implement OCFUNC Change-Id: Ieb9cddf8876bf8cd5ee1705d9210d22c3959e8cc Reviewed-on: https://go-review.googlesource.com/14329 Reviewed-by: Keith Randall Run-TryBot: Todd Neal --- src/cmd/compile/internal/gc/ssa.go | 12 ++++--- src/cmd/compile/internal/gc/ssa_test.go | 3 ++ .../compile/internal/gc/testdata/closure_ssa.go | 39 ++++++++++++++++++++++ 3 files changed, 50 insertions(+), 4 deletions(-) create mode 100644 src/cmd/compile/internal/gc/testdata/closure_ssa.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 386420f26b..4fe8ba8836 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1203,6 +1203,9 @@ func (s *state) expr(n *Node) *ssa.Value { s.stmtList(n.Ninit) switch n.Op { + case OCFUNC: + aux := &ssa.ExternSymbol{n.Type, n.Left.Sym} + return s.entryNewValue1A(ssa.OpAddr, n.Type, aux, s.sb) case ONAME: if n.Class == PFUNC { // "value" of a function is the address of the function's closure @@ -1296,16 +1299,17 @@ func (s *state) expr(n *Node) *ssa.Value { case OCONVNOP: to := n.Type from := n.Left.Type - if to.Etype == TFUNC { - s.Unimplementedf("CONVNOP closure") - return nil - } // 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) 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 diff --git a/src/cmd/compile/internal/gc/ssa_test.go b/src/cmd/compile/internal/gc/ssa_test.go index 0bce902982..feaea8b463 100644 --- a/src/cmd/compile/internal/gc/ssa_test.go +++ b/src/cmd/compile/internal/gc/ssa_test.go @@ -78,3 +78,6 @@ 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") } 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 0000000000..ac1e51a23e --- /dev/null +++ b/src/cmd/compile/internal/gc/testdata/closure_ssa.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. + +// map_ssa.go tests map operations. +package main + +import "fmt" + +var failed = false + +func testCFunc_ssa() int { + switch { // prevent inlining + } + 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") + } +} -- cgit v1.3 From 2f518071577d177c5ec5b4c0c9e9dcd14e9cd32a Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Thu, 10 Sep 2015 11:37:09 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: fix real/imag ops They were using the result type to look up the op, not the arg type. Change-Id: I0641cba363fa6e7a66ad0860aa340106c10c2cea Reviewed-on: https://go-review.googlesource.com/14469 Reviewed-by: Brad Fitzpatrick Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/gc/ssa.go | 5 +++- src/cmd/compile/internal/gc/testdata/fp_ssa.go | 32 ++++++++++++++++++++++++++ 2 files changed, 36 insertions(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 4fe8ba8836..5132c53000 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1638,9 +1638,12 @@ func (s *state) expr(n *Node) *ssa.Value { 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, OIMAG, OREAL: + case ONOT, OCOM: 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) diff --git a/src/cmd/compile/internal/gc/testdata/fp_ssa.go b/src/cmd/compile/internal/gc/testdata/fp_ssa.go index 9bd545f878..6985cd0641 100644 --- a/src/cmd/compile/internal/gc/testdata/fp_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/fp_ssa.go @@ -1496,6 +1496,18 @@ func cx128neg_ssa(a complex128) complex128 { return -a } +func cx128real_ssa(a complex128) float64 { + switch { // prevent inlining + } + return real(a) +} + +func cx128imag_ssa(a complex128) float64 { + switch { // prevent inlining + } + return imag(a) +} + func cx128cnst_ssa(a complex128) complex128 { switch { // prevent inlining } @@ -1533,6 +1545,18 @@ func cx64neg_ssa(a complex64) complex64 { return -a } +func cx64real_ssa(a complex64) float32 { + switch { // prevent inlining + } + return real(a) +} + +func cx64imag_ssa(a complex64) float32 { + switch { // prevent inlining + } + return imag(a) +} + func complexTest128() int { fails := 0 var a complex128 = 1 + 2i @@ -1542,6 +1566,8 @@ func complexTest128() int { 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) fails += expectCx128("sum", sum, 4+8i) @@ -1549,6 +1575,8 @@ func complexTest128() int { 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) return fails @@ -1563,12 +1591,16 @@ func complexTest64() int { prod := cx64prod_ssa(b, a) quot := cx64quot_ssa(b, a) neg := cx64neg_ssa(a) + r := cx64real_ssa(a) + i := cx64imag_ssa(a) 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) return fails } -- cgit v1.3 From db380bf44bcd8bcfdcbb68d18855111090282a63 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Thu, 10 Sep 2015 11:05:42 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: add == and != for complex Change-Id: Iefabce4eb0dbc313dd1863513b45307cc76c545a Reviewed-on: https://go-review.googlesource.com/14468 Reviewed-by: Brad Fitzpatrick --- src/cmd/compile/internal/gc/ssa.go | 16 ++++++++ src/cmd/compile/internal/gc/testdata/fp_ssa.go | 55 ++++++++++++++++++++++++++ 2 files changed, 71 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 5132c53000..b69631338e 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1476,6 +1476,22 @@ func (s *state) expr(n *Node) *ssa.Value { 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.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) diff --git a/src/cmd/compile/internal/gc/testdata/fp_ssa.go b/src/cmd/compile/internal/gc/testdata/fp_ssa.go index 6985cd0641..e7480a1138 100644 --- a/src/cmd/compile/internal/gc/testdata/fp_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/fp_ssa.go @@ -1557,6 +1557,45 @@ func cx64imag_ssa(a complex64) float32 { return imag(a) } +func cx128eq_ssa(a, b complex128) bool { + switch { // prevent inlining + } + return a == b +} + +func cx128ne_ssa(a, b complex128) bool { + switch { // prevent inlining + } + return a != b +} + +func cx64eq_ssa(a, b complex64) bool { + switch { // prevent inlining + } + return a == b +} + +func cx64ne_ssa(a, b complex64) bool { + switch { // prevent inlining + } + 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 @@ -1569,6 +1608,10 @@ func complexTest128() int { 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) @@ -1578,6 +1621,10 @@ func complexTest128() int { 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 } @@ -1593,6 +1640,10 @@ func complexTest64() int { 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) @@ -1601,6 +1652,10 @@ func complexTest64() int { 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 } -- cgit v1.3 From c244ce097c1d75b4fd178683f74bfd9318a81ebe Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Thu, 10 Sep 2015 14:59:00 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: fix complex compares It was using 64-bit float comparison ops for complex64. It should use 32-bit float comparison. Fixes build. Change-Id: I6452b227257fecc09e04cd092ccf328d1fc9917f Reviewed-on: https://go-review.googlesource.com/14497 Run-TryBot: Keith Randall Reviewed-by: Brad Fitzpatrick --- src/cmd/compile/internal/gc/ssa.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index b69631338e..b29c328814 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1477,7 +1477,7 @@ func (s *state) expr(n *Node) *ssa.Value { a := s.expr(n.Left) b := s.expr(n.Right) if n.Left.Type.IsComplex() { - pt := floatForComplex(n.Type) + 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)) -- cgit v1.3 From f5c53e0deb37b6f108e73bdb8b9a5955b2db5315 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Wed, 9 Sep 2015 18:03:41 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: simplify how exit blocks are used Move to implicit (mostly) instead of explicit exit blocks. RET and RETJMP have no outgoing edges - they implicitly exit. CALL only has one outgoing edge, as its exception edge is implicit as well. Exit blocks are only used for unconditionally panicking code, like the failed branches of nil and bounds checks. There may now be more than one exit block. No merges happen at exit blocks. The only downside is it is harder to find all the places code can exit the method. See the reverse dominator code for an example. Change-Id: I42e2fd809a4bf81301ab993e29ad9f203ce48eb0 Reviewed-on: https://go-review.googlesource.com/14462 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/gc/ssa.go | 44 +++-------------- src/cmd/compile/internal/ssa/check.go | 18 +++---- src/cmd/compile/internal/ssa/critical.go | 2 +- src/cmd/compile/internal/ssa/dom.go | 67 ++++++++++++++------------ src/cmd/compile/internal/ssa/gen/genericOps.go | 25 +++++----- src/cmd/compile/internal/ssa/opGen.go | 12 ++--- 6 files changed, 71 insertions(+), 97 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index b29c328814..35d9e6a690 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -74,9 +74,6 @@ func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { // Allocate starting block s.f.Entry = s.f.NewBlock(ssa.BlockPlain) - // Allocate exit block - s.exit = s.f.NewBlock(ssa.BlockExit) - // Allocate starting values s.vars = map[*Node]*ssa.Value{} s.labels = map[string]*ssaLabel{} @@ -121,14 +118,8 @@ func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { b := s.endBlock() b.Kind = ssa.BlockRet b.Control = m - b.AddEdgeTo(s.exit) } - // Finish up exit block - s.startBlock(s.exit) - s.exit.Control = s.mem() - s.endBlock() - // Check that we used all labels for name, lab := range s.labels { if !lab.used() && !lab.reported { @@ -181,9 +172,6 @@ type state struct { // function we're building f *ssa.Func - // exit block that "return" jumps to (and panics jump to) - exit *ssa.Block - // labels and labeled control flow nodes (OFOR, OSWITCH, OSELECT) in f labels map[string]*ssaLabel labeledNodes map[*Node]*ssaLabel @@ -582,7 +570,6 @@ func (s *state) stmt(n *Node) { b := s.endBlock() b.Kind = ssa.BlockRet b.Control = m - b.AddEdgeTo(s.exit) case ORETJMP: s.stmtList(n.List) m := s.mem() @@ -590,7 +577,6 @@ func (s *state) stmt(n *Node) { b.Kind = ssa.BlockRetJmp b.Aux = n.Left.Sym b.Control = m - b.AddEdgeTo(s.exit) case OCONTINUE, OBREAK: var op string @@ -776,7 +762,6 @@ func (s *state) stmt(n *Node) { b.Kind = ssa.BlockCall b.Control = r b.AddEdgeTo(bNext) - b.AddEdgeTo(s.exit) s.startBlock(bNext) default: @@ -1859,7 +1844,6 @@ func (s *state) expr(n *Node) *ssa.Value { b.Kind = ssa.BlockCall b.Control = call b.AddEdgeTo(bNext) - b.AddEdgeTo(s.exit) // read result from stack at the start of the fallthrough block s.startBlock(bNext) @@ -2154,11 +2138,12 @@ func (s *state) nilCheck(ptr *ssa.Value) { bPanic := s.f.NewBlock(ssa.BlockPlain) b.AddEdgeTo(bNext) b.AddEdgeTo(bPanic) - bPanic.AddEdgeTo(s.exit) s.startBlock(bPanic) // TODO: implicit nil checks somehow? - s.vars[&memvar] = s.newValue2(ssa.OpPanicNilCheck, ssa.TypeMem, ptr, s.mem()) + chk := s.newValue2(ssa.OpPanicNilCheck, ssa.TypeMem, ptr, s.mem()) s.endBlock() + bPanic.Kind = ssa.BlockExit + bPanic.Control = chk s.startBlock(bNext) } @@ -2200,12 +2185,13 @@ func (s *state) check(cmp *ssa.Value, panicOp ssa.Op) { bPanic := s.f.NewBlock(ssa.BlockPlain) b.AddEdgeTo(bNext) b.AddEdgeTo(bPanic) - bPanic.AddEdgeTo(s.exit) s.startBlock(bPanic) // The panic check takes/returns memory to ensure that the right // memory state is observed if the panic happens. - s.vars[&memvar] = s.newValue1(panicOp, ssa.TypeMem, s.mem()) + chk := s.newValue1(panicOp, ssa.TypeMem, s.mem()) s.endBlock() + bPanic.Kind = ssa.BlockExit + bPanic.Control = chk s.startBlock(bNext) } @@ -3492,18 +3478,8 @@ func genFPJump(s *genState, b, next *ssa.Block, jumps *[2][2]floatingEQNEJump) { func (s *genState) genBlock(b, next *ssa.Block) { lineno = b.Line - // after a panic call, don't emit any branch code - if len(b.Values) > 0 { - switch b.Values[len(b.Values)-1].Op { - case ssa.OpAMD64LoweredPanicNilCheck, - ssa.OpAMD64LoweredPanicIndexCheck, - ssa.OpAMD64LoweredPanicSliceCheck: - return - } - } - switch b.Kind { - case ssa.BlockPlain: + case ssa.BlockPlain, ssa.BlockCall: if b.Succs[0] != next { p := Prog(obj.AJMP) p.To.Type = obj.TYPE_BRANCH @@ -3520,12 +3496,6 @@ func (s *genState) genBlock(b, next *ssa.Block) { p.To.Type = obj.TYPE_MEM p.To.Name = obj.NAME_EXTERN p.To.Sym = Linksym(b.Aux.(*Sym)) - case ssa.BlockCall: - 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.BlockAMD64EQF: genFPJump(s, b, next, &eqfJumps) diff --git a/src/cmd/compile/internal/ssa/check.go b/src/cmd/compile/internal/ssa/check.go index 9747585f4a..44ce4a3c71 100644 --- a/src/cmd/compile/internal/ssa/check.go +++ b/src/cmd/compile/internal/ssa/check.go @@ -60,8 +60,8 @@ func checkFunc(f *Func) { f.Fatalf("exit block %s has non-memory control value %s", b, b.Control.LongString()) } case BlockRet: - if len(b.Succs) != 1 { - f.Fatalf("ret block %s len(Succs)==%d, want 1", b, len(b.Succs)) + 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) @@ -69,12 +69,9 @@ func checkFunc(f *Func) { if !b.Control.Type.IsMemory() { f.Fatalf("ret block %s has non-memory control value %s", b, b.Control.LongString()) } - if b.Succs[0].Kind != BlockExit { - f.Fatalf("ret block %s has successor %s, not Exit", b, b.Succs[0].Kind) - } case BlockRetJmp: - if len(b.Succs) != 1 { - f.Fatalf("retjmp block %s len(Succs)==%d, want 1", b, len(b.Succs)) + 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) @@ -82,9 +79,6 @@ func checkFunc(f *Func) { if !b.Control.Type.IsMemory() { f.Fatalf("retjmp block %s has non-memory control value %s", b, b.Control.LongString()) } - if b.Succs[0].Kind != BlockExit { - f.Fatalf("retjmp block %s has successor %s, not Exit", b, b.Succs[0].Kind) - } if b.Aux == nil { f.Fatalf("retjmp block %s has nil Aux field", b) } @@ -119,8 +113,8 @@ func checkFunc(f *Func) { f.Fatalf("if block %s has non-bool control value %s", b, b.Control.LongString()) } case BlockCall: - if len(b.Succs) != 2 { - f.Fatalf("call block %s len(Succs)==%d, want 2", b, len(b.Succs)) + 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) diff --git a/src/cmd/compile/internal/ssa/critical.go b/src/cmd/compile/internal/ssa/critical.go index 439d4823e5..ba75450875 100644 --- a/src/cmd/compile/internal/ssa/critical.go +++ b/src/cmd/compile/internal/ssa/critical.go @@ -9,7 +9,7 @@ package ssa // 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 || b.Kind == BlockExit { + if len(b.Preds) <= 1 { continue } diff --git a/src/cmd/compile/internal/ssa/dom.go b/src/cmd/compile/internal/ssa/dom.go index b6fda0c953..2267281237 100644 --- a/src/cmd/compile/internal/ssa/dom.go +++ b/src/cmd/compile/internal/ssa/dom.go @@ -54,12 +54,13 @@ func postorder(f *Func) []*Block { type linkedBlocks func(*Block) []*Block -// dfs performs a depth first search over the blocks. dfnum contains a mapping +// 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 dfs(entry *Block, succFn linkedBlocks) (dfnum []int, order []*Block, parent []*Block) { - maxBlockID := entry.Func.NumBlocks() +// to block. +func dfs(entries []*Block, succFn linkedBlocks) (dfnum []int, order []*Block, parent []*Block) { + maxBlockID := entries[0].Func.NumBlocks() dfnum = make([]int, maxBlockID) order = make([]*Block, maxBlockID) @@ -67,23 +68,28 @@ func dfs(entry *Block, succFn linkedBlocks) (dfnum []int, order []*Block, parent n := 0 s := make([]*Block, 0, 256) - s = append(s, entry) - parent[entry.ID] = entry - 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 - dfnum[w.ID] = notExplored + for _, entry := range entries { + if dfnum[entry.ID] != notFound { + continue // already found from a previous entry + } + s = append(s, entry) + parent[entry.ID] = entry + 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 + dfnum[w.ID] = notExplored + } } + dfnum[node.ID] = n + order[n] = node } - dfnum[node.ID] = n - order[n] = node } return @@ -98,7 +104,7 @@ func dominators(f *Func) []*Block { //TODO: benchmark and try to find criteria for swapping between // dominatorsSimple and dominatorsLT - return dominatorsLT(f.Entry, preds, succs) + return dominatorsLT([]*Block{f.Entry}, preds, succs) } // postDominators computes the post-dominator tree for f. @@ -110,35 +116,36 @@ func postDominators(f *Func) []*Block { return nil } - // find the exit block, maybe store it as f.Exit instead? - var exit *Block + // find the exit blocks + var exits []*Block for i := len(f.Blocks) - 1; i >= 0; i-- { - if f.Blocks[i].Kind == BlockExit { - exit = f.Blocks[i] + switch f.Blocks[i].Kind { + case BlockExit, BlockRet, BlockRetJmp, BlockCall: + exits = append(exits, f.Blocks[i]) break } } - // infite loop with no exit - if exit == nil { + // infinite loop with no exit + if exits == nil { return make([]*Block, f.NumBlocks()) } - return dominatorsLT(exit, succs, preds) + return 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 dominatorsLT(entry *Block, predFn linkedBlocks, succFn linkedBlocks) []*Block { +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 // 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. - dfnum, vertex, parent := dfs(entry, succFn) + dfnum, vertex, parent := dfs(entries, succFn) - maxBlockID := entry.Func.NumBlocks() + maxBlockID := entries[0].Func.NumBlocks() semi := make([]*Block, maxBlockID) samedom := make([]*Block, maxBlockID) idom := make([]*Block, maxBlockID) diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 1c26946781..a9497644e8 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -366,24 +366,27 @@ var genericOps = []opData{ {name: "VarKill"}, // aux is a *gc.Node of a variable that is known to be dead. arg0=mem, returns mem } -// kind control successors -// ------------------------------------------ -// Exit return mem [] -// Ret return mem [exit] +// 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 [nopanic, exit] (control opcode should be OpCall or OpStaticCall) +// Call mem [next] yes (control opcode should be OpCall or OpStaticCall) // First nil [always,never] var genericBlocks = []blockData{ - {name: "Exit"}, // no successors. There should only be 1 of these. - {name: "Dead"}, // no successors; determined to be dead but not yet removed {name: "Plain"}, // a single successor {name: "If"}, // 2 successors, if control goto Succs[0] else goto Succs[1] - {name: "Call"}, // 2 successors, normal return and panic - {name: "First"}, // 2 successors, always takes the first one (second is dead) - {name: "Ret"}, // 1 successor, branches to exit - {name: "RetJmp"}, // 1 successor, branches to exit. Jumps to b.Aux.(*gc.Sym) + {name: "Call"}, // 1 successor, control is call op (of memory 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() { diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index bca6654158..7918c209a4 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -22,14 +22,14 @@ const ( BlockAMD64ORD BlockAMD64NAN - BlockExit - BlockDead BlockPlain BlockIf BlockCall - BlockFirst BlockRet BlockRetJmp + BlockExit + BlockFirst + BlockDead ) var blockString = [...]string{ @@ -50,14 +50,14 @@ var blockString = [...]string{ BlockAMD64ORD: "ORD", BlockAMD64NAN: "NAN", - BlockExit: "Exit", - BlockDead: "Dead", BlockPlain: "Plain", BlockIf: "If", BlockCall: "Call", - BlockFirst: "First", BlockRet: "Ret", BlockRetJmp: "RetJmp", + BlockExit: "Exit", + BlockFirst: "First", + BlockDead: "Dead", } func (k BlockKind) String() string { return blockString[k] } -- cgit v1.3 From cea441427e7a007ea5e35a4baa9cc2cb5d000f64 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Tue, 8 Sep 2015 16:52:25 -0700 Subject: [dev.ssa] cmd/compile: add constBool helpers Change-Id: I1f93ea65bbdc895cd4eff7545e1688a64d85aae5 Reviewed-on: https://go-review.googlesource.com/14520 Run-TryBot: Josh Bleecher Snyder Reviewed-by: Brad Fitzpatrick --- src/cmd/compile/internal/gc/ssa.go | 15 +++++++-------- src/cmd/compile/internal/ssa/func.go | 8 ++++++++ 2 files changed, 15 insertions(+), 8 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 35d9e6a690..b68a8b1a36 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -371,7 +371,10 @@ func (s *state) entryNewValue2(op ssa.Op, t ssa.Type, arg0, arg1 *ssa.Value) *ss return s.f.Entry.NewValue2(s.peekLine(), op, t, arg0, arg1) } -// constInt* routines add a new const int value to the entry block. +// 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) } @@ -647,7 +650,7 @@ func (s *state) stmt(n *Node) { if n.Left != nil { cond = s.expr(n.Left) } else { - cond = s.entryNewValue0I(ssa.OpConstBool, Types[TBOOL], 1) // 1 = true + cond = s.constBool(true) } b = s.endBlock() b.Kind = ssa.BlockIf @@ -1223,11 +1226,7 @@ func (s *state) expr(n *Node) *ssa.Value { case CTSTR: return s.entryNewValue0A(ssa.OpConstString, n.Type, n.Val().U) case CTBOOL: - if n.Val().U.(bool) { - return s.entryNewValue0I(ssa.OpConstBool, Types[TBOOL], 1) // 1 = true - } else { - return s.entryNewValue0I(ssa.OpConstBool, Types[TBOOL], 0) // 0 = false - } + return s.constBool(n.Val().U.(bool)) case CTNIL: t := n.Type switch { @@ -1947,7 +1946,7 @@ func (s *state) zeroVal(t *Type) *ssa.Value { case t.IsPtr(): return s.entryNewValue0(ssa.OpConstNil, t) case t.IsBoolean(): - return s.entryNewValue0I(ssa.OpConstBool, Types[TBOOL], 0) // 0 = false + return s.constBool(false) case t.IsInterface(): return s.entryNewValue0(ssa.OpConstInterface, t) case t.IsSlice(): diff --git a/src/cmd/compile/internal/ssa/func.go b/src/cmd/compile/internal/ssa/func.go index b6956a459f..1ea7c2e2de 100644 --- a/src/cmd/compile/internal/ssa/func.go +++ b/src/cmd/compile/internal/ssa/func.go @@ -266,6 +266,14 @@ func (b *Block) NewValue3I(line int32, op Op, t Type, aux int64, arg0, arg1, arg } // ConstInt returns an int constant representing its argument. +func (f *Func) ConstBool(line int32, t Type, c bool) *Value { + // TODO: cache? + i := int64(0) + if c { + i = 1 + } + return f.Entry.NewValue0I(line, OpConstBool, t, i) +} func (f *Func) ConstInt8(line int32, t Type, c int8) *Value { // TODO: cache? return f.Entry.NewValue0I(line, OpConst8, t, int64(c)) -- cgit v1.3 From 9552295833ddec28f1e4dffc8f3e80b6448e6f83 Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Fri, 11 Sep 2015 10:28:33 -0700 Subject: [dev.ssa] cmd/compile: minor CSE cleanup Remove unnecessary local var split. Change-Id: I907ef682b5fd9b3a67771edd1fe90c558f8937ea Reviewed-on: https://go-review.googlesource.com/14523 Run-TryBot: Josh Bleecher Snyder Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/cse.go | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/cse.go b/src/cmd/compile/internal/ssa/cse.go index 3b007c6192..25f424fbee 100644 --- a/src/cmd/compile/internal/ssa/cse.go +++ b/src/cmd/compile/internal/ssa/cse.go @@ -92,20 +92,18 @@ func cse(f *Func) { // 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, - // other values to the end of e, and track where the split is. + // move the values equivalent to v to the beginning of e + // and other values to the end of e. allvals := e - split := len(e) eqloop: for j := 1; j < len(e); { w := e[j] for i := 0; i < len(v.Args); i++ { if valueEqClass[v.Args[i].ID] != valueEqClass[w.Args[i].ID] || !v.Type.Equal(w.Type) { // w is not equivalent to v. - // move it to the end, shrink e, and move the split. + // 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] - split-- valueEqClass[w.ID] = len(partition) changed = true continue eqloop @@ -115,8 +113,8 @@ func cse(f *Func) { j++ } partition[i] = e - if split < len(allvals) { - partition = append(partition, allvals[split:]) + if len(e) < len(allvals) { + partition = append(partition, allvals[len(e):]) } } -- cgit v1.3 From 0726931c10b7e021a5d01f210bdad66f39a4321e Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Sat, 29 Aug 2015 14:54:45 -0700 Subject: [dev.ssa] cmd/compile: refactor assign Move the AST to SSA conversion to the caller. This enables it to be used in contexts in which the RHS is already an *ssa.Value. Change-Id: Ibb87210fb9fda095a9b7c7f4ad1264a7cbd269bf Reviewed-on: https://go-review.googlesource.com/14521 Run-TryBot: Josh Bleecher Snyder Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 25 ++++++++++++------------- 1 file changed, 12 insertions(+), 13 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index b68a8b1a36..7086a4f84a 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -461,7 +461,8 @@ func (s *state) stmt(n *Node) { palloc = callnew(n.Left.Type) prealloc[n.Left] = palloc } - s.assign(OAS, n.Left.Name.Heapaddr, palloc) + r := s.expr(palloc) + s.assign(n.Left.Name.Heapaddr, r, false) case OLABEL: sym := n.Left.Sym @@ -530,7 +531,11 @@ func (s *state) stmt(n *Node) { s.f.StaticData = append(data, n) return } - s.assign(n.Op, n.Left, n.Right) + var r *ssa.Value + if n.Right != nil { + r = s.expr(n.Right) + } + s.assign(n.Left, r, n.Op == OASWB) case OIF: cond := s.expr(n.Left) @@ -1864,18 +1869,14 @@ func (s *state) expr(n *Node) *ssa.Value { } } -func (s *state) assign(op uint8, left *Node, right *Node) { +func (s *state) assign(left *Node, right *ssa.Value, wb bool) { if left.Op == ONAME && isblank(left) { - if right != nil { - s.expr(right) - } return } // TODO: do write barrier - // if op == OASWB + // if wb t := left.Type dowidth(t) - var val *ssa.Value if right == nil { // right == nil means use the zero value of the assigned type. if !canSSA(left) { @@ -1887,13 +1888,11 @@ func (s *state) assign(op uint8, left *Node, right *Node) { s.vars[&memvar] = s.newValue2I(ssa.OpZero, ssa.TypeMem, t.Size(), addr, s.mem()) return } - val = s.zeroVal(t) - } else { - val = s.expr(right) + right = s.zeroVal(t) } if left.Op == ONAME && canSSA(left) { // Update variable assignment. - s.vars[left] = val + s.vars[left] = right return } // not ssa-able. Treat as a store. @@ -1901,7 +1900,7 @@ func (s *state) assign(op uint8, left *Node, right *Node) { if left.Op == ONAME { s.vars[&memvar] = s.newValue1A(ssa.OpVarDef, ssa.TypeMem, left, s.mem()) } - s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, t.Size(), addr, val, s.mem()) + s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, t.Size(), addr, right, s.mem()) } // zeroVal returns the zero value for type t. -- cgit v1.3 From a329e21ccdc0a3df9630ccab2096ea658e17201b Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Sat, 12 Sep 2015 13:26:57 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: implement OSQRT Change-Id: Iec61ca1bdc064c29ceca6d47f600d5643d0a64dd Reviewed-on: https://go-review.googlesource.com/14533 Reviewed-by: Brad Fitzpatrick --- src/cmd/compile/internal/gc/ssa.go | 10 +++++++++- src/cmd/compile/internal/ssa/gen/AMD64.rules | 2 ++ src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 2 ++ src/cmd/compile/internal/ssa/gen/genericOps.go | 2 ++ src/cmd/compile/internal/ssa/opGen.go | 18 ++++++++++++++++++ src/cmd/compile/internal/ssa/rewriteAMD64.go | 16 ++++++++++++++++ 6 files changed, 49 insertions(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 7086a4f84a..a0bd07d681 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -988,6 +988,8 @@ var opToSSA = map[opAndType]ssa.Op{ 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) uint8 { @@ -1643,7 +1645,7 @@ func (s *state) expr(n *Node) *ssa.Value { 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: + case ONOT, OCOM, OSQRT: a := s.expr(n.Left) return s.newValue1(s.ssaOp(n.Op, n.Type), a.Type, a) case OIMAG, OREAL: @@ -3325,6 +3327,12 @@ func (s *genState) genValue(v *ssa.Value) { 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, diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index cba16eadc7..0591e8f8ef 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -89,6 +89,8 @@ (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) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 0eee551f32..d5bd5b38e0 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -307,6 +307,8 @@ func init() { {name: "NOTW", reg: gp11, asm: "NOTW"}, // ^arg0 {name: "NOTB", reg: gp11, asm: "NOTB"}, // ^arg0 + {name: "SQRTSD", reg: fp11, asm: "SQRTSD"}, // sqrt(arg0) + {name: "SBBQcarrymask", reg: flagsgp, asm: "SBBQ"}, // (int64)(-1) if carry is set, 0 if carry is clear. {name: "SBBLcarrymask", reg: flagsgp, asm: "SBBL"}, // (int32)(-1) if carry is set, 0 if carry is clear. // Note: SBBW and SBBB are subsumed by SBBL diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index a9497644e8..dcaff959c3 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -232,6 +232,8 @@ var genericOps = []opData{ {name: "Com32"}, {name: "Com64"}, + {name: "Sqrt"}, // sqrt(arg0), float64 only + // Data movement {name: "Phi"}, // select an argument based on which predecessor block we came from {name: "Copy"}, // output = arg0 diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 7918c209a4..f7f1ca3068 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -203,6 +203,7 @@ const ( OpAMD64NOTL OpAMD64NOTW OpAMD64NOTB + OpAMD64SQRTSD OpAMD64SBBQcarrymask OpAMD64SBBLcarrymask OpAMD64SETEQ @@ -448,6 +449,7 @@ const ( OpCom16 OpCom32 OpCom64 + OpSqrt OpPhi OpCopy OpConstBool @@ -2361,6 +2363,18 @@ var opcodeTable = [...]opInfo{ }, }, }, + { + name: "SQRTSD", + 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", asm: x86.ASBBQ, @@ -3809,6 +3823,10 @@ var opcodeTable = [...]opInfo{ name: "Com64", generic: true, }, + { + name: "Sqrt", + generic: true, + }, { name: "Phi", generic: true, diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 7917d8d971..cb6405d44d 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -9391,6 +9391,22 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endcef6d6001d3f25cf5dacee11a46e5c8c endcef6d6001d3f25cf5dacee11a46e5c8c: ; + case OpSqrt: + // match: (Sqrt x) + // cond: + // result: (SQRTSD x) + { + x := v.Args[0] + v.Op = OpAMD64SQRTSD + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end72f79ca9ec139e15856aaa03338cf543 + end72f79ca9ec139e15856aaa03338cf543: + ; case OpStaticCall: // match: (StaticCall [argwid] {target} mem) // cond: -- cgit v1.3 From 7e390724d275363c335d7c6980f1131d13b9d192 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Sat, 12 Sep 2015 14:14:02 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: implement OCOMPLEX Change-Id: I1e5993e0e56481ce838c0e3979b1a3052e72dba5 Reviewed-on: https://go-review.googlesource.com/14535 Reviewed-by: Brad Fitzpatrick --- src/cmd/compile/internal/gc/ssa.go | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index a0bd07d681..7da49fc6f0 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1633,6 +1633,10 @@ func (s *state) expr(n *Node) *ssa.Value { 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: -- cgit v1.3 From 46ffb026b4ffc5a872a74a4ec3892b8ddad8bd8e Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Sat, 12 Sep 2015 14:06:44 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: OCHECKNIL is a statement, not an expression Change-Id: I5a683f532a5a0b2bc862d80c871e8dc6721016fc Reviewed-on: https://go-review.googlesource.com/14534 Reviewed-by: Brad Fitzpatrick --- src/cmd/compile/internal/gc/ssa.go | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 7da49fc6f0..70350e0e2c 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -772,6 +772,10 @@ func (s *state) stmt(n *Node) { b.AddEdgeTo(bNext) s.startBlock(bNext) + case OCHECKNIL: + p := s.expr(n.Left) + s.nilCheck(p) + default: s.Unimplementedf("unhandled stmt %s", opnames[n.Op]) } @@ -1661,11 +1665,6 @@ func (s *state) expr(n *Node) *ssa.Value { case OADDR: return s.addr(n.Left) - case OCHECKNIL: - p := s.expr(n.Left) - s.nilCheck(p) - return p - 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) -- cgit v1.3 From fda72e03751ab876ced9351611e42ad019090ec8 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Sat, 12 Sep 2015 14:45:58 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: don't treat vardef/varkill as reads This makes deadstore elimination work reasonably again. Change-Id: I3a8caced71f12dfb6c1d0c68b7a7d8d7a736ea23 Reviewed-on: https://go-review.googlesource.com/14536 Reviewed-by: Brad Fitzpatrick --- src/cmd/compile/internal/ssa/deadstore.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/deadstore.go b/src/cmd/compile/internal/ssa/deadstore.go index 982bd7fa70..89f7504341 100644 --- a/src/cmd/compile/internal/ssa/deadstore.go +++ b/src/cmd/compile/internal/ssa/deadstore.go @@ -30,7 +30,7 @@ func dse(f *Func) { for _, a := range v.Args { if a.Block == b && a.Type.IsMemory() { storeUse.add(a.ID) - if v.Op != OpStore && v.Op != OpZero { + 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) -- cgit v1.3 From c7081409bb58edc0fcbccbba230b1667845e94a6 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Thu, 10 Sep 2015 10:01:15 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: fix string index MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Change-Id: I984d3e0410ac38c4e42ae8e3670ea47e2140de76 Reviewed-on: https://go-review.googlesource.com/14466 Reviewed-by: Alexandru Moșoi Reviewed-by: Todd Neal --- src/cmd/compile/internal/gc/ssa.go | 23 ++++++------ src/cmd/compile/internal/gc/testdata/string_ssa.go | 41 ++++++++++++++++++++++ 2 files changed, 54 insertions(+), 10 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 70350e0e2c..0551ddbf08 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1693,19 +1693,22 @@ func (s *state) expr(n *Node) *ssa.Value { a := s.expr(n.Left) i := s.expr(n.Right) i = s.extendIndex(i) - var elemtype *Type - var len *ssa.Value if n.Left.Type.IsString() { - len = s.newValue1(ssa.OpStringLen, Types[TINT], a) - elemtype = Types[TUINT8] + 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()) } else { - len = s.constInt(Types[TINT], n.Left.Type.Bound) - elemtype = n.Left.Type.Type - } - if !n.Bounded { - s.boundsCheck(i, len) + if !n.Bounded { + len := s.constInt(Types[TINT], n.Left.Type.Bound) + s.boundsCheck(i, len) + } + return s.newValue2(ssa.OpArrayIndex, n.Left.Type.Type, a, i) } - return s.newValue2(ssa.OpArrayIndex, elemtype, a, i) } else { // slice p := s.addr(n) return s.newValue2(ssa.OpLoad, n.Left.Type.Type, p, s.mem()) diff --git a/src/cmd/compile/internal/gc/testdata/string_ssa.go b/src/cmd/compile/internal/gc/testdata/string_ssa.go index 448433acd3..0ff6ce1a12 100644 --- a/src/cmd/compile/internal/gc/testdata/string_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/string_ssa.go @@ -70,6 +70,7 @@ func testStructSlice() { p.slice_ssa() if "pre" != p.prefix { println("wrong field slice: wanted %s got %s", "pre", p.prefix) + failed = true } } @@ -114,11 +115,51 @@ func testSmallIndexType() { } } +func testStringElem_ssa(s string, i int) byte { + switch { // prevent inlining + } + 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 + } + } +} + +func testStringElemConst_ssa(i int) byte { + switch { // prevent inlining + } + 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") -- cgit v1.3 From 5505e8ccc74e8e4cbacace0143730a309b1a7655 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Sat, 12 Sep 2015 23:27:26 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: implement slice opcodes Implement OSLICE, OSLICEARR, OSLICESTR, OSLICE3, OSLICE3ARR. reviewer: Ignore the code in OINDEX, that's from CL 14466. Change-Id: I00cc8aecd4c6f40ea5517cd660bb0ce759d91171 Reviewed-on: https://go-review.googlesource.com/14538 Reviewed-by: Todd Neal --- src/cmd/compile/internal/gc/ssa.go | 210 +++++++++++++++------- src/cmd/compile/internal/gc/ssa_test.go | 2 + src/cmd/compile/internal/gc/testdata/array_ssa.go | 147 +++++++++++++++ src/cmd/compile/internal/gc/type.go | 4 + src/cmd/compile/internal/ssa/type.go | 2 + src/cmd/compile/internal/ssa/type_test.go | 2 + 6 files changed, 307 insertions(+), 60 deletions(-) create mode 100644 src/cmd/compile/internal/gc/testdata/array_ssa.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 0551ddbf08..738685b044 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -240,6 +240,9 @@ func (s *state) Unimplementedf(msg string, args ...interface{}) { s.config.Unimp // dummy node for the memory variable var memvar = Node{Op: ONAME, Sym: &Sym{Name: "mem"}} +// dummy nodes for temporary variables +var ptrvar = Node{Op: ONAME, Sym: &Sym{Name: "ptr"}} + // startBlock sets the current block we're generating code in to b. func (s *state) startBlock(b *ssa.Block) { if s.curBlock != nil { @@ -1747,70 +1750,38 @@ func (s *state) expr(n *Node) *ssa.Value { data := s.expr(n.Right) 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: - // Evaluate the string once. - str := s.expr(n.Left) - ptr := s.newValue1(ssa.OpStringPtr, Ptrto(Types[TUINT8]), str) - len := s.newValue1(ssa.OpStringLen, Types[TINT], str) - zero := s.constInt(Types[TINT], 0) - - // Evaluate the slice indexes. - var low, high *ssa.Value - if n.Right.Left == nil { - low = zero - } else { - low = s.extendIndex(s.expr(n.Right.Left)) + 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 { - high = len - } else { - high = s.extendIndex(s.expr(n.Right.Right)) + if n.Right.Right != nil { + j = s.extendIndex(s.expr(n.Right.Right)) } - - // Panic if slice indices are not in bounds. - s.sliceBoundsCheck(low, high) - s.sliceBoundsCheck(high, len) - - // Generate the following code assuming that indexes are in bounds. - // The conditional is to make sure that we don't generate a string - // that points to the next object in memory. - // rlen = (SubPtr high low) - // p = ptr - // if rlen != 0 { - // p = (AddPtr ptr low) - // } - // result = (StringMake p size) - rlen := s.newValue2(ssa.OpSubPtr, Types[TINT], high, low) - - // Use n as the "variable" for p. - s.vars[n] = ptr - - // Generate code to test the resulting slice length. - var cmp *ssa.Value - if s.config.IntSize == 8 { - cmp = s.newValue2(ssa.OpNeq64, Types[TBOOL], rlen, zero) - } else { - cmp = s.newValue2(ssa.OpNeq32, Types[TBOOL], rlen, zero) + 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)) } - - 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) - s.vars[n] = s.newValue2(ssa.OpAddPtr, Ptrto(Types[TUINT8]), ptr, low) - s.endBlock() - - // All done. - merge := s.f.NewBlock(ssa.BlockPlain) - b.AddEdgeTo(merge) - nz.AddEdgeTo(merge) - s.startBlock(merge) - return s.newValue2(ssa.OpStringMake, Types[TSTRING], s.variable(n, Ptrto(Types[TUINT8])), rlen) + 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, OCALLMETH: left := n.Left @@ -2201,6 +2172,125 @@ func (s *state) check(cmp *ssa.Value, panicOp ssa.Op) { s.startBlock(bNext) } +// 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 = (SubPtr j i) + // rcap = (SubPtr k i) + // p = ptr + // if rcap != 0 { + // p = (AddPtr ptr (MulPtr low (ConstPtr size))) + // } + // result = (SliceMake p size) + rlen := s.newValue2(ssa.OpSubPtr, 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(ssa.OpSubPtr, Types[TINT], k, i) + } + + s.vars[&ptrvar] = ptr + + // Generate code to test the resulting slice length. + var cmp *ssa.Value + if s.config.IntSize == 8 { + cmp = s.newValue2(ssa.OpNeq64, Types[TBOOL], rcap, s.constInt(Types[TINT], 0)) + } else { + cmp = s.newValue2(ssa.OpNeq32, 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(ssa.OpMulPtr, Types[TUINTPTR], 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 diff --git a/src/cmd/compile/internal/gc/ssa_test.go b/src/cmd/compile/internal/gc/ssa_test.go index feaea8b463..74415fd560 100644 --- a/src/cmd/compile/internal/gc/ssa_test.go +++ b/src/cmd/compile/internal/gc/ssa_test.go @@ -81,3 +81,5 @@ 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") } 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 0000000000..d7004ff26a --- /dev/null +++ b/src/cmd/compile/internal/gc/testdata/array_ssa.go @@ -0,0 +1,147 @@ +package main + +var failed = false + +func testSliceLenCap12_ssa(a [10]int, i, j int) (int, int) { + switch { // prevent inlining + } + b := a[i:j] + return len(b), cap(b) +} + +func testSliceLenCap1_ssa(a [10]int, i, j int) (int, int) { + switch { // prevent inlining + } + b := a[i:] + return len(b), cap(b) +} + +func testSliceLenCap2_ssa(a [10]int, i, j int) (int, int) { + switch { // prevent inlining + } + 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 + } + } +} + +func testSliceGetElement_ssa(a [10]int, i, j, p int) int { + switch { // prevent inlining + } + 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 + } + } +} + +func testSliceSetElement_ssa(a *[10]int, i, j, p, x int) { + switch { // prevent inlining + } + (*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/type.go b/src/cmd/compile/internal/gc/type.go index cdd9b3f14a..3e07df367d 100644 --- a/src/cmd/compile/internal/gc/type.go +++ b/src/cmd/compile/internal/gc/type.go @@ -84,6 +84,10 @@ 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) IsInterface() bool { return t.Etype == TINTER } diff --git a/src/cmd/compile/internal/ssa/type.go b/src/cmd/compile/internal/ssa/type.go index decde6889e..6800731de6 100644 --- a/src/cmd/compile/internal/ssa/type.go +++ b/src/cmd/compile/internal/ssa/type.go @@ -20,6 +20,7 @@ type Type interface { IsPtr() bool IsString() bool IsSlice() bool + IsArray() bool IsInterface() bool IsMemory() bool // special ssa-package-only types @@ -50,6 +51,7 @@ 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) IsInterface() bool { return false } func (t *CompilerType) IsMemory() bool { return t.Memory } func (t *CompilerType) IsFlags() bool { return t.Flags } diff --git a/src/cmd/compile/internal/ssa/type_test.go b/src/cmd/compile/internal/ssa/type_test.go index b106688e84..f3ac0aec2c 100644 --- a/src/cmd/compile/internal/ssa/type_test.go +++ b/src/cmd/compile/internal/ssa/type_test.go @@ -16,6 +16,7 @@ type TypeImpl struct { Ptr bool string bool slice bool + array bool inter bool Elem_ Type @@ -32,6 +33,7 @@ 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) IsInterface() bool { return t.inter } func (t *TypeImpl) IsMemory() bool { return false } func (t *TypeImpl) IsFlags() bool { return false } -- cgit v1.3 From e3869a6b65bb0f95dac7eca3d86055160b12589f Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Mon, 7 Sep 2015 23:18:02 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: implement write barriers For now, we only use typedmemmove. This can be optimized in future CLs. Also add a feature to help with binary searching bad compilations. Together with GOSSAPKG, GOSSAHASH specifies the last few binary digits of the hash of function names that should be compiled. So GOSSAHASH=0110 means compile only those functions whose last 4 bits of hash are 0110. By adding digits to the front we can binary search for the function whose SSA-generated code is causing a test to fail. Change-Id: I5a8b6b70c6f034f59e5753965234cd42ea36d524 Reviewed-on: https://go-review.googlesource.com/14530 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/builtin.go | 1 + src/cmd/compile/internal/gc/builtin/runtime.go | 1 + src/cmd/compile/internal/gc/ssa.go | 62 ++++++++++++++++++++++++-- src/cmd/compile/internal/gc/ssa_test.go | 1 - src/cmd/dist/test.go | 7 +-- src/cmd/internal/obj/stack.go | 2 +- src/runtime/mbarrier.go | 8 ++++ src/runtime/stack2.go | 4 +- test/nosplit.go | 4 +- 9 files changed, 76 insertions(+), 14 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/builtin.go b/src/cmd/compile/internal/gc/builtin.go index f09dd5690f..0e5fe2ab60 100644 --- a/src/cmd/compile/internal/gc/builtin.go +++ b/src/cmd/compile/internal/gc/builtin.go @@ -118,6 +118,7 @@ const runtimeimport = "" + "func @\"\".writebarrierfat1110 (@\"\".dst·1 *any, _ uintptr, @\"\".src·3 any)\n" + "func @\"\".writebarrierfat1111 (@\"\".dst·1 *any, _ uintptr, @\"\".src·3 any)\n" + "func @\"\".typedmemmove (@\"\".typ·1 *byte, @\"\".dst·2 *any, @\"\".src·3 *any)\n" + + "func @\"\".typedmemmove_nostore (@\"\".typ·1 *byte, @\"\".dst·2 *any)\n" + "func @\"\".typedslicecopy (@\"\".typ·2 *byte, @\"\".dst·3 any, @\"\".src·4 any) (? int)\n" + "func @\"\".selectnbsend (@\"\".chanType·2 *byte, @\"\".hchan·3 chan<- any, @\"\".elem·4 *any) (? bool)\n" + "func @\"\".selectnbrecv (@\"\".chanType·2 *byte, @\"\".elem·3 *any, @\"\".hchan·4 <-chan any) (? bool)\n" + diff --git a/src/cmd/compile/internal/gc/builtin/runtime.go b/src/cmd/compile/internal/gc/builtin/runtime.go index 6210f10cdf..f8487de45b 100644 --- a/src/cmd/compile/internal/gc/builtin/runtime.go +++ b/src/cmd/compile/internal/gc/builtin/runtime.go @@ -147,6 +147,7 @@ func writebarrierfat1111(dst *any, _ uintptr, src any) // *byte is really *runtime.Type func typedmemmove(typ *byte, dst *any, src *any) +func typedmemmove_nostore(typ *byte, dst *any) func typedslicecopy(typ *byte, dst any, src any) int func selectnbsend(chanType *byte, hchan chan<- any, elem *any) bool diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 738685b044..e6a5627abf 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -6,6 +6,7 @@ package gc import ( "bytes" + "crypto/sha1" "fmt" "html" "math" @@ -162,7 +163,28 @@ func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { // TODO: enable codegen more broadly once the codegen stabilizes // and runtime support is in (gc maps, write barriers, etc.) - return s.f, usessa || localpkg.Name == os.Getenv("GOSSAPKG") + if usessa { + return s.f, true + } + if localpkg.Name != os.Getenv("GOSSAPKG") { + return s.f, false + } + if os.Getenv("GOSSAHASH") == "" { + // Use everything in the package + return s.f, true + } + // Check the hash of the name against a partial input hash. + // We use this feature to do a binary search within a package 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, os.Getenv("GOSSAHASH")) { + fmt.Println("GOSSAHASH triggered %s\n", name) + return s.f, true + } + return s.f, false } type state struct { @@ -744,6 +766,7 @@ func (s *state) stmt(n *Node) { fn := call.Left if call.Op != OCALLFUNC { s.Unimplementedf("defer/go of %s", opnames[call.Op]) + return } // Run all argument assignments. The arg slots have already @@ -1852,8 +1875,6 @@ func (s *state) assign(left *Node, right *ssa.Value, wb bool) { if left.Op == ONAME && isblank(left) { return } - // TODO: do write barrier - // if wb t := left.Type dowidth(t) if right == nil { @@ -1880,6 +1901,41 @@ func (s *state) assign(left *Node, right *ssa.Value, wb bool) { s.vars[&memvar] = s.newValue1A(ssa.OpVarDef, ssa.TypeMem, left, s.mem()) } s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, t.Size(), addr, right, s.mem()) + if wb { + // if writeBarrierEnabled { + // typedmemmove_nostore(t, &l) + // } + bThen := s.f.NewBlock(ssa.BlockPlain) + bNext := s.f.NewBlock(ssa.BlockPlain) + + aux := &ssa.ExternSymbol{Types[TBOOL], syslook("writeBarrierEnabled", 0).Sym} + flagaddr := s.newValue1A(ssa.OpAddr, Ptrto(Types[TBOOL]), aux, s.sb) + flag := s.newValue2(ssa.OpLoad, Types[TBOOL], flagaddr, s.mem()) + b := s.endBlock() + b.Kind = ssa.BlockIf + b.Likely = ssa.BranchUnlikely + b.Control = flag + b.AddEdgeTo(bThen) + b.AddEdgeTo(bNext) + + s.startBlock(bThen) + // NOTE: there must be no GC suspension points between the write above + // (the OpStore) and this call to typedmemmove_nostore. + // TODO: writebarrierptr_nostore if just one pointer word (or a few?) + taddr := s.newValue1A(ssa.OpAddr, Types[TUINTPTR], &ssa.ExternSymbol{Types[TUINTPTR], typenamesym(left.Type)}, s.sb) + s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), s.sp, taddr, s.mem()) + spplus8 := s.newValue1I(ssa.OpOffPtr, Types[TUINTPTR], int64(Widthptr), s.sp) + s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), spplus8, addr, s.mem()) + call := s.newValue1A(ssa.OpStaticCall, ssa.TypeMem, syslook("typedmemmove_nostore", 0).Sym, s.mem()) + call.AuxInt = int64(2 * Widthptr) + s.vars[&memvar] = call + c := s.endBlock() + c.Kind = ssa.BlockCall + c.Control = call + c.AddEdgeTo(bNext) + + s.startBlock(bNext) + } } // zeroVal returns the zero value for type t. diff --git a/src/cmd/compile/internal/gc/ssa_test.go b/src/cmd/compile/internal/gc/ssa_test.go index 74415fd560..b3ab09d914 100644 --- a/src/cmd/compile/internal/gc/ssa_test.go +++ b/src/cmd/compile/internal/gc/ssa_test.go @@ -31,7 +31,6 @@ func doTest(t *testing.T, filename string, kind string) { cmd := exec.Command("go", kind, filepath.Join("testdata", filename)) cmd.Stdout = &stdout cmd.Stderr = &stderr - // TODO: set GOGC=off until we have stackmaps if err := cmd.Run(); err != nil { t.Fatalf("Failed: %v:\nOut: %s\nStderr: %s\n", err, &stdout, &stderr) } diff --git a/src/cmd/dist/test.go b/src/cmd/dist/test.go index d80547ed1c..5f8afd0cb3 100644 --- a/src/cmd/dist/test.go +++ b/src/cmd/dist/test.go @@ -277,11 +277,6 @@ func (t *tester) registerStdTest(pkg string) { // TODO: Remove when SSA codegen is used by default. func (t *tester) registerSSATest(pkg string) { - switch pkg { - // known failures due to GOGC=off - case "runtime", "runtime/pprof", "runtime/trace", "sync": - return - } t.tests = append(t.tests, distTest{ name: "go_test_ssa:" + pkg, heading: "Testing packages with SSA codegen.", @@ -297,7 +292,7 @@ func (t *tester) registerSSATest(pkg string) { } args = append(args, pkg) cmd := exec.Command("go", args...) - cmd.Env = mergeEnvLists([]string{"GOSSAPKG=" + path.Base(pkg), "GOGC=off"}, os.Environ()) + cmd.Env = mergeEnvLists([]string{"GOSSAPKG=" + path.Base(pkg)}, os.Environ()) cmd.Stdout = os.Stdout cmd.Stderr = os.Stderr return cmd.Run() diff --git a/src/cmd/internal/obj/stack.go b/src/cmd/internal/obj/stack.go index 87698b3eeb..b1630b55fc 100644 --- a/src/cmd/internal/obj/stack.go +++ b/src/cmd/internal/obj/stack.go @@ -41,7 +41,7 @@ const ( STACKSYSTEM = 0 StackSystem = STACKSYSTEM StackBig = 4096 - StackGuard = 640*stackGuardMultiplier + StackSystem + StackGuard = 960*stackGuardMultiplier + StackSystem StackSmall = 128 StackLimit = StackGuard - StackSystem - StackSmall ) diff --git a/src/runtime/mbarrier.go b/src/runtime/mbarrier.go index 0dbe1ffc9d..c94e44f142 100644 --- a/src/runtime/mbarrier.go +++ b/src/runtime/mbarrier.go @@ -185,6 +185,14 @@ func typedmemmove(typ *_type, dst, src unsafe.Pointer) { heapBitsBulkBarrier(uintptr(dst), typ.size) } +//go:nosplit +func typedmemmove_nostore(typ *_type, dst unsafe.Pointer) { + if typ.kind&kindNoPointers != 0 { + return + } + heapBitsBulkBarrier(uintptr(dst), typ.size) +} + //go:linkname reflect_typedmemmove reflect.typedmemmove func reflect_typedmemmove(typ *_type, dst, src unsafe.Pointer) { typedmemmove(typ, dst, src) diff --git a/src/runtime/stack2.go b/src/runtime/stack2.go index 5ec8d8d060..02b82ebe13 100644 --- a/src/runtime/stack2.go +++ b/src/runtime/stack2.go @@ -54,6 +54,8 @@ The linkers explore all possible call traces involving non-splitting functions to make sure that this limit cannot be violated. */ +// Constants here match those in cmd/internal/obj/stack.go. + const ( // StackSystem is a number of additional bytes to add // to each stack below the usual guard area for OS-specific @@ -84,7 +86,7 @@ const ( // The stack guard is a pointer this many bytes above the // bottom of the stack. - _StackGuard = 640*stackGuardMultiplier + _StackSystem + _StackGuard = 960*stackGuardMultiplier + _StackSystem // After a stack split check the SP is allowed to be this // many bytes below the stack guard. This saves an instruction diff --git a/test/nosplit.go b/test/nosplit.go index e5c2a9f30e..e7c00f5783 100644 --- a/test/nosplit.go +++ b/test/nosplit.go @@ -285,12 +285,12 @@ TestCases: // Instead of rewriting the test cases above, adjust // the first stack frame to use up the extra bytes. if i == 0 { - size += 512 - 128 + size += 832 - 128 // Noopt builds have a larger stackguard. // See ../cmd/dist/buildruntime.go:stackGuardMultiplier for _, s := range strings.Split(os.Getenv("GO_GCFLAGS"), " ") { if s == "-N" { - size += 640 + size += 960 } } } -- cgit v1.3 From cde977c23cbf5fb29f12bcbca5164530d0256019 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Tue, 15 Sep 2015 09:02:07 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: fix sign extension + load combo Load-and-sign-extend opcodes were being generated in the wrong block, leading to having more than one memory variable live at once. Fix the rules + add a test. Change-Id: Iadf80e55ea901549c15c628ae295c2d0f1f64525 Reviewed-on: https://go-review.googlesource.com/14591 Reviewed-by: Todd Neal Run-TryBot: Todd Neal --- .../compile/internal/gc/testdata/loadstore_ssa.go | 21 ++++++++++++++++ src/cmd/compile/internal/ssa/gen/AMD64.rules | 10 ++++++-- src/cmd/compile/internal/ssa/regalloc.go | 28 ++++++++++++++++++++++ src/cmd/compile/internal/ssa/rewriteAMD64.go | 22 ++++++++++------- 4 files changed, 71 insertions(+), 10 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/testdata/loadstore_ssa.go b/src/cmd/compile/internal/gc/testdata/loadstore_ssa.go index cf37095742..e986f53bc6 100644 --- a/src/cmd/compile/internal/gc/testdata/loadstore_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/loadstore_ssa.go @@ -57,10 +57,31 @@ func testStoreSize_ssa(p *uint16, q *uint16, v uint32) { 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 + } +} + func main() { testLoadStoreOrder() testStoreSize() + testExtStore() if failed { panic("failed") diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 0591e8f8ef..5f34f76eda 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -474,8 +474,14 @@ (SETNE (InvertFlags x)) -> (SETNE x) // sign extended loads -(MOVBQSX (MOVBload [off] {sym} ptr mem)) -> (MOVBQSXload [off] {sym} ptr mem) -(MOVBQZX (MOVBload [off] {sym} ptr mem)) -> (MOVBQZXload [off] {sym} ptr mem) +// 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. +// TODO: somehow have this rewrite rule put the new MOVBQSXload in +// v.Args[0].Block instead of in v.Block? +(MOVBQSX (MOVBload [off] {sym} ptr mem)) && b == v.Args[0].Block -> (MOVBQSXload [off] {sym} ptr mem) +(MOVBQZX (MOVBload [off] {sym} ptr mem)) && b == v.Args[0].Block -> (MOVBQZXload [off] {sym} ptr mem) // TODO: more // Don't extend before storing diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index 3122c7a130..f529b42fe0 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -1046,5 +1046,33 @@ func (f *Func) live() [][][]ID { break } } + + // Make sure that there is only one live memory variable in each set. + // Ideally we should check this at every instructiom, but at every + // edge seems good enough for now. + isMem := make([]bool, f.NumValues()) + for _, b := range f.Blocks { + for _, v := range b.Values { + isMem[v.ID] = v.Type.IsMemory() + } + } + for _, b := range f.Blocks { + for i, c := range b.Succs { + nmem := 0 + for _, id := range live[b.ID][i] { + if isMem[id] { + nmem++ + } + } + if nmem > 1 { + f.Fatalf("more than one mem live on edge %v->%v: %v", b, c, live[b.ID][i]) + } + // TODO: figure out why we get nmem==0 occasionally. + //if nmem == 0 { + // f.Fatalf("no mem live on edge %v->%v: %v", b, c, live[b.ID][i]) + //} + } + } + return live } diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index cb6405d44d..d2f5ca8f32 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -3939,16 +3939,19 @@ func rewriteValueAMD64(v *Value, config *Config) bool { ; case OpAMD64MOVBQSX: // match: (MOVBQSX (MOVBload [off] {sym} ptr mem)) - // cond: + // cond: b == v.Args[0].Block // result: (MOVBQSXload [off] {sym} ptr mem) { if v.Args[0].Op != OpAMD64MOVBload { - goto end9de452216bde3b2e2a2d01f43da1f78e + goto end4fcdab76af223d4a6b942b532ebf860b } off := v.Args[0].AuxInt sym := v.Args[0].Aux ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] + if !(b == v.Args[0].Block) { + goto end4fcdab76af223d4a6b942b532ebf860b + } v.Op = OpAMD64MOVBQSXload v.AuxInt = 0 v.Aux = nil @@ -3959,21 +3962,24 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto end9de452216bde3b2e2a2d01f43da1f78e - end9de452216bde3b2e2a2d01f43da1f78e: + goto end4fcdab76af223d4a6b942b532ebf860b + end4fcdab76af223d4a6b942b532ebf860b: ; case OpAMD64MOVBQZX: // match: (MOVBQZX (MOVBload [off] {sym} ptr mem)) - // cond: + // cond: b == v.Args[0].Block // result: (MOVBQZXload [off] {sym} ptr mem) { if v.Args[0].Op != OpAMD64MOVBload { - goto end573f4e6a6fe8032338b85fddd4d1bab4 + goto endce35c966b0a38aa124a610e5616a220c } off := v.Args[0].AuxInt sym := v.Args[0].Aux ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] + if !(b == v.Args[0].Block) { + goto endce35c966b0a38aa124a610e5616a220c + } v.Op = OpAMD64MOVBQZXload v.AuxInt = 0 v.Aux = nil @@ -3984,8 +3990,8 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto end573f4e6a6fe8032338b85fddd4d1bab4 - end573f4e6a6fe8032338b85fddd4d1bab4: + goto endce35c966b0a38aa124a610e5616a220c + endce35c966b0a38aa124a610e5616a220c: ; case OpAMD64MOVBload: // match: (MOVBload [off1] {sym} (ADDQconst [off2] ptr) mem) -- cgit v1.3 From 6793cb755c01c4e5fa074518281ccb6abda61b54 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Tue, 15 Sep 2015 15:39:47 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: turn off runtime ssa tests Fixes build. Not great, but it will let others make progress. Change-Id: If9cf2bbb5016e40aa91cf1c8bb62982ae2aed5e4 Reviewed-on: https://go-review.googlesource.com/14621 Reviewed-by: Keith Randall --- src/cmd/dist/test.go | 5 +++++ 1 file changed, 5 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/dist/test.go b/src/cmd/dist/test.go index 5f8afd0cb3..2cc4610595 100644 --- a/src/cmd/dist/test.go +++ b/src/cmd/dist/test.go @@ -277,6 +277,11 @@ func (t *tester) registerStdTest(pkg string) { // TODO: Remove when SSA codegen is used by default. func (t *tester) registerSSATest(pkg string) { + switch pkg { + // known failures + case "runtime": + return + } t.tests = append(t.tests, distTest{ name: "go_test_ssa:" + pkg, heading: "Testing packages with SSA codegen.", -- cgit v1.3 From 9d22c101f58dd8f65410fb352562b91de5fbcb7a Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Fri, 11 Sep 2015 11:02:57 -0700 Subject: [dev.ssa] cmd/compile/internal/gc: implement OAPPEND Change-Id: I1fbce8c421c48074a964b4d9481c92fbc3524f80 Reviewed-on: https://go-review.googlesource.com/14525 Reviewed-by: Todd Neal --- src/cmd/compile/internal/gc/ssa.go | 182 +++++++++++++++++---- src/cmd/compile/internal/gc/ssa_test.go | 2 + src/cmd/compile/internal/gc/testdata/append_ssa.go | 71 ++++++++ 3 files changed, 221 insertions(+), 34 deletions(-) create mode 100644 src/cmd/compile/internal/gc/testdata/append_ssa.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index e6a5627abf..5cd074b0c6 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -181,7 +181,7 @@ func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { hstr += fmt.Sprintf("%08b", b) } if strings.HasSuffix(hstr, os.Getenv("GOSSAHASH")) { - fmt.Println("GOSSAHASH triggered %s\n", name) + fmt.Printf("GOSSAHASH triggered %s\n", name) return s.f, true } return s.f, false @@ -264,6 +264,7 @@ var memvar = Node{Op: ONAME, Sym: &Sym{Name: "mem"}} // dummy nodes for temporary variables var ptrvar = Node{Op: ONAME, Sym: &Sym{Name: "ptr"}} +var capvar = Node{Op: ONAME, Sym: &Sym{Name: "cap"}} // startBlock sets the current block we're generating code in to b. func (s *state) startBlock(b *ssa.Block) { @@ -560,6 +561,16 @@ func (s *state) stmt(n *Node) { if n.Right != nil { r = s.expr(n.Right) } + if n.Right != nil && n.Right.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. + s.assign(n.Left, r, true) + return + } s.assign(n.Left, r, n.Op == OASWB) case OIF: @@ -1865,6 +1876,103 @@ func (s *state) expr(n *Node) *ssa.Value { case OGETG: return s.newValue0(ssa.OpGetG, n.Type) + 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) + + // Evaluate args + nargs := int64(count(n.List) - 1) + args := make([]*ssa.Value, 0, nargs) + for l := n.List.Next; l != nil; l = l.Next { + args = append(args, s.expr(l.N)) + } + + // Allocate new blocks + grow := s.f.NewBlock(ssa.BlockPlain) + growresult := s.f.NewBlock(ssa.BlockPlain) + assign := s.f.NewBlock(ssa.BlockPlain) + + // Decide if we need to grow + 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) + + spplus1 := s.newValue1I(ssa.OpOffPtr, Types[TUINTPTR], int64(Widthptr), s.sp) + spplus2 := s.newValue1I(ssa.OpOffPtr, Types[TUINTPTR], int64(2*Widthptr), s.sp) + spplus3 := s.newValue1I(ssa.OpOffPtr, Types[TUINTPTR], int64(3*Widthptr), s.sp) + spplus4 := s.newValue1I(ssa.OpOffPtr, Types[TUINTPTR], int64(4*Widthptr), s.sp) + s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), s.sp, taddr, s.mem()) + s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), spplus1, p, s.mem()) + s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), spplus2, l, s.mem()) + s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), spplus3, c, s.mem()) + s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), spplus4, nl, s.mem()) + call := s.newValue1A(ssa.OpStaticCall, ssa.TypeMem, syslook("growslice", 0).Sym, s.mem()) + call.AuxInt = int64(8 * Widthptr) + s.vars[&memvar] = call + b = s.endBlock() + b.Kind = ssa.BlockCall + b.Control = call + b.AddEdgeTo(growresult) + + // Read result of growslice + s.startBlock(growresult) + spplus5 := s.newValue1I(ssa.OpOffPtr, Types[TUINTPTR], int64(5*Widthptr), s.sp) + // Note: we don't need to read the result's length. + spplus7 := s.newValue1I(ssa.OpOffPtr, Types[TUINTPTR], int64(7*Widthptr), s.sp) + s.vars[&ptrvar] = s.newValue2(ssa.OpLoad, pt, spplus5, s.mem()) + s.vars[&capvar] = s.newValue2(ssa.OpLoad, Types[TINT], spplus7, s.mem()) + b = s.endBlock() + b.AddEdgeTo(assign) + + // assign new elements to slots + s.startBlock(assign) + 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) + for i, arg := range args { + addr := s.newValue2(ssa.OpPtrIndex, pt, p2, s.constInt(Types[TUINTPTR], int64(i))) + s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, et.Size(), addr, arg, s.mem()) + if haspointers(et) { + // TODO: just one write barrier call for all of these writes? + // TODO: maybe just one writeBarrierEnabled check? + s.insertWB(et, addr) + } + } + + // make result + r := s.newValue3(ssa.OpSliceMake, n.Type, p, nl, c) + delete(s.vars, &ptrvar) + delete(s.vars, &capvar) + return r + default: s.Unimplementedf("unhandled expr %s", opnames[n.Op]) return nil @@ -1902,39 +2010,7 @@ func (s *state) assign(left *Node, right *ssa.Value, wb bool) { } s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, t.Size(), addr, right, s.mem()) if wb { - // if writeBarrierEnabled { - // typedmemmove_nostore(t, &l) - // } - bThen := s.f.NewBlock(ssa.BlockPlain) - bNext := s.f.NewBlock(ssa.BlockPlain) - - aux := &ssa.ExternSymbol{Types[TBOOL], syslook("writeBarrierEnabled", 0).Sym} - flagaddr := s.newValue1A(ssa.OpAddr, Ptrto(Types[TBOOL]), aux, s.sb) - flag := s.newValue2(ssa.OpLoad, Types[TBOOL], flagaddr, s.mem()) - b := s.endBlock() - b.Kind = ssa.BlockIf - b.Likely = ssa.BranchUnlikely - b.Control = flag - b.AddEdgeTo(bThen) - b.AddEdgeTo(bNext) - - s.startBlock(bThen) - // NOTE: there must be no GC suspension points between the write above - // (the OpStore) and this call to typedmemmove_nostore. - // TODO: writebarrierptr_nostore if just one pointer word (or a few?) - taddr := s.newValue1A(ssa.OpAddr, Types[TUINTPTR], &ssa.ExternSymbol{Types[TUINTPTR], typenamesym(left.Type)}, s.sb) - s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), s.sp, taddr, s.mem()) - spplus8 := s.newValue1I(ssa.OpOffPtr, Types[TUINTPTR], int64(Widthptr), s.sp) - s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), spplus8, addr, s.mem()) - call := s.newValue1A(ssa.OpStaticCall, ssa.TypeMem, syslook("typedmemmove_nostore", 0).Sym, s.mem()) - call.AuxInt = int64(2 * Widthptr) - s.vars[&memvar] = call - c := s.endBlock() - c.Kind = ssa.BlockCall - c.Control = call - c.AddEdgeTo(bNext) - - s.startBlock(bNext) + s.insertWB(left.Type, addr) } } @@ -2228,6 +2304,44 @@ func (s *state) check(cmp *ssa.Value, panicOp ssa.Op) { s.startBlock(bNext) } +// insertWB inserts a write barrier. A value of type t has already +// been stored at location p. Tell the runtime about this write. +// Note: there must be no GC suspension points between the write and +// the call that this function inserts. +func (s *state) insertWB(t *Type, p *ssa.Value) { + // if writeBarrierEnabled { + // typedmemmove_nostore(&t, p) + // } + bThen := s.f.NewBlock(ssa.BlockPlain) + bNext := s.f.NewBlock(ssa.BlockPlain) + + aux := &ssa.ExternSymbol{Types[TBOOL], syslook("writeBarrierEnabled", 0).Sym} + flagaddr := s.newValue1A(ssa.OpAddr, Ptrto(Types[TBOOL]), aux, s.sb) + flag := s.newValue2(ssa.OpLoad, Types[TBOOL], flagaddr, s.mem()) + b := s.endBlock() + b.Kind = ssa.BlockIf + b.Likely = ssa.BranchUnlikely + b.Control = flag + b.AddEdgeTo(bThen) + b.AddEdgeTo(bNext) + + s.startBlock(bThen) + // TODO: writebarrierptr_nostore if just one pointer word (or a few?) + taddr := s.newValue1A(ssa.OpAddr, Types[TUINTPTR], &ssa.ExternSymbol{Types[TUINTPTR], typenamesym(t)}, s.sb) + s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), s.sp, taddr, s.mem()) + spplus8 := s.newValue1I(ssa.OpOffPtr, Types[TUINTPTR], int64(Widthptr), s.sp) + s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), spplus8, p, s.mem()) + call := s.newValue1A(ssa.OpStaticCall, ssa.TypeMem, syslook("typedmemmove_nostore", 0).Sym, s.mem()) + call.AuxInt = int64(2 * Widthptr) + s.vars[&memvar] = call + c := s.endBlock() + c.Kind = ssa.BlockCall + c.Control = call + c.AddEdgeTo(bNext) + + s.startBlock(bNext) +} + // 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. diff --git a/src/cmd/compile/internal/gc/ssa_test.go b/src/cmd/compile/internal/gc/ssa_test.go index b3ab09d914..bbd06748b1 100644 --- a/src/cmd/compile/internal/gc/ssa_test.go +++ b/src/cmd/compile/internal/gc/ssa_test.go @@ -82,3 +82,5 @@ func TestDeferNoReturn(t *testing.T) { buildTest(t, "deferNoReturn_ssa.go") } 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") } 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 0000000000..dba81736c8 --- /dev/null +++ b/src/cmd/compile/internal/gc/testdata/append_ssa.go @@ -0,0 +1,71 @@ +// 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 + +func appendOne_ssa(a []int, x int) []int { + switch { // prevent inlining + } + return append(a, x) +} +func appendThree_ssa(a []int, x, y, z int) []int { + switch { // prevent inlining + } + 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") + } +} -- cgit v1.3 From 1e4ebfdda59f9e5df4bfb5edf3827a9393c1c4de Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Thu, 10 Sep 2015 13:53:27 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: fix iface and slice comparisons A simpler way to do iface/slice comparisons. Fixes some cases of failed lowerings. Change-Id: Ia252bc8648293a2d460f63c41f1591785543a1e9 Reviewed-on: https://go-review.googlesource.com/14493 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/gc/ssa.go | 9 +- src/cmd/compile/internal/ssa/gen/generic.rules | 13 ++- src/cmd/compile/internal/ssa/gen/genericOps.go | 20 ++-- src/cmd/compile/internal/ssa/opGen.go | 18 +++- src/cmd/compile/internal/ssa/rewritegeneric.go | 142 ++++++++++++------------- 5 files changed, 103 insertions(+), 99 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 5cd074b0c6..30c3f2f88c 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -950,8 +950,8 @@ var opToSSA = map[opAndType]ssa.Op{ opAndType{OEQ, TUINT32}: ssa.OpEq32, opAndType{OEQ, TINT64}: ssa.OpEq64, opAndType{OEQ, TUINT64}: ssa.OpEq64, - opAndType{OEQ, TINTER}: ssa.OpEqFat, // e == nil only - opAndType{OEQ, TARRAY}: ssa.OpEqFat, // slice only; a == nil only + 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, @@ -970,8 +970,8 @@ var opToSSA = map[opAndType]ssa.Op{ opAndType{ONE, TUINT32}: ssa.OpNeq32, opAndType{ONE, TINT64}: ssa.OpNeq64, opAndType{ONE, TUINT64}: ssa.OpNeq64, - opAndType{ONE, TINTER}: ssa.OpNeqFat, // e != nil only - opAndType{ONE, TARRAY}: ssa.OpNeqFat, // slice only; a != nil only + 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, @@ -1522,7 +1522,6 @@ func (s *state) expr(n *Node) *ssa.Value { 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: diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index b704014287..f54496e8a8 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -66,13 +66,12 @@ (EqPtr (ConstNil) p) -> (Not (IsNonNil p)) // slice and interface comparisons -// the frontend ensures that we can only compare against nil -// start by putting nil on the right to simplify the other rules -(EqFat x y) && x.Op == OpConstNil && y.Op != OpConstNil -> (EqFat y x) -(NeqFat x y) && x.Op == OpConstNil && y.Op != OpConstNil -> (NeqFat y x) -// it suffices to check the first word (backing array for slices, dynamic type for interfaces) -(EqFat (Load ptr mem) (ConstNil)) -> (EqPtr (Load ptr mem) (ConstPtr [0])) -(NeqFat (Load ptr mem) (ConstNil)) -> (NeqPtr (Load ptr mem) (ConstPtr [0])) +// 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)) // indexing operations // Note: bounds check has already been done diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index dcaff959c3..71683c16bd 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -160,7 +160,8 @@ var genericOps = []opData{ {name: "Eq32"}, {name: "Eq64"}, {name: "EqPtr"}, - {name: "EqFat"}, // slice/interface; arg0 or arg1 is nil; other cases handled by frontend + {name: "EqInter"}, // arg0 or arg1 is nil; other cases handled by frontend + {name: "EqSlice"}, // arg0 or arg1 is nil; other cases handled by frontend {name: "Eq32F"}, {name: "Eq64F"}, @@ -169,7 +170,8 @@ var genericOps = []opData{ {name: "Neq32"}, {name: "Neq64"}, {name: "NeqPtr"}, - {name: "NeqFat"}, // slice/interface; arg0 or arg1 is nil; other cases handled by frontend + {name: "NeqInter"}, // arg0 or arg1 is nil; other cases handled by frontend + {name: "NeqSlice"}, // arg0 or arg1 is nil; other cases handled by frontend {name: "Neq32F"}, {name: "Neq64F"}, @@ -334,10 +336,10 @@ var genericOps = []opData{ {name: "StructSelect"}, // arg0=struct, auxint=field offset. Returns field at that offset (size=size of result type) // Slices - {name: "SliceMake"}, // arg0=ptr, arg1=len, arg2=cap - {name: "SlicePtr"}, // ptr(arg0) - {name: "SliceLen"}, // len(arg0) - {name: "SliceCap"}, // cap(arg0) + {name: "SliceMake"}, // arg0=ptr, arg1=len, arg2=cap + {name: "SlicePtr", typ: "Uintptr"}, // ptr(arg0) + {name: "SliceLen"}, // len(arg0) + {name: "SliceCap"}, // cap(arg0) // Complex (part/whole) {name: "ComplexMake"}, // arg0=real, arg1=imag @@ -350,9 +352,9 @@ var genericOps = []opData{ {name: "StringLen"}, // len(arg0) // Interfaces - {name: "IMake"}, // arg0=itab, arg1=data - {name: "ITab"}, // arg0=interface, returns itable field - {name: "IData"}, // arg0=interface, returns data field + {name: "IMake"}, // arg0=itab, arg1=data + {name: "ITab", typ: "Uintptr"}, // arg0=interface, returns itable field + {name: "IData"}, // arg0=interface, returns data field // Spill&restore ops for the register allocator. These are // semantically identical to OpCopy; they do not take/return diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index f7f1ca3068..0a7e8c75c7 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -387,7 +387,8 @@ const ( OpEq32 OpEq64 OpEqPtr - OpEqFat + OpEqInter + OpEqSlice OpEq32F OpEq64F OpNeq8 @@ -395,7 +396,8 @@ const ( OpNeq32 OpNeq64 OpNeqPtr - OpNeqFat + OpNeqInter + OpNeqSlice OpNeq32F OpNeq64F OpLess8 @@ -3576,7 +3578,11 @@ var opcodeTable = [...]opInfo{ generic: true, }, { - name: "EqFat", + name: "EqInter", + generic: true, + }, + { + name: "EqSlice", generic: true, }, { @@ -3608,7 +3614,11 @@ var opcodeTable = [...]opInfo{ generic: true, }, { - name: "NeqFat", + name: "NeqInter", + generic: true, + }, + { + name: "NeqSlice", generic: true, }, { diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index 0334c0cd95..afca4cfed9 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -427,56 +427,29 @@ func rewriteValuegeneric(v *Value, config *Config) bool { goto enda66da0d3e7e51624ee46527727c48a9a enda66da0d3e7e51624ee46527727c48a9a: ; - case OpEqFat: - // match: (EqFat x y) - // cond: x.Op == OpConstNil && y.Op != OpConstNil - // result: (EqFat y x) + case OpEqInter: + // match: (EqInter x y) + // cond: + // result: (EqPtr (ITab x) (ITab y)) { x := v.Args[0] y := v.Args[1] - if !(x.Op == OpConstNil && y.Op != OpConstNil) { - goto endcea7f7399afcff860c54d82230a9a934 - } - v.Op = OpEqFat - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(y) - v.AddArg(x) - return true - } - goto endcea7f7399afcff860c54d82230a9a934 - endcea7f7399afcff860c54d82230a9a934: - ; - // match: (EqFat (Load ptr mem) (ConstNil)) - // cond: - // result: (EqPtr (Load ptr mem) (ConstPtr [0])) - { - if v.Args[0].Op != OpLoad { - goto end6f10fb57a906a2c23667c770acb6abf9 - } - ptr := v.Args[0].Args[0] - mem := v.Args[0].Args[1] - if v.Args[1].Op != OpConstNil { - goto end6f10fb57a906a2c23667c770acb6abf9 - } v.Op = OpEqPtr v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpLoad, TypeInvalid) + v0 := b.NewValue0(v.Line, OpITab, TypeInvalid) + v0.AddArg(x) v0.Type = config.fe.TypeUintptr() - v0.AddArg(ptr) - v0.AddArg(mem) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpConstPtr, TypeInvalid) - v1.AuxInt = 0 + v1 := b.NewValue0(v.Line, OpITab, TypeInvalid) + v1.AddArg(y) v1.Type = config.fe.TypeUintptr() v.AddArg(v1) return true } - goto end6f10fb57a906a2c23667c770acb6abf9 - end6f10fb57a906a2c23667c770acb6abf9: + goto endfcedc545b9bbbe3790786c8981b12d32 + endfcedc545b9bbbe3790786c8981b12d32: ; case OpEqPtr: // match: (EqPtr p (ConstNil)) @@ -521,6 +494,30 @@ func rewriteValuegeneric(v *Value, config *Config) bool { goto end7cdc0d5c38fbffe6287c8928803b038e end7cdc0d5c38fbffe6287c8928803b038e: ; + case OpEqSlice: + // match: (EqSlice x y) + // cond: + // result: (EqPtr (SlicePtr x) (SlicePtr y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpEqPtr + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpSlicePtr, TypeInvalid) + v0.AddArg(x) + v0.Type = config.fe.TypeUintptr() + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpSlicePtr, TypeInvalid) + v1.AddArg(y) + v1.Type = config.fe.TypeUintptr() + v.AddArg(v1) + return true + } + goto end2937092dca53f896cd527e59e92cab1d + end2937092dca53f896cd527e59e92cab1d: + ; case OpIData: // match: (IData (IMake _ data)) // cond: @@ -953,56 +950,29 @@ func rewriteValuegeneric(v *Value, config *Config) bool { goto end09a0deaf3c42627d0d2d3efa96e30745 end09a0deaf3c42627d0d2d3efa96e30745: ; - case OpNeqFat: - // match: (NeqFat x y) - // cond: x.Op == OpConstNil && y.Op != OpConstNil - // result: (NeqFat y x) + case OpNeqInter: + // match: (NeqInter x y) + // cond: + // result: (NeqPtr (ITab x) (ITab y)) { x := v.Args[0] y := v.Args[1] - if !(x.Op == OpConstNil && y.Op != OpConstNil) { - goto end94c68f7dc30c66ed42e507e01c4e5dc7 - } - v.Op = OpNeqFat - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(y) - v.AddArg(x) - return true - } - goto end94c68f7dc30c66ed42e507e01c4e5dc7 - end94c68f7dc30c66ed42e507e01c4e5dc7: - ; - // match: (NeqFat (Load ptr mem) (ConstNil)) - // cond: - // result: (NeqPtr (Load ptr mem) (ConstPtr [0])) - { - if v.Args[0].Op != OpLoad { - goto end3ffd7685735a83eaee8dc2577ae89d79 - } - ptr := v.Args[0].Args[0] - mem := v.Args[0].Args[1] - if v.Args[1].Op != OpConstNil { - goto end3ffd7685735a83eaee8dc2577ae89d79 - } v.Op = OpNeqPtr v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpLoad, TypeInvalid) + v0 := b.NewValue0(v.Line, OpITab, TypeInvalid) + v0.AddArg(x) v0.Type = config.fe.TypeUintptr() - v0.AddArg(ptr) - v0.AddArg(mem) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpConstPtr, TypeInvalid) - v1.AuxInt = 0 + v1 := b.NewValue0(v.Line, OpITab, TypeInvalid) + v1.AddArg(y) v1.Type = config.fe.TypeUintptr() v.AddArg(v1) return true } - goto end3ffd7685735a83eaee8dc2577ae89d79 - end3ffd7685735a83eaee8dc2577ae89d79: + goto end17b2333bf57e9fe81a671be02f9c4c14 + end17b2333bf57e9fe81a671be02f9c4c14: ; case OpNeqPtr: // match: (NeqPtr p (ConstNil)) @@ -1041,6 +1011,30 @@ func rewriteValuegeneric(v *Value, config *Config) bool { goto enddd95e9c3606d9fd48034f1a703561e45 enddd95e9c3606d9fd48034f1a703561e45: ; + case OpNeqSlice: + // match: (NeqSlice x y) + // cond: + // result: (NeqPtr (SlicePtr x) (SlicePtr y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpNeqPtr + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpSlicePtr, TypeInvalid) + v0.AddArg(x) + v0.Type = config.fe.TypeUintptr() + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpSlicePtr, TypeInvalid) + v1.AddArg(y) + v1.Type = config.fe.TypeUintptr() + v.AddArg(v1) + return true + } + goto endc6bc83c506e491236ca66ea1081231a2 + endc6bc83c506e491236ca66ea1081231a2: + ; case OpOr16: // match: (Or16 x x) // cond: -- cgit v1.3 From d24768e14df109fb04a89ba0037dc6069fa60810 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Wed, 9 Sep 2015 23:56:59 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: complete call ops OCALLINTER, as well as ODEFER/OPROC with OCALLMETH/OCALLINTER. Move all the call logic to its own routine, a lot of the code is shared. Change-Id: Ieac59596165e434cc6d1d7b5e46b78957e9c5ed3 Reviewed-on: https://go-review.googlesource.com/14464 Reviewed-by: Todd Neal Reviewed-by: David Chase --- src/cmd/compile/internal/gc/ssa.go | 233 +++++++++++++++---------- src/cmd/compile/internal/ssa/gen/AMD64.rules | 1 + src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 1 + src/cmd/compile/internal/ssa/gen/genericOps.go | 1 + src/cmd/compile/internal/ssa/opGen.go | 15 ++ src/cmd/compile/internal/ssa/rewriteAMD64.go | 20 +++ 6 files changed, 178 insertions(+), 93 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 30c3f2f88c..c2d2f8be4d 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -468,7 +468,11 @@ func (s *state) stmt(n *Node) { // Expression statements case OCALLFUNC, OCALLMETH, OCALLINTER: - s.expr(n) + s.call(n, callNormal) + case ODEFER: + s.call(n.Left, callDefer) + case OPROC: + s.call(n.Left, callGo) case ODCL: if n.Left.Class&PHEAP == 0 { @@ -772,43 +776,6 @@ func (s *state) stmt(n *Node) { // with respect to call ops. s.vars[&memvar] = s.newValue1A(ssa.OpVarKill, ssa.TypeMem, n.Left, s.mem()) - case OPROC, ODEFER: - call := n.Left - fn := call.Left - if call.Op != OCALLFUNC { - s.Unimplementedf("defer/go of %s", opnames[call.Op]) - return - } - - // Run all argument assignments. The arg slots have already - // been offset by 2*widthptr. - s.stmtList(call.List) - - // Write argsize and closure (args to Newproc/Deferproc) - argsize := s.constInt32(Types[TUINT32], int32(fn.Type.Argwid)) - s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, 4, s.sp, argsize, s.mem()) - closure := s.expr(fn) - 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()) - - // Call deferproc or newproc - bNext := s.f.NewBlock(ssa.BlockPlain) - var op ssa.Op - switch n.Op { - case ODEFER: - op = ssa.OpDeferCall - case OPROC: - op = ssa.OpGoCall - } - r := s.newValue1(op, ssa.TypeMem, s.mem()) - r.AuxInt = fn.Type.Argwid + 2*int64(Widthptr) // total stack space used - s.vars[&memvar] = r - b := s.endBlock() - b.Kind = ssa.BlockCall - b.Control = r - b.AddEdgeTo(bNext) - s.startBlock(bNext) - case OCHECKNIL: p := s.expr(n.Left) s.nilCheck(p) @@ -1816,61 +1783,8 @@ func (s *state) expr(n *Node) *ssa.Value { p, l, c := s.slice(n.Left.Type, v, i, j, k) return s.newValue3(ssa.OpSliceMake, n.Type, p, l, c) - case OCALLFUNC, OCALLMETH: - left := n.Left - static := left.Op == ONAME && left.Class == PFUNC - - if n.Op == OCALLMETH { - // Rewrite to an OCALLFUNC: (p.f)(...) becomes (f)(p, ...) - // Take care not to modify the original AST. - if left.Op != ODOTMETH { - Fatalf("OCALLMETH: n.Left not an ODOTMETH: %v", left) - } - - newLeft := *left.Right - newLeft.Type = left.Type - if newLeft.Op == ONAME { - newLeft.Class = PFUNC - } - left = &newLeft - static = true - } - - // evaluate closure - var closure *ssa.Value - if !static { - closure = s.expr(left) - } - - // run all argument assignments - s.stmtList(n.List) - - bNext := s.f.NewBlock(ssa.BlockPlain) - var call *ssa.Value - if static { - call = s.newValue1A(ssa.OpStaticCall, ssa.TypeMem, left.Sym, s.mem()) - } else { - entry := s.newValue2(ssa.OpLoad, Types[TUINTPTR], closure, s.mem()) - call = s.newValue3(ssa.OpClosureCall, ssa.TypeMem, entry, closure, s.mem()) - } - dowidth(left.Type) - call.AuxInt = left.Type.Argwid // call operations carry the argsize of the callee along with them - s.vars[&memvar] = call - b := s.endBlock() - b.Kind = ssa.BlockCall - b.Control = call - b.AddEdgeTo(bNext) - - // read result from stack at the start of the fallthrough block - s.startBlock(bNext) - var titer Iter - fp := Structfirst(&titer, Getoutarg(left.Type)) - if fp == nil { - // CALLFUNC has no return value. Continue with the next statement. - return nil - } - a := s.entryNewValue1I(ssa.OpOffPtr, Ptrto(fp.Type), fp.Width, s.sp) - return s.newValue2(ssa.OpLoad, fp.Type, a, call) + case OCALLFUNC, OCALLINTER, OCALLMETH: + return s.call(n, callNormal) case OGETG: return s.newValue0(ssa.OpGetG, n.Type) @@ -2065,6 +1979,132 @@ func (s *state) zeroVal(t *Type) *ssa.Value { return nil } +type callKind int8 + +const ( + callNormal callKind = iota + callDefer + callGo +) + +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) + if closure == nil { + return nil // TODO: remove when expr always returns non-nil + } + 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 { + var argStart int64 + if HasLinkRegister() { + argStart += int64(Widthptr) + } + 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) + + // Read result from stack at the start of the fallthrough block + 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 + } + a := s.entryNewValue1I(ssa.OpOffPtr, Ptrto(fp.Type), fp.Width, s.sp) + return s.newValue2(ssa.OpLoad, fp.Type, a, call) +} + // 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 uint8) int8 { @@ -3578,6 +3618,13 @@ func (s *genState) genValue(v *ssa.Value) { 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]) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 5f34f76eda..26ad70278f 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -356,6 +356,7 @@ (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? diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index d5bd5b38e0..b46dbca6c7 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -390,6 +390,7 @@ func init() { {name: "CALLclosure", reg: regInfo{[]regMask{gpsp, buildReg("DX"), 0}, callerSave, nil}}, // call function via closure. arg0=codeptr, arg1=closure, arg2=mem, auxint=argsize, returns mem {name: "CALLdefer", reg: regInfo{clobbers: callerSave}}, // call deferproc. arg0=mem, auxint=argsize, returns mem {name: "CALLgo", reg: regInfo{clobbers: callerSave}}, // call newproc. arg0=mem, auxint=argsize, returns mem + {name: "CALLinter", reg: regInfo{inputs: []regMask{gp}, clobbers: callerSave}}, // call fn by pointer. arg0=codeptr, arg1=mem, auxint=argsize, returns mem {name: "REPMOVSB", reg: regInfo{[]regMask{buildReg("DI"), buildReg("SI"), buildReg("CX")}, buildReg("DI SI CX"), nil}}, // move arg2 bytes from arg1 to arg0. arg3=mem, returns memory diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 71683c16bd..1b9006e4e1 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -286,6 +286,7 @@ var genericOps = []opData{ {name: "StaticCall"}, // call function aux.(*gc.Sym), arg0=memory. auxint=arg size. Returns memory. {name: "DeferCall"}, // defer call. arg0=memory, auxint=arg size. Returns memory. {name: "GoCall"}, // go call. arg0=memory, auxint=arg size. Returns memory. + {name: "InterCall"}, // interface call. arg0=code pointer, arg1=memory, auxint=arg size. Returns memory. // Conversions: signed extensions, zero (unsigned) extensions, truncations {name: "SignExt8to16", typ: "Int16"}, diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 0a7e8c75c7..7e17b7d552 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -266,6 +266,7 @@ const ( OpAMD64CALLclosure OpAMD64CALLdefer OpAMD64CALLgo + OpAMD64CALLinter OpAMD64REPMOVSB OpAMD64InvertFlags OpAMD64LoweredPanicNilCheck @@ -479,6 +480,7 @@ const ( OpStaticCall OpDeferCall OpGoCall + OpInterCall OpSignExt8to16 OpSignExt8to32 OpSignExt8to64 @@ -3081,6 +3083,15 @@ var opcodeTable = [...]opInfo{ 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", + 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: "REPMOVSB", reg: regInfo{ @@ -3945,6 +3956,10 @@ var opcodeTable = [...]opInfo{ name: "GoCall", generic: true, }, + { + name: "InterCall", + generic: true, + }, { name: "SignExt8to16", generic: true, diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index d2f5ca8f32..d4b13f3b9a 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -2768,6 +2768,26 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto enda49fcae3630a097c78aa58189c90a97a enda49fcae3630a097c78aa58189c90a97a: ; + case OpInterCall: + // match: (InterCall [argwid] entry mem) + // cond: + // result: (CALLinter [argwid] entry mem) + { + argwid := v.AuxInt + entry := v.Args[0] + mem := v.Args[1] + v.Op = OpAMD64CALLinter + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = argwid + v.AddArg(entry) + v.AddArg(mem) + return true + } + goto endc04351e492ed362efc6aa75121bca305 + endc04351e492ed362efc6aa75121bca305: + ; case OpIsInBounds: // match: (IsInBounds idx len) // cond: -- cgit v1.3 From 5f10573e6005f1ad34710335af94c1ba6d1a6157 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Thu, 17 Sep 2015 15:19:23 -0700 Subject: [dev.ssa] cmd/compile: Generate AUNDEF at the end of BlockExit blocks Generate AUNDEF for every exit block, not just for certain control values. Change-Id: Ife500ac5159ee790bc1e70c0e9b0b1f854bc4c47 Reviewed-on: https://go-review.googlesource.com/14721 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/gc/ssa.go | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index c2d2f8be4d..c053eabcba 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -3536,19 +3536,16 @@ func (s *genState) genValue(v *ssa.Value) { q.From.Reg = x86.REG_AX q.To.Type = obj.TYPE_MEM q.To.Reg = r - Prog(obj.AUNDEF) // tell plive.go that we never reach here case ssa.OpAMD64LoweredPanicIndexCheck: p := Prog(obj.ACALL) p.To.Type = obj.TYPE_MEM p.To.Name = obj.NAME_EXTERN p.To.Sym = Linksym(Panicindex.Sym) - Prog(obj.AUNDEF) case ssa.OpAMD64LoweredPanicSliceCheck: p := Prog(obj.ACALL) p.To.Type = obj.TYPE_MEM p.To.Name = obj.NAME_EXTERN p.To.Sym = Linksym(panicslice.Sym) - Prog(obj.AUNDEF) case ssa.OpAMD64LoweredGetG: r := regnum(v) // See the comments in cmd/internal/obj/x86/obj6.go @@ -3804,6 +3801,7 @@ func (s *genState) genBlock(b, next *ssa.Block) { 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() -- cgit v1.3 From 269baa981e327caea3adb4722f17b4b02d5c834c Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Thu, 17 Sep 2015 10:31:16 -0700 Subject: [dev.ssa] cmd/compile: implement ODOTTYPE and OAS2DOTTYPE Taken over and completed from Josh's change https://go-review.googlesource.com/#/c/14524/ Change-Id: If5d4f732843cc3e99bd5edda54458f0a8be73e91 Reviewed-on: https://go-review.googlesource.com/14690 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/gc/ssa.go | 143 +++++++++++++++++++- src/cmd/compile/internal/gc/ssa_test.go | 3 + src/cmd/compile/internal/gc/testdata/assert_ssa.go | 147 +++++++++++++++++++++ 3 files changed, 287 insertions(+), 6 deletions(-) create mode 100644 src/cmd/compile/internal/gc/testdata/assert_ssa.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index c053eabcba..7268a34a12 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -259,12 +259,17 @@ func (s *state) Logf(msg string, args ...interface{}) { s.config.Logf( func (s *state) Fatalf(msg string, args ...interface{}) { s.config.Fatalf(msg, args...) } func (s *state) Unimplementedf(msg string, args ...interface{}) { s.config.Unimplementedf(msg, args...) } -// dummy node for the memory variable -var memvar = Node{Op: ONAME, Sym: &Sym{Name: "mem"}} - -// dummy nodes for temporary variables -var ptrvar = Node{Op: ONAME, Sym: &Sym{Name: "ptr"}} -var capvar = Node{Op: ONAME, Sym: &Sym{Name: "cap"}} +var ( + // dummy node for the memory variable + memvar = Node{Op: ONAME, Sym: &Sym{Name: "mem"}} + + // dummy nodes for temporary variables + ptrvar = Node{Op: ONAME, Sym: &Sym{Name: "ptr"}} + capvar = Node{Op: ONAME, Sym: &Sym{Name: "cap"}} + typVar = Node{Op: ONAME, Sym: &Sym{Name: "typ"}} + idataVar = Node{Op: ONAME, Sym: &Sym{Name: "idata"}} + okVar = Node{Op: ONAME, Sym: &Sym{Name: "ok"}} +) // startBlock sets the current block we're generating code in to b. func (s *state) startBlock(b *ssa.Block) { @@ -474,6 +479,12 @@ func (s *state) stmt(n *Node) { case OPROC: s.call(n.Left, callGo) + case OAS2DOTTYPE: + res, resok := s.dottype(n.Rlist.N, true) + s.assign(n.List.N, res, false) + s.assign(n.List.Next.N, resok, false) + return + case ODCL: if n.Left.Class&PHEAP == 0 { return @@ -1471,6 +1482,10 @@ func (s *state) expr(n *Node) *ssa.Value { s.Unimplementedf("unhandled OCONV %s -> %s", Econv(int(n.Left.Type.Etype), 0), Econv(int(n.Type.Etype), 0)) 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) @@ -2723,6 +2738,122 @@ func (s *state) floatToUint(cvttab *f2uCvtTab, n *Node, x *ssa.Value, ft, tt *Ty 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) + } + + // 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) + + spplus1 := s.newValue1I(ssa.OpOffPtr, Types[TUINTPTR], int64(Widthptr), s.sp) + spplus2 := s.newValue1I(ssa.OpOffPtr, Types[TUINTPTR], int64(2*Widthptr), s.sp) + taddr := s.newValue1A(ssa.OpAddr, byteptr, &ssa.ExternSymbol{byteptr, typenamesym(n.Left.Type)}, s.sb) + s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), s.sp, typ, s.mem()) // actual dynamic type + s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), spplus1, target, s.mem()) // type we're casting to + s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), spplus2, taddr, s.mem()) // static source type + call := s.newValue1A(ssa.OpStaticCall, ssa.TypeMem, syslook("panicdottype", 0).Sym, s.mem()) + s.endBlock() + bFail.Kind = ssa.BlockExit + bFail.Control = call + + // 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, diff --git a/src/cmd/compile/internal/gc/ssa_test.go b/src/cmd/compile/internal/gc/ssa_test.go index bbd06748b1..b63749fcc6 100644 --- a/src/cmd/compile/internal/gc/ssa_test.go +++ b/src/cmd/compile/internal/gc/ssa_test.go @@ -48,6 +48,9 @@ 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") } 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 0000000000..d64d4fc35a --- /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") + } +} -- cgit v1.3 From b32217a2730b322f4bdc2a00ff9159bae853b939 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Thu, 17 Sep 2015 16:45:10 -0700 Subject: [dev.ssa] cmd/compile: consistent naming of temporary vars ptrvar -> ptrVar, etc. Change-Id: Id38bed0e145711dfe3bdc9541ab4741da6a570a2 Reviewed-on: https://go-review.googlesource.com/14725 Reviewed-by: Todd Neal --- src/cmd/compile/internal/gc/ssa.go | 80 +++++++++++++++++++------------------- 1 file changed, 40 insertions(+), 40 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 7268a34a12..186c1a2996 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -261,11 +261,11 @@ func (s *state) Unimplementedf(msg string, args ...interface{}) { s.config.Unimp var ( // dummy node for the memory variable - memvar = Node{Op: ONAME, Sym: &Sym{Name: "mem"}} + memVar = Node{Op: ONAME, Sym: &Sym{Name: "mem"}} // dummy nodes for temporary variables - ptrvar = Node{Op: ONAME, Sym: &Sym{Name: "ptr"}} - capvar = Node{Op: ONAME, Sym: &Sym{Name: "cap"}} + ptrVar = Node{Op: ONAME, Sym: &Sym{Name: "ptr"}} + capVar = Node{Op: ONAME, Sym: &Sym{Name: "cap"}} typVar = Node{Op: ONAME, Sym: &Sym{Name: "typ"}} idataVar = Node{Op: ONAME, Sym: &Sym{Name: "idata"}} okVar = Node{Op: ONAME, Sym: &Sym{Name: "ok"}} @@ -785,7 +785,7 @@ func (s *state) stmt(n *Node) { // 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. - s.vars[&memvar] = s.newValue1A(ssa.OpVarKill, ssa.TypeMem, n.Left, s.mem()) + s.vars[&memVar] = s.newValue1A(ssa.OpVarKill, ssa.TypeMem, n.Left, s.mem()) case OCHECKNIL: p := s.expr(n.Left) @@ -1840,8 +1840,8 @@ func (s *state) expr(n *Node) *ssa.Value { 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 + s.vars[&ptrVar] = p + s.vars[&capVar] = c b := s.endBlock() b.Kind = ssa.BlockIf b.Likely = ssa.BranchUnlikely @@ -1857,14 +1857,14 @@ func (s *state) expr(n *Node) *ssa.Value { spplus2 := s.newValue1I(ssa.OpOffPtr, Types[TUINTPTR], int64(2*Widthptr), s.sp) spplus3 := s.newValue1I(ssa.OpOffPtr, Types[TUINTPTR], int64(3*Widthptr), s.sp) spplus4 := s.newValue1I(ssa.OpOffPtr, Types[TUINTPTR], int64(4*Widthptr), s.sp) - s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), s.sp, taddr, s.mem()) - s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), spplus1, p, s.mem()) - s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), spplus2, l, s.mem()) - s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), spplus3, c, s.mem()) - s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), spplus4, nl, s.mem()) + s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), s.sp, taddr, s.mem()) + s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), spplus1, p, s.mem()) + s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), spplus2, l, s.mem()) + s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), spplus3, c, s.mem()) + s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), spplus4, nl, s.mem()) call := s.newValue1A(ssa.OpStaticCall, ssa.TypeMem, syslook("growslice", 0).Sym, s.mem()) call.AuxInt = int64(8 * Widthptr) - s.vars[&memvar] = call + s.vars[&memVar] = call b = s.endBlock() b.Kind = ssa.BlockCall b.Control = call @@ -1875,19 +1875,19 @@ func (s *state) expr(n *Node) *ssa.Value { spplus5 := s.newValue1I(ssa.OpOffPtr, Types[TUINTPTR], int64(5*Widthptr), s.sp) // Note: we don't need to read the result's length. spplus7 := s.newValue1I(ssa.OpOffPtr, Types[TUINTPTR], int64(7*Widthptr), s.sp) - s.vars[&ptrvar] = s.newValue2(ssa.OpLoad, pt, spplus5, s.mem()) - s.vars[&capvar] = s.newValue2(ssa.OpLoad, Types[TINT], spplus7, s.mem()) + s.vars[&ptrVar] = s.newValue2(ssa.OpLoad, pt, spplus5, s.mem()) + s.vars[&capVar] = s.newValue2(ssa.OpLoad, Types[TINT], spplus7, s.mem()) b = s.endBlock() b.AddEdgeTo(assign) // assign new elements to slots s.startBlock(assign) - p = s.variable(&ptrvar, pt) // generates phi for ptr - c = s.variable(&capvar, Types[TINT]) // generates phi for cap + 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) for i, arg := range args { addr := s.newValue2(ssa.OpPtrIndex, pt, p2, s.constInt(Types[TUINTPTR], int64(i))) - s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, et.Size(), addr, arg, s.mem()) + s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, et.Size(), addr, arg, s.mem()) if haspointers(et) { // TODO: just one write barrier call for all of these writes? // TODO: maybe just one writeBarrierEnabled check? @@ -1897,8 +1897,8 @@ func (s *state) expr(n *Node) *ssa.Value { // make result r := s.newValue3(ssa.OpSliceMake, n.Type, p, nl, c) - delete(s.vars, &ptrvar) - delete(s.vars, &capvar) + delete(s.vars, &ptrVar) + delete(s.vars, &capVar) return r default: @@ -1919,9 +1919,9 @@ func (s *state) assign(left *Node, right *ssa.Value, wb bool) { // if we can't ssa this memory, treat it as just zeroing out the backing memory addr := s.addr(left) if left.Op == ONAME { - s.vars[&memvar] = s.newValue1A(ssa.OpVarDef, ssa.TypeMem, left, s.mem()) + s.vars[&memVar] = s.newValue1A(ssa.OpVarDef, ssa.TypeMem, left, s.mem()) } - s.vars[&memvar] = s.newValue2I(ssa.OpZero, ssa.TypeMem, t.Size(), addr, s.mem()) + s.vars[&memVar] = s.newValue2I(ssa.OpZero, ssa.TypeMem, t.Size(), addr, s.mem()) return } right = s.zeroVal(t) @@ -1934,9 +1934,9 @@ func (s *state) assign(left *Node, right *ssa.Value, wb bool) { // not ssa-able. Treat as a store. addr := s.addr(left) if left.Op == ONAME { - s.vars[&memvar] = s.newValue1A(ssa.OpVarDef, ssa.TypeMem, left, s.mem()) + s.vars[&memVar] = s.newValue1A(ssa.OpVarDef, ssa.TypeMem, left, s.mem()) } - s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, t.Size(), addr, right, s.mem()) + s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, t.Size(), addr, right, s.mem()) if wb { s.insertWB(left.Type, addr) } @@ -2068,16 +2068,16 @@ func (s *state) call(n *Node, k callKind) *ssa.Value { 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()) + 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()) + 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()) + s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), addr, closure, s.mem()) stksize += 2 * int64(Widthptr) } @@ -2102,7 +2102,7 @@ func (s *state) call(n *Node, k callKind) *ssa.Value { call.AuxInt = stksize // Call operations carry the argsize of the callee along with them // Finish call block - s.vars[&memvar] = call + s.vars[&memVar] = call b := s.endBlock() b.Kind = ssa.BlockCall b.Control = call @@ -2382,12 +2382,12 @@ func (s *state) insertWB(t *Type, p *ssa.Value) { s.startBlock(bThen) // TODO: writebarrierptr_nostore if just one pointer word (or a few?) taddr := s.newValue1A(ssa.OpAddr, Types[TUINTPTR], &ssa.ExternSymbol{Types[TUINTPTR], typenamesym(t)}, s.sb) - s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), s.sp, taddr, s.mem()) + s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), s.sp, taddr, s.mem()) spplus8 := s.newValue1I(ssa.OpOffPtr, Types[TUINTPTR], int64(Widthptr), s.sp) - s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), spplus8, p, s.mem()) + s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), spplus8, p, s.mem()) call := s.newValue1A(ssa.OpStaticCall, ssa.TypeMem, syslook("typedmemmove_nostore", 0).Sym, s.mem()) call.AuxInt = int64(2 * Widthptr) - s.vars[&memvar] = call + s.vars[&memVar] = call c := s.endBlock() c.Kind = ssa.BlockCall c.Control = call @@ -2477,7 +2477,7 @@ func (s *state) slice(t *Type, v, i, j, k *ssa.Value) (p, l, c *ssa.Value) { rcap = s.newValue2(ssa.OpSubPtr, Types[TINT], k, i) } - s.vars[&ptrvar] = ptr + s.vars[&ptrVar] = ptr // Generate code to test the resulting slice length. var cmp *ssa.Value @@ -2502,7 +2502,7 @@ func (s *state) slice(t *Type, v, i, j, k *ssa.Value) (p, l, c *ssa.Value) { } else { inc = s.newValue2(ssa.OpMulPtr, Types[TUINTPTR], i, s.constInt(Types[TINT], elemtype.Width)) } - s.vars[&ptrvar] = s.newValue2(ssa.OpAddPtr, ptrtype, ptr, inc) + s.vars[&ptrVar] = s.newValue2(ssa.OpAddPtr, ptrtype, ptr, inc) s.endBlock() // All done. @@ -2510,8 +2510,8 @@ func (s *state) slice(t *Type, v, i, j, k *ssa.Value) (p, l, c *ssa.Value) { b.AddEdgeTo(merge) nz.AddEdgeTo(merge) s.startBlock(merge) - rptr := s.variable(&ptrvar, ptrtype) - delete(s.vars, &ptrvar) + rptr := s.variable(&ptrVar, ptrtype) + delete(s.vars, &ptrVar) return rptr, rlen, rcap } @@ -2814,9 +2814,9 @@ func (s *state) dottype(n *Node, commaok bool) (res, resok *ssa.Value) { spplus1 := s.newValue1I(ssa.OpOffPtr, Types[TUINTPTR], int64(Widthptr), s.sp) spplus2 := s.newValue1I(ssa.OpOffPtr, Types[TUINTPTR], int64(2*Widthptr), s.sp) taddr := s.newValue1A(ssa.OpAddr, byteptr, &ssa.ExternSymbol{byteptr, typenamesym(n.Left.Type)}, s.sb) - s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), s.sp, typ, s.mem()) // actual dynamic type - s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), spplus1, target, s.mem()) // type we're casting to - s.vars[&memvar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), spplus2, taddr, s.mem()) // static source type + s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), s.sp, typ, s.mem()) // actual dynamic type + s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), spplus1, target, s.mem()) // type we're casting to + s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), spplus2, taddr, s.mem()) // static source type call := s.newValue1A(ssa.OpStaticCall, ssa.TypeMem, syslook("panicdottype", 0).Sym, s.mem()) s.endBlock() bFail.Kind = ssa.BlockExit @@ -2924,7 +2924,7 @@ func (s *state) variable(name *Node, t ssa.Type) *ssa.Value { } func (s *state) mem() *ssa.Value { - return s.variable(&memvar, ssa.TypeMem) + return s.variable(&memVar, ssa.TypeMem) } func (s *state) linkForwardReferences() { @@ -2952,7 +2952,7 @@ func (s *state) lookupVarIncoming(b *ssa.Block, t ssa.Type, name *Node) *ssa.Val // TODO(khr): have lookupVarIncoming overwrite the fwdRef or copy it // will be used in, instead of having the result used in a copy value. if b == s.f.Entry { - if name == &memvar { + if name == &memVar { return s.startmem } // variable is live at the entry block. Load it. @@ -2974,7 +2974,7 @@ func (s *state) lookupVarIncoming(b *ssa.Block, t ssa.Type, name *Node) *ssa.Val // 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, // so use the default/zero value. - if name == &memvar { + if name == &memVar { return s.startmem } return s.zeroVal(name.Type) -- cgit v1.3 From d3886906b18d292643117b55c987ec9b35b226b3 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Fri, 18 Sep 2015 22:12:38 -0700 Subject: [dev.ssa] cmd/compile: implement OSTRUCTLIT and OARRAYLIT The frontend rewrites most literals, so we see only zero ones during SSA construction. We can implement those using the existing zeroing behavior. Change-Id: I390ad1be0a4b6729baf0c8936c7610aae2aef049 Reviewed-on: https://go-review.googlesource.com/14754 Reviewed-by: David Chase Run-TryBot: Brad Fitzpatrick TryBot-Result: Gobot Gobot --- src/cmd/compile/internal/gc/ssa.go | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 186c1a2996..fb7e0c54ac 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -574,7 +574,16 @@ func (s *state) stmt(n *Node) { } var r *ssa.Value if n.Right != nil { - r = s.expr(n.Right) + if n.Right.Op == OSTRUCTLIT || n.Right.Op == OARRAYLIT { + // All literals with nonzero fields have already been + // rewritten during walk. Any that remain are just T{} + // or equivalents. Leave r = nil to get zeroing behavior. + if !iszero(n.Right) { + Fatalf("literal with nonzero value in SSA: %v", n.Right) + } + } else { + r = s.expr(n.Right) + } } if n.Right != nil && n.Right.Op == OAPPEND { // Yuck! The frontend gets rid of the write barrier, but we need it! -- cgit v1.3 From 37590bddc417c2675f4979a9467edc1961f88b61 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Fri, 18 Sep 2015 22:58:10 -0700 Subject: [dev.ssa] cmd/compile: move un-SSAable objects We need to move any objects whose types are not SSA-able. Fixes the "not lowered: Load ARRAY PTR64 mem" errors. Change-Id: I7a0b609f917d7fb34bc9215fee4da15f9961cf6c Reviewed-on: https://go-review.googlesource.com/14753 Reviewed-by: David Chase Run-TryBot: Brad Fitzpatrick TryBot-Result: Gobot Gobot --- src/cmd/compile/internal/gc/ssa.go | 4 +++ src/cmd/compile/internal/ssa/config.go | 2 ++ src/cmd/compile/internal/ssa/export_test.go | 5 +++ src/cmd/compile/internal/ssa/gen/generic.rules | 6 ++-- src/cmd/compile/internal/ssa/rewritegeneric.go | 48 ++++++++++++++------------ 5 files changed, 39 insertions(+), 26 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index fb7e0c54ac..8e0f0dcc9b 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -4242,6 +4242,10 @@ func (e *ssaExport) Auto(t ssa.Type) fmt.Stringer { return n } +func (e ssaExport) CanSSA(t ssa.Type) bool { + return canSSAType(t.(*Type)) +} + // 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. diff --git a/src/cmd/compile/internal/ssa/config.go b/src/cmd/compile/internal/ssa/config.go index 8ae74d0b2f..c935a2b83e 100644 --- a/src/cmd/compile/internal/ssa/config.go +++ b/src/cmd/compile/internal/ssa/config.go @@ -34,6 +34,8 @@ type TypeSource interface { TypeUintptr() Type TypeString() Type TypeBytePtr() Type // TODO: use unsafe.Pointer instead? + + CanSSA(t Type) bool } type Logger interface { diff --git a/src/cmd/compile/internal/ssa/export_test.go b/src/cmd/compile/internal/ssa/export_test.go index 7c314c2630..c0db5c8d96 100644 --- a/src/cmd/compile/internal/ssa/export_test.go +++ b/src/cmd/compile/internal/ssa/export_test.go @@ -50,3 +50,8 @@ 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/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index f54496e8a8..8195d6b010 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -176,9 +176,9 @@ data (Store [config.PtrSize] dst itab mem)) -// big-object moves (TODO: remove?) -(Store [size] dst (Load src mem) mem) && size > config.IntSize -> (Move [size] dst src mem) -(Store [size] dst (Load src mem) (VarDef {x} mem)) && size > config.IntSize -> (Move [size] dst src (VarDef {x} mem)) +// un-SSAable values use mem->mem copies +(Store [size] dst (Load src mem) mem) && !config.fe.CanSSA(t) -> (Move [size] dst src mem) +(Store [size] dst (Load src mem) (VarDef {x} mem)) && !config.fe.CanSSA(t) -> (Move [size] dst src (VarDef {x} mem)) (If (IsNonNil (GetG)) yes no) -> (First nil yes no) diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index afca4cfed9..8534e2a865 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -430,7 +430,7 @@ func rewriteValuegeneric(v *Value, config *Config) bool { case OpEqInter: // match: (EqInter x y) // cond: - // result: (EqPtr (ITab x) (ITab y)) + // result: (EqPtr (ITab x) (ITab y)) { x := v.Args[0] y := v.Args[1] @@ -448,8 +448,8 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto endfcedc545b9bbbe3790786c8981b12d32 - endfcedc545b9bbbe3790786c8981b12d32: + goto end1cc40483caab33ece971ab7e6c8fdfca + end1cc40483caab33ece971ab7e6c8fdfca: ; case OpEqPtr: // match: (EqPtr p (ConstNil)) @@ -497,7 +497,7 @@ func rewriteValuegeneric(v *Value, config *Config) bool { case OpEqSlice: // match: (EqSlice x y) // cond: - // result: (EqPtr (SlicePtr x) (SlicePtr y)) + // result: (EqPtr (SlicePtr x) (SlicePtr y)) { x := v.Args[0] y := v.Args[1] @@ -515,8 +515,8 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto end2937092dca53f896cd527e59e92cab1d - end2937092dca53f896cd527e59e92cab1d: + goto end9cd53ca57ee90aa09c54f8071c8e8769 + end9cd53ca57ee90aa09c54f8071c8e8769: ; case OpIData: // match: (IData (IMake _ data)) @@ -1398,22 +1398,23 @@ func rewriteValuegeneric(v *Value, config *Config) bool { goto endaa801a871178ae3256b3f6f5d9f13514 endaa801a871178ae3256b3f6f5d9f13514: ; - // match: (Store [size] dst (Load src mem) mem) - // cond: size > config.IntSize + // match: (Store [size] dst (Load src mem) mem) + // cond: !config.fe.CanSSA(t) // result: (Move [size] dst src mem) { size := v.AuxInt dst := v.Args[0] if v.Args[1].Op != OpLoad { - goto enda18a7163888e2f4fca9f38bae56cef42 + goto end45295326269ba18413dceb7b608a0b9d } + t := v.Args[1].Type src := v.Args[1].Args[0] mem := v.Args[1].Args[1] if v.Args[2] != mem { - goto enda18a7163888e2f4fca9f38bae56cef42 + goto end45295326269ba18413dceb7b608a0b9d } - if !(size > config.IntSize) { - goto enda18a7163888e2f4fca9f38bae56cef42 + if !(!config.fe.CanSSA(t)) { + goto end45295326269ba18413dceb7b608a0b9d } v.Op = OpMove v.AuxInt = 0 @@ -1425,29 +1426,30 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto enda18a7163888e2f4fca9f38bae56cef42 - enda18a7163888e2f4fca9f38bae56cef42: + goto end45295326269ba18413dceb7b608a0b9d + end45295326269ba18413dceb7b608a0b9d: ; - // match: (Store [size] dst (Load src mem) (VarDef {x} mem)) - // cond: size > config.IntSize + // match: (Store [size] dst (Load src mem) (VarDef {x} mem)) + // cond: !config.fe.CanSSA(t) // result: (Move [size] dst src (VarDef {x} mem)) { size := v.AuxInt dst := v.Args[0] if v.Args[1].Op != OpLoad { - goto endc671c9b1be99e3125fe81e29018bc0e6 + goto end7f3cc0baffb82ba3ee879599b189a512 } + t := v.Args[1].Type src := v.Args[1].Args[0] mem := v.Args[1].Args[1] if v.Args[2].Op != OpVarDef { - goto endc671c9b1be99e3125fe81e29018bc0e6 + goto end7f3cc0baffb82ba3ee879599b189a512 } x := v.Args[2].Aux if v.Args[2].Args[0] != mem { - goto endc671c9b1be99e3125fe81e29018bc0e6 + goto end7f3cc0baffb82ba3ee879599b189a512 } - if !(size > config.IntSize) { - goto endc671c9b1be99e3125fe81e29018bc0e6 + if !(!config.fe.CanSSA(t)) { + goto end7f3cc0baffb82ba3ee879599b189a512 } v.Op = OpMove v.AuxInt = 0 @@ -1463,8 +1465,8 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto endc671c9b1be99e3125fe81e29018bc0e6 - endc671c9b1be99e3125fe81e29018bc0e6: + goto end7f3cc0baffb82ba3ee879599b189a512 + end7f3cc0baffb82ba3ee879599b189a512: ; case OpStringLen: // match: (StringLen (StringMake _ len)) -- cgit v1.3 From d29e92be523efd8270c0e7ca0eaa6afa86bbedca Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Sat, 19 Sep 2015 12:01:39 -0700 Subject: [dev.ssa] cmd/compile: Use varkill only for non-SSAable vars For variables which get SSA'd, SSA keeps track of all the def/kill. It is only for on-stack variables that we need them. This reduces stack frame sizes significantly because often the only use of a variable was a varkill, and without that last use the variable doesn't get allocated in the frame at all. Fixes #12602 Change-Id: I3f00a768aa5ddd8d7772f375b25f846086a3e689 Reviewed-on: https://go-review.googlesource.com/14758 Reviewed-by: Brad Fitzpatrick --- src/cmd/compile/internal/gc/ssa.go | 4 +++- src/cmd/internal/obj/stack.go | 2 +- src/runtime/stack2.go | 2 +- test/nosplit.go | 4 ++-- 4 files changed, 7 insertions(+), 5 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 8e0f0dcc9b..6cb5c571c2 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -794,7 +794,9 @@ func (s *state) stmt(n *Node) { // 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. - s.vars[&memVar] = s.newValue1A(ssa.OpVarKill, ssa.TypeMem, n.Left, s.mem()) + if !canSSA(n.Left) { + s.vars[&memVar] = s.newValue1A(ssa.OpVarKill, ssa.TypeMem, n.Left, s.mem()) + } case OCHECKNIL: p := s.expr(n.Left) diff --git a/src/cmd/internal/obj/stack.go b/src/cmd/internal/obj/stack.go index b1630b55fc..87698b3eeb 100644 --- a/src/cmd/internal/obj/stack.go +++ b/src/cmd/internal/obj/stack.go @@ -41,7 +41,7 @@ const ( STACKSYSTEM = 0 StackSystem = STACKSYSTEM StackBig = 4096 - StackGuard = 960*stackGuardMultiplier + StackSystem + StackGuard = 640*stackGuardMultiplier + StackSystem StackSmall = 128 StackLimit = StackGuard - StackSystem - StackSmall ) diff --git a/src/runtime/stack2.go b/src/runtime/stack2.go index 02b82ebe13..59d4ef694d 100644 --- a/src/runtime/stack2.go +++ b/src/runtime/stack2.go @@ -86,7 +86,7 @@ const ( // The stack guard is a pointer this many bytes above the // bottom of the stack. - _StackGuard = 960*stackGuardMultiplier + _StackSystem + _StackGuard = 640*stackGuardMultiplier + _StackSystem // After a stack split check the SP is allowed to be this // many bytes below the stack guard. This saves an instruction diff --git a/test/nosplit.go b/test/nosplit.go index e7c00f5783..e5c2a9f30e 100644 --- a/test/nosplit.go +++ b/test/nosplit.go @@ -285,12 +285,12 @@ TestCases: // Instead of rewriting the test cases above, adjust // the first stack frame to use up the extra bytes. if i == 0 { - size += 832 - 128 + size += 512 - 128 // Noopt builds have a larger stackguard. // See ../cmd/dist/buildruntime.go:stackGuardMultiplier for _, s := range strings.Split(os.Getenv("GO_GCFLAGS"), " ") { if s == "-N" { - size += 960 + size += 640 } } } -- cgit v1.3 From 8c5bfcc52ba9aced772935cdf45a99cf3d465f1e Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Fri, 18 Sep 2015 15:11:30 -0700 Subject: [dev.ssa] cmd/compile: Move runtime call gen to its own function Change-Id: I5de36244de4dcc4a9827ee0fa04526e3e3578e7f Reviewed-on: https://go-review.googlesource.com/14755 Reviewed-by: David Chase --- src/cmd/compile/internal/gc/go.go | 6 ++ src/cmd/compile/internal/gc/pgen.go | 3 + src/cmd/compile/internal/gc/ssa.go | 122 +++++++++++++++++++++--------------- 3 files changed, 81 insertions(+), 50 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/go.go b/src/cmd/compile/internal/gc/go.go index 424e647033..a0c1ab894d 100644 --- a/src/cmd/compile/internal/gc/go.go +++ b/src/cmd/compile/internal/gc/go.go @@ -866,3 +866,9 @@ var Panicindex *Node var panicslice *Node var throwreturn *Node + +var growslice *Node + +var typedmemmove_nostore *Node + +var panicdottype *Node diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/pgen.go index 67fe8e6d7c..b15fb6dba1 100644 --- a/src/cmd/compile/internal/gc/pgen.go +++ b/src/cmd/compile/internal/gc/pgen.go @@ -338,6 +338,9 @@ func compile(fn *Node) { Panicindex = Sysfunc("panicindex") panicslice = Sysfunc("panicslice") throwreturn = Sysfunc("throwreturn") + growslice = Sysfunc("growslice") + typedmemmove_nostore = Sysfunc("typedmemmove_nostore") + panicdottype = Sysfunc("panicdottype") } lno := setlineno(fn) diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 6cb5c571c2..4b71d1f880 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1842,7 +1842,6 @@ func (s *state) expr(n *Node) *ssa.Value { // Allocate new blocks grow := s.f.NewBlock(ssa.BlockPlain) - growresult := s.f.NewBlock(ssa.BlockPlain) assign := s.f.NewBlock(ssa.BlockPlain) // Decide if we need to grow @@ -1864,30 +1863,12 @@ func (s *state) expr(n *Node) *ssa.Value { s.startBlock(grow) taddr := s.newValue1A(ssa.OpAddr, Types[TUINTPTR], &ssa.ExternSymbol{Types[TUINTPTR], typenamesym(n.Type)}, s.sb) - spplus1 := s.newValue1I(ssa.OpOffPtr, Types[TUINTPTR], int64(Widthptr), s.sp) - spplus2 := s.newValue1I(ssa.OpOffPtr, Types[TUINTPTR], int64(2*Widthptr), s.sp) - spplus3 := s.newValue1I(ssa.OpOffPtr, Types[TUINTPTR], int64(3*Widthptr), s.sp) - spplus4 := s.newValue1I(ssa.OpOffPtr, Types[TUINTPTR], int64(4*Widthptr), s.sp) - s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), s.sp, taddr, s.mem()) - s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), spplus1, p, s.mem()) - s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), spplus2, l, s.mem()) - s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), spplus3, c, s.mem()) - s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), spplus4, nl, s.mem()) - call := s.newValue1A(ssa.OpStaticCall, ssa.TypeMem, syslook("growslice", 0).Sym, s.mem()) - call.AuxInt = int64(8 * Widthptr) - s.vars[&memVar] = call - b = s.endBlock() - b.Kind = ssa.BlockCall - b.Control = call - b.AddEdgeTo(growresult) - - // Read result of growslice - s.startBlock(growresult) - spplus5 := s.newValue1I(ssa.OpOffPtr, Types[TUINTPTR], int64(5*Widthptr), s.sp) - // Note: we don't need to read the result's length. - spplus7 := s.newValue1I(ssa.OpOffPtr, Types[TUINTPTR], int64(7*Widthptr), s.sp) - s.vars[&ptrVar] = s.newValue2(ssa.OpLoad, pt, spplus5, s.mem()) - s.vars[&capVar] = s.newValue2(ssa.OpLoad, Types[TINT], spplus7, s.mem()) + 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) @@ -1907,10 +1888,9 @@ func (s *state) expr(n *Node) *ssa.Value { } // make result - r := s.newValue3(ssa.OpSliceMake, n.Type, p, nl, c) delete(s.vars, &ptrVar) delete(s.vars, &capVar) - return r + return s.newValue3(ssa.OpSliceMake, n.Type, p, nl, c) default: s.Unimplementedf("unhandled expr %s", opnames[n.Op]) @@ -2369,6 +2349,68 @@ func (s *state) check(cmp *ssa.Value, panicOp ssa.Op) { 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 +} + // insertWB inserts a write barrier. A value of type t has already // been stored at location p. Tell the runtime about this write. // Note: there must be no GC suspension points between the write and @@ -2378,7 +2420,6 @@ func (s *state) insertWB(t *Type, p *ssa.Value) { // typedmemmove_nostore(&t, p) // } bThen := s.f.NewBlock(ssa.BlockPlain) - bNext := s.f.NewBlock(ssa.BlockPlain) aux := &ssa.ExternSymbol{Types[TBOOL], syslook("writeBarrierEnabled", 0).Sym} flagaddr := s.newValue1A(ssa.OpAddr, Ptrto(Types[TBOOL]), aux, s.sb) @@ -2388,23 +2429,13 @@ func (s *state) insertWB(t *Type, p *ssa.Value) { b.Likely = ssa.BranchUnlikely b.Control = flag b.AddEdgeTo(bThen) - b.AddEdgeTo(bNext) s.startBlock(bThen) // TODO: writebarrierptr_nostore if just one pointer word (or a few?) taddr := s.newValue1A(ssa.OpAddr, Types[TUINTPTR], &ssa.ExternSymbol{Types[TUINTPTR], typenamesym(t)}, s.sb) - s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), s.sp, taddr, s.mem()) - spplus8 := s.newValue1I(ssa.OpOffPtr, Types[TUINTPTR], int64(Widthptr), s.sp) - s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), spplus8, p, s.mem()) - call := s.newValue1A(ssa.OpStaticCall, ssa.TypeMem, syslook("typedmemmove_nostore", 0).Sym, s.mem()) - call.AuxInt = int64(2 * Widthptr) - s.vars[&memVar] = call - c := s.endBlock() - c.Kind = ssa.BlockCall - c.Control = call - c.AddEdgeTo(bNext) + s.rtcall(typedmemmove_nostore, true, nil, taddr, p) - s.startBlock(bNext) + b.AddEdgeTo(s.curBlock) } // slice computes the slice v[i:j:k] and returns ptr, len, and cap of result. @@ -2821,17 +2852,8 @@ func (s *state) dottype(n *Node, commaok bool) (res, resok *ssa.Value) { if !commaok { // on failure, panic by calling panicdottype s.startBlock(bFail) - - spplus1 := s.newValue1I(ssa.OpOffPtr, Types[TUINTPTR], int64(Widthptr), s.sp) - spplus2 := s.newValue1I(ssa.OpOffPtr, Types[TUINTPTR], int64(2*Widthptr), s.sp) taddr := s.newValue1A(ssa.OpAddr, byteptr, &ssa.ExternSymbol{byteptr, typenamesym(n.Left.Type)}, s.sb) - s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), s.sp, typ, s.mem()) // actual dynamic type - s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), spplus1, target, s.mem()) // type we're casting to - s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), spplus2, taddr, s.mem()) // static source type - call := s.newValue1A(ssa.OpStaticCall, ssa.TypeMem, syslook("panicdottype", 0).Sym, s.mem()) - s.endBlock() - bFail.Kind = ssa.BlockExit - bFail.Control = call + s.rtcall(panicdottype, false, nil, typ, target, taddr) // on success, return idata field s.startBlock(bOk) -- cgit v1.3 From 3a70bf9c0c7d6035788df0801129f44ea410aff5 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Thu, 17 Sep 2015 16:54:15 -0700 Subject: [dev.ssa] cmd/compile: use function calls instead of special ops for panics There's no need for special ops for panicindex and panicslice. Just use regular runtime calls. Change-Id: I71b9b73f4f1ebce1220fdc1e7b7f65cfcf4b7bae Reviewed-on: https://go-review.googlesource.com/14726 Reviewed-by: David Chase --- src/cmd/compile/internal/gc/ssa.go | 26 ++++++--------------- src/cmd/compile/internal/ssa/gen/AMD64.rules | 2 -- src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 2 -- src/cmd/compile/internal/ssa/gen/genericOps.go | 6 ++--- src/cmd/compile/internal/ssa/opGen.go | 20 ---------------- src/cmd/compile/internal/ssa/rewriteAMD64.go | 32 -------------------------- 6 files changed, 9 insertions(+), 79 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 4b71d1f880..b9da5eda7c 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -2312,7 +2312,7 @@ func (s *state) boundsCheck(idx, len *ssa.Value) { // bounds check cmp := s.newValue2(ssa.OpIsInBounds, Types[TBOOL], idx, len) - s.check(cmp, ssa.OpPanicIndexCheck) + s.check(cmp, Panicindex) } // sliceBoundsCheck generates slice bounds checking code. Checks if 0 <= idx <= len, branches to exit if not. @@ -2326,11 +2326,11 @@ func (s *state) sliceBoundsCheck(idx, len *ssa.Value) { // bounds check cmp := s.newValue2(ssa.OpIsSliceInBounds, Types[TBOOL], idx, len) - s.check(cmp, ssa.OpPanicSliceCheck) + s.check(cmp, panicslice) } -// If cmp (a bool) is true, panic using the given op. -func (s *state) check(cmp *ssa.Value, panicOp ssa.Op) { +// 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 @@ -2340,12 +2340,10 @@ func (s *state) check(cmp *ssa.Value, panicOp ssa.Op) { b.AddEdgeTo(bNext) b.AddEdgeTo(bPanic) s.startBlock(bPanic) - // The panic check takes/returns memory to ensure that the right + // The panic call takes/returns memory to ensure that the right // memory state is observed if the panic happens. - chk := s.newValue1(panicOp, ssa.TypeMem, s.mem()) - s.endBlock() - bPanic.Kind = ssa.BlockExit - bPanic.Control = chk + s.rtcall(fn, false, nil) + s.startBlock(bNext) } @@ -3700,16 +3698,6 @@ func (s *genState) genValue(v *ssa.Value) { q.From.Reg = x86.REG_AX q.To.Type = obj.TYPE_MEM q.To.Reg = r - case ssa.OpAMD64LoweredPanicIndexCheck: - p := Prog(obj.ACALL) - p.To.Type = obj.TYPE_MEM - p.To.Name = obj.NAME_EXTERN - p.To.Sym = Linksym(Panicindex.Sym) - case ssa.OpAMD64LoweredPanicSliceCheck: - p := Prog(obj.ACALL) - p.To.Type = obj.TYPE_MEM - p.To.Name = obj.NAME_EXTERN - p.To.Sym = Linksym(panicslice.Sym) case ssa.OpAMD64LoweredGetG: r := regnum(v) // See the comments in cmd/internal/obj/x86/obj6.go diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 26ad70278f..5b83c9781f 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -287,8 +287,6 @@ (IsSliceInBounds idx len) -> (SETBE (CMPQ idx len)) (PanicNilCheck ptr mem) -> (LoweredPanicNilCheck ptr mem) -(PanicIndexCheck mem) -> (LoweredPanicIndexCheck mem) -(PanicSliceCheck mem) -> (LoweredPanicSliceCheck mem) (GetG) -> (LoweredGetG) (Move [size] dst src mem) -> (REPMOVSB dst src (MOVQconst [size]) mem) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index b46dbca6c7..79d45e990a 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -403,8 +403,6 @@ func init() { // Pseudo-ops {name: "LoweredPanicNilCheck", reg: gp10}, - {name: "LoweredPanicIndexCheck"}, - {name: "LoweredPanicSliceCheck"}, {name: "LoweredGetG", reg: gp01}, } diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 1b9006e4e1..ff63fa880c 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -325,10 +325,8 @@ var genericOps = []opData{ {name: "IsSliceInBounds", typ: "Bool"}, // 0 <= arg0 <= arg1 // Pseudo-ops - {name: "PanicNilCheck"}, // trigger a dereference fault; arg0=nil ptr, arg1=mem, returns mem - {name: "PanicIndexCheck"}, // trigger a bounds check failure, arg0=mem, returns mem - {name: "PanicSliceCheck"}, // trigger a slice bounds check failure, arg0=mem, returns mem - {name: "GetG"}, // runtime.getg() (read g pointer) + {name: "PanicNilCheck"}, // trigger a dereference fault; arg0=nil ptr, arg1=mem, returns mem + {name: "GetG"}, // runtime.getg() (read g pointer) // Indexing operations {name: "ArrayIndex"}, // arg0=array, arg1=index. Returns a[i] diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 7e17b7d552..8617cf3e62 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -270,8 +270,6 @@ const ( OpAMD64REPMOVSB OpAMD64InvertFlags OpAMD64LoweredPanicNilCheck - OpAMD64LoweredPanicIndexCheck - OpAMD64LoweredPanicSliceCheck OpAMD64LoweredGetG OpAdd8 @@ -513,8 +511,6 @@ const ( OpIsInBounds OpIsSliceInBounds OpPanicNilCheck - OpPanicIndexCheck - OpPanicSliceCheck OpGetG OpArrayIndex OpPtrIndex @@ -3115,14 +3111,6 @@ var opcodeTable = [...]opInfo{ }, }, }, - { - name: "LoweredPanicIndexCheck", - reg: regInfo{}, - }, - { - name: "LoweredPanicSliceCheck", - reg: regInfo{}, - }, { name: "LoweredGetG", reg: regInfo{ @@ -4088,14 +4076,6 @@ var opcodeTable = [...]opInfo{ name: "PanicNilCheck", generic: true, }, - { - name: "PanicIndexCheck", - generic: true, - }, - { - name: "PanicSliceCheck", - generic: true, - }, { name: "GetG", generic: true, diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index d4b13f3b9a..50510d2351 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -6905,22 +6905,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end6f8a8c559a167d1f0a5901d09a1fb248 end6f8a8c559a167d1f0a5901d09a1fb248: ; - case OpPanicIndexCheck: - // match: (PanicIndexCheck mem) - // cond: - // result: (LoweredPanicIndexCheck mem) - { - mem := v.Args[0] - v.Op = OpAMD64LoweredPanicIndexCheck - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(mem) - return true - } - goto enda5014ba73d3550a5b66424044395c70f - enda5014ba73d3550a5b66424044395c70f: - ; case OpPanicNilCheck: // match: (PanicNilCheck ptr mem) // cond: @@ -6939,22 +6923,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto enda02b1ad5a6f929b782190145f2c8628b enda02b1ad5a6f929b782190145f2c8628b: ; - case OpPanicSliceCheck: - // match: (PanicSliceCheck mem) - // cond: - // result: (LoweredPanicSliceCheck mem) - { - mem := v.Args[0] - v.Op = OpAMD64LoweredPanicSliceCheck - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(mem) - return true - } - goto end238ed0074810b55bd2bba7b45cdeed68 - end238ed0074810b55bd2bba7b45cdeed68: - ; case OpRsh16Ux16: // match: (Rsh16Ux16 x y) // cond: -- cgit v1.3 From 04d6edc36debf5e3ec5420f2522f7ef4341bb65e Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Fri, 18 Sep 2015 18:23:34 -0700 Subject: [dev.ssa] cmd/compile: clean up zeroing. Use duffzero when appropriate. Change-Id: I4deb03340e87f43179d5e22bf81843c17b5581fc Reviewed-on: https://go-review.googlesource.com/14756 Reviewed-by: David Chase --- src/cmd/compile/internal/gc/ssa.go | 27 +- src/cmd/compile/internal/gc/ssa_test.go | 2 + .../compile/internal/gc/testdata/gen/zeroGen.go | 88 ++++ src/cmd/compile/internal/gc/testdata/zero_ssa.go | 563 +++++++++++++++++++++ src/cmd/compile/internal/ssa/gen/AMD64.rules | 53 +- src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 86 ++-- src/cmd/compile/internal/ssa/opGen.go | 11 +- src/cmd/compile/internal/ssa/rewrite.go | 49 ++ src/cmd/compile/internal/ssa/rewriteAMD64.go | 417 +++++++++++++-- 9 files changed, 1183 insertions(+), 113 deletions(-) create mode 100644 src/cmd/compile/internal/gc/testdata/gen/zeroGen.go create mode 100644 src/cmd/compile/internal/gc/testdata/zero_ssa.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index b9da5eda7c..51cf01a9ed 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -3613,22 +3613,12 @@ func (s *genState) genValue(v *ssa.Value) { ssa.OpAMD64CVTTSS2SL, ssa.OpAMD64CVTTSD2SL, ssa.OpAMD64CVTTSS2SQ, ssa.OpAMD64CVTTSD2SQ, ssa.OpAMD64CVTSS2SD, ssa.OpAMD64CVTSD2SS: opregreg(v.Op.Asm(), regnum(v), regnum(v.Args[0])) - case ssa.OpAMD64MOVXzero: - nb := v.AuxInt - offset := int64(0) - reg := regnum(v.Args[0]) - for nb >= 8 { - nb, offset = movZero(x86.AMOVQ, 8, nb, offset, reg) - } - for nb >= 4 { - nb, offset = movZero(x86.AMOVL, 4, nb, offset, reg) - } - for nb >= 2 { - nb, offset = movZero(x86.AMOVW, 2, nb, offset, reg) - } - for nb >= 1 { - nb, offset = movZero(x86.AMOVB, 1, nb, offset, reg) - } + 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.OpCopy: // TODO: lower to MOVQ earlier? if v.Type.IsMemory() { return @@ -3830,11 +3820,6 @@ func (s *genState) genValue(v *ssa.Value) { case ssa.OpAMD64InvertFlags: v.Fatalf("InvertFlags should never make it to codegen %v", v) case ssa.OpAMD64REPSTOSQ: - p := Prog(x86.AXORL) // TODO: lift out zeroing into its own instruction? - p.From.Type = obj.TYPE_REG - p.From.Reg = x86.REG_AX - p.To.Type = obj.TYPE_REG - p.To.Reg = x86.REG_AX Prog(x86.AREP) Prog(x86.ASTOSQ) case ssa.OpAMD64REPMOVSB: diff --git a/src/cmd/compile/internal/gc/ssa_test.go b/src/cmd/compile/internal/gc/ssa_test.go index b63749fcc6..dafbcf2166 100644 --- a/src/cmd/compile/internal/gc/ssa_test.go +++ b/src/cmd/compile/internal/gc/ssa_test.go @@ -87,3 +87,5 @@ 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") } 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 0000000000..90e8029f3f --- /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/zero_ssa.go b/src/cmd/compile/internal/gc/testdata/zero_ssa.go new file mode 100644 index 0000000000..0ec883b7f4 --- /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/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 5b83c9781f..3d308d7ef8 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -565,15 +565,50 @@ // lower Zero instructions with word sizes (Zero [0] _ mem) -> mem -(Zero [1] destptr mem) -> (MOVBstore destptr (MOVBconst [0]) mem) -(Zero [2] destptr mem) -> (MOVWstore destptr (MOVWconst [0]) mem) -(Zero [4] destptr mem) -> (MOVLstore destptr (MOVLconst [0]) mem) -(Zero [8] destptr mem) -> (MOVQstore destptr (MOVQconst [0]) mem) - -// rewrite anything less than 4 words into a series of MOV[BWLQ] $0, ptr(off) instructions -(Zero [size] destptr mem) && size < 4*8 -> (MOVXzero [size] destptr mem) -// Use STOSQ to zero memory. Rewrite this into storing the words with REPSTOSQ and then filling in the remainder with linear moves -(Zero [size] destptr mem) && size >= 4*8 -> (Zero [size%8] (OffPtr [size-(size%8)] destptr) (REPSTOSQ destptr (MOVQconst [size/8]) mem)) +(Zero [1] destptr mem) -> (MOVBstore destptr (MOVBconst [0]) mem) +(Zero [2] destptr mem) -> (MOVWstore destptr (MOVWconst [0]) mem) +(Zero [4] destptr mem) -> (MOVLstore destptr (MOVLconst [0]) mem) +(Zero [8] destptr mem) -> (MOVQstore destptr (MOVQconst [0]) mem) + +(Zero [3] destptr mem) -> + (MOVBstore (ADDQconst [2] destptr) (MOVBconst [0]) + (MOVWstore destptr (MOVWconst [0]) mem)) +(Zero [5] destptr mem) -> + (MOVBstore (ADDQconst [4] destptr) (MOVBconst [0]) + (MOVLstore destptr (MOVLconst [0]) mem)) +(Zero [6] destptr mem) -> + (MOVWstore (ADDQconst [4] destptr) (MOVWconst [0]) + (MOVLstore destptr (MOVLconst [0]) mem)) +(Zero [7] destptr mem) -> + (MOVLstore (ADDQconst [3] destptr) (MOVLconst [0]) + (MOVLstore destptr (MOVLconst [0]) mem)) + +// Strip off any fractional word zeroing. +(Zero [size] destptr mem) && size%8 != 0 && size > 8 -> + (Zero [size-size%8] (ADDQconst destptr [size%8]) + (MOVQstore destptr (MOVQconst [0]) mem)) + +// Zero small numbers of words directly. +(Zero [16] destptr mem) -> + (MOVQstore (ADDQconst [8] destptr) (MOVQconst [0]) + (MOVQstore destptr (MOVQconst [0]) mem)) +(Zero [24] destptr mem) -> + (MOVQstore (ADDQconst [16] destptr) (MOVQconst [0]) + (MOVQstore (ADDQconst [8] destptr) (MOVQconst [0]) + (MOVQstore destptr (MOVQconst [0]) mem))) +(Zero [32] destptr mem) -> + (MOVQstore (ADDQconst [24] destptr) (MOVQconst [0]) + (MOVQstore (ADDQconst [16] destptr) (MOVQconst [0]) + (MOVQstore (ADDQconst [8] destptr) (MOVQconst [0]) + (MOVQstore destptr (MOVQconst [0]) mem)))) + +// Medium zeroing uses a duff device. +(Zero [size] destptr mem) && size <= 1024 && size%8 == 0 -> + (DUFFZERO [duffStart(size)] (ADDQconst [duffAdj(size)] destptr) (MOVQconst [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) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 79d45e990a..6f318d3589 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -117,9 +117,8 @@ func init() { 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}} + gpstore = regInfo{inputs: []regMask{gpspsb, gpsp, 0}} + gpstoreidx = regInfo{inputs: []regMask{gpspsb, gpsp, gpsp, 0}} fp01 = regInfo{inputs: []regMask{}, outputs: fponly} fp21 = regInfo{inputs: []regMask{fp, fp}, outputs: fponly} @@ -167,14 +166,14 @@ func init() { {name: "MOVSDstoreidx8", reg: fpstoreidx, asm: "MOVSD"}, // fp64 indexed by 8i store // binary ops - {name: "ADDQ", reg: gp21, asm: "ADDQ"}, // arg0 + arg1 - {name: "ADDL", reg: gp21, asm: "ADDL"}, // arg0 + arg1 - {name: "ADDW", reg: gp21, asm: "ADDW"}, // arg0 + arg1 - {name: "ADDB", reg: gp21, asm: "ADDB"}, // arg0 + arg1 - {name: "ADDQconst", reg: gp11, asm: "ADDQ"}, // arg0 + auxint - {name: "ADDLconst", reg: gp11, asm: "ADDL"}, // arg0 + auxint - {name: "ADDWconst", reg: gp11, asm: "ADDW"}, // arg0 + auxint - {name: "ADDBconst", reg: gp11, asm: "ADDB"}, // arg0 + auxint + {name: "ADDQ", reg: gp21, asm: "ADDQ"}, // arg0 + arg1 + {name: "ADDL", reg: gp21, asm: "ADDL"}, // arg0 + arg1 + {name: "ADDW", reg: gp21, asm: "ADDW"}, // arg0 + arg1 + {name: "ADDB", reg: gp21, asm: "ADDB"}, // arg0 + arg1 + {name: "ADDQconst", reg: gp11, asm: "ADDQ", typ: "UInt64"}, // arg0 + auxint + {name: "ADDLconst", reg: gp11, asm: "ADDL"}, // arg0 + auxint + {name: "ADDWconst", reg: gp11, asm: "ADDW"}, // arg0 + auxint + {name: "ADDBconst", reg: gp11, asm: "ADDB"}, // arg0 + auxint {name: "SUBQ", reg: gp21, asm: "SUBQ"}, // arg0 - arg1 {name: "SUBL", reg: gp21, asm: "SUBL"}, // arg0 - arg1 @@ -343,10 +342,10 @@ func init() { // clobbers flags as liblink will rewrite these to XOR reg, reg if the constant is zero // TODO: revisit when issue 12405 is fixed - {name: "MOVBconst", reg: gp01flags, asm: "MOVB"}, // 8 low bits of auxint - {name: "MOVWconst", reg: gp01flags, asm: "MOVW"}, // 16 low bits of auxint - {name: "MOVLconst", reg: gp01flags, asm: "MOVL"}, // 32 low bits of auxint - {name: "MOVQconst", reg: gp01flags, asm: "MOVQ"}, // auxint + {name: "MOVBconst", reg: gp01flags, asm: "MOVB", typ: "UInt8"}, // 8 low bits of auxint + {name: "MOVWconst", reg: gp01flags, asm: "MOVW", typ: "UInt16"}, // 16 low bits of auxint + {name: "MOVLconst", reg: gp01flags, asm: "MOVL", typ: "UInt32"}, // 32 low bits of auxint + {name: "MOVQconst", reg: gp01flags, asm: "MOVQ", typ: "UInt64"}, // auxint {name: "CVTTSD2SL", reg: fpgp, asm: "CVTTSD2SL"}, // convert float64 to int32 {name: "CVTTSD2SQ", reg: fpgp, asm: "CVTTSD2SQ"}, // convert float64 to int64 @@ -368,24 +367,45 @@ func init() { {name: "LEAQ8", reg: gp21sb}, // arg0 + 8*arg1 + auxint // auxint+aux == add auxint and the offset of the symbol in aux (if any) to the effective address - {name: "MOVBload", reg: gpload, asm: "MOVB"}, // load byte from arg0+auxint+aux. arg1=mem - {name: "MOVBQSXload", reg: gpload, asm: "MOVBQSX"}, // ditto, extend to int64 - {name: "MOVBQZXload", reg: gpload, asm: "MOVBQZX"}, // ditto, extend to uint64 - {name: "MOVWload", reg: gpload, asm: "MOVW"}, // load 2 bytes from arg0+auxint+aux. arg1=mem - {name: "MOVLload", reg: gpload, asm: "MOVL"}, // load 4 bytes from arg0+auxint+aux. arg1=mem - {name: "MOVQload", reg: gpload, asm: "MOVQ"}, // load 8 bytes from arg0+auxint+aux. arg1=mem - {name: "MOVQloadidx8", reg: gploadidx, asm: "MOVQ"}, // load 8 bytes from arg0+8*arg1+auxint+aux. arg2=mem - {name: "MOVBstore", reg: gpstore, asm: "MOVB"}, // store byte in arg1 to arg0+auxint+aux. arg2=mem - {name: "MOVWstore", reg: gpstore, asm: "MOVW"}, // store 2 bytes in arg1 to arg0+auxint+aux. arg2=mem - {name: "MOVLstore", reg: gpstore, asm: "MOVL"}, // store 4 bytes in arg1 to arg0+auxint+aux. arg2=mem - {name: "MOVQstore", reg: gpstore, asm: "MOVQ"}, // store 8 bytes in arg1 to arg0+auxint+aux. arg2=mem - {name: "MOVQstoreidx8", reg: gpstoreidx, asm: "MOVQ"}, // store 8 bytes in arg2 to arg0+8*arg1+auxint+aux. arg3=mem - - {name: "MOVXzero", reg: gpstoreconst}, // store auxint 0 bytes into arg0 using a series of MOV instructions. arg1=mem. - - {name: "REPSTOSQ", reg: regInfo{[]regMask{buildReg("DI"), buildReg("CX")}, buildReg("DI AX CX FLAGS"), nil}}, // store arg1 8-byte words containing zero into arg0 using STOSQ. arg2=mem. - - //TODO: set register clobber to everything? + {name: "MOVBload", reg: gpload, asm: "MOVB"}, // load byte from arg0+auxint+aux. arg1=mem + {name: "MOVBQSXload", reg: gpload, asm: "MOVBQSX"}, // ditto, extend to int64 + {name: "MOVBQZXload", reg: gpload, asm: "MOVBQZX"}, // ditto, extend to uint64 + {name: "MOVWload", reg: gpload, asm: "MOVW"}, // load 2 bytes from arg0+auxint+aux. arg1=mem + {name: "MOVLload", reg: gpload, asm: "MOVL"}, // load 4 bytes from arg0+auxint+aux. arg1=mem + {name: "MOVQload", reg: gpload, asm: "MOVQ"}, // load 8 bytes from arg0+auxint+aux. arg1=mem + {name: "MOVQloadidx8", reg: gploadidx, asm: "MOVQ"}, // load 8 bytes from arg0+8*arg1+auxint+aux. arg2=mem + {name: "MOVBstore", reg: gpstore, asm: "MOVB", typ: "Mem"}, // store byte in arg1 to arg0+auxint+aux. arg2=mem + {name: "MOVWstore", reg: gpstore, asm: "MOVW", typ: "Mem"}, // store 2 bytes in arg1 to arg0+auxint+aux. arg2=mem + {name: "MOVLstore", reg: gpstore, asm: "MOVL", typ: "Mem"}, // store 4 bytes in arg1 to arg0+auxint+aux. arg2=mem + {name: "MOVQstore", reg: gpstore, asm: "MOVQ", typ: "Mem"}, // store 8 bytes in arg1 to arg0+auxint+aux. arg2=mem + {name: "MOVQstoreidx8", reg: gpstoreidx, asm: "MOVQ"}, // store 8 bytes in arg2 to arg0+8*arg1+auxint+aux. arg3=mem + + // 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", + reg: regInfo{ + inputs: []regMask{buildReg("DI"), buildReg("AX")}, + clobbers: buildReg("DI FLAGS"), + }, + }, + + // 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", + reg: regInfo{ + inputs: []regMask{buildReg("DI"), buildReg("CX"), buildReg("AX")}, + clobbers: buildReg("DI CX FLAGS"), + }, + }, + {name: "CALLstatic", reg: regInfo{clobbers: callerSave}}, // call static function aux.(*gc.Sym). arg0=mem, auxint=argsize, returns mem {name: "CALLclosure", reg: regInfo{[]regMask{gpsp, buildReg("DX"), 0}, callerSave, nil}}, // call function via closure. arg0=codeptr, arg1=closure, arg2=mem, auxint=argsize, returns mem {name: "CALLdefer", reg: regInfo{clobbers: callerSave}}, // call deferproc. arg0=mem, auxint=argsize, returns mem diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 8617cf3e62..0da7946365 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -260,7 +260,7 @@ const ( OpAMD64MOVLstore OpAMD64MOVQstore OpAMD64MOVQstoreidx8 - OpAMD64MOVXzero + OpAMD64DUFFZERO OpAMD64REPSTOSQ OpAMD64CALLstatic OpAMD64CALLclosure @@ -3034,11 +3034,13 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVXzero", + name: "DUFFZERO", reg: regInfo{ inputs: []inputInfo{ - {0, 4295032831}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 .SB + {0, 128}, // .DI + {1, 1}, // .AX }, + clobbers: 8589934720, // .DI .FLAGS }, }, { @@ -3047,8 +3049,9 @@ var opcodeTable = [...]opInfo{ inputs: []inputInfo{ {0, 128}, // .DI {1, 2}, // .CX + {2, 1}, // .AX }, - clobbers: 8589934723, // .AX .CX .DI .FLAGS + clobbers: 8589934722, // .CX .DI .FLAGS }, }, { diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go index 5c47ec6660..4e783062ec 100644 --- a/src/cmd/compile/internal/ssa/rewrite.go +++ b/src/cmd/compile/internal/ssa/rewrite.go @@ -178,3 +178,52 @@ func b2i(b bool) int64 { func f2i(f float64) int64 { return int64(math.Float64bits(f)) } + +// DUFFZERO consists of repeated blocks of 4 MOVs + ADD, +// with 4 STOSQs at the very end. +// The trailing STOSQs prevent the need for a DI preadjustment +// for small numbers of words to clear. +// See runtime/mkduff.go. +const ( + dzBlocks = 31 // 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 + dzDIStep = 8 // number of bytes cleared by each MOV instruction + + dzTailLen = 4 // number of final STOSQ instructions + dzTailSize = 2 // size of single STOSQ instruction + + dzSize = dzBlocks*dzBlockSize + dzTailLen*dzTailSize // total size of DUFFZERO routine +) + +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%8 != 0 { + panic("bad duffzero size") + } + // TODO: arch-dependent + off := int64(dzSize) + off -= dzTailLen * dzTailSize + size -= dzTailLen * dzDIStep + q := size / dzDIStep + blocks, singles := q/dzBlockLen, q%dzBlockLen + off -= dzBlockSize * blocks + var adj int64 + if singles > 0 { + off -= dzAddSize + dzMovSize*singles + adj -= dzDIStep * (dzBlockLen - singles) + } + return off, adj +} diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 50510d2351..590efdb2eb 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -10204,10 +10204,10 @@ func rewriteValueAMD64(v *Value, config *Config) bool { ; // match: (Zero [1] destptr mem) // cond: - // result: (MOVBstore destptr (MOVBconst [0]) mem) + // result: (MOVBstore destptr (MOVBconst [0]) mem) { if v.AuxInt != 1 { - goto end56bcaef03cce4d15c03efff669bb5585 + goto endf7c8ca6a444f19e1142977e2ac42ab24 } destptr := v.Args[0] mem := v.Args[1] @@ -10217,21 +10217,21 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(destptr) v0 := b.NewValue0(v.Line, OpAMD64MOVBconst, TypeInvalid) - v0.Type = config.Frontend().TypeInt8() v0.AuxInt = 0 + v0.Type = config.fe.TypeUInt8() v.AddArg(v0) v.AddArg(mem) return true } - goto end56bcaef03cce4d15c03efff669bb5585 - end56bcaef03cce4d15c03efff669bb5585: + goto endf7c8ca6a444f19e1142977e2ac42ab24 + endf7c8ca6a444f19e1142977e2ac42ab24: ; // match: (Zero [2] destptr mem) // cond: - // result: (MOVWstore destptr (MOVWconst [0]) mem) + // result: (MOVWstore destptr (MOVWconst [0]) mem) { if v.AuxInt != 2 { - goto endf52f08f1f7b0ae220c4cfca6586a8586 + goto end7609a67450ab21eba86f456886fc8496 } destptr := v.Args[0] mem := v.Args[1] @@ -10241,21 +10241,21 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(destptr) v0 := b.NewValue0(v.Line, OpAMD64MOVWconst, TypeInvalid) - v0.Type = config.Frontend().TypeInt16() v0.AuxInt = 0 + v0.Type = config.fe.TypeUInt16() v.AddArg(v0) v.AddArg(mem) return true } - goto endf52f08f1f7b0ae220c4cfca6586a8586 - endf52f08f1f7b0ae220c4cfca6586a8586: + goto end7609a67450ab21eba86f456886fc8496 + end7609a67450ab21eba86f456886fc8496: ; // match: (Zero [4] destptr mem) // cond: - // result: (MOVLstore destptr (MOVLconst [0]) mem) + // result: (MOVLstore destptr (MOVLconst [0]) mem) { if v.AuxInt != 4 { - goto end41c91e0c7a23e233de77812b5264fd10 + goto enda8e1cf1298794cc3cb79cab108e33007 } destptr := v.Args[0] mem := v.Args[1] @@ -10265,21 +10265,21 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(destptr) v0 := b.NewValue0(v.Line, OpAMD64MOVLconst, TypeInvalid) - v0.Type = config.Frontend().TypeInt32() v0.AuxInt = 0 + v0.Type = config.fe.TypeUInt32() v.AddArg(v0) v.AddArg(mem) return true } - goto end41c91e0c7a23e233de77812b5264fd10 - end41c91e0c7a23e233de77812b5264fd10: + goto enda8e1cf1298794cc3cb79cab108e33007 + enda8e1cf1298794cc3cb79cab108e33007: ; // match: (Zero [8] destptr mem) // cond: - // result: (MOVQstore destptr (MOVQconst [0]) mem) + // result: (MOVQstore destptr (MOVQconst [0]) mem) { if v.AuxInt != 8 { - goto end157ad586af643d8dac6cc84a776000ca + goto end1791556f0b03ea065d38a3267fbe01c6 } destptr := v.Args[0] mem := v.Args[1] @@ -10289,70 +10289,395 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.resetArgs() v.AddArg(destptr) v0 := b.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) - v0.Type = config.Frontend().TypeInt64() v0.AuxInt = 0 + v0.Type = config.fe.TypeUInt64() v.AddArg(v0) v.AddArg(mem) return true } - goto end157ad586af643d8dac6cc84a776000ca - end157ad586af643d8dac6cc84a776000ca: + goto end1791556f0b03ea065d38a3267fbe01c6 + end1791556f0b03ea065d38a3267fbe01c6: ; - // match: (Zero [size] destptr mem) - // cond: size < 4*8 - // result: (MOVXzero [size] destptr mem) + // match: (Zero [3] destptr mem) + // cond: + // result: (MOVBstore (ADDQconst [2] destptr) (MOVBconst [0]) (MOVWstore destptr (MOVWconst [0]) mem)) { - size := v.AuxInt + if v.AuxInt != 3 { + goto end7f8f5c8214f8b81a73fdde78b03ce53c + } destptr := v.Args[0] mem := v.Args[1] - if !(size < 4*8) { - goto endf0a22f1506977610ac0a310eee152075 + v.Op = OpAMD64MOVBstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) + v0.AuxInt = 2 + v0.AddArg(destptr) + v0.Type = config.fe.TypeUInt64() + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64MOVBconst, TypeInvalid) + v1.AuxInt = 0 + v1.Type = config.fe.TypeUInt8() + v.AddArg(v1) + v2 := b.NewValue0(v.Line, OpAMD64MOVWstore, TypeInvalid) + v2.AddArg(destptr) + v3 := b.NewValue0(v.Line, OpAMD64MOVWconst, TypeInvalid) + v3.AuxInt = 0 + v3.Type = config.fe.TypeUInt16() + v2.AddArg(v3) + v2.AddArg(mem) + v2.Type = TypeMem + v.AddArg(v2) + return true + } + goto end7f8f5c8214f8b81a73fdde78b03ce53c + end7f8f5c8214f8b81a73fdde78b03ce53c: + ; + // match: (Zero [5] destptr mem) + // cond: + // result: (MOVBstore (ADDQconst [4] destptr) (MOVBconst [0]) (MOVLstore destptr (MOVLconst [0]) mem)) + { + if v.AuxInt != 5 { + goto end54466baa4eac09020bee720efbb82d0f } - v.Op = OpAMD64MOVXzero + destptr := v.Args[0] + mem := v.Args[1] + v.Op = OpAMD64MOVBstore v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = size - v.AddArg(destptr) - v.AddArg(mem) + v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) + v0.AuxInt = 4 + v0.AddArg(destptr) + v0.Type = config.fe.TypeUInt64() + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64MOVBconst, TypeInvalid) + v1.AuxInt = 0 + v1.Type = config.fe.TypeUInt8() + v.AddArg(v1) + v2 := b.NewValue0(v.Line, OpAMD64MOVLstore, TypeInvalid) + v2.AddArg(destptr) + v3 := b.NewValue0(v.Line, OpAMD64MOVLconst, TypeInvalid) + v3.AuxInt = 0 + v3.Type = config.fe.TypeUInt32() + v2.AddArg(v3) + v2.AddArg(mem) + v2.Type = TypeMem + v.AddArg(v2) return true } - goto endf0a22f1506977610ac0a310eee152075 - endf0a22f1506977610ac0a310eee152075: + goto end54466baa4eac09020bee720efbb82d0f + end54466baa4eac09020bee720efbb82d0f: + ; + // match: (Zero [6] destptr mem) + // cond: + // result: (MOVWstore (ADDQconst [4] destptr) (MOVWconst [0]) (MOVLstore destptr (MOVLconst [0]) mem)) + { + if v.AuxInt != 6 { + goto end3a37ae6095ddc37646d6ad6eeda986e2 + } + destptr := v.Args[0] + mem := v.Args[1] + v.Op = OpAMD64MOVWstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) + v0.AuxInt = 4 + v0.AddArg(destptr) + v0.Type = config.fe.TypeUInt64() + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64MOVWconst, TypeInvalid) + v1.AuxInt = 0 + v1.Type = config.fe.TypeUInt16() + v.AddArg(v1) + v2 := b.NewValue0(v.Line, OpAMD64MOVLstore, TypeInvalid) + v2.AddArg(destptr) + v3 := b.NewValue0(v.Line, OpAMD64MOVLconst, TypeInvalid) + v3.AuxInt = 0 + v3.Type = config.fe.TypeUInt32() + v2.AddArg(v3) + v2.AddArg(mem) + v2.Type = TypeMem + v.AddArg(v2) + return true + } + goto end3a37ae6095ddc37646d6ad6eeda986e2 + end3a37ae6095ddc37646d6ad6eeda986e2: + ; + // match: (Zero [7] destptr mem) + // cond: + // result: (MOVLstore (ADDQconst [3] destptr) (MOVLconst [0]) (MOVLstore destptr (MOVLconst [0]) mem)) + { + if v.AuxInt != 7 { + goto endd53a750fa01c5a5a238ba8fcabb416b2 + } + destptr := v.Args[0] + mem := v.Args[1] + v.Op = OpAMD64MOVLstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) + v0.AuxInt = 3 + v0.AddArg(destptr) + v0.Type = config.fe.TypeUInt64() + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64MOVLconst, TypeInvalid) + v1.AuxInt = 0 + v1.Type = config.fe.TypeUInt32() + v.AddArg(v1) + v2 := b.NewValue0(v.Line, OpAMD64MOVLstore, TypeInvalid) + v2.AddArg(destptr) + v3 := b.NewValue0(v.Line, OpAMD64MOVLconst, TypeInvalid) + v3.AuxInt = 0 + v3.Type = config.fe.TypeUInt32() + v2.AddArg(v3) + v2.AddArg(mem) + v2.Type = TypeMem + v.AddArg(v2) + return true + } + goto endd53a750fa01c5a5a238ba8fcabb416b2 + endd53a750fa01c5a5a238ba8fcabb416b2: ; // match: (Zero [size] destptr mem) - // cond: size >= 4*8 - // result: (Zero [size%8] (OffPtr [size-(size%8)] destptr) (REPSTOSQ destptr (MOVQconst [size/8]) mem)) + // cond: size%8 != 0 && size > 8 + // result: (Zero [size-size%8] (ADDQconst destptr [size%8]) (MOVQstore destptr (MOVQconst [0]) mem)) { size := v.AuxInt destptr := v.Args[0] mem := v.Args[1] - if !(size >= 4*8) { - goto end84c39fe2e8d40e0042a10741a0ef16bd + if !(size%8 != 0 && size > 8) { + goto end5efefe1d9cca07e7ad6f4832f774b938 } v.Op = OpZero v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = size % 8 - v0 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v0.Type = config.Frontend().TypeUInt64() - v0.AuxInt = size - (size % 8) + v.AuxInt = size - size%8 + v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) v0.AddArg(destptr) + v0.AuxInt = size % 8 + v0.Type = config.fe.TypeUInt64() v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64REPSTOSQ, TypeInvalid) - v1.Type = TypeMem + v1 := b.NewValue0(v.Line, OpAMD64MOVQstore, TypeInvalid) v1.AddArg(destptr) v2 := b.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) - v2.Type = config.Frontend().TypeUInt64() - v2.AuxInt = size / 8 + v2.AuxInt = 0 + v2.Type = config.fe.TypeUInt64() v1.AddArg(v2) v1.AddArg(mem) + v1.Type = TypeMem + v.AddArg(v1) + return true + } + goto end5efefe1d9cca07e7ad6f4832f774b938 + end5efefe1d9cca07e7ad6f4832f774b938: + ; + // match: (Zero [16] destptr mem) + // cond: + // result: (MOVQstore (ADDQconst [8] destptr) (MOVQconst [0]) (MOVQstore destptr (MOVQconst [0]) mem)) + { + if v.AuxInt != 16 { + goto endad489c16378959a764292e8b1cb72ba2 + } + destptr := v.Args[0] + mem := v.Args[1] + v.Op = OpAMD64MOVQstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) + v0.AuxInt = 8 + v0.AddArg(destptr) + v0.Type = config.fe.TypeUInt64() + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) + v1.AuxInt = 0 + v1.Type = config.fe.TypeUInt64() v.AddArg(v1) + v2 := b.NewValue0(v.Line, OpAMD64MOVQstore, TypeInvalid) + v2.AddArg(destptr) + v3 := b.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) + v3.AuxInt = 0 + v3.Type = config.fe.TypeUInt64() + v2.AddArg(v3) + v2.AddArg(mem) + v2.Type = TypeMem + v.AddArg(v2) + return true + } + goto endad489c16378959a764292e8b1cb72ba2 + endad489c16378959a764292e8b1cb72ba2: + ; + // match: (Zero [24] destptr mem) + // cond: + // result: (MOVQstore (ADDQconst [16] destptr) (MOVQconst [0]) (MOVQstore (ADDQconst [8] destptr) (MOVQconst [0]) (MOVQstore destptr (MOVQconst [0]) mem))) + { + if v.AuxInt != 24 { + goto enddc443320a1be0b3c2e213bd6778197dd + } + destptr := v.Args[0] + mem := v.Args[1] + v.Op = OpAMD64MOVQstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) + v0.AuxInt = 16 + v0.AddArg(destptr) + v0.Type = config.fe.TypeUInt64() + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) + v1.AuxInt = 0 + v1.Type = config.fe.TypeUInt64() + v.AddArg(v1) + v2 := b.NewValue0(v.Line, OpAMD64MOVQstore, TypeInvalid) + v3 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) + v3.AuxInt = 8 + v3.AddArg(destptr) + v3.Type = config.fe.TypeUInt64() + v2.AddArg(v3) + v4 := b.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) + v4.AuxInt = 0 + v4.Type = config.fe.TypeUInt64() + v2.AddArg(v4) + v5 := b.NewValue0(v.Line, OpAMD64MOVQstore, TypeInvalid) + v5.AddArg(destptr) + v6 := b.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) + v6.AuxInt = 0 + v6.Type = config.fe.TypeUInt64() + v5.AddArg(v6) + v5.AddArg(mem) + v5.Type = TypeMem + v2.AddArg(v5) + v2.Type = TypeMem + v.AddArg(v2) + return true + } + goto enddc443320a1be0b3c2e213bd6778197dd + enddc443320a1be0b3c2e213bd6778197dd: + ; + // match: (Zero [32] destptr mem) + // cond: + // result: (MOVQstore (ADDQconst [24] destptr) (MOVQconst [0]) (MOVQstore (ADDQconst [16] destptr) (MOVQconst [0]) (MOVQstore (ADDQconst [8] destptr) (MOVQconst [0]) (MOVQstore destptr (MOVQconst [0]) mem)))) + { + if v.AuxInt != 32 { + goto end282b5e36693f06e2cd1ac563e0d419b5 + } + destptr := v.Args[0] + mem := v.Args[1] + v.Op = OpAMD64MOVQstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) + v0.AuxInt = 24 + v0.AddArg(destptr) + v0.Type = config.fe.TypeUInt64() + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) + v1.AuxInt = 0 + v1.Type = config.fe.TypeUInt64() + v.AddArg(v1) + v2 := b.NewValue0(v.Line, OpAMD64MOVQstore, TypeInvalid) + v3 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) + v3.AuxInt = 16 + v3.AddArg(destptr) + v3.Type = config.fe.TypeUInt64() + v2.AddArg(v3) + v4 := b.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) + v4.AuxInt = 0 + v4.Type = config.fe.TypeUInt64() + v2.AddArg(v4) + v5 := b.NewValue0(v.Line, OpAMD64MOVQstore, TypeInvalid) + v6 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) + v6.AuxInt = 8 + v6.AddArg(destptr) + v6.Type = config.fe.TypeUInt64() + v5.AddArg(v6) + v7 := b.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) + v7.AuxInt = 0 + v7.Type = config.fe.TypeUInt64() + v5.AddArg(v7) + v8 := b.NewValue0(v.Line, OpAMD64MOVQstore, TypeInvalid) + v8.AddArg(destptr) + v9 := b.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) + v9.AuxInt = 0 + v9.Type = config.fe.TypeUInt64() + v8.AddArg(v9) + v8.AddArg(mem) + v8.Type = TypeMem + v5.AddArg(v8) + v5.Type = TypeMem + v2.AddArg(v5) + v2.Type = TypeMem + v.AddArg(v2) + return true + } + goto end282b5e36693f06e2cd1ac563e0d419b5 + end282b5e36693f06e2cd1ac563e0d419b5: + ; + // match: (Zero [size] destptr mem) + // cond: size <= 1024 && size%8 == 0 + // result: (DUFFZERO [duffStart(size)] (ADDQconst [duffAdj(size)] destptr) (MOVQconst [0]) mem) + { + size := v.AuxInt + destptr := v.Args[0] + mem := v.Args[1] + if !(size <= 1024 && size%8 == 0) { + goto endfae59ebc96f670276efea844c3b302ac + } + v.Op = OpAMD64DUFFZERO + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = duffStart(size) + v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) + v0.AuxInt = duffAdj(size) + v0.AddArg(destptr) + v0.Type = config.fe.TypeUInt64() + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) + v1.AuxInt = 0 + v1.Type = config.fe.TypeUInt64() + v.AddArg(v1) + v.AddArg(mem) + return true + } + goto endfae59ebc96f670276efea844c3b302ac + endfae59ebc96f670276efea844c3b302ac: + ; + // match: (Zero [size] destptr mem) + // cond: size > 1024 && size%8 == 0 + // result: (REPSTOSQ destptr (MOVQconst [size/8]) (MOVQconst [0]) mem) + { + size := v.AuxInt + destptr := v.Args[0] + mem := v.Args[1] + if !(size > 1024 && size%8 == 0) { + goto endb9d55d4ba0e70ed918e3ac757727441b + } + v.Op = OpAMD64REPSTOSQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(destptr) + v0 := b.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) + v0.AuxInt = size / 8 + v0.Type = config.fe.TypeUInt64() + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) + v1.AuxInt = 0 + v1.Type = config.fe.TypeUInt64() + v.AddArg(v1) + v.AddArg(mem) return true } - goto end84c39fe2e8d40e0042a10741a0ef16bd - end84c39fe2e8d40e0042a10741a0ef16bd: + goto endb9d55d4ba0e70ed918e3ac757727441b + endb9d55d4ba0e70ed918e3ac757727441b: ; case OpZeroExt16to32: // match: (ZeroExt16to32 x) -- cgit v1.3 From 956f3199a397ef05a4a34b2059d15c033556517a Mon Sep 17 00:00:00 2001 From: David Chase Date: Fri, 11 Sep 2015 16:40:05 -0400 Subject: [dev.ssa] cmd/compile: addressed vars and closures Cleaned up first-block-in-function code. Added cases for |PHEAP for PPARAM and PAUTO. Made PPARAMOUT act more like PAUTO for purposes of address generation and vardef placement. Added cases for OCLOSUREVAR and Ops for getting closure pointer. Closure ops are scheduled at top of entry block to capture DX. Wrote test that seems to show proper behavior for addressed parameters, locals, and returns. Change-Id: Iee93ebf9e3d9f74cfb4d1c1da8038eb278d8a857 Reviewed-on: https://go-review.googlesource.com/14650 Reviewed-by: Keith Randall Run-TryBot: David Chase --- src/cmd/compile/internal/gc/plive.go | 2 +- src/cmd/compile/internal/gc/ssa.go | 56 +++++- src/cmd/compile/internal/gc/ssa_test.go | 2 + src/cmd/compile/internal/gc/syntax.go | 2 +- .../compile/internal/gc/testdata/addressed_ssa.go | 216 +++++++++++++++++++++ src/cmd/compile/internal/ssa/check.go | 2 +- src/cmd/compile/internal/ssa/gen/AMD64.rules | 1 + src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 4 + src/cmd/compile/internal/ssa/gen/genericOps.go | 1 + src/cmd/compile/internal/ssa/opGen.go | 14 ++ src/cmd/compile/internal/ssa/regalloc.go | 10 +- src/cmd/compile/internal/ssa/rewriteAMD64.go | 14 ++ src/cmd/compile/internal/ssa/schedule.go | 37 +++- 13 files changed, 339 insertions(+), 22 deletions(-) create mode 100644 src/cmd/compile/internal/gc/testdata/addressed_ssa.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/plive.go b/src/cmd/compile/internal/gc/plive.go index 2ac639629c..c7414d0c9b 100644 --- a/src/cmd/compile/internal/gc/plive.go +++ b/src/cmd/compile/internal/gc/plive.go @@ -1383,7 +1383,7 @@ func livenessepilogue(lv *Liveness) { } 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) } } } diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 51cf01a9ed..f4d5946c03 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -24,7 +24,7 @@ import ( // it will never return nil, and the bool can be removed. func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { name := fn.Func.Nname.Sym.Name - usessa = strings.HasSuffix(name, "_ssa") || name == os.Getenv("GOSSAFUNC") + usessa = strings.HasSuffix(name, "_ssa") || strings.Contains(name, "_ssa.") || name == os.Getenv("GOSSAFUNC") if usessa { fmt.Println("generating SSA for", name) @@ -76,22 +76,30 @@ func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { s.f.Entry = s.f.NewBlock(ssa.BlockPlain) // Allocate starting values - s.vars = map[*Node]*ssa.Value{} s.labels = map[string]*ssaLabel{} s.labeledNodes = map[*Node]*ssaLabel{} s.startmem = s.entryNewValue0(ssa.OpArg, 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 + // Generate addresses of local declarations s.decladdrs = map[*Node]*ssa.Value{} for d := fn.Func.Dcl; d != nil; d = d.Next { n := d.N switch n.Class { - case PPARAM, PPARAMOUT: + case PPARAM: aux := &ssa.ArgSymbol{Typ: n.Type, Node: n} s.decladdrs[n] = s.entryNewValue1A(ssa.OpAddr, Ptrto(n.Type), aux, s.sp) - case PAUTO: + case PAUTO | PHEAP: + // TODO this looks wrong for PAUTO|PHEAP, no vardef, but also no definition + aux := &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 seems to not occur + // This ends up wrong, have to do it at the PARAM node instead. + case PAUTO, PPARAMOUT: // processed at each use, to prevent Addr coming // before the decl. case PFUNC: @@ -109,7 +117,6 @@ func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { s.decladdrs[nodfp] = s.entryNewValue1A(ssa.OpAddr, Types[TUINTPTR], aux, s.sp) // Convert the AST-based IR to the SSA-based IR - s.startBlock(s.f.Entry) s.stmtList(fn.Func.Enter) s.stmtList(fn.Nbody) @@ -1231,6 +1238,23 @@ func (s *state) expr(n *Node) *ssa.Value { case OCFUNC: aux := &ssa.ExternSymbol{n.Type, n.Left.Sym} return s.entryNewValue1A(ssa.OpAddr, n.Type, aux, s.sb) + case OPARAM: + // Reach through param to expected ONAME w/ PHEAP|PARAM class + // to reference the incoming parameter. Used in initialization + // of heap storage allocated for escaping params, where it appears + // as the RHS of an OAS node. No point doing SSA for this variable, + // this is the only use. + 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} + addr := s.entryNewValue1A(ssa.OpAddr, Ptrto(n.Type), aux, s.sp) + return s.newValue2(ssa.OpLoad, p.Type, addr, s.mem()) case ONAME: if n.Class == PFUNC { // "value" of a function is the address of the function's closure @@ -1243,6 +1267,9 @@ func (s *state) expr(n *Node) *ssa.Value { } addr := s.addr(n) return s.newValue2(ssa.OpLoad, n.Type, addr, s.mem()) + case OCLOSUREVAR: + addr := s.addr(n) + return s.newValue2(ssa.OpLoad, n.Type, addr, s.mem()) case OLITERAL: switch n.Val().Ctype() { case CTINT: @@ -2138,8 +2165,8 @@ func (s *state) addr(n *Node) *ssa.Value { v = s.entryNewValue1I(ssa.OpOffPtr, v.Type, n.Xoffset, v) } return v - case PPARAM, PPARAMOUT: - // parameter/result slot or local variable + case PPARAM: + // parameter slot v := s.decladdrs[n] if v == nil { if flag_race != 0 && n.String() == ".fp" { @@ -2159,7 +2186,10 @@ func (s *state) addr(n *Node) *ssa.Value { // between vardef and addr ops. aux := &ssa.AutoSymbol{Typ: n.Type, Node: n} return s.newValue1A(ssa.OpAddr, Ptrto(n.Type), aux, s.sp) - case PAUTO | PHEAP, PPARAMREF: + case PPARAMOUT: // Same as PAUTO -- cannot generate LEA early. + aux := &ssa.ArgSymbol{Typ: n.Type, Node: n} + return s.newValue1A(ssa.OpAddr, Ptrto(n.Type), 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) @@ -2205,6 +2235,10 @@ func (s *state) addr(n *Node) *ssa.Value { p := s.expr(n.Left) s.nilCheck(p) return s.newValue2(ssa.OpAddPtr, p.Type, p, s.constIntPtr(Types[TUINTPTR], n.Xoffset)) + case OCLOSUREVAR: + return s.newValue2(ssa.OpAddPtr, Ptrto(n.Type), + s.entryNewValue0(ssa.OpGetClosurePtr, Types[TUINTPTR]), + s.constIntPtr(Types[TUINTPTR], n.Xoffset)) default: s.Unimplementedf("unhandled addr %v", Oconv(int(n.Op), 0)) return nil @@ -3688,6 +3722,12 @@ func (s *genState) genValue(v *ssa.Value) { q.From.Reg = x86.REG_AX q.To.Type = obj.TYPE_MEM q.To.Reg = r + 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 diff --git a/src/cmd/compile/internal/gc/ssa_test.go b/src/cmd/compile/internal/gc/ssa_test.go index dafbcf2166..1e06fd0d3d 100644 --- a/src/cmd/compile/internal/gc/ssa_test.go +++ b/src/cmd/compile/internal/gc/ssa_test.go @@ -89,3 +89,5 @@ 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") } diff --git a/src/cmd/compile/internal/gc/syntax.go b/src/cmd/compile/internal/gc/syntax.go index 5081ea0cb9..b71a1e7b0d 100644 --- a/src/cmd/compile/internal/gc/syntax.go +++ b/src/cmd/compile/internal/gc/syntax.go @@ -148,7 +148,7 @@ type Param struct { // Func holds Node fields used only with function-like nodes. type Func struct { Shortname *Node - Enter *NodeList + Enter *NodeList // for example, allocate and initialize memory for escaping parameters Exit *NodeList Cvars *NodeList // closure params Dcl *NodeList // 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 0000000000..f9f459360b --- /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/ssa/check.go b/src/cmd/compile/internal/ssa/check.go index 44ce4a3c71..6c45957fdc 100644 --- a/src/cmd/compile/internal/ssa/check.go +++ b/src/cmd/compile/internal/ssa/check.go @@ -231,7 +231,7 @@ func checkFunc(f *Func) { y = b.Preds[i] } if !domCheck(f, idom, x, y) { - f.Fatalf("arg %d of value %s does not dominate", i, v.LongString()) + f.Fatalf("arg %d of value %s does not dominate, arg=%s", i, v.LongString(), arg.LongString()) } } } diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 3d308d7ef8..b02af9413e 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -288,6 +288,7 @@ (PanicNilCheck ptr mem) -> (LoweredPanicNilCheck ptr mem) (GetG) -> (LoweredGetG) +(GetClosurePtr) -> (LoweredGetClosurePtr) (Move [size] dst src mem) -> (REPMOVSB dst src (MOVQconst [size]) mem) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 6f318d3589..5d171dc87a 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -424,6 +424,10 @@ func init() { // Pseudo-ops {name: "LoweredPanicNilCheck", reg: gp10}, {name: "LoweredGetG", reg: gp01}, + // 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")}}}, } var AMD64blocks = []blockData{ diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index ff63fa880c..1ee38103ac 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -327,6 +327,7 @@ var genericOps = []opData{ // Pseudo-ops {name: "PanicNilCheck"}, // trigger a dereference fault; arg0=nil ptr, arg1=mem, returns mem {name: "GetG"}, // runtime.getg() (read g pointer) + {name: "GetClosurePtr"}, // get closure pointer from dedicated register // Indexing operations {name: "ArrayIndex"}, // arg0=array, arg1=index. Returns a[i] diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 0da7946365..c52ef2d352 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -271,6 +271,7 @@ const ( OpAMD64InvertFlags OpAMD64LoweredPanicNilCheck OpAMD64LoweredGetG + OpAMD64LoweredGetClosurePtr OpAdd8 OpAdd16 @@ -512,6 +513,7 @@ const ( OpIsSliceInBounds OpPanicNilCheck OpGetG + OpGetClosurePtr OpArrayIndex OpPtrIndex OpOffPtr @@ -3122,6 +3124,14 @@ var opcodeTable = [...]opInfo{ }, }, }, + { + name: "LoweredGetClosurePtr", + reg: regInfo{ + outputs: []regMask{ + 4, // .DX + }, + }, + }, { name: "Add8", @@ -4083,6 +4093,10 @@ var opcodeTable = [...]opInfo{ name: "GetG", generic: true, }, + { + name: "GetClosurePtr", + generic: true, + }, { name: "ArrayIndex", generic: true, diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index f529b42fe0..9d0aab64cc 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -333,7 +333,11 @@ func (s *regAllocState) allocReg(mask regMask) register { // farthest-in-the-future use. // TODO: Prefer registers with already spilled Values? // TODO: Modify preference using affinity graph. - mask &^= 1<<4 | 1<<32 // don't spill SP or SB + + // SP and SB are allocated specially. No regular value should + // be allocated to them. + mask &^= 1<<4 | 1<<32 + maxuse := int32(-1) for t := register(0); t < numRegs; t++ { if mask>>t&1 == 0 { @@ -381,9 +385,7 @@ func (s *regAllocState) allocValToReg(v *Value, mask regMask, nospill bool) *Val return s.regs[r].c } - // SP and SB are allocated specially. No regular value should - // be allocated to them. - mask &^= 1<<4 | 1<<32 + mask &^= 1<<4 | 1<<32 // don't spill SP or SB // Allocate a register. r := s.allocReg(mask) diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 590efdb2eb..71cbb8171b 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -2397,6 +2397,20 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto enda617119faaccc0f0c2d23548116cf331 enda617119faaccc0f0c2d23548116cf331: ; + case OpGetClosurePtr: + // match: (GetClosurePtr) + // cond: + // result: (LoweredGetClosurePtr) + { + v.Op = OpAMD64LoweredGetClosurePtr + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + return true + } + goto end6fd0b53f0acb4d35e7d7fa78d2ca1392 + end6fd0b53f0acb4d35e7d7fa78d2ca1392: + ; case OpGetG: // match: (GetG) // cond: diff --git a/src/cmd/compile/internal/ssa/schedule.go b/src/cmd/compile/internal/ssa/schedule.go index e551a6375c..949de31afc 100644 --- a/src/cmd/compile/internal/ssa/schedule.go +++ b/src/cmd/compile/internal/ssa/schedule.go @@ -4,6 +4,17 @@ 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 @@ -21,7 +32,7 @@ func schedule(f *Func) { var order []*Value // priority queue of legally schedulable (0 unscheduled uses) values - var priq [5][]*Value + var priq [ScoreCount][]*Value // maps mem values to the next live memory value nextMem := make([]*Value, f.NumValues()) @@ -69,27 +80,39 @@ func schedule(f *Func) { // 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.") + } + score[v.ID] = ScorePhi case v.Op == OpPhi: // We want all the phis first. - score[v.ID] = 0 + 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] = 1 + 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] = 3 + score[v.ID] = ScoreFlags default: - score[v.ID] = 2 + 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] = 4 + 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 @@ -100,7 +123,7 @@ func schedule(f *Func) { if v.Op != OpPhi { for _, a := range v.Args { if a == b.Control { - score[v.ID] = 4 + score[v.ID] = ScoreControl } } } -- cgit v1.3 From 579ccd831fc9c0e4ed05a904bb0ff61e5124c70c Mon Sep 17 00:00:00 2001 From: David Chase Date: Wed, 23 Sep 2015 09:59:39 -0400 Subject: [dev.ssa] cmd/compile: remove done items from TODO Change-Id: I5ee2953f7d387ef5bc70f6958763f775f0ae72dc Reviewed-on: https://go-review.googlesource.com/14880 Reviewed-by: Brad Fitzpatrick --- src/cmd/compile/internal/ssa/TODO | 2 -- 1 file changed, 2 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/TODO b/src/cmd/compile/internal/ssa/TODO index 3644bf3abd..9d6014e312 100644 --- a/src/cmd/compile/internal/ssa/TODO +++ b/src/cmd/compile/internal/ssa/TODO @@ -3,8 +3,6 @@ be complete soon. Coverage -------- -- Closure args -- PHEAP vars Correctness ----------- -- cgit v1.3 From 9aba7e76f605f7c4fad49886e710152730c34b69 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Mon, 5 Oct 2015 13:48:40 -0700 Subject: [dev.ssa] cmd/compile: Eval append args after growslice For appending large types, we want to evaluate the values being appended after the growslice call, not before. Evaluating them before leads to phi operations on large types which confuses the lowering pass. The order pass has already removed any side-effects from the values being appended, so it doesn't matter if we do this last eval before or after the growslice call. This change fixes a bunch (but not all) of our failed lowerings. Change-Id: I7c697d4d5275d71b7ef4677b830fd86c52ba03a4 Reviewed-on: https://go-review.googlesource.com/15430 Reviewed-by: David Chase Run-TryBot: David Chase --- src/cmd/compile/internal/gc/ssa.go | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index f4d5946c03..7e00fc9162 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1860,18 +1860,12 @@ func (s *state) expr(n *Node) *ssa.Value { // Evaluate slice slice := s.expr(n.List.N) - // Evaluate args - nargs := int64(count(n.List) - 1) - args := make([]*ssa.Value, 0, nargs) - for l := n.List.Next; l != nil; l = l.Next { - args = append(args, s.expr(l.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) @@ -1901,6 +1895,13 @@ func (s *state) expr(n *Node) *ssa.Value { // assign new elements to slots s.startBlock(assign) + + // Evaluate args + args := make([]*ssa.Value, 0, nargs) + for l := n.List.Next; l != nil; l = l.Next { + args = append(args, s.expr(l.N)) + } + 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) -- cgit v1.3 From 808d7c70d5d5107697e4bfacbf66a80cb1d1e06d Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Wed, 7 Oct 2015 14:35:25 -0700 Subject: [dev.ssa] cmd/compile: fix failed lowerings One was OAPPEND of large types. We need to mem-mem copy them instead of storing them. Another was pointer-like struct and array types being put in the data field of an eface. We need to use the underlying pointer type for the load that fills in the eface.data field. Change-Id: Id8278c0381904e52d59011a66ce46386b41b5521 Reviewed-on: https://go-review.googlesource.com/15552 Run-TryBot: Keith Randall Reviewed-by: David Chase --- src/cmd/compile/internal/gc/ssa.go | 40 +++++++++++++++++++++++-- src/cmd/compile/internal/gc/type.go | 41 +++++++++++++++++++++++++ src/cmd/compile/internal/ssa/type.go | 50 +++++++++++++++++++------------ src/cmd/compile/internal/ssa/type_test.go | 42 +++++++++++++++----------- 4 files changed, 134 insertions(+), 39 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 7e00fc9162..69a9b8639b 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1801,6 +1801,31 @@ func (s *state) expr(n *Node) *ssa.Value { 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. + 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, data.Type.FieldOff(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: @@ -1898,8 +1923,15 @@ func (s *state) expr(n *Node) *ssa.Value { // Evaluate args args := make([]*ssa.Value, 0, nargs) + store := make([]bool, 0, nargs) for l := n.List.Next; l != nil; l = l.Next { - args = append(args, s.expr(l.N)) + if canSSAType(l.N.Type) { + args = append(args, s.expr(l.N)) + store = append(store, true) + } else { + args = append(args, s.addr(l.N)) + store = append(store, false) + } } p = s.variable(&ptrVar, pt) // generates phi for ptr @@ -1907,7 +1939,11 @@ func (s *state) expr(n *Node) *ssa.Value { p2 := s.newValue2(ssa.OpPtrIndex, pt, p, l) for i, arg := range args { addr := s.newValue2(ssa.OpPtrIndex, pt, p2, s.constInt(Types[TUINTPTR], int64(i))) - s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, et.Size(), addr, arg, s.mem()) + if store[i] { + s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, et.Size(), addr, arg, s.mem()) + } else { + s.vars[&memVar] = s.newValue3I(ssa.OpMove, ssa.TypeMem, et.Size(), addr, arg, s.mem()) + } if haspointers(et) { // TODO: just one write barrier call for all of these writes? // TODO: maybe just one writeBarrierEnabled check? diff --git a/src/cmd/compile/internal/gc/type.go b/src/cmd/compile/internal/gc/type.go index 3e07df367d..87af2860e8 100644 --- a/src/cmd/compile/internal/gc/type.go +++ b/src/cmd/compile/internal/gc/type.go @@ -88,6 +88,10 @@ 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 } @@ -99,5 +103,42 @@ 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 } diff --git a/src/cmd/compile/internal/ssa/type.go b/src/cmd/compile/internal/ssa/type.go index 6800731de6..d558881b2f 100644 --- a/src/cmd/compile/internal/ssa/type.go +++ b/src/cmd/compile/internal/ssa/type.go @@ -21,14 +21,21 @@ type Type interface { IsString() bool IsSlice() bool IsArray() bool + IsStruct() bool IsInterface() bool IsMemory() bool // special ssa-package-only types IsFlags() bool - Elem() Type // given []T or *T, return T + 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 @@ -41,24 +48,29 @@ type CompilerType struct { Flags 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) IsInterface() bool { return false } -func (t *CompilerType) IsMemory() bool { return t.Memory } -func (t *CompilerType) IsFlags() bool { return t.Flags } -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) 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) 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") } func (t *CompilerType) Equal(u Type) bool { x, ok := u.(*CompilerType) diff --git a/src/cmd/compile/internal/ssa/type_test.go b/src/cmd/compile/internal/ssa/type_test.go index f3ac0aec2c..c8889608db 100644 --- a/src/cmd/compile/internal/ssa/type_test.go +++ b/src/cmd/compile/internal/ssa/type_test.go @@ -17,30 +17,36 @@ type TypeImpl struct { 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) IsInterface() bool { return t.inter } -func (t *TypeImpl) IsMemory() bool { return false } -func (t *TypeImpl) IsFlags() 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) 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) 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) -- cgit v1.3 From 8824dccc282884919e6747396d7ff704825b5076 Mon Sep 17 00:00:00 2001 From: David Chase Date: Thu, 8 Oct 2015 12:39:56 -0400 Subject: [dev.ssa] cmd/compile: fixed heap-escaped-paramout Changed tree generation to correctly use PARAMOUT instead of PARAM. Emit Func.Exit before any returns. Change-Id: I2fa53cc7fad05fb4eea21081ba33d1f66db4ed49 Reviewed-on: https://go-review.googlesource.com/15610 Reviewed-by: Keith Randall Run-TryBot: David Chase --- src/cmd/compile/internal/gc/gsubr.go | 15 ++++++++++++++- src/cmd/compile/internal/gc/ssa.go | 15 +++++++++++++-- src/cmd/compile/internal/gc/walk.go | 2 +- 3 files changed, 28 insertions(+), 4 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/gsubr.go b/src/cmd/compile/internal/gc/gsubr.go index 7e085d94b2..ecb2303196 100644 --- a/src/cmd/compile/internal/gc/gsubr.go +++ b/src/cmd/compile/internal/gc/gsubr.go @@ -507,6 +507,16 @@ func newplist() *obj.Plist { 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 @@ -532,7 +542,7 @@ func nodarg(t *Type, fp int) *Node { Fatalf("nodarg: not field %v", t) } - if fp == 1 { + if fp == 1 || fp == -1 { var n *Node for l := Curfn.Func.Dcl; l != nil; l = l.Next { n = l.N @@ -573,6 +583,9 @@ fp: 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/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 69a9b8639b..629774c2bc 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -30,6 +30,7 @@ func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { fmt.Println("generating SSA for", name) dumplist("buildssa-enter", fn.Func.Enter) dumplist("buildssa-body", fn.Nbody) + dumplist("buildssa-exit", fn.Func.Exit) } var s state @@ -43,6 +44,7 @@ func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { s.config = ssa.NewConfig(Thearch.Thestring, &e) s.f = s.config.NewFunc() s.f.Name = name + s.exitCode = fn.Func.Exit if name == os.Getenv("GOSSAFUNC") { // TODO: tempfile? it is handy to have the location @@ -97,8 +99,8 @@ func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { // TODO this looks wrong for PAUTO|PHEAP, no vardef, but also no definition aux := &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 seems to not occur - // This ends up wrong, have to do it at the PARAM node instead. + case PPARAM | PHEAP, PPARAMOUT | PHEAP: + // This ends up wrong, have to do it at the PARAM node instead. case PAUTO, PPARAMOUT: // processed at each use, to prevent Addr coming // before the decl. @@ -122,6 +124,7 @@ func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { // fallthrough to exit if s.curBlock != nil { + s.stmtList(s.exitCode) m := s.mem() b := s.endBlock() b.Kind = ssa.BlockRet @@ -156,6 +159,9 @@ func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { // Link up variable uses to variable definitions s.linkForwardReferences() + // Don't carry reference this around longer than necessary + s.exitCode = nil + // Main call to ssa package to compile function ssa.Compile(s.f) @@ -207,6 +213,9 @@ type state struct { // 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 *NodeList // unlabeled break and continue statement tracking breakTo *ssa.Block // current target for plain break statement @@ -641,12 +650,14 @@ func (s *state) stmt(n *Node) { case ORETURN: s.stmtList(n.List) + s.stmtList(s.exitCode) m := s.mem() b := s.endBlock() b.Kind = ssa.BlockRet b.Control = m case ORETJMP: s.stmtList(n.List) + s.stmtList(s.exitCode) m := s.mem() b := s.endBlock() b.Kind = ssa.BlockRetJmp diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go index ae19e6fda5..27890f2d9b 100644 --- a/src/cmd/compile/internal/gc/walk.go +++ b/src/cmd/compile/internal/gc/walk.go @@ -2674,7 +2674,7 @@ func paramstoheap(argin **Type, out int) *NodeList { // 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 = list(nn, Nod(OAS, nodarg(t, 1), nil)) + nn = list(nn, Nod(OAS, nodarg(t, -1), nil)) } if v == nil || v.Class&PHEAP == 0 { -- cgit v1.3 From 32ffbf7e0f1e79b28eb7da7bc21ab7ce478ef3ef Mon Sep 17 00:00:00 2001 From: David Chase Date: Thu, 8 Oct 2015 17:14:12 -0400 Subject: [dev.ssa] cmd/compile: handle addr of PARAM nodes Turns out that these do occur after all, so did the obvious refactoring into the addr method. Also added better debugging for the case of unhandled closure args. Change-Id: I1cd8ac58f78848bae0b995736f1c744fd20a6c95 Reviewed-on: https://go-review.googlesource.com/15640 Reviewed-by: Keith Randall Run-TryBot: David Chase --- src/cmd/compile/internal/gc/ssa.go | 31 ++++++++++++++----------------- 1 file changed, 14 insertions(+), 17 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 629774c2bc..45ae132cde 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1250,22 +1250,8 @@ func (s *state) expr(n *Node) *ssa.Value { aux := &ssa.ExternSymbol{n.Type, n.Left.Sym} return s.entryNewValue1A(ssa.OpAddr, n.Type, aux, s.sb) case OPARAM: - // Reach through param to expected ONAME w/ PHEAP|PARAM class - // to reference the incoming parameter. Used in initialization - // of heap storage allocated for escaping params, where it appears - // as the RHS of an OAS node. No point doing SSA for this variable, - // this is the only use. - 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} - addr := s.entryNewValue1A(ssa.OpAddr, Ptrto(n.Type), aux, s.sp) - return s.newValue2(ssa.OpLoad, p.Type, addr, s.mem()) + addr := s.addr(n) + 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 @@ -2287,6 +2273,17 @@ func (s *state) addr(n *Node) *ssa.Value { return s.newValue2(ssa.OpAddPtr, Ptrto(n.Type), s.entryNewValue0(ssa.OpGetClosurePtr, Types[TUINTPTR]), s.constIntPtr(Types[TUINTPTR], 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, Ptrto(n.Type), aux, s.sp) default: s.Unimplementedf("unhandled addr %v", Oconv(int(n.Op), 0)) return nil @@ -3072,7 +3069,7 @@ func (s *state) lookupVarIncoming(b *ssa.Block, t ssa.Type, name *Node) *ssa.Val addr := s.decladdrs[name] if addr == nil { // TODO: closure args reach here. - s.Unimplementedf("unhandled closure arg") + 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) -- cgit v1.3 From 9703564c9aaa037b95b6dcbdefe0fa505710c4ff Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Fri, 9 Oct 2015 09:33:29 -0700 Subject: [dev.ssa] cmd/compile: make sure we don't move loads between blocks This can lead to multiple stores being live at once. Do OINDEX and ODOT using addresses & loads instead of specific ops. This keeps SSA values from containing unSSAable types. Change-Id: I79567e9d43cdee09084eb89ea0bd7aa3aad48ada Reviewed-on: https://go-review.googlesource.com/15654 Run-TryBot: Keith Randall Reviewed-by: David Chase --- src/cmd/compile/internal/gc/ssa.go | 39 +++++++++++++------------- src/cmd/compile/internal/ssa/gen/generic.rules | 4 +-- src/cmd/compile/internal/ssa/rewritegeneric.go | 22 +++++++++------ 3 files changed, 36 insertions(+), 29 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 45ae132cde..b568c58fba 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1732,8 +1732,9 @@ func (s *state) expr(n *Node) *ssa.Value { return s.newValue2(ssa.OpLoad, n.Type, p, s.mem()) case ODOT: - v := s.expr(n.Left) - return s.newValue1I(ssa.OpStructSelect, n.Type, n.Xoffset, v) + // TODO: fix when we can SSA struct types. + p := s.addr(n) + return s.newValue2(ssa.OpLoad, n.Type, p, s.mem()) case ODOTPTR: p := s.expr(n.Left) @@ -1742,29 +1743,29 @@ func (s *state) expr(n *Node) *ssa.Value { return s.newValue2(ssa.OpLoad, n.Type, p, s.mem()) case OINDEX: - if n.Left.Type.Bound >= 0 { // array or string + switch { + case n.Left.Type.IsString(): a := s.expr(n.Left) i := s.expr(n.Right) i = s.extendIndex(i) - if n.Left.Type.IsString() { - 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()) - } else { - if !n.Bounded { - len := s.constInt(Types[TINT], n.Left.Type.Bound) - s.boundsCheck(i, len) - } - return s.newValue2(ssa.OpArrayIndex, n.Left.Type.Type, a, i) + if !n.Bounded { + len := s.newValue1(ssa.OpStringLen, Types[TINT], a) + s.boundsCheck(i, len) } - } else { // slice + 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) + 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) 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: diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index 8195d6b010..1de7a6b00f 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -75,9 +75,9 @@ // indexing operations // Note: bounds check has already been done -(ArrayIndex (Load ptr mem) idx) -> (Load (PtrIndex ptr idx) mem) +(ArrayIndex (Load ptr mem) idx) && b == v.Args[0].Block -> (Load (PtrIndex ptr idx) mem) (PtrIndex ptr idx) -> (AddPtr ptr (MulPtr idx (ConstPtr [t.Elem().Size()]))) -(StructSelect [idx] (Load ptr mem)) -> (Load (OffPtr [idx] ptr) mem) +(StructSelect [idx] (Load ptr mem)) && b == v.Args[0].Block -> (Load (OffPtr [idx] ptr) mem) // complex ops (ComplexReal (ComplexMake real _ )) -> real diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index 8534e2a865..99c49a8c79 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -136,15 +136,18 @@ func rewriteValuegeneric(v *Value, config *Config) bool { ; case OpArrayIndex: // match: (ArrayIndex (Load ptr mem) idx) - // cond: + // cond: b == v.Args[0].Block // result: (Load (PtrIndex ptr idx) mem) { if v.Args[0].Op != OpLoad { - goto end4894dd7b58383fee5f8a92be08437c33 + goto end68b373270d9d605c420497edefaa71df } ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] idx := v.Args[1] + if !(b == v.Args[0].Block) { + goto end68b373270d9d605c420497edefaa71df + } v.Op = OpLoad v.AuxInt = 0 v.Aux = nil @@ -157,8 +160,8 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto end4894dd7b58383fee5f8a92be08437c33 - end4894dd7b58383fee5f8a92be08437c33: + goto end68b373270d9d605c420497edefaa71df + end68b373270d9d605c420497edefaa71df: ; case OpCom16: // match: (Com16 (Com16 x)) @@ -1510,15 +1513,18 @@ func rewriteValuegeneric(v *Value, config *Config) bool { ; case OpStructSelect: // match: (StructSelect [idx] (Load ptr mem)) - // cond: + // cond: b == v.Args[0].Block // result: (Load (OffPtr [idx] ptr) mem) { idx := v.AuxInt if v.Args[0].Op != OpLoad { - goto end16fdb45e1dd08feb36e3cc3fb5ed8935 + goto endd1a92da3e00c16a8f5bd3bd30deca298 } ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] + if !(b == v.Args[0].Block) { + goto endd1a92da3e00c16a8f5bd3bd30deca298 + } v.Op = OpLoad v.AuxInt = 0 v.Aux = nil @@ -1531,8 +1537,8 @@ func rewriteValuegeneric(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto end16fdb45e1dd08feb36e3cc3fb5ed8935 - end16fdb45e1dd08feb36e3cc3fb5ed8935: + goto endd1a92da3e00c16a8f5bd3bd30deca298 + endd1a92da3e00c16a8f5bd3bd30deca298: ; case OpSub16: // match: (Sub16 x x) -- cgit v1.3 From 177b697ba534431a266c9882af53fb776eb9b505 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Tue, 13 Oct 2015 11:08:08 -0700 Subject: [dev.ssa] cmd/compile: allow rewrite rules to specify a target block Some rewrite rules need to make sure the rewrite target ends up in a specific block. For example: (MOVBQSX (MOVBload [off] {sym} ptr mem)) -> @v.Args[0].Block (MOVBQSXload [off] {sym} ptr mem) The MOVBQSXload op needs to be in the same block as the MOVBload (to ensure exactly one memory is live at basic block boundaries). Change-Id: Ibe49a4183ca91f6c859cba8135927f01d176e064 Reviewed-on: https://go-review.googlesource.com/15804 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/ssa/gen/AMD64.rules | 6 +-- src/cmd/compile/internal/ssa/gen/generic.rules | 2 +- src/cmd/compile/internal/ssa/gen/rulegen.go | 29 ++++++++++---- src/cmd/compile/internal/ssa/rewriteAMD64.go | 52 +++++++++++++------------- src/cmd/compile/internal/ssa/rewritegeneric.go | 28 +++++++------- 5 files changed, 65 insertions(+), 52 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index b02af9413e..f160ce81af 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -478,10 +478,8 @@ // 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. -// TODO: somehow have this rewrite rule put the new MOVBQSXload in -// v.Args[0].Block instead of in v.Block? -(MOVBQSX (MOVBload [off] {sym} ptr mem)) && b == v.Args[0].Block -> (MOVBQSXload [off] {sym} ptr mem) -(MOVBQZX (MOVBload [off] {sym} ptr mem)) && b == v.Args[0].Block -> (MOVBQZXload [off] {sym} ptr mem) +(MOVBQSX (MOVBload [off] {sym} ptr mem)) -> @v.Args[0].Block (MOVBQSXload [off] {sym} ptr mem) +(MOVBQZX (MOVBload [off] {sym} ptr mem)) -> @v.Args[0].Block (MOVBQZXload [off] {sym} ptr mem) // TODO: more // Don't extend before storing diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index 1de7a6b00f..01026042bf 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -77,7 +77,7 @@ // Note: bounds check has already been done (ArrayIndex (Load ptr mem) idx) && b == v.Args[0].Block -> (Load (PtrIndex ptr idx) mem) (PtrIndex ptr idx) -> (AddPtr ptr (MulPtr idx (ConstPtr [t.Elem().Size()]))) -(StructSelect [idx] (Load ptr mem)) && b == v.Args[0].Block -> (Load (OffPtr [idx] ptr) mem) +(StructSelect [idx] (Load ptr mem)) -> @v.Args[0].Block (Load (OffPtr [idx] ptr) mem) // complex ops (ComplexReal (ComplexMake real _ )) -> real diff --git a/src/cmd/compile/internal/ssa/gen/rulegen.go b/src/cmd/compile/internal/ssa/gen/rulegen.go index 5dcbf1ee1c..80371c94c4 100644 --- a/src/cmd/compile/internal/ssa/gen/rulegen.go +++ b/src/cmd/compile/internal/ssa/gen/rulegen.go @@ -26,7 +26,7 @@ import ( ) // rule syntax: -// sexpr [&& extra conditions] -> sexpr +// sexpr [&& extra conditions] -> [@block] sexpr // // sexpr are s-expressions (lisp-like parenthesized groupings) // sexpr ::= (opcode sexpr*) @@ -266,7 +266,7 @@ func genRules(arch 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)) + fmt.Fprintf(w, "b.Control = %s\n", genResult0(w, arch, t[1], new(int), false, "b")) } if len(newsuccs) < len(succs) { fmt.Fprintf(w, "b.Succs = b.Succs[:%d]\n", len(newsuccs)) @@ -407,9 +407,16 @@ func genMatch0(w io.Writer, arch arch, match, v, fail string, m map[string]strin } func genResult(w io.Writer, arch arch, result string) { - genResult0(w, arch, result, new(int), true) + loc := "b" + if result[0] == '@' { + // parse @block directive + s := strings.SplitN(result[1:], " ", 2) + loc = s[0] + result = s[1] + } + genResult0(w, arch, result, new(int), true, loc) } -func genResult0(w io.Writer, arch arch, result string, alloc *int, top bool) string { +func genResult0(w io.Writer, arch arch, result string, alloc *int, top bool, loc string) string { if result[0] != '(' { // variable if top { @@ -429,7 +436,7 @@ func genResult0(w io.Writer, arch arch, result string, alloc *int, top bool) str s := split(result[1 : len(result)-1]) // remove parens, then split var v string var hasType bool - if top { + if top && loc == "b" { v = "v" fmt.Fprintf(w, "v.Op = %s\n", opName(s[0], arch)) fmt.Fprintf(w, "v.AuxInt = 0\n") @@ -439,7 +446,15 @@ func genResult0(w io.Writer, arch arch, result string, alloc *int, top bool) str } else { v = fmt.Sprintf("v%d", *alloc) *alloc++ - fmt.Fprintf(w, "%s := b.NewValue0(v.Line, %s, TypeInvalid)\n", v, opName(s[0], arch)) + fmt.Fprintf(w, "%s := %s.NewValue0(v.Line, %s, TypeInvalid)\n", v, loc, opName(s[0], arch)) + if top { + // Rewrite original into a copy + fmt.Fprintf(w, "v.Op = OpCopy\n") + fmt.Fprintf(w, "v.AuxInt = 0\n") + fmt.Fprintf(w, "v.Aux = nil\n") + fmt.Fprintf(w, "v.resetArgs()\n") + fmt.Fprintf(w, "v.AddArg(%s)\n", v) + } } for _, a := range s[1:] { if a[0] == '<' { @@ -457,7 +472,7 @@ func genResult0(w io.Writer, arch arch, result string, alloc *int, top bool) str fmt.Fprintf(w, "%s.Aux = %s\n", v, x) } else { // regular argument (sexpr or variable) - x := genResult0(w, arch, a, alloc, false) + x := genResult0(w, arch, a, alloc, false, loc) fmt.Fprintf(w, "%s.AddArg(%s)\n", v, x) } } diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 71cbb8171b..4ac4744b64 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -3973,59 +3973,59 @@ func rewriteValueAMD64(v *Value, config *Config) bool { ; case OpAMD64MOVBQSX: // match: (MOVBQSX (MOVBload [off] {sym} ptr mem)) - // cond: b == v.Args[0].Block - // result: (MOVBQSXload [off] {sym} ptr mem) + // cond: + // result: @v.Args[0].Block (MOVBQSXload [off] {sym} ptr mem) { if v.Args[0].Op != OpAMD64MOVBload { - goto end4fcdab76af223d4a6b942b532ebf860b + goto end19c38f3a1a37dca50637c917fa26e4f7 } off := v.Args[0].AuxInt sym := v.Args[0].Aux ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] - if !(b == v.Args[0].Block) { - goto end4fcdab76af223d4a6b942b532ebf860b - } - v.Op = OpAMD64MOVBQSXload + v0 := v.Args[0].Block.NewValue0(v.Line, OpAMD64MOVBQSXload, TypeInvalid) + v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = off - v.Aux = sym - v.AddArg(ptr) - v.AddArg(mem) + v.AddArg(v0) + v0.Type = v.Type + v0.AuxInt = off + v0.Aux = sym + v0.AddArg(ptr) + v0.AddArg(mem) return true } - goto end4fcdab76af223d4a6b942b532ebf860b - end4fcdab76af223d4a6b942b532ebf860b: + goto end19c38f3a1a37dca50637c917fa26e4f7 + end19c38f3a1a37dca50637c917fa26e4f7: ; case OpAMD64MOVBQZX: // match: (MOVBQZX (MOVBload [off] {sym} ptr mem)) - // cond: b == v.Args[0].Block - // result: (MOVBQZXload [off] {sym} ptr mem) + // cond: + // result: @v.Args[0].Block (MOVBQZXload [off] {sym} ptr mem) { if v.Args[0].Op != OpAMD64MOVBload { - goto endce35c966b0a38aa124a610e5616a220c + goto end1169bcf3d56fa24321b002eaebd5a62d } off := v.Args[0].AuxInt sym := v.Args[0].Aux ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] - if !(b == v.Args[0].Block) { - goto endce35c966b0a38aa124a610e5616a220c - } - v.Op = OpAMD64MOVBQZXload + v0 := v.Args[0].Block.NewValue0(v.Line, OpAMD64MOVBQZXload, TypeInvalid) + v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = off - v.Aux = sym - v.AddArg(ptr) - v.AddArg(mem) + v.AddArg(v0) + v0.Type = v.Type + v0.AuxInt = off + v0.Aux = sym + v0.AddArg(ptr) + v0.AddArg(mem) return true } - goto endce35c966b0a38aa124a610e5616a220c - endce35c966b0a38aa124a610e5616a220c: + goto end1169bcf3d56fa24321b002eaebd5a62d + end1169bcf3d56fa24321b002eaebd5a62d: ; case OpAMD64MOVBload: // match: (MOVBload [off1] {sym} (ADDQconst [off2] ptr) mem) diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index 99c49a8c79..46d97b57e3 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -1513,32 +1513,32 @@ func rewriteValuegeneric(v *Value, config *Config) bool { ; case OpStructSelect: // match: (StructSelect [idx] (Load ptr mem)) - // cond: b == v.Args[0].Block - // result: (Load (OffPtr [idx] ptr) mem) + // cond: + // result: @v.Args[0].Block (Load (OffPtr [idx] ptr) mem) { idx := v.AuxInt if v.Args[0].Op != OpLoad { - goto endd1a92da3e00c16a8f5bd3bd30deca298 + goto end27abc5bf0299ce1bd5457af6ce8e3fba } ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] - if !(b == v.Args[0].Block) { - goto endd1a92da3e00c16a8f5bd3bd30deca298 - } - v.Op = OpLoad + v0 := v.Args[0].Block.NewValue0(v.Line, OpLoad, TypeInvalid) + v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v0.Type = v.Type.PtrTo() - v0.AuxInt = idx - v0.AddArg(ptr) v.AddArg(v0) - v.AddArg(mem) + v0.Type = v.Type + v1 := v.Args[0].Block.NewValue0(v.Line, OpOffPtr, TypeInvalid) + v1.Type = v.Type.PtrTo() + v1.AuxInt = idx + v1.AddArg(ptr) + v0.AddArg(v1) + v0.AddArg(mem) return true } - goto endd1a92da3e00c16a8f5bd3bd30deca298 - endd1a92da3e00c16a8f5bd3bd30deca298: + goto end27abc5bf0299ce1bd5457af6ce8e3fba + end27abc5bf0299ce1bd5457af6ce8e3fba: ; case OpSub16: // match: (Sub16 x x) -- cgit v1.3 From 57670ad8b29fb62dc87e970fde95e3263f6948ff Mon Sep 17 00:00:00 2001 From: David Chase Date: Fri, 9 Oct 2015 16:48:30 -0400 Subject: [dev.ssa] cmd/compile: fill remaining SSA gaps Changed racewalk/race detector to use FP in a more sensible way. Relaxed checks for CONVNOP when race detecting. Modified tighten to ensure that GetClosurePtr cannot float out of entry block (turns out this cannot be relaxed, DX is sometimes stomped by other code accompanying race detection). Added case for addr(CONVNOP) Modified addr to take "bounded" flag to suppress nilchecks where it is set (usually, by race detector). Cannot leave unimplemented-complainer enabled because it turns out we are optimistically running SSA on every platform. Change-Id: Ife021654ee4065b3ffac62326d09b4b317b9f2e0 Reviewed-on: https://go-review.googlesource.com/15710 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/builtin.go | 1 + src/cmd/compile/internal/gc/builtin/runtime.go | 1 + src/cmd/compile/internal/gc/racewalk.go | 14 ++------ src/cmd/compile/internal/gc/ssa.go | 47 ++++++++++++++++---------- src/cmd/compile/internal/ssa/schedule.go | 2 +- src/cmd/compile/internal/ssa/tighten.go | 3 +- src/runtime/race_amd64.s | 16 ++++++++- 7 files changed, 53 insertions(+), 31 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/builtin.go b/src/cmd/compile/internal/gc/builtin.go index 0e5fe2ab60..66f66a7690 100644 --- a/src/cmd/compile/internal/gc/builtin.go +++ b/src/cmd/compile/internal/gc/builtin.go @@ -151,6 +151,7 @@ const runtimeimport = "" + "func @\"\".uint64tofloat64 (? uint64) (? float64)\n" + "func @\"\".complex128div (@\"\".num·2 complex128, @\"\".den·3 complex128) (@\"\".quo·1 complex128)\n" + "func @\"\".racefuncenter (? uintptr)\n" + + "func @\"\".racefuncenterfp (? *int32)\n" + "func @\"\".racefuncexit ()\n" + "func @\"\".raceread (? uintptr)\n" + "func @\"\".racewrite (? uintptr)\n" + diff --git a/src/cmd/compile/internal/gc/builtin/runtime.go b/src/cmd/compile/internal/gc/builtin/runtime.go index f8487de45b..43c35ca850 100644 --- a/src/cmd/compile/internal/gc/builtin/runtime.go +++ b/src/cmd/compile/internal/gc/builtin/runtime.go @@ -189,6 +189,7 @@ func complex128div(num complex128, den complex128) (quo complex128) // race detection func racefuncenter(uintptr) +func racefuncenterfp(*int32) func racefuncexit() func raceread(uintptr) func racewrite(uintptr) diff --git a/src/cmd/compile/internal/gc/racewalk.go b/src/cmd/compile/internal/gc/racewalk.go index 9301d87d2e..852ae98ec1 100644 --- a/src/cmd/compile/internal/gc/racewalk.go +++ b/src/cmd/compile/internal/gc/racewalk.go @@ -11,7 +11,7 @@ import ( // The racewalk pass modifies the code tree for 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. @@ -26,7 +26,7 @@ import ( // at best instrumentation would cause infinite recursion. var omit_pkgs = []string{"runtime", "runtime/race"} -// 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 noinst_pkgs = []string{"sync", "sync/atomic"} @@ -64,15 +64,7 @@ func racewalk(fn *Node) { racewalklist(fn.Func.Exit, nil) } - // nodpc is the PC of the caller as extracted by - // getcallerpc. We use -widthptr(FP) for x86. - // BUG: this will not work on arm. - nodpc := Nod(OXXX, nil, nil) - - *nodpc = *nodfp - nodpc.Type = Types[TUINTPTR] - nodpc.Xoffset = int64(-Widthptr) - nd := mkcall("racefuncenter", nil, nil, nodpc) + nd := mkcall("racefuncenterfp", nil, nil, Nod(OADDR, nodfp, nil)) fn.Func.Enter = concat(list1(nd), fn.Func.Enter) nd = mkcall("racefuncexit", nil, nil) fn.Func.Exit = list(fn.Func.Exit, nd) diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index b568c58fba..312d494f5d 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1250,7 +1250,7 @@ func (s *state) expr(n *Node) *ssa.Value { aux := &ssa.ExternSymbol{n.Type, n.Left.Sym} return s.entryNewValue1A(ssa.OpAddr, n.Type, aux, s.sb) case OPARAM: - addr := s.addr(n) + addr := s.addr(n, false) return s.newValue2(ssa.OpLoad, n.Left.Type, addr, s.mem()) case ONAME: if n.Class == PFUNC { @@ -1262,10 +1262,10 @@ func (s *state) expr(n *Node) *ssa.Value { if canSSA(n) { return s.variable(n, n.Type) } - addr := s.addr(n) + addr := s.addr(n, false) return s.newValue2(ssa.OpLoad, n.Type, addr, s.mem()) case OCLOSUREVAR: - addr := s.addr(n) + addr := s.addr(n, false) return s.newValue2(ssa.OpLoad, n.Type, addr, s.mem()) case OLITERAL: switch n.Val().Ctype() { @@ -1376,8 +1376,10 @@ func (s *state) expr(n *Node) *ssa.Value { } if flag_race != 0 { - s.Unimplementedf("questionable CONVNOP from race detector %v -> %v\n", from, to) - return nil + // 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 { @@ -1716,7 +1718,7 @@ func (s *state) expr(n *Node) *ssa.Value { return s.expr(n.Left) case OADDR: - return s.addr(n.Left) + return s.addr(n.Left, n.Bounded) case OINDREG: if int(n.Reg) != Thearch.REGSP { @@ -1733,7 +1735,7 @@ func (s *state) expr(n *Node) *ssa.Value { case ODOT: // TODO: fix when we can SSA struct types. - p := s.addr(n) + p := s.addr(n, false) return s.newValue2(ssa.OpLoad, n.Type, p, s.mem()) case ODOTPTR: @@ -1757,11 +1759,11 @@ func (s *state) expr(n *Node) *ssa.Value { 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) + 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) + 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) @@ -1927,7 +1929,7 @@ func (s *state) expr(n *Node) *ssa.Value { args = append(args, s.expr(l.N)) store = append(store, true) } else { - args = append(args, s.addr(l.N)) + args = append(args, s.addr(l.N, false)) store = append(store, false) } } @@ -1970,7 +1972,7 @@ func (s *state) assign(left *Node, right *ssa.Value, wb bool) { // right == nil means use the zero value of the assigned type. if !canSSA(left) { // if we can't ssa this memory, treat it as just zeroing out the backing memory - addr := s.addr(left) + addr := s.addr(left, false) if left.Op == ONAME { s.vars[&memVar] = s.newValue1A(ssa.OpVarDef, ssa.TypeMem, left, s.mem()) } @@ -1985,7 +1987,7 @@ func (s *state) assign(left *Node, right *ssa.Value, wb bool) { return } // not ssa-able. Treat as a store. - addr := s.addr(left) + addr := s.addr(left, false) if left.Op == ONAME { s.vars[&memVar] = s.newValue1A(ssa.OpVarDef, ssa.TypeMem, left, s.mem()) } @@ -2187,7 +2189,9 @@ func etypesign(e uint8) int8 { // 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. -func (s *state) addr(n *Node) *ssa.Value { +// 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 { switch n.Op { case ONAME: switch n.Class { @@ -2250,7 +2254,7 @@ func (s *state) addr(n *Node) *ssa.Value { p := s.newValue1(ssa.OpSlicePtr, Ptrto(n.Left.Type.Type), a) return s.newValue2(ssa.OpPtrIndex, Ptrto(n.Left.Type.Type), p, i) } else { // array - a := s.addr(n.Left) + a := s.addr(n.Left, bounded) i := s.expr(n.Right) i = s.extendIndex(i) len := s.constInt(Types[TINT], n.Left.Type.Bound) @@ -2261,14 +2265,18 @@ func (s *state) addr(n *Node) *ssa.Value { } case OIND: p := s.expr(n.Left) - s.nilCheck(p) + if !bounded { + s.nilCheck(p) + } return p case ODOT: - p := s.addr(n.Left) + p := s.addr(n.Left, bounded) return s.newValue2(ssa.OpAddPtr, p.Type, p, s.constIntPtr(Types[TUINTPTR], n.Xoffset)) case ODOTPTR: p := s.expr(n.Left) - s.nilCheck(p) + if !bounded { + s.nilCheck(p) + } return s.newValue2(ssa.OpAddPtr, p.Type, p, s.constIntPtr(Types[TUINTPTR], n.Xoffset)) case OCLOSUREVAR: return s.newValue2(ssa.OpAddPtr, Ptrto(n.Type), @@ -2285,6 +2293,11 @@ func (s *state) addr(n *Node) *ssa.Value { original_p.Xoffset = n.Xoffset aux := &ssa.ArgSymbol{Typ: n.Type, Node: &original_p} return s.entryNewValue1A(ssa.OpAddr, Ptrto(n.Type), aux, s.sp) + case OCONVNOP: + addr := s.addr(n.Left, bounded) + to := Ptrto(n.Type) + return s.newValue1(ssa.OpCopy, to, addr) // ensure that addr has the right type + default: s.Unimplementedf("unhandled addr %v", Oconv(int(n.Op), 0)) return nil diff --git a/src/cmd/compile/internal/ssa/schedule.go b/src/cmd/compile/internal/ssa/schedule.go index 949de31afc..dd0a42a5dd 100644 --- a/src/cmd/compile/internal/ssa/schedule.go +++ b/src/cmd/compile/internal/ssa/schedule.go @@ -86,7 +86,7 @@ func schedule(f *Func) { // 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.") + f.Fatalf("LoweredGetClosurePtr appeared outside of entry block, b=%s", b.String()) } score[v.ID] = ScorePhi case v.Op == OpPhi: diff --git a/src/cmd/compile/internal/ssa/tighten.go b/src/cmd/compile/internal/ssa/tighten.go index a43218095e..05c349cc17 100644 --- a/src/cmd/compile/internal/ssa/tighten.go +++ b/src/cmd/compile/internal/ssa/tighten.go @@ -54,7 +54,8 @@ func tighten(f *Func) { for _, b := range f.Blocks { for i := 0; i < len(b.Values); i++ { v := b.Values[i] - if v.Op == OpPhi { + if v.Op == OpPhi || v.Op == OpGetClosurePtr { + // GetClosurePtr must stay in entry block continue } if uses[v.ID] == 1 && !phi[v.ID] && home[v.ID] != b && len(v.Args) < 2 { diff --git a/src/runtime/race_amd64.s b/src/runtime/race_amd64.s index d9e674b61f..80c4d79a7d 100644 --- a/src/runtime/race_amd64.s +++ b/src/runtime/race_amd64.s @@ -159,14 +159,28 @@ call: 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 -- cgit v1.3 From 366dcc4529d09c31f7b0df65003792022bc5ec09 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Sat, 17 Oct 2015 21:14:56 -0700 Subject: [dev.ssa] cmd/compile: Reuse stack slots for spill locations For each type, maintain a list of stack slots used to spill SSA values to the stack. Reuse those stack slots for noninterfering spills. Lowers frame sizes. As an example, runtime.mSpan_Sweep goes from 584 bytes to 392 bytes. heapBitsSetType goes from 576 bytes to 152 bytes. Change-Id: I0e9afe80c2fd84aff9eb368318685de293c363d0 Reviewed-on: https://go-review.googlesource.com/16022 Reviewed-by: David Chase --- src/cmd/compile/internal/ssa/stackalloc.go | 252 +++++++++++++++++++++++------ 1 file changed, 203 insertions(+), 49 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/stackalloc.go b/src/cmd/compile/internal/ssa/stackalloc.go index d60f8d1df2..17d1f66cea 100644 --- a/src/cmd/compile/internal/ssa/stackalloc.go +++ b/src/cmd/compile/internal/ssa/stackalloc.go @@ -2,83 +2,237 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -package ssa +// TODO: live at start of block instead? -// setloc sets the home location of v to loc. -func setloc(home []Location, v *Value, loc Location) []Location { - for v.ID >= ID(len(home)) { - home = append(home, nil) - } - home[v.ID] = loc - return home -} +package ssa // stackalloc allocates storage in the stack frame for // all Values that did not get a register. func stackalloc(f *Func) { - home := f.RegAlloc - - // Assign stack locations to phis first, because we - // must also assign the same locations to the phi stores - // introduced during regalloc. + // Cache value types by ID. + types := make([]Type, f.NumValues()) for _, b := range f.Blocks { for _, v := range b.Values { - if v.Op != OpPhi { - continue + types[v.ID] = v.Type + } + } + + // Build interference graph among StoreReg and stack phi ops. + live := f.liveSpills() + interfere := make([][]ID, f.NumValues()) + s := newSparseSet(f.NumValues()) + for _, b := range f.Blocks { + // Start with known live values at the end of the block. + s.clear() + for i := 0; i < len(b.Succs); i++ { + s.addAll(live[b.ID][i]) + } + + // Propagate backwards to the start of the block. + // Remember interfering sets. + for i := len(b.Values) - 1; i >= 0; i-- { + v := b.Values[i] + switch { + case v.Op == OpStoreReg, v.isStackPhi(): + s.remove(v.ID) + for _, id := range s.contents() { + if v.Type == types[id] { + interfere[v.ID] = append(interfere[v.ID], id) + interfere[id] = append(interfere[id], v.ID) + } + } + case v.Op == OpLoadReg: + s.add(v.Args[0].ID) } - if v.Type.IsMemory() { // TODO: only "regallocable" types + } + } + + // Figure out which StoreReg ops are phi args. We don't pick slots for + // phi args because a stack phi and its args must all use the same stack slot. + phiArg := make([]bool, f.NumValues()) + for _, b := range f.Blocks { + for _, v := range b.Values { + if !v.isStackPhi() { continue } - if int(v.ID) < len(home) && home[v.ID] != nil { - continue // register-based phi - } - // stack-based phi - n := f.Config.fe.Auto(v.Type) - f.Logf("stackalloc: %s: for %v <%v>\n", n, v, v.Type) - loc := &LocalSlot{n} - home = setloc(home, v, loc) - for _, w := range v.Args { - if w.Op != OpStoreReg { - f.Fatalf("stack-based phi must have StoreReg args") - } - home = setloc(home, w, loc) + for _, a := range v.Args { + phiArg[a.ID] = true } } } - // Now do all other unassigned values. + // For each type, we keep track of all the stack slots we + // have allocated for that type. + 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 non-phi-arg StoreReg and each stack phi. + used := make([]bool, f.NumValues()) for _, b := range f.Blocks { for _, v := range b.Values { - if v.ID < ID(len(home)) && home[v.ID] != nil { + if v.Op != OpStoreReg && !v.isStackPhi() { continue } - if v.Type.IsMemory() { // TODO: only "regallocable" types + if phiArg[v.ID] { continue } - if len(v.Args) == 0 { - // v will have been materialized wherever it is needed. - continue + // 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 } - if len(v.Args) == 1 && (v.Args[0].Op == OpSP || v.Args[0].Op == OpSB) { - continue + for _, xid := range interfere[v.ID] { + slot := slots[xid] + if slot >= 0 { + used[slot] = true + } } + if v.Op == OpPhi { + // Stack phi and args must get the same stack slot, so + // anything they interfere with is something v the phi + // interferes with. + for _, a := range v.Args { + for _, xid := range interfere[a.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{f.Config.fe.Auto(v.Type)}) + locations[v.Type] = locs + } + // Use the stack variable at that index for v. + loc := locs[i] + f.setHome(v, loc) + slots[v.ID] = i + if v.Op == OpPhi { + for _, a := range v.Args { + f.setHome(a, loc) + slots[a.ID] = i + } + } + } + } +} + +// live returns a map from block ID and successor edge index to a list +// of StoreReg/stackphi value IDs live on that edge. +// 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 (f *Func) liveSpills() [][][]ID { + live := make([][][]ID, f.NumBlocks()) + for _, b := range f.Blocks { + live[b.ID] = make([][]ID, len(b.Succs)) + } + var phis []*Value + + s := newSparseSet(f.NumValues()) + t := newSparseSet(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. + po := postorder(f) + for { + changed := false + for _, b := range po { + // Start with known live values at the end of the block + s.clear() + for i := 0; i < len(b.Succs); i++ { + s.addAll(live[b.ID][i]) + } + + // Propagate backwards to the start of the block + phis = phis[:0] + for i := len(b.Values) - 1; i >= 0; i-- { + v := b.Values[i] + switch { + case v.Op == OpStoreReg: + s.remove(v.ID) + case v.Op == OpLoadReg: + s.add(v.Args[0].ID) + case v.isStackPhi(): + s.remove(v.ID) + // save stack phi ops for later + phis = append(phis, v) + } + } + + // 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 { + // Find index of b in p's successors. + var j int + for j = 0; j < len(p.Succs); j++ { + if p.Succs[j] == b { + break + } + } + t.clear() + t.addAll(live[p.ID][j]) + t.addAll(s.contents()) + for _, v := range phis { + t.add(v.Args[i].ID) + } + if t.size() == len(live[p.ID][j]) { + continue + } + // grow p's live set + live[p.ID][j] = append(live[p.ID][j][:0], t.contents()...) + changed = true + } + } - n := f.Config.fe.Auto(v.Type) - f.Logf("stackalloc: %s for %v\n", n, v) - loc := &LocalSlot{n} - home = setloc(home, v, loc) + if !changed { + break } } + return live +} - f.RegAlloc = home +func (f *Func) getHome(v *Value) Location { + if int(v.ID) >= len(f.RegAlloc) { + return nil + } + return f.RegAlloc[v.ID] +} - // TODO: share stack slots among noninterfering (& gc type compatible) values +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 } -// align increases n to the next multiple of a. a must be a power of 2. -func align(n int64, a int64) int64 { - if a == 0 { - return n +func (v *Value) isStackPhi() bool { + if v.Op != OpPhi { + return false + } + if v.Type == TypeMem { + return false + } + if int(v.ID) >= len(v.Block.Func.RegAlloc) { + return true } - return (n + a - 1) &^ (a - 1) + return v.Block.Func.RegAlloc[v.ID] == nil + // TODO: use a separate opcode for StackPhi? } -- cgit v1.3 From d076ef749b8628c9743f6544eb30e8fde5d7f289 Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Thu, 15 Oct 2015 20:25:32 -0500 Subject: [dev.ssa] cmd/compile/internal/ssa: reuse symbols Reuse the ArgSymbol for nodes so that the Aux values will be equal for cse. Change-Id: Iaae80bd19ff2d3f51b6c9049fd860e04baa6f175 Reviewed-on: https://go-review.googlesource.com/15930 Reviewed-by: Keith Randall Run-TryBot: Todd Neal --- src/cmd/compile/internal/gc/ssa.go | 34 ++++++++++++++++++++++++++++++---- 1 file changed, 30 insertions(+), 4 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 312d494f5d..7219ffd653 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -87,17 +87,19 @@ func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { 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 d := fn.Func.Dcl; d != nil; d = d.Next { n := d.N switch n.Class { case PPARAM: - aux := &ssa.ArgSymbol{Typ: n.Type, Node: n} + aux := s.lookupSymbol(n, &ssa.ArgSymbol{Typ: n.Type, Node: n}) s.decladdrs[n] = s.entryNewValue1A(ssa.OpAddr, Ptrto(n.Type), aux, s.sp) case PAUTO | PHEAP: // TODO this looks wrong for PAUTO|PHEAP, no vardef, but also no definition - aux := &ssa.AutoSymbol{Typ: n.Type, Node: n} + 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. @@ -234,6 +236,9 @@ type state struct { // 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, frame pointer, and stack pointer startmem *ssa.Value sp *ssa.Value @@ -1247,7 +1252,7 @@ func (s *state) expr(n *Node) *ssa.Value { s.stmtList(n.Ninit) switch n.Op { case OCFUNC: - aux := &ssa.ExternSymbol{n.Type, n.Left.Sym} + 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) @@ -2187,6 +2192,25 @@ func etypesign(e uint8) int8 { 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 @@ -2226,7 +2250,9 @@ func (s *state) addr(n *Node, bounded bool) *ssa.Value { aux := &ssa.AutoSymbol{Typ: n.Type, Node: n} return s.newValue1A(ssa.OpAddr, Ptrto(n.Type), aux, s.sp) case PPARAMOUT: // Same as PAUTO -- cannot generate LEA early. - aux := &ssa.ArgSymbol{Typ: n.Type, Node: n} + // 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, Ptrto(n.Type), aux, s.sp) case PAUTO | PHEAP, PPARAM | PHEAP, PPARAMOUT | PHEAP, PPARAMREF: return s.expr(n.Name.Heapaddr) -- cgit v1.3 From c64a6f636282e1db66e6bda681be9b76069b1918 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Mon, 19 Oct 2015 10:57:03 -0700 Subject: [dev.ssa] cmd/compile: Rematerialize in regalloc Rematerialize constants instead of spilling and loading them. "Constants" includes constant offsets from SP and SB. Should help somewhat with stack frame sizes. I'm not sure exactly how much yet. Change-Id: I44dbad97aae870cf31cb6e89c92fe4f6a2b9586f Reviewed-on: https://go-review.googlesource.com/16029 Run-TryBot: Keith Randall Reviewed-by: David Chase --- src/cmd/compile/internal/ssa/regalloc.go | 36 +++++++++++++++++++++++++++++--- 1 file changed, 33 insertions(+), 3 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index 9d0aab64cc..6418bb375d 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -399,6 +399,12 @@ func (s *regAllocState) allocValToReg(v *Value, mask regMask, nospill bool) *Val panic("bad register state") } c = s.curBlock.NewValue1(v.Line, OpCopy, v.Type, s.regs[r2].c) + } else if v.rematerializeable() { + // Rematerialize instead of loading from the spill location. + c = s.curBlock.NewValue0(v.Line, v.Op, v.Type) + c.Aux = v.Aux + c.AuxInt = v.AuxInt + c.AddArgs(v.Args...) } else { switch { // It is difficult to spill and reload flags on many architectures. @@ -433,7 +439,6 @@ func (s *regAllocState) allocValToReg(v *Value, mask regMask, nospill bool) *Val c.AddArgs(args...) // Load v from its spill location. - // TODO: rematerialize if we can. case vi.spill2 != nil: if logSpills { fmt.Println("regalloc: load spill2") @@ -737,8 +742,13 @@ func (s *regAllocState) regalloc(f *Func) { continue } - // TODO: If value is rematerializeable, don't issue it here. - // Instead, rely on argument loading code to put it in a register when needed. + if v.rematerializeable() { + // Value is rematerializeable, don't issue it here. + // It will get issued just before each use (see + // allocValueToReg). + pc++ + continue + } // Move arguments to registers for _, i := range regspec.inputs { @@ -962,6 +972,26 @@ func (s *regAllocState) regalloc(f *Func) { f.RegAlloc = s.home } +func (v *Value) rematerializeable() bool { + // TODO: add a flags field to opInfo for this test? + + // rematerializeable ops must be able to fill any register. + outputs := opcodeTable[v.Op].reg.outputs + if len(outputs) == 0 || countRegs(outputs[0]) <= 1 { + // Note: this case handles OpAMD64LoweredGetClosurePtr + // which can't be moved. + return false + } + // TODO: maybe not OpAMD64LoweredGetG? + if len(v.Args) == 0 { + return true + } + if len(v.Args) == 1 && (v.Args[0].Op == OpSP || v.Args[0].Op == OpSB) { + return true + } + return false +} + // live returns a map from block ID and successor edge index to a list // of value IDs live on that edge. // TODO: this could be quadratic if lots of variables are live across lots of -- cgit v1.3 From 2dc88eead8d28c6d84f60e30746d90a76f920be6 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Mon, 19 Oct 2015 16:13:58 -0700 Subject: [dev.ssa] cmd/compile: Don't rematerialize getg It isn't safe in functions that also call setg. Change-Id: I76a7bf0401b4b6c8a129c245b15a2d6f06080e94 Reviewed-on: https://go-review.googlesource.com/16095 Reviewed-by: Todd Neal --- src/cmd/compile/internal/ssa/regalloc.go | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index 6418bb375d..72b056cd8d 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -982,7 +982,11 @@ func (v *Value) rematerializeable() bool { // which can't be moved. return false } - // TODO: maybe not OpAMD64LoweredGetG? + if v.Op == OpAMD64LoweredGetG { + // It would almost always be ok to rematerialize this op. + // The annoying exception is functions that call runtime.setg. + return false + } if len(v.Args) == 0 { return true } -- cgit v1.3 From 65df9c4c2b6750f207b71e65a01b2b16de7d3b61 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Mon, 19 Oct 2015 18:44:50 -0700 Subject: [dev.ssa] cmd/compile: don't move mem-using values in tighten pass It isn't safe, the place where we're moving the value to might have a different live memory. Moving will introduce two simultaneously live memories. Change-Id: I07e61a6db8ef285088c530dc2e5d5768d27871ff Reviewed-on: https://go-review.googlesource.com/16099 Reviewed-by: David Chase Run-TryBot: David Chase --- src/cmd/compile/internal/ssa/tighten.go | 5 +++++ 1 file changed, 5 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/tighten.go b/src/cmd/compile/internal/ssa/tighten.go index 05c349cc17..1da5071a2a 100644 --- a/src/cmd/compile/internal/ssa/tighten.go +++ b/src/cmd/compile/internal/ssa/tighten.go @@ -58,6 +58,11 @@ func tighten(f *Func) { // GetClosurePtr must stay in entry block 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, -- cgit v1.3 From d694f83c2138dbb85b0fd99e1ed96e0d719c41cc Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Mon, 19 Oct 2015 18:54:40 -0700 Subject: [dev.ssa] cmd/compile: getg needs a memory arg getg reads from memory, so it should really have a memory arg. It is critical in functions which call setg to make sure getg gets ordered correctly with setg. Change-Id: Ief4875421f741fc49c07b0e1f065ce2535232341 Reviewed-on: https://go-review.googlesource.com/16100 Run-TryBot: Keith Randall Reviewed-by: David Chase Run-TryBot: David Chase --- src/cmd/compile/internal/gc/ssa.go | 2 +- src/cmd/compile/internal/ssa/gen/AMD64.rules | 2 +- src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 2 +- src/cmd/compile/internal/ssa/gen/generic.rules | 2 +- src/cmd/compile/internal/ssa/gen/genericOps.go | 2 +- src/cmd/compile/internal/ssa/regalloc.go | 5 ----- src/cmd/compile/internal/ssa/rewriteAMD64.go | 10 ++++++---- src/cmd/compile/internal/ssa/rewritegeneric.go | 10 +++++----- 8 files changed, 16 insertions(+), 19 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 7219ffd653..3ef82322e5 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1870,7 +1870,7 @@ func (s *state) expr(n *Node) *ssa.Value { return s.call(n, callNormal) case OGETG: - return s.newValue0(ssa.OpGetG, n.Type) + return s.newValue1(ssa.OpGetG, n.Type, s.mem()) case OAPPEND: // append(s, e1, e2, e3). Compile like: diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index f160ce81af..b30df5f8d4 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -287,7 +287,7 @@ (IsSliceInBounds idx len) -> (SETBE (CMPQ idx len)) (PanicNilCheck ptr mem) -> (LoweredPanicNilCheck ptr mem) -(GetG) -> (LoweredGetG) +(GetG mem) -> (LoweredGetG mem) (GetClosurePtr) -> (LoweredGetClosurePtr) (Move [size] dst src mem) -> (REPMOVSB dst src (MOVQconst [size]) mem) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 5d171dc87a..e9414238b0 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -423,7 +423,7 @@ func init() { // Pseudo-ops {name: "LoweredPanicNilCheck", reg: gp10}, - {name: "LoweredGetG", reg: gp01}, + {name: "LoweredGetG", 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) diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index 01026042bf..42eec3dd75 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -180,7 +180,7 @@ (Store [size] dst (Load src mem) mem) && !config.fe.CanSSA(t) -> (Move [size] dst src mem) (Store [size] dst (Load src mem) (VarDef {x} mem)) && !config.fe.CanSSA(t) -> (Move [size] dst src (VarDef {x} mem)) -(If (IsNonNil (GetG)) yes no) -> (First nil yes no) +(If (IsNonNil (GetG _)) yes no) -> (First nil yes no) (If (Not cond) yes no) -> (If cond no yes) (If (ConstBool [c]) yes no) && c == 1 -> (First nil yes no) diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 1ee38103ac..5881596441 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -326,7 +326,7 @@ var genericOps = []opData{ // Pseudo-ops {name: "PanicNilCheck"}, // trigger a dereference fault; arg0=nil ptr, arg1=mem, returns mem - {name: "GetG"}, // runtime.getg() (read g pointer) + {name: "GetG"}, // runtime.getg() (read g pointer). arg0=mem {name: "GetClosurePtr"}, // get closure pointer from dedicated register // Indexing operations diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index 72b056cd8d..9cf589b215 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -982,11 +982,6 @@ func (v *Value) rematerializeable() bool { // which can't be moved. return false } - if v.Op == OpAMD64LoweredGetG { - // It would almost always be ok to rematerialize this op. - // The annoying exception is functions that call runtime.setg. - return false - } if len(v.Args) == 0 { return true } diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 4ac4744b64..5fad78aa3c 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -2412,18 +2412,20 @@ func rewriteValueAMD64(v *Value, config *Config) bool { end6fd0b53f0acb4d35e7d7fa78d2ca1392: ; case OpGetG: - // match: (GetG) + // match: (GetG mem) // cond: - // result: (LoweredGetG) + // result: (LoweredGetG mem) { + mem := v.Args[0] v.Op = OpAMD64LoweredGetG v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.AddArg(mem) return true } - goto endb17140e71dd641aa4d89e14479160260 - endb17140e71dd641aa4d89e14479160260: + goto endf543eaaf68c4bef1d4cdc8ba19683723 + endf543eaaf68c4bef1d4cdc8ba19683723: ; case OpGoCall: // match: (GoCall [argwid] mem) diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index 46d97b57e3..7f9c855948 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -1697,16 +1697,16 @@ func rewriteValuegeneric(v *Value, config *Config) bool { func rewriteBlockgeneric(b *Block) bool { switch b.Kind { case BlockIf: - // match: (If (IsNonNil (GetG)) yes no) + // match: (If (IsNonNil (GetG _)) yes no) // cond: // result: (First nil yes no) { v := b.Control if v.Op != OpIsNonNil { - goto endafdc4e2525f9933ab0ae7effc3559597 + goto end41b95d88b4cebdb0ce392bd3c1c89e95 } if v.Args[0].Op != OpGetG { - goto endafdc4e2525f9933ab0ae7effc3559597 + goto end41b95d88b4cebdb0ce392bd3c1c89e95 } yes := b.Succs[0] no := b.Succs[1] @@ -1716,8 +1716,8 @@ func rewriteBlockgeneric(b *Block) bool { b.Succs[1] = no return true } - goto endafdc4e2525f9933ab0ae7effc3559597 - endafdc4e2525f9933ab0ae7effc3559597: + goto end41b95d88b4cebdb0ce392bd3c1c89e95 + end41b95d88b4cebdb0ce392bd3c1c89e95: ; // match: (If (Not cond) yes no) // cond: -- cgit v1.3 From fbfc18c52281a4ac6dd812274e9a3b4774f77f76 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Tue, 20 Oct 2015 13:56:16 -0700 Subject: [dev.ssa] cmd/compile: don't issue nops for static data It confuses live variable analysis to have a bunch of unreachable no-ops at the end of a function. Symptom is: gc/plive.go:483 panic: interface conversion: interface {} is nil, not *gc.BasicBlock I don't see any reason why the old compiler needs these no-ops either. all.bash passes with the equivalent code removed on master. Change-Id: Ifcd2c3e139aa16314f08aebc9079b2fb7aa60556 Reviewed-on: https://go-review.googlesource.com/16132 Reviewed-by: David Chase --- src/cmd/compile/internal/gc/sinit.go | 3 --- 1 file changed, 3 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go index 70d32f75c6..c1165cde05 100644 --- a/src/cmd/compile/internal/gc/sinit.go +++ b/src/cmd/compile/internal/gc/sinit.go @@ -1431,9 +1431,6 @@ func gen_as_init(n *Node, reportOnly bool) bool { case OSLICEARR: if nr.Right.Op == OKEY && nr.Right.Left == nil && nr.Right.Right == nil { nr = nr.Left - if !reportOnly { - gused(nil) // in case the data is the dest of a goto - } nl := nr if nr == nil || nr.Op != OADDR { goto no -- cgit v1.3 From f206b16ff735015d4ca6b9d3ffafcee353fafa82 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Mon, 19 Oct 2015 12:24:22 -0700 Subject: [dev.ssa] cmd/compile: assign unused registers to phi ops Register phis are better than stack phis. If we have unused registers available, use them for phis. Change-Id: I3045711c65caa1b6d0be29131b87b57466320cc2 Reviewed-on: https://go-review.googlesource.com/16080 Run-TryBot: Keith Randall Reviewed-by: David Chase --- src/cmd/compile/internal/ssa/regalloc.go | 32 ++++++++++++++++++-------------- 1 file changed, 18 insertions(+), 14 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index 9cf589b215..abbb540a7e 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -567,14 +567,12 @@ func (s *regAllocState) setState(state []regState) { } } -// compatReg returns a register compatible with the a value and is used when -// spilling/loading. -// TODO: choose a better default register (set of reg by type?). -func compatReg(v *Value) regMask { +// compatRegs returns the set of registers which can store v. +func (v *Value) compatRegs() regMask { if v.Type.IsFloat() { - return 1 << 16 // X0 + return 0xffff << 16 // X0-X15 } - return 1 << 0 // AX + return 0xffef << 0 // AX-R15, except SP } func (s *regAllocState) regalloc(f *Func) { @@ -688,15 +686,21 @@ func (s *regAllocState) regalloc(f *Func) { } 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 + m := v.compatRegs() & ^s.used + if m == 0 { + // 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 + } + // Allocate phi to an unused register. + r = pickReg(m) + } else { + s.freeReg(r) } // register-based phi // Transfer ownership of register from input arg to phi. - s.freeReg(r) 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) @@ -872,7 +876,7 @@ func (s *regAllocState) regalloc(f *Func) { // This stack-based phi is the argument of some other // phi in this block. We must make a copy of its // value so that we don't clobber it prematurely. - c := s.allocValToReg(v, s.values[v.ID].regs|compatReg(v), false) + c := s.allocValToReg(v, v.compatRegs(), false) d := p.NewValue1(v.Line, OpStoreReg, v.Type, c) s.values[v.ID].spill2 = d } @@ -884,7 +888,7 @@ func (s *regAllocState) regalloc(f *Func) { // If already in a register, use that. If not, pick a compatible // register. w := v.Args[i] - c := s.allocValToReg(w, s.values[w.ID].regs|compatReg(w), false) + c := s.allocValToReg(w, w.compatRegs(), false) v.Args[i] = p.NewValue1(v.Line, OpStoreReg, v.Type, c) } // Figure out what value goes in each register. -- cgit v1.3 From 7d6124697223ecf9d5ce21221377da2b9c7fd9f3 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Thu, 22 Oct 2015 13:07:38 -0700 Subject: [dev.ssa] cmd/compile: implement reserved registers BP for framepointer experiment R15 for dynamic linking Change-Id: I28e48be461d04a4d5c9b013f48fce5c0e58d6a08 Reviewed-on: https://go-review.googlesource.com/16231 Run-TryBot: Todd Neal Reviewed-by: Todd Neal --- src/cmd/compile/internal/gc/ssa.go | 6 +++--- src/cmd/compile/internal/ssa/config.go | 9 +++++++-- src/cmd/compile/internal/ssa/regalloc.go | 31 ++++++++++++++++++++++++------- 3 files changed, 34 insertions(+), 12 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 918d71ca6d..64391b0fca 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -41,7 +41,7 @@ func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { var e ssaExport e.log = usessa - s.config = ssa.NewConfig(Thearch.Thestring, &e) + s.config = ssa.NewConfig(Thearch.Thestring, &e, Ctxt) s.f = s.config.NewFunc() s.f.Name = name s.exitCode = fn.Func.Exit @@ -239,7 +239,7 @@ type state struct { // symbols for PEXTERN, PAUTO and PPARAMOUT variables so they can be reused. varsyms map[*Node]interface{} - // starting values. Memory, frame pointer, and stack pointer + // starting values. Memory, stack pointer, and globals pointer startmem *ssa.Value sp *ssa.Value sb *ssa.Value @@ -4367,7 +4367,7 @@ func (e *ssaExport) Auto(t ssa.Type) fmt.Stringer { return n } -func (e ssaExport) CanSSA(t ssa.Type) bool { +func (e *ssaExport) CanSSA(t ssa.Type) bool { return canSSAType(t.(*Type)) } diff --git a/src/cmd/compile/internal/ssa/config.go b/src/cmd/compile/internal/ssa/config.go index c935a2b83e..efb8b146a1 100644 --- a/src/cmd/compile/internal/ssa/config.go +++ b/src/cmd/compile/internal/ssa/config.go @@ -4,7 +4,10 @@ package ssa -import "fmt" +import ( + "cmd/internal/obj" + "fmt" +) type Config struct { arch string // "amd64", etc. @@ -14,6 +17,7 @@ type Config struct { 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 // TODO: more stuff. Compiler flags of interest, ... } @@ -63,7 +67,7 @@ type Frontend interface { } // NewConfig returns a new configuration object for the given architecture. -func NewConfig(arch string, fe Frontend) *Config { +func NewConfig(arch string, fe Frontend, ctxt *obj.Link) *Config { c := &Config{arch: arch, fe: fe} switch arch { case "amd64": @@ -79,6 +83,7 @@ func NewConfig(arch string, fe Frontend) *Config { default: fe.Unimplementedf("arch %s not implemented", arch) } + c.ctxt = ctxt return c } diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index abbb540a7e..d42b14a984 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -100,6 +100,7 @@ package ssa import ( + "cmd/internal/obj" "fmt" "unsafe" ) @@ -386,6 +387,7 @@ func (s *regAllocState) allocValToReg(v *Value, mask regMask, nospill bool) *Val } mask &^= 1<<4 | 1<<32 // don't spill SP or SB + mask &^= s.reserved() // Allocate a register. r := s.allocReg(mask) @@ -568,11 +570,14 @@ func (s *regAllocState) setState(state []regState) { } // compatRegs returns the set of registers which can store v. -func (v *Value) compatRegs() regMask { +func (s *regAllocState) compatRegs(v *Value) regMask { + var m regMask if v.Type.IsFloat() { - return 0xffff << 16 // X0-X15 + m = 0xffff << 16 // X0-X15 + } else { + m = 0xffef << 0 // AX-R15, except SP } - return 0xffef << 0 // AX-R15, except SP + return m &^ s.reserved() } func (s *regAllocState) regalloc(f *Func) { @@ -686,7 +691,7 @@ func (s *regAllocState) regalloc(f *Func) { } r := phiRegs[i] if r == noRegister { - m := v.compatRegs() & ^s.used + m := s.compatRegs(v) & ^s.used if m == 0 { // stack-based phi // Spills will be inserted in all the predecessors below. @@ -774,7 +779,7 @@ func (s *regAllocState) regalloc(f *Func) { var r register var mask regMask if len(regspec.outputs) > 0 { - mask = regspec.outputs[0] + mask = regspec.outputs[0] &^ s.reserved() } if mask != 0 { r = s.allocReg(mask) @@ -876,7 +881,7 @@ func (s *regAllocState) regalloc(f *Func) { // This stack-based phi is the argument of some other // phi in this block. We must make a copy of its // value so that we don't clobber it prematurely. - c := s.allocValToReg(v, v.compatRegs(), false) + c := s.allocValToReg(v, s.compatRegs(v), false) d := p.NewValue1(v.Line, OpStoreReg, v.Type, c) s.values[v.ID].spill2 = d } @@ -888,7 +893,7 @@ func (s *regAllocState) regalloc(f *Func) { // If already in a register, use that. If not, pick a compatible // register. w := v.Args[i] - c := s.allocValToReg(w, w.compatRegs(), false) + c := s.allocValToReg(w, s.compatRegs(w), false) v.Args[i] = p.NewValue1(v.Line, OpStoreReg, v.Type, c) } // Figure out what value goes in each register. @@ -1111,3 +1116,15 @@ func (f *Func) live() [][][]ID { return live } + +// 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 +} -- cgit v1.3 From 3abb8441087dbc1f08320c40a750ac1a7209b9fe Mon Sep 17 00:00:00 2001 From: David Chase Date: Fri, 23 Oct 2015 12:34:03 -0400 Subject: [dev.ssa] cmd/compile: repair ssa testing build and test Calls to NewConfig required an extra parameter that sometimes could not be nil. Change-Id: I806dd53c045056a0c2d30d641a20fe27fb790539 Reviewed-on: https://go-review.googlesource.com/16272 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/dom_test.go | 2 +- src/cmd/compile/internal/ssa/export_test.go | 4 +++- src/cmd/compile/internal/ssa/nilcheck_test.go | 20 ++++++++++---------- 3 files changed, 14 insertions(+), 12 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/dom_test.go b/src/cmd/compile/internal/ssa/dom_test.go index b46dcebc72..eff7205fa3 100644 --- a/src/cmd/compile/internal/ssa/dom_test.go +++ b/src/cmd/compile/internal/ssa/dom_test.go @@ -160,7 +160,7 @@ func genMaxPredValue(size int) []bloc { var domBenchRes []*Block func benchmarkDominators(b *testing.B, size int, bg blockGen) { - c := NewConfig("amd64", DummyFrontend{b}) + c := NewConfig("amd64", DummyFrontend{b}, nil) fun := Fun(c, "entry", bg(size)...) CheckFunc(fun.f) diff --git a/src/cmd/compile/internal/ssa/export_test.go b/src/cmd/compile/internal/ssa/export_test.go index c0db5c8d96..76a05f91d9 100644 --- a/src/cmd/compile/internal/ssa/export_test.go +++ b/src/cmd/compile/internal/ssa/export_test.go @@ -5,6 +5,7 @@ package ssa import ( + "cmd/internal/obj" "fmt" "testing" ) @@ -15,7 +16,8 @@ var Opt = opt var Deadcode = deadcode func testConfig(t *testing.T) *Config { - return NewConfig("amd64", DummyFrontend{t}) + testCtxt := &obj.Link{} + return NewConfig("amd64", DummyFrontend{t}, testCtxt) } // DummyFrontend is a test-only frontend. diff --git a/src/cmd/compile/internal/ssa/nilcheck_test.go b/src/cmd/compile/internal/ssa/nilcheck_test.go index cbd17e0093..c0a3d8af69 100644 --- a/src/cmd/compile/internal/ssa/nilcheck_test.go +++ b/src/cmd/compile/internal/ssa/nilcheck_test.go @@ -40,7 +40,7 @@ func benchmarkNilCheckDeep(b *testing.B, depth int) { Bloc("exit", Exit("mem")), ) - c := NewConfig("amd64", DummyFrontend{b}) + c := NewConfig("amd64", DummyFrontend{b}, nil) fun := Fun(c, "entry", blocs...) CheckFunc(fun.f) @@ -64,7 +64,7 @@ func isNilCheck(b *Block) bool { // 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}) + c := NewConfig("amd64", DummyFrontend{t}, nil) fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), @@ -101,7 +101,7 @@ func TestNilcheckSimple(t *testing.T) { // 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}) + c := NewConfig("amd64", DummyFrontend{t}, nil) fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), @@ -137,7 +137,7 @@ func TestNilcheckDomOrder(t *testing.T) { // 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}) + c := NewConfig("amd64", DummyFrontend{t}, nil) fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), @@ -170,7 +170,7 @@ func TestNilcheckAddr(t *testing.T) { // 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}) + c := NewConfig("amd64", DummyFrontend{t}, nil) fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), @@ -204,7 +204,7 @@ func TestNilcheckAddPtr(t *testing.T) { // 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}) + c := NewConfig("amd64", DummyFrontend{t}, nil) fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), @@ -248,7 +248,7 @@ func TestNilcheckPhi(t *testing.T) { // 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}) + c := NewConfig("amd64", DummyFrontend{t}, nil) fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), @@ -296,7 +296,7 @@ func TestNilcheckKeepRemove(t *testing.T) { // 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}) + c := NewConfig("amd64", DummyFrontend{t}, nil) fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), @@ -347,7 +347,7 @@ func TestNilcheckInFalseBranch(t *testing.T) { // 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}) + c := NewConfig("amd64", DummyFrontend{t}, nil) fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), @@ -386,7 +386,7 @@ func TestNilcheckUser(t *testing.T) { // 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}) + c := NewConfig("amd64", DummyFrontend{t}, nil) fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpArg, TypeMem, 0, ".mem"), -- cgit v1.3 From e99dd520665000dfeb848fb4ecd381314b8fe61b Mon Sep 17 00:00:00 2001 From: David Chase Date: Mon, 19 Oct 2015 11:36:07 -0400 Subject: [dev.ssa] cmd/compile: enhance SSA filtering, add OpConvert Modified GOSSA{HASH.PKG} environment variable filters to make it easier to make/run with all SSA for testing. Disable attempts at SSA for architectures that are not amd64 (avoid spurious errors/unimplementeds.) Removed easy out for unimplemented features. Add convert op for proper liveness in presence of uintptr to/from unsafe.Pointer conversions. Tweaked stack sizes to get a pass on windows; 1024 instead 768, was observed to pass at least once. Change-Id: Ida3800afcda67d529e3b1cf48ca4a3f0fa48b2c5 Reviewed-on: https://go-review.googlesource.com/16201 Reviewed-by: Keith Randall Run-TryBot: David Chase --- src/cmd/compile/internal/gc/pgen.go | 4 +- src/cmd/compile/internal/gc/ssa.go | 85 +++++++++++++++++--------- src/cmd/compile/internal/ssa/gen/AMD64.rules | 3 + src/cmd/compile/internal/ssa/gen/genericOps.go | 5 +- src/cmd/compile/internal/ssa/opGen.go | 5 ++ src/cmd/compile/internal/ssa/rewriteAMD64.go | 18 ++++++ src/cmd/compile/internal/ssa/tighten.go | 8 ++- src/cmd/dist/test.go | 5 -- src/cmd/internal/obj/stack.go | 2 +- src/cmd/internal/obj/util.go | 3 + src/runtime/stack.go | 2 +- test/nosplit.go | 8 ++- 12 files changed, 105 insertions(+), 43 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/pgen.go index a5010a31b4..b3ba2fbb46 100644 --- a/src/cmd/compile/internal/gc/pgen.go +++ b/src/cmd/compile/internal/gc/pgen.go @@ -414,7 +414,9 @@ func compile(fn *Node) { // Build an SSA backend function. // TODO: get rid of usessa. - ssafn, usessa = buildssa(Curfn) + if Thearch.Thestring == "amd64" { + ssafn, usessa = buildssa(Curfn) + } continpc = nil breakpc = nil diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 64391b0fca..8939f14136 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -24,8 +24,32 @@ import ( // it will never return nil, and the bool can be removed. func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { name := fn.Func.Nname.Sym.Name + gossahash := os.Getenv("GOSSAHASH") usessa = strings.HasSuffix(name, "_ssa") || strings.Contains(name, "_ssa.") || name == os.Getenv("GOSSAFUNC") + // 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 == "y" or "Y" THEN + // compile this function (and everything else) with SSA + + // 3. IF GOSSAHASH == "" THEN + // 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 remove, and the 2) dependence on GOSSAHASH changes + // from "y"/"Y" to empty -- then SSA is default, and is disabled by setting + // GOSSAHASH to a value that is neither 0 nor 1 (e.g., "N" or "X") + if usessa { fmt.Println("generating SSA for", name) dumplist("buildssa-enter", fn.Func.Enter) @@ -58,17 +82,6 @@ func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { } }() - // If SSA support for the function is incomplete, - // assume that any panics are due to violated - // invariants. Swallow them silently. - defer func() { - if err := recover(); err != nil { - if !e.unimplemented { - panic(err) - } - } - }() - // We construct SSA using an algorithm similar to // Brau, Buchwald, Hack, Leißa, Mallon, and Zwinkau // http://pp.info.uni-karlsruhe.de/uploads/publikationen/braun13cc.pdf @@ -167,27 +180,17 @@ func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { // Main call to ssa package to compile function ssa.Compile(s.f) - // Calculate stats about what percentage of functions SSA handles. - if false { - fmt.Printf("SSA implemented: %t\n", !e.unimplemented) - } - - if e.unimplemented { - return nil, false - } - - // TODO: enable codegen more broadly once the codegen stabilizes - // and runtime support is in (gc maps, write barriers, etc.) - if usessa { + if usessa || gossahash == "y" || gossahash == "Y" { return s.f, true } - if localpkg.Name != os.Getenv("GOSSAPKG") { - return s.f, false - } - if os.Getenv("GOSSAHASH") == "" { + if gossahash == "" { + if localpkg.Name != os.Getenv("GOSSAPKG") { + return s.f, false + } // Use everything in the package return s.f, true } + // Check the hash of the name against a partial input hash. // We use this feature to do a binary search within a package to // find a function that is incorrectly compiled. @@ -195,10 +198,26 @@ func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { for _, b := range sha1.Sum([]byte(name)) { hstr += fmt.Sprintf("%08b", b) } - if strings.HasSuffix(hstr, os.Getenv("GOSSAHASH")) { + + if strings.HasSuffix(hstr, gossahash) { fmt.Printf("GOSSAHASH triggered %s\n", name) return s.f, true } + + // Iteratively try additional hashes to allow tests for multi-point + // failure. + for i := 0; true; i++ { + ev := fmt.Sprintf("GOSSAHASH%d", i) + evv := os.Getenv(ev) + if evv == "" { + break + } + if strings.HasSuffix(hstr, evv) { + fmt.Printf("%s triggered %s\n", ev, name) + return s.f, true + } + } + return s.f, false } @@ -1353,6 +1372,15 @@ func (s *state) expr(n *Node) *ssa.Value { // 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.newValue1(ssa.OpConvert, to, x) + } + v := s.newValue1(ssa.OpCopy, to, x) // ensure that v has the right type // CONVNOP closure @@ -1364,6 +1392,7 @@ func (s *state) expr(n *Node) *ssa.Value { if from.Etype == to.Etype { return v } + // unsafe.Pointer <--> *T if to.Etype == TUNSAFEPTR && from.IsPtr() || from.Etype == TUNSAFEPTR && to.IsPtr() { return v diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index dd50dd2d27..abe103571d 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -281,6 +281,9 @@ (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 x) -> (LEAQ x) + // checks (IsNonNil p) -> (SETNE (TESTQ p p)) (IsInBounds idx len) -> (SETB (CMPQ idx len)) diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 5881596441..8a8837c0e9 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -237,8 +237,9 @@ var genericOps = []opData{ {name: "Sqrt"}, // sqrt(arg0), float64 only // Data movement - {name: "Phi"}, // select an argument based on which predecessor block we came from - {name: "Copy"}, // output = arg0 + {name: "Phi"}, // select an argument based on which predecessor block we came from + {name: "Copy"}, // output = arg0 + {name: "Convert"}, // output = arg0 -- a copy that converts to/from a pointer // constants. Constant values are stored in the aux field. // booleans have a bool aux field, strings have a string aux diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index d86dce354b..4c191807ba 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -455,6 +455,7 @@ const ( OpSqrt OpPhi OpCopy + OpConvert OpConstBool OpConstString OpConstNil @@ -3866,6 +3867,10 @@ var opcodeTable = [...]opInfo{ name: "Copy", generic: true, }, + { + name: "Convert", + generic: true, + }, { name: "ConstBool", generic: true, diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 2fd9a08d5b..3fe272c204 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -1670,6 +1670,24 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endc395c0a53eeccf597e225a07b53047d1 endc395c0a53eeccf597e225a07b53047d1: ; + case OpConvert: + // match: (Convert x) + // cond: + // result: (LEAQ x) + { + t := v.Type + x := v.Args[0] + v.Op = OpAMD64LEAQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = t + v.AddArg(x) + return true + } + goto end1cac40a6074914d6ae3d4aa039a625ed + end1cac40a6074914d6ae3d4aa039a625ed: + ; case OpCvt32Fto32: // match: (Cvt32Fto32 x) // cond: diff --git a/src/cmd/compile/internal/ssa/tighten.go b/src/cmd/compile/internal/ssa/tighten.go index 1da5071a2a..4fa26d2d18 100644 --- a/src/cmd/compile/internal/ssa/tighten.go +++ b/src/cmd/compile/internal/ssa/tighten.go @@ -54,8 +54,12 @@ func tighten(f *Func) { for _, b := range f.Blocks { for i := 0; i < len(b.Values); i++ { v := b.Values[i] - if v.Op == OpPhi || v.Op == OpGetClosurePtr { - // GetClosurePtr must stay in entry block + if v.Op == OpPhi || v.Op == OpGetClosurePtr || v.Op == OpConvert { + // GetClosurePtr 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() { diff --git a/src/cmd/dist/test.go b/src/cmd/dist/test.go index c92109afa5..be6cdb5c0b 100644 --- a/src/cmd/dist/test.go +++ b/src/cmd/dist/test.go @@ -278,11 +278,6 @@ func (t *tester) registerStdTest(pkg string) { // TODO: Remove when SSA codegen is used by default. func (t *tester) registerSSATest(pkg string) { - switch pkg { - // known failures - case "runtime": - return - } t.tests = append(t.tests, distTest{ name: "go_test_ssa:" + pkg, heading: "Testing packages with SSA codegen.", diff --git a/src/cmd/internal/obj/stack.go b/src/cmd/internal/obj/stack.go index 87698b3eeb..1ca673285a 100644 --- a/src/cmd/internal/obj/stack.go +++ b/src/cmd/internal/obj/stack.go @@ -41,7 +41,7 @@ const ( STACKSYSTEM = 0 StackSystem = STACKSYSTEM StackBig = 4096 - StackGuard = 640*stackGuardMultiplier + StackSystem + StackGuard = 1024*stackGuardMultiplier + StackSystem StackSmall = 128 StackLimit = StackGuard - StackSystem - StackSmall ) diff --git a/src/cmd/internal/obj/util.go b/src/cmd/internal/obj/util.go index 73d33666e2..a71d69edfc 100644 --- a/src/cmd/internal/obj/util.go +++ b/src/cmd/internal/obj/util.go @@ -385,6 +385,9 @@ func Dconv(p *Prog, a *Addr) string { 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/runtime/stack.go b/src/runtime/stack.go index 1809a4d9ac..128278ebdc 100644 --- a/src/runtime/stack.go +++ b/src/runtime/stack.go @@ -86,7 +86,7 @@ const ( // The stack guard is a pointer this many bytes above the // bottom of the stack. - _StackGuard = 640*stackGuardMultiplier + _StackSystem + _StackGuard = 1024*stackGuardMultiplier + _StackSystem // After a stack split check the SP is allowed to be this // many bytes below the stack guard. This saves an instruction diff --git a/test/nosplit.go b/test/nosplit.go index e5c2a9f30e..70e8fced86 100644 --- a/test/nosplit.go +++ b/test/nosplit.go @@ -9,6 +9,7 @@ package main import ( "bytes" + "cmd/internal/obj" "fmt" "io/ioutil" "log" @@ -285,12 +286,13 @@ TestCases: // Instead of rewriting the test cases above, adjust // the first stack frame to use up the extra bytes. if i == 0 { - size += 512 - 128 + size += (obj.StackGuard - 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 += 640 + size += obj.StackGuard } } } -- cgit v1.3 From a3180d8b1daff3e0238a3ff08dd9a4213a9e1266 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Fri, 23 Oct 2015 14:08:50 -0700 Subject: [dev.ssa] cmd/compile: get rid of converts in unsafe.Pointer arithmetic unsafe.Pointer->uintptr, add, then uintptr->unsafe.Pointer. Do the add directly on the pointer type instead. Change-Id: I5a3a32691d0a000e16975857974ed9a1039c6d28 Reviewed-on: https://go-review.googlesource.com/16281 Run-TryBot: Keith Randall Reviewed-by: David Chase --- src/cmd/compile/internal/ssa/gen/generic.rules | 3 +++ src/cmd/compile/internal/ssa/rewritegeneric.go | 24 ++++++++++++++++++++++++ 2 files changed, 27 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index 42eec3dd75..4dd7ac586a 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -185,3 +185,6 @@ (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) off)) -> (Add64 ptr off) diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index 7f9c855948..91427e2f2a 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -354,6 +354,30 @@ func rewriteValuegeneric(v *Value, config *Config) bool { goto end2eb756398dd4c6b6d126012a26284c89 end2eb756398dd4c6b6d126012a26284c89: ; + case OpConvert: + // match: (Convert (Add64 (Convert ptr) off)) + // cond: + // result: (Add64 ptr off) + { + if v.Args[0].Op != OpAdd64 { + goto end913a7ecf456c00ffbee36c2dbbf0e1af + } + if v.Args[0].Args[0].Op != OpConvert { + goto end913a7ecf456c00ffbee36c2dbbf0e1af + } + ptr := v.Args[0].Args[0].Args[0] + off := v.Args[0].Args[1] + v.Op = OpAdd64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v.AddArg(off) + return true + } + goto end913a7ecf456c00ffbee36c2dbbf0e1af + end913a7ecf456c00ffbee36c2dbbf0e1af: + ; case OpEq16: // match: (Eq16 x x) // cond: -- cgit v1.3 From 31115a5c98935b5dee2de73b991bc391141dfb9d Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Fri, 23 Oct 2015 19:12:49 -0700 Subject: [dev.ssa] cmd/compile: optimize nil checks Use faulting loads instead of test/jeq to do nil checks. Fold nil checks into a following load/store if possible. Makes binaries about 2% smaller. Change-Id: I54af0f0a93c853f37e34e0ce7e3f01dd2ac87f64 Reviewed-on: https://go-review.googlesource.com/16287 Reviewed-by: David Chase --- src/cmd/compile/internal/gc/ssa.go | 70 +++++++++++++++++--------- src/cmd/compile/internal/gc/type.go | 1 + src/cmd/compile/internal/ssa/check.go | 10 ++++ src/cmd/compile/internal/ssa/dom.go | 2 +- src/cmd/compile/internal/ssa/gen/AMD64.rules | 2 +- src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 4 +- src/cmd/compile/internal/ssa/gen/generic.rules | 2 +- src/cmd/compile/internal/ssa/gen/genericOps.go | 4 +- src/cmd/compile/internal/ssa/gen/rulegen.go | 2 +- src/cmd/compile/internal/ssa/nilcheck.go | 24 +++++++-- src/cmd/compile/internal/ssa/opGen.go | 25 +++++---- src/cmd/compile/internal/ssa/regalloc.go | 2 +- src/cmd/compile/internal/ssa/rewriteAMD64.go | 36 ++++++------- src/cmd/compile/internal/ssa/rewritegeneric.go | 26 +++++----- src/cmd/compile/internal/ssa/type.go | 4 ++ src/cmd/compile/internal/ssa/type_test.go | 1 + 16 files changed, 136 insertions(+), 79 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 8939f14136..50fc935dec 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -18,6 +18,9 @@ import ( "cmd/internal/obj/x86" ) +// Smallest possible faulting page at address zero. +const minZeroPage = 4096 + // buildssa builds an SSA function // and reports whether it should be used. // Once the SSA implementation is complete, @@ -2428,21 +2431,12 @@ func (s *state) nilCheck(ptr *ssa.Value) { if Disable_checknil != 0 { return } - c := s.newValue1(ssa.OpIsNonNil, Types[TBOOL], ptr) + chk := s.newValue2(ssa.OpNilCheck, ssa.TypeVoid, ptr, s.mem()) b := s.endBlock() - b.Kind = ssa.BlockIf - b.Control = c - b.Likely = ssa.BranchLikely + b.Kind = ssa.BlockCheck + b.Control = chk bNext := s.f.NewBlock(ssa.BlockPlain) - bPanic := s.f.NewBlock(ssa.BlockPlain) b.AddEdgeTo(bNext) - b.AddEdgeTo(bPanic) - s.startBlock(bPanic) - // TODO: implicit nil checks somehow? - chk := s.newValue2(ssa.OpPanicNilCheck, ssa.TypeMem, ptr, s.mem()) - s.endBlock() - bPanic.Kind = ssa.BlockExit - bPanic.Control = chk s.startBlock(bNext) } @@ -3827,18 +3821,6 @@ func (s *genState) genValue(v *ssa.Value) { case ssa.OpArg: // memory arg needs no code // TODO: check that only mem arg goes here. - case ssa.OpAMD64LoweredPanicNilCheck: - if Debug_checknil != 0 && v.Line > 1 { // v.Line==1 in generated wrappers - Warnl(int(v.Line), "generated nil check") - } - // Write to memory address 0. It doesn't matter what we write; use AX. - // Input 0 is the pointer we just checked, use it as the destination. - r := regnum(v.Args[0]) - q := Prog(x86.AMOVL) - q.From.Type = obj.TYPE_REG - q.From.Reg = x86.REG_AX - q.To.Type = obj.TYPE_MEM - q.To.Reg = r case ssa.OpAMD64LoweredGetClosurePtr: // Output is hardwired to DX only, // and DX contains the closure pointer on @@ -3986,6 +3968,44 @@ func (s *genState) genValue(v *ssa.Value) { Gvardef(v.Aux.(*Node)) case ssa.OpVarKill: gvarkill(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. + for _, w := range v.Block.Succs[0].Values { + 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] != v.Args[1] { + 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: + if w.Args[0] == v.Args[0] && w.Aux == nil && w.AuxInt >= 0 && w.AuxInt < minZeroPage { + return + } + } + if w.Type.IsMemory() { + // 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()) } @@ -4088,7 +4108,7 @@ func (s *genState) genBlock(b, next *ssa.Block) { lineno = b.Line switch b.Kind { - case ssa.BlockPlain, ssa.BlockCall: + case ssa.BlockPlain, ssa.BlockCall, ssa.BlockCheck: if b.Succs[0] != next { p := Prog(obj.AJMP) p.To.Type = obj.TYPE_BRANCH diff --git a/src/cmd/compile/internal/gc/type.go b/src/cmd/compile/internal/gc/type.go index 87af2860e8..483ebd96ea 100644 --- a/src/cmd/compile/internal/gc/type.go +++ b/src/cmd/compile/internal/gc/type.go @@ -142,3 +142,4 @@ func (t *Type) NumElem() int64 { 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/ssa/check.go b/src/cmd/compile/internal/ssa/check.go index 6c45957fdc..ca3bbfe494 100644 --- a/src/cmd/compile/internal/ssa/check.go +++ b/src/cmd/compile/internal/ssa/check.go @@ -122,6 +122,16 @@ func checkFunc(f *Func) { 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)) diff --git a/src/cmd/compile/internal/ssa/dom.go b/src/cmd/compile/internal/ssa/dom.go index 2267281237..0d342d184e 100644 --- a/src/cmd/compile/internal/ssa/dom.go +++ b/src/cmd/compile/internal/ssa/dom.go @@ -120,7 +120,7 @@ func postDominators(f *Func) []*Block { var exits []*Block for i := len(f.Blocks) - 1; i >= 0; i-- { switch f.Blocks[i].Kind { - case BlockExit, BlockRet, BlockRetJmp, BlockCall: + case BlockExit, BlockRet, BlockRetJmp, BlockCall, BlockCheck: exits = append(exits, f.Blocks[i]) break } diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index abe103571d..4eef40c478 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -288,8 +288,8 @@ (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) -(PanicNilCheck ptr mem) -> (LoweredPanicNilCheck ptr mem) (GetG mem) -> (LoweredGetG mem) (GetClosurePtr) -> (LoweredGetClosurePtr) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 14d497a2f4..2af50d3584 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -106,7 +106,6 @@ func init() { clobbers: ax | flags} gp11mod = regInfo{inputs: []regMask{ax, gpsp &^ dx}, outputs: []regMask{dx}, clobbers: ax | flags} - gp10 = regInfo{inputs: []regMask{gp}} gp2flags = regInfo{inputs: []regMask{gpsp, gpsp}, outputs: flagsonly} gp1flags = regInfo{inputs: []regMask{gpsp}, outputs: flagsonly} @@ -423,12 +422,13 @@ func init() { {name: "InvertFlags"}, // reverse direction of arg0 // Pseudo-ops - {name: "LoweredPanicNilCheck", reg: gp10}, {name: "LoweredGetG", 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", reg: regInfo{inputs: []regMask{gpsp}, clobbers: flags}}, } var AMD64blocks = []blockData{ diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index 4dd7ac586a..507ac487ca 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -180,7 +180,7 @@ (Store [size] dst (Load src mem) mem) && !config.fe.CanSSA(t) -> (Move [size] dst src mem) (Store [size] dst (Load src mem) (VarDef {x} mem)) && !config.fe.CanSSA(t) -> (Move [size] dst src (VarDef {x} mem)) -(If (IsNonNil (GetG _)) yes no) -> (First nil yes no) +(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) diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 8a8837c0e9..62df826cf4 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -324,9 +324,9 @@ var genericOps = []opData{ {name: "IsNonNil", typ: "Bool"}, // arg0 != nil {name: "IsInBounds", typ: "Bool"}, // 0 <= arg0 < arg1 {name: "IsSliceInBounds", typ: "Bool"}, // 0 <= arg0 <= arg1 + {name: "NilCheck", typ: "Void"}, // arg0=ptr, arg1=mem. Panics if arg0 is nil, returns void. // Pseudo-ops - {name: "PanicNilCheck"}, // trigger a dereference fault; arg0=nil ptr, arg1=mem, returns mem {name: "GetG"}, // runtime.getg() (read g pointer). arg0=mem {name: "GetClosurePtr"}, // get closure pointer from dedicated register @@ -379,12 +379,14 @@ var genericOps = []opData{ // 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 diff --git a/src/cmd/compile/internal/ssa/gen/rulegen.go b/src/cmd/compile/internal/ssa/gen/rulegen.go index 80371c94c4..71c9ca7ec2 100644 --- a/src/cmd/compile/internal/ssa/gen/rulegen.go +++ b/src/cmd/compile/internal/ssa/gen/rulegen.go @@ -585,7 +585,7 @@ func blockName(name string, arch arch) string { // typeName returns the string to use to generate a type. func typeName(typ string) string { switch typ { - case "Flags", "Mem": + case "Flags", "Mem", "Void": return "Type" + typ default: return "config.fe.Type" + typ + "()" diff --git a/src/cmd/compile/internal/ssa/nilcheck.go b/src/cmd/compile/internal/ssa/nilcheck.go index 0c3cb3e294..5b012a8551 100644 --- a/src/cmd/compile/internal/ssa/nilcheck.go +++ b/src/cmd/compile/internal/ssa/nilcheck.go @@ -4,6 +4,8 @@ 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 @@ -86,8 +88,16 @@ func nilcheckelim(f *Func) { // Eliminate the nil check. // The deadcode pass will remove vestigial values, // and the fuse pass will join this block with its successor. - node.block.Kind = BlockFirst - node.block.Control = nil + 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) + } } } @@ -119,6 +129,9 @@ func nilcheckelim(f *Func) { // 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] } @@ -126,12 +139,15 @@ func checkedptr(b *Block) *Value { } // nonnilptr returns the Value, if any, -// that is non-nil due to b being the success block -// of an OpIsNonNil block for the value and having a single +// 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] } diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 4c191807ba..bddb1176ad 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -25,6 +25,7 @@ const ( BlockPlain BlockIf BlockCall + BlockCheck BlockRet BlockRetJmp BlockExit @@ -53,6 +54,7 @@ var blockString = [...]string{ BlockPlain: "Plain", BlockIf: "If", BlockCall: "Call", + BlockCheck: "Check", BlockRet: "Ret", BlockRetJmp: "RetJmp", BlockExit: "Exit", @@ -270,9 +272,9 @@ const ( OpAMD64CALLinter OpAMD64REPMOVSB OpAMD64InvertFlags - OpAMD64LoweredPanicNilCheck OpAMD64LoweredGetG OpAMD64LoweredGetClosurePtr + OpAMD64LoweredNilCheck OpAdd8 OpAdd16 @@ -513,7 +515,7 @@ const ( OpIsNonNil OpIsInBounds OpIsSliceInBounds - OpPanicNilCheck + OpNilCheck OpGetG OpGetClosurePtr OpArrayIndex @@ -3118,14 +3120,6 @@ var opcodeTable = [...]opInfo{ name: "InvertFlags", reg: regInfo{}, }, - { - name: "LoweredPanicNilCheck", - reg: regInfo{ - inputs: []inputInfo{ - {0, 65519}, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 - }, - }, - }, { name: "LoweredGetG", reg: regInfo{ @@ -3142,6 +3136,15 @@ var opcodeTable = [...]opInfo{ }, }, }, + { + name: "LoweredNilCheck", + 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: "Add8", @@ -4100,7 +4103,7 @@ var opcodeTable = [...]opInfo{ generic: true, }, { - name: "PanicNilCheck", + name: "NilCheck", generic: true, }, { diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index d42b14a984..8181f8d39b 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -802,7 +802,7 @@ func (s *regAllocState) regalloc(f *Func) { } // Load control value into reg - if b.Control != nil && !b.Control.Type.IsMemory() { + if b.Control != nil && !b.Control.Type.IsMemory() && !b.Control.Type.IsVoid() { // TODO: regspec for block control values, instead of using // register set from the control op's output. s.allocValToReg(b.Control, opcodeTable[b.Control.Op].reg.outputs[0], false) diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 3fe272c204..f32b524689 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -6356,6 +6356,24 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end3b8bb3b4952011d1d40f993d8717cf16 end3b8bb3b4952011d1d40f993d8717cf16: ; + case OpNilCheck: + // match: (NilCheck ptr mem) + // cond: + // result: (LoweredNilCheck ptr mem) + { + ptr := v.Args[0] + mem := v.Args[1] + v.Op = OpAMD64LoweredNilCheck + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto end75520e60179564948a625707b84e8a8d + end75520e60179564948a625707b84e8a8d: + ; case OpNot: // match: (Not x) // cond: @@ -6939,24 +6957,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end6f8a8c559a167d1f0a5901d09a1fb248 end6f8a8c559a167d1f0a5901d09a1fb248: ; - case OpPanicNilCheck: - // match: (PanicNilCheck ptr mem) - // cond: - // result: (LoweredPanicNilCheck ptr mem) - { - ptr := v.Args[0] - mem := v.Args[1] - v.Op = OpAMD64LoweredPanicNilCheck - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(ptr) - v.AddArg(mem) - return true - } - goto enda02b1ad5a6f929b782190145f2c8628b - enda02b1ad5a6f929b782190145f2c8628b: - ; case OpRsh16Ux16: // match: (Rsh16Ux16 x y) // cond: diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index 91427e2f2a..3bd017b74a 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -1720,29 +1720,29 @@ func rewriteValuegeneric(v *Value, config *Config) bool { } func rewriteBlockgeneric(b *Block) bool { switch b.Kind { - case BlockIf: - // match: (If (IsNonNil (GetG _)) yes no) + case BlockCheck: + // match: (Check (NilCheck (GetG _) _) next) // cond: - // result: (First nil yes no) + // result: (Plain nil next) { v := b.Control - if v.Op != OpIsNonNil { - goto end41b95d88b4cebdb0ce392bd3c1c89e95 + if v.Op != OpNilCheck { + goto end6e20d932d6961903b0dcf16eac513826 } if v.Args[0].Op != OpGetG { - goto end41b95d88b4cebdb0ce392bd3c1c89e95 + goto end6e20d932d6961903b0dcf16eac513826 } - yes := b.Succs[0] - no := b.Succs[1] - b.Kind = BlockFirst + next := b.Succs[0] + b.Kind = BlockPlain b.Control = nil - b.Succs[0] = yes - b.Succs[1] = no + b.Succs[0] = next + b.Likely = BranchUnknown return true } - goto end41b95d88b4cebdb0ce392bd3c1c89e95 - end41b95d88b4cebdb0ce392bd3c1c89e95: + goto end6e20d932d6961903b0dcf16eac513826 + end6e20d932d6961903b0dcf16eac513826: ; + case BlockIf: // match: (If (Not cond) yes no) // cond: // result: (If cond no yes) diff --git a/src/cmd/compile/internal/ssa/type.go b/src/cmd/compile/internal/ssa/type.go index d558881b2f..8b6098f65f 100644 --- a/src/cmd/compile/internal/ssa/type.go +++ b/src/cmd/compile/internal/ssa/type.go @@ -26,6 +26,7 @@ type Type interface { 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 @@ -46,6 +47,7 @@ type CompilerType struct { Name string Memory bool Flags bool + Void bool } func (t *CompilerType) Size() int64 { return 0 } // Size in bytes @@ -63,6 +65,7 @@ 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") } @@ -84,4 +87,5 @@ var ( TypeInvalid = &CompilerType{Name: "invalid"} TypeMem = &CompilerType{Name: "mem", Memory: true} TypeFlags = &CompilerType{Name: "flags", Flags: true} + TypeVoid = &CompilerType{Name: "void", Void: true} ) diff --git a/src/cmd/compile/internal/ssa/type_test.go b/src/cmd/compile/internal/ssa/type_test.go index c8889608db..af111a59af 100644 --- a/src/cmd/compile/internal/ssa/type_test.go +++ b/src/cmd/compile/internal/ssa/type_test.go @@ -39,6 +39,7 @@ 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_ } -- cgit v1.3 From 10462eb30f60c140bd3ab524272488f9e349335d Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Wed, 21 Oct 2015 17:18:07 -0700 Subject: [dev.ssa] cmd/compile: better copying Replace REP MOVSB with all the copying techniques used by the old compiler. Copy in chunks, DUFFCOPY, etc. Introduces MOVO opcodes and an Int128 type to move around 16 bytes at a time. Change-Id: I1e73e68ca1d8b3dd58bb4af2f4c9e5d9bf13a502 Reviewed-on: https://go-review.googlesource.com/16174 Reviewed-by: Todd Neal Run-TryBot: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 13 +- src/cmd/compile/internal/gc/ssa_test.go | 2 + src/cmd/compile/internal/gc/testdata/copy_ssa.go | 726 +++++++++++++++++++++ .../compile/internal/gc/testdata/gen/copyGen.go | 93 +++ src/cmd/compile/internal/ssa/gen/AMD64.rules | 51 +- src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 55 +- src/cmd/compile/internal/ssa/gen/rulegen.go | 2 +- src/cmd/compile/internal/ssa/opGen.go | 39 +- src/cmd/compile/internal/ssa/rewriteAMD64.go | 574 +++++++++++++++- src/cmd/compile/internal/ssa/type.go | 2 + 10 files changed, 1527 insertions(+), 30 deletions(-) create mode 100644 src/cmd/compile/internal/gc/testdata/copy_ssa.go create mode 100644 src/cmd/compile/internal/gc/testdata/gen/copyGen.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 50fc935dec..96c9a5fc9c 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -3697,7 +3697,7 @@ func (s *genState) genValue(v *ssa.Value) { 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: + case ssa.OpAMD64MOVQload, ssa.OpAMD64MOVSSload, ssa.OpAMD64MOVSDload, ssa.OpAMD64MOVLload, ssa.OpAMD64MOVWload, ssa.OpAMD64MOVBload, ssa.OpAMD64MOVBQSXload, ssa.OpAMD64MOVBQZXload, ssa.OpAMD64MOVOload: p := Prog(v.Op.Asm()) p.From.Type = obj.TYPE_MEM p.From.Reg = regnum(v.Args[0]) @@ -3722,7 +3722,7 @@ func (s *genState) genValue(v *ssa.Value) { 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: + 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]) @@ -3763,6 +3763,11 @@ func (s *genState) genValue(v *ssa.Value) { } 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: // TODO: lower to MOVQ earlier? if v.Type.IsMemory() { @@ -3961,9 +3966,9 @@ func (s *genState) genValue(v *ssa.Value) { case ssa.OpAMD64REPSTOSQ: Prog(x86.AREP) Prog(x86.ASTOSQ) - case ssa.OpAMD64REPMOVSB: + case ssa.OpAMD64REPMOVSQ: Prog(x86.AREP) - Prog(x86.AMOVSB) + Prog(x86.AMOVSQ) case ssa.OpVarDef: Gvardef(v.Aux.(*Node)) case ssa.OpVarKill: diff --git a/src/cmd/compile/internal/gc/ssa_test.go b/src/cmd/compile/internal/gc/ssa_test.go index 1e06fd0d3d..5a881ed819 100644 --- a/src/cmd/compile/internal/gc/ssa_test.go +++ b/src/cmd/compile/internal/gc/ssa_test.go @@ -91,3 +91,5 @@ 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") } 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 0000000000..44f0223a43 --- /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/gen/copyGen.go b/src/cmd/compile/internal/gc/testdata/gen/copyGen.go new file mode 100644 index 0000000000..a699fac6c0 --- /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/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 4eef40c478..a6ea970fdb 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -293,7 +293,50 @@ (GetG mem) -> (LoweredGetG mem) (GetClosurePtr) -> (LoweredGetClosurePtr) -(Move [size] dst src mem) -> (REPMOVSB dst src (MOVQconst [size]) mem) +// 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 [size%16]) (ADDQconst 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 [size%16]) (ADDQconst 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) @@ -504,6 +547,7 @@ (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) @@ -511,6 +555,7 @@ (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) // 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. @@ -526,6 +571,8 @@ (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) @@ -539,6 +586,8 @@ (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) // indexed loads and stores (MOVQloadidx8 [off1] {sym} (ADDQconst [off2] ptr) idx mem) -> (MOVQloadidx8 [addOff(off1, off2)] {sym} ptr idx mem) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 2af50d3584..80f7096f80 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -366,18 +366,21 @@ func init() { {name: "LEAQ8", reg: gp21sb}, // arg0 + 8*arg1 + auxint // auxint+aux == add auxint and the offset of the symbol in aux (if any) to the effective address - {name: "MOVBload", reg: gpload, asm: "MOVB"}, // load byte from arg0+auxint+aux. arg1=mem - {name: "MOVBQSXload", reg: gpload, asm: "MOVBQSX"}, // ditto, extend to int64 - {name: "MOVBQZXload", reg: gpload, asm: "MOVBQZX"}, // ditto, extend to uint64 - {name: "MOVWload", reg: gpload, asm: "MOVW"}, // load 2 bytes from arg0+auxint+aux. arg1=mem - {name: "MOVLload", reg: gpload, asm: "MOVL"}, // load 4 bytes from arg0+auxint+aux. arg1=mem - {name: "MOVQload", reg: gpload, asm: "MOVQ"}, // load 8 bytes from arg0+auxint+aux. arg1=mem - {name: "MOVQloadidx8", reg: gploadidx, asm: "MOVQ"}, // load 8 bytes from arg0+8*arg1+auxint+aux. arg2=mem - {name: "MOVBstore", reg: gpstore, asm: "MOVB", typ: "Mem"}, // store byte in arg1 to arg0+auxint+aux. arg2=mem - {name: "MOVWstore", reg: gpstore, asm: "MOVW", typ: "Mem"}, // store 2 bytes in arg1 to arg0+auxint+aux. arg2=mem - {name: "MOVLstore", reg: gpstore, asm: "MOVL", typ: "Mem"}, // store 4 bytes in arg1 to arg0+auxint+aux. arg2=mem - {name: "MOVQstore", reg: gpstore, asm: "MOVQ", typ: "Mem"}, // store 8 bytes in arg1 to arg0+auxint+aux. arg2=mem - {name: "MOVQstoreidx8", reg: gpstoreidx, asm: "MOVQ"}, // store 8 bytes in arg2 to arg0+8*arg1+auxint+aux. arg3=mem + {name: "MOVBload", reg: gpload, asm: "MOVB", typ: "UInt8"}, // load byte from arg0+auxint+aux. arg1=mem + {name: "MOVBQSXload", reg: gpload, asm: "MOVBQSX"}, // ditto, extend to int64 + {name: "MOVBQZXload", reg: gpload, asm: "MOVBQZX"}, // ditto, extend to uint64 + {name: "MOVWload", reg: gpload, asm: "MOVW", typ: "UInt16"}, // load 2 bytes from arg0+auxint+aux. arg1=mem + {name: "MOVLload", reg: gpload, asm: "MOVL", typ: "UInt32"}, // load 4 bytes from arg0+auxint+aux. arg1=mem + {name: "MOVQload", reg: gpload, asm: "MOVQ", typ: "UInt64"}, // load 8 bytes from arg0+auxint+aux. arg1=mem + {name: "MOVQloadidx8", reg: gploadidx, asm: "MOVQ"}, // load 8 bytes from arg0+8*arg1+auxint+aux. arg2=mem + {name: "MOVBstore", reg: gpstore, asm: "MOVB", typ: "Mem"}, // store byte in arg1 to arg0+auxint+aux. arg2=mem + {name: "MOVWstore", reg: gpstore, asm: "MOVW", typ: "Mem"}, // store 2 bytes in arg1 to arg0+auxint+aux. arg2=mem + {name: "MOVLstore", reg: gpstore, asm: "MOVL", typ: "Mem"}, // store 4 bytes in arg1 to arg0+auxint+aux. arg2=mem + {name: "MOVQstore", reg: gpstore, asm: "MOVQ", typ: "Mem"}, // store 8 bytes in arg1 to arg0+auxint+aux. arg2=mem + {name: "MOVQstoreidx8", reg: gpstoreidx, asm: "MOVQ"}, // store 8 bytes in arg2 to arg0+8*arg1+auxint+aux. arg3=mem + + {name: "MOVOload", reg: fpload, asm: "MOVUPS", typ: "Int128"}, // load 16 bytes from arg0+auxint+aux. arg1=mem + {name: "MOVOstore", reg: fpstore, asm: "MOVUPS", typ: "Mem"}, // store 16 bytes in arg1 to arg0+auxint+aux. arg2=mem // arg0 = (duff-adjusted) pointer to start of memory to zero // arg1 = value to store (will always be zero) @@ -391,7 +394,7 @@ func init() { clobbers: buildReg("DI FLAGS"), }, }, - {name: "MOVOconst", reg: regInfo{nil, 0, []regMask{fp}}, typ: "Float64"}, + {name: "MOVOconst", reg: regInfo{nil, 0, []regMask{fp}}, typ: "Int128"}, // arg0 = address of memory to zero // arg1 = # of 8-byte words to zero @@ -412,7 +415,31 @@ func init() { {name: "CALLgo", reg: regInfo{clobbers: callerSave}}, // call newproc. arg0=mem, auxint=argsize, returns mem {name: "CALLinter", reg: regInfo{inputs: []regMask{gp}, clobbers: callerSave}}, // call fn by pointer. arg0=codeptr, arg1=mem, auxint=argsize, returns mem - {name: "REPMOVSB", reg: regInfo{[]regMask{buildReg("DI"), buildReg("SI"), buildReg("CX")}, buildReg("DI SI CX"), nil}}, // move arg2 bytes from arg1 to arg0. arg3=mem, returns memory + // arg0 = destination pointer + // arg1 = source pointer + // arg2 = mem + // auxint = offset from duffcopy symbol to call + // returns memory + { + name: "DUFFCOPY", + reg: regInfo{ + inputs: []regMask{buildReg("DI"), buildReg("SI")}, + clobbers: buildReg("DI SI X0"), // uses X0 as a temporary + }, + }, + + // arg0 = destination pointer + // arg1 = source pointer + // arg2 = # of 8-byte words to copy + // arg3 = mem + // returns memory + { + name: "REPMOVSQ", + 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, diff --git a/src/cmd/compile/internal/ssa/gen/rulegen.go b/src/cmd/compile/internal/ssa/gen/rulegen.go index 71c9ca7ec2..1aef1dab8f 100644 --- a/src/cmd/compile/internal/ssa/gen/rulegen.go +++ b/src/cmd/compile/internal/ssa/gen/rulegen.go @@ -585,7 +585,7 @@ func blockName(name string, arch arch) string { // typeName returns the string to use to generate a type. func typeName(typ string) string { switch typ { - case "Flags", "Mem", "Void": + case "Flags", "Mem", "Void", "Int128": return "Type" + typ default: return "config.fe.Type" + typ + "()" diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index bddb1176ad..a1a2ce9e49 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -262,6 +262,8 @@ const ( OpAMD64MOVLstore OpAMD64MOVQstore OpAMD64MOVQstoreidx8 + OpAMD64MOVOload + OpAMD64MOVOstore OpAMD64DUFFZERO OpAMD64MOVOconst OpAMD64REPSTOSQ @@ -270,7 +272,8 @@ const ( OpAMD64CALLdefer OpAMD64CALLgo OpAMD64CALLinter - OpAMD64REPMOVSB + OpAMD64DUFFCOPY + OpAMD64REPMOVSQ OpAMD64InvertFlags OpAMD64LoweredGetG OpAMD64LoweredGetClosurePtr @@ -3039,6 +3042,28 @@ var opcodeTable = [...]opInfo{ }, }, }, + { + name: "MOVOload", + 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", + 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: "DUFFZERO", reg: regInfo{ @@ -3106,7 +3131,17 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "REPMOVSB", + name: "DUFFCOPY", + reg: regInfo{ + inputs: []inputInfo{ + {0, 128}, // .DI + {1, 64}, // .SI + }, + clobbers: 65728, // .SI .DI .X0 + }, + }, + { + name: "REPMOVSQ", reg: regInfo{ inputs: []inputInfo{ {0, 128}, // .DI diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index f32b524689..1d7695fa4b 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -4379,6 +4379,120 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endd57b1e4313fc7a3331340a9af00ba116 endd57b1e4313fc7a3331340a9af00ba116: ; + case OpAMD64MOVOload: + // match: (MOVOload [off1] {sym} (ADDQconst [off2] ptr) mem) + // cond: + // result: (MOVOload [addOff(off1, off2)] {sym} ptr mem) + { + off1 := v.AuxInt + sym := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto endf1e8fcf569ddd8b3f7a2f61696971913 + } + off2 := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + mem := v.Args[1] + v.Op = OpAMD64MOVOload + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = sym + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto endf1e8fcf569ddd8b3f7a2f61696971913 + endf1e8fcf569ddd8b3f7a2f61696971913: + ; + // match: (MOVOload [off1] {sym1} (LEAQ [off2] {sym2} base) mem) + // cond: canMergeSym(sym1, sym2) + // result: (MOVOload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem) + { + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ { + goto endd36cf9b00af7a8f44fb8c60067a8efb2 + } + off2 := v.Args[0].AuxInt + sym2 := v.Args[0].Aux + base := v.Args[0].Args[0] + mem := v.Args[1] + if !(canMergeSym(sym1, sym2)) { + goto endd36cf9b00af7a8f44fb8c60067a8efb2 + } + v.Op = OpAMD64MOVOload + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(base) + v.AddArg(mem) + return true + } + goto endd36cf9b00af7a8f44fb8c60067a8efb2 + endd36cf9b00af7a8f44fb8c60067a8efb2: + ; + case OpAMD64MOVOstore: + // match: (MOVOstore [off1] {sym} (ADDQconst [off2] ptr) val mem) + // cond: + // result: (MOVOstore [addOff(off1, off2)] {sym} ptr val mem) + { + off1 := v.AuxInt + sym := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto end2be573aa1bd919e567e6156a4ee36517 + } + off2 := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + val := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64MOVOstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = sym + v.AddArg(ptr) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto end2be573aa1bd919e567e6156a4ee36517 + end2be573aa1bd919e567e6156a4ee36517: + ; + // 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) + { + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ { + goto endc28b9b3efe9eb235e1586c4555280c20 + } + 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)) { + goto endc28b9b3efe9eb235e1586c4555280c20 + } + v.Op = OpAMD64MOVOstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(base) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto endc28b9b3efe9eb235e1586c4555280c20 + endc28b9b3efe9eb235e1586c4555280c20: + ; case OpAMD64MOVQload: // match: (MOVQload [off1] {sym} (ADDQconst [off2] ptr) mem) // cond: @@ -5803,29 +5917,473 @@ func rewriteValueAMD64(v *Value, config *Config) bool { end9b3274d9dd7f1e91c75ce5e7b548fe97: ; case OpMove: - // match: (Move [size] dst src mem) + // match: (Move [0] _ _ mem) + // cond: + // result: mem + { + if v.AuxInt != 0 { + goto end0961cbfe144a616cba75190d07d65e41 + } + mem := v.Args[2] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = mem.Type + v.AddArg(mem) + return true + } + goto end0961cbfe144a616cba75190d07d65e41 + end0961cbfe144a616cba75190d07d65e41: + ; + // match: (Move [1] dst src mem) + // cond: + // result: (MOVBstore dst (MOVBload src mem) mem) + { + if v.AuxInt != 1 { + goto end72e5dd27e999493b67ea3af4ecc60d48 + } + dst := v.Args[0] + src := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64MOVBstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(dst) + v0 := b.NewValue0(v.Line, OpAMD64MOVBload, TypeInvalid) + v0.AddArg(src) + v0.AddArg(mem) + v0.Type = config.fe.TypeUInt8() + v.AddArg(v0) + v.AddArg(mem) + return true + } + goto end72e5dd27e999493b67ea3af4ecc60d48 + end72e5dd27e999493b67ea3af4ecc60d48: + ; + // match: (Move [2] dst src mem) + // cond: + // result: (MOVWstore dst (MOVWload src mem) mem) + { + if v.AuxInt != 2 { + goto end017f774e406d4578b4bcefcd8db8ec1e + } + dst := v.Args[0] + src := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64MOVWstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(dst) + v0 := b.NewValue0(v.Line, OpAMD64MOVWload, TypeInvalid) + v0.AddArg(src) + v0.AddArg(mem) + v0.Type = config.fe.TypeUInt16() + v.AddArg(v0) + v.AddArg(mem) + return true + } + goto end017f774e406d4578b4bcefcd8db8ec1e + end017f774e406d4578b4bcefcd8db8ec1e: + ; + // match: (Move [4] dst src mem) + // cond: + // result: (MOVLstore dst (MOVLload src mem) mem) + { + if v.AuxInt != 4 { + goto end938ec47a2ddf8e9b4bf71ffade6e5b3f + } + dst := v.Args[0] + src := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64MOVLstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(dst) + v0 := b.NewValue0(v.Line, OpAMD64MOVLload, TypeInvalid) + v0.AddArg(src) + v0.AddArg(mem) + v0.Type = config.fe.TypeUInt32() + v.AddArg(v0) + v.AddArg(mem) + return true + } + goto end938ec47a2ddf8e9b4bf71ffade6e5b3f + end938ec47a2ddf8e9b4bf71ffade6e5b3f: + ; + // match: (Move [8] dst src mem) + // cond: + // result: (MOVQstore dst (MOVQload src mem) mem) + { + if v.AuxInt != 8 { + goto end696b3498f5fee17f49ae0f708d3dfe4b + } + dst := v.Args[0] + src := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64MOVQstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(dst) + v0 := b.NewValue0(v.Line, OpAMD64MOVQload, TypeInvalid) + v0.AddArg(src) + v0.AddArg(mem) + v0.Type = config.fe.TypeUInt64() + v.AddArg(v0) + v.AddArg(mem) + return true + } + goto end696b3498f5fee17f49ae0f708d3dfe4b + end696b3498f5fee17f49ae0f708d3dfe4b: + ; + // match: (Move [16] dst src mem) + // cond: + // result: (MOVOstore dst (MOVOload src mem) mem) + { + if v.AuxInt != 16 { + goto end4894ace925d468c10a5b0c5b91fc4c1c + } + dst := v.Args[0] + src := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64MOVOstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(dst) + v0 := b.NewValue0(v.Line, OpAMD64MOVOload, TypeInvalid) + v0.AddArg(src) + v0.AddArg(mem) + v0.Type = TypeInt128 + v.AddArg(v0) + v.AddArg(mem) + return true + } + goto end4894ace925d468c10a5b0c5b91fc4c1c + end4894ace925d468c10a5b0c5b91fc4c1c: + ; + // match: (Move [3] dst src mem) + // cond: + // result: (MOVBstore [2] dst (MOVBload [2] src mem) (MOVWstore dst (MOVWload src mem) mem)) + { + if v.AuxInt != 3 { + goto end76ce0004999139fe4608c3c5356eb364 + } + dst := v.Args[0] + src := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64MOVBstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 2 + v.AddArg(dst) + v0 := b.NewValue0(v.Line, OpAMD64MOVBload, TypeInvalid) + v0.AuxInt = 2 + v0.AddArg(src) + v0.AddArg(mem) + v0.Type = config.fe.TypeUInt8() + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64MOVWstore, TypeInvalid) + v1.AddArg(dst) + v2 := b.NewValue0(v.Line, OpAMD64MOVWload, TypeInvalid) + v2.AddArg(src) + v2.AddArg(mem) + v2.Type = config.fe.TypeUInt16() + v1.AddArg(v2) + v1.AddArg(mem) + v1.Type = TypeMem + v.AddArg(v1) + return true + } + goto end76ce0004999139fe4608c3c5356eb364 + end76ce0004999139fe4608c3c5356eb364: + ; + // match: (Move [5] dst src mem) + // cond: + // result: (MOVBstore [4] dst (MOVBload [4] src mem) (MOVLstore dst (MOVLload src mem) mem)) + { + if v.AuxInt != 5 { + goto end21378690c0f39bdd6b46566d57da34e3 + } + dst := v.Args[0] + src := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64MOVBstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 4 + v.AddArg(dst) + v0 := b.NewValue0(v.Line, OpAMD64MOVBload, TypeInvalid) + v0.AuxInt = 4 + v0.AddArg(src) + v0.AddArg(mem) + v0.Type = config.fe.TypeUInt8() + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64MOVLstore, TypeInvalid) + v1.AddArg(dst) + v2 := b.NewValue0(v.Line, OpAMD64MOVLload, TypeInvalid) + v2.AddArg(src) + v2.AddArg(mem) + v2.Type = config.fe.TypeUInt32() + v1.AddArg(v2) + v1.AddArg(mem) + v1.Type = TypeMem + v.AddArg(v1) + return true + } + goto end21378690c0f39bdd6b46566d57da34e3 + end21378690c0f39bdd6b46566d57da34e3: + ; + // match: (Move [6] dst src mem) // cond: - // result: (REPMOVSB dst src (MOVQconst [size]) mem) + // result: (MOVWstore [4] dst (MOVWload [4] src mem) (MOVLstore dst (MOVLload src mem) mem)) + { + if v.AuxInt != 6 { + goto endcb6e509881d8638d8cae3af4f2b19a8e + } + dst := v.Args[0] + src := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64MOVWstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 4 + v.AddArg(dst) + v0 := b.NewValue0(v.Line, OpAMD64MOVWload, TypeInvalid) + v0.AuxInt = 4 + v0.AddArg(src) + v0.AddArg(mem) + v0.Type = config.fe.TypeUInt16() + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64MOVLstore, TypeInvalid) + v1.AddArg(dst) + v2 := b.NewValue0(v.Line, OpAMD64MOVLload, TypeInvalid) + v2.AddArg(src) + v2.AddArg(mem) + v2.Type = config.fe.TypeUInt32() + v1.AddArg(v2) + v1.AddArg(mem) + v1.Type = TypeMem + v.AddArg(v1) + return true + } + goto endcb6e509881d8638d8cae3af4f2b19a8e + endcb6e509881d8638d8cae3af4f2b19a8e: + ; + // match: (Move [7] dst src mem) + // cond: + // result: (MOVLstore [3] dst (MOVLload [3] src mem) (MOVLstore dst (MOVLload src mem) mem)) + { + if v.AuxInt != 7 { + goto end3429ae54bc071c0856ad366c79b7ab97 + } + dst := v.Args[0] + src := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64MOVLstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 3 + v.AddArg(dst) + v0 := b.NewValue0(v.Line, OpAMD64MOVLload, TypeInvalid) + v0.AuxInt = 3 + v0.AddArg(src) + v0.AddArg(mem) + v0.Type = config.fe.TypeUInt32() + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64MOVLstore, TypeInvalid) + v1.AddArg(dst) + v2 := b.NewValue0(v.Line, OpAMD64MOVLload, TypeInvalid) + v2.AddArg(src) + v2.AddArg(mem) + v2.Type = config.fe.TypeUInt32() + v1.AddArg(v2) + v1.AddArg(mem) + v1.Type = TypeMem + v.AddArg(v1) + return true + } + goto end3429ae54bc071c0856ad366c79b7ab97 + end3429ae54bc071c0856ad366c79b7ab97: + ; + // 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)) + { + size := v.AuxInt + dst := v.Args[0] + src := v.Args[1] + mem := v.Args[2] + if !(size > 8 && size < 16) { + goto endc90f121709d5411d389649dea89a2251 + } + v.Op = OpAMD64MOVQstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = size - 8 + v.AddArg(dst) + v0 := b.NewValue0(v.Line, OpAMD64MOVQload, TypeInvalid) + v0.AuxInt = size - 8 + v0.AddArg(src) + v0.AddArg(mem) + v0.Type = config.fe.TypeUInt64() + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64MOVQstore, TypeInvalid) + v1.AddArg(dst) + v2 := b.NewValue0(v.Line, OpAMD64MOVQload, TypeInvalid) + v2.AddArg(src) + v2.AddArg(mem) + v2.Type = config.fe.TypeUInt64() + v1.AddArg(v2) + v1.AddArg(mem) + v1.Type = TypeMem + v.AddArg(v1) + return true + } + goto endc90f121709d5411d389649dea89a2251 + endc90f121709d5411d389649dea89a2251: + ; + // match: (Move [size] dst src mem) + // cond: size > 16 && size%16 != 0 && size%16 <= 8 + // result: (Move [size-size%16] (ADDQconst dst [size%16]) (ADDQconst src [size%16]) (MOVQstore dst (MOVQload src mem) mem)) + { + size := v.AuxInt + dst := v.Args[0] + src := v.Args[1] + mem := v.Args[2] + if !(size > 16 && size%16 != 0 && size%16 <= 8) { + goto end376c57db23b866866f23677c6cde43ba + } + v.Op = OpMove + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = size - size%16 + v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) + v0.Type = dst.Type + v0.AddArg(dst) + v0.AuxInt = size % 16 + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) + v1.Type = src.Type + v1.AddArg(src) + v1.AuxInt = size % 16 + v.AddArg(v1) + v2 := b.NewValue0(v.Line, OpAMD64MOVQstore, TypeInvalid) + v2.AddArg(dst) + v3 := b.NewValue0(v.Line, OpAMD64MOVQload, TypeInvalid) + v3.AddArg(src) + v3.AddArg(mem) + v3.Type = config.fe.TypeUInt64() + v2.AddArg(v3) + v2.AddArg(mem) + v2.Type = TypeMem + v.AddArg(v2) + return true + } + goto end376c57db23b866866f23677c6cde43ba + end376c57db23b866866f23677c6cde43ba: + ; + // match: (Move [size] dst src mem) + // cond: size > 16 && size%16 != 0 && size%16 > 8 + // result: (Move [size-size%16] (ADDQconst dst [size%16]) (ADDQconst src [size%16]) (MOVOstore dst (MOVOload src mem) mem)) { size := v.AuxInt dst := v.Args[0] src := v.Args[1] mem := v.Args[2] - v.Op = OpAMD64REPMOVSB + if !(size > 16 && size%16 != 0 && size%16 > 8) { + goto end2f82f76766a21f8802768380cf10a497 + } + v.Op = OpMove + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = size - size%16 + v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) + v0.Type = dst.Type + v0.AddArg(dst) + v0.AuxInt = size % 16 + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) + v1.Type = src.Type + v1.AddArg(src) + v1.AuxInt = size % 16 + v.AddArg(v1) + v2 := b.NewValue0(v.Line, OpAMD64MOVOstore, TypeInvalid) + v2.AddArg(dst) + v3 := b.NewValue0(v.Line, OpAMD64MOVOload, TypeInvalid) + v3.AddArg(src) + v3.AddArg(mem) + v3.Type = TypeInt128 + v2.AddArg(v3) + v2.AddArg(mem) + v2.Type = TypeMem + v.AddArg(v2) + return true + } + goto end2f82f76766a21f8802768380cf10a497 + end2f82f76766a21f8802768380cf10a497: + ; + // match: (Move [size] dst src mem) + // cond: size >= 32 && size <= 16*64 && size%16 == 0 + // result: (DUFFCOPY [14*(64-size/16)] dst src mem) + { + size := v.AuxInt + dst := v.Args[0] + src := v.Args[1] + mem := v.Args[2] + if !(size >= 32 && size <= 16*64 && size%16 == 0) { + goto endcb66da6685f0079ee1f84d10fa561f22 + } + v.Op = OpAMD64DUFFCOPY + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 14 * (64 - size/16) + v.AddArg(dst) + v.AddArg(src) + v.AddArg(mem) + return true + } + goto endcb66da6685f0079ee1f84d10fa561f22 + endcb66da6685f0079ee1f84d10fa561f22: + ; + // match: (Move [size] dst src mem) + // cond: size > 16*64 && size%8 == 0 + // result: (REPMOVSQ dst src (MOVQconst [size/8]) mem) + { + size := v.AuxInt + dst := v.Args[0] + src := v.Args[1] + mem := v.Args[2] + if !(size > 16*64 && size%8 == 0) { + goto end7ae25ff1bbdcf34efef09613745e9d6e + } + v.Op = OpAMD64REPMOVSQ v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AddArg(dst) v.AddArg(src) v0 := b.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) - v0.Type = config.Frontend().TypeUInt64() - v0.AuxInt = size + v0.AuxInt = size / 8 + v0.Type = config.fe.TypeUInt64() v.AddArg(v0) v.AddArg(mem) return true } - goto end4dd156b33beb9981378c91e46f055a56 - end4dd156b33beb9981378c91e46f055a56: + goto end7ae25ff1bbdcf34efef09613745e9d6e + end7ae25ff1bbdcf34efef09613745e9d6e: ; case OpMul16: // match: (Mul16 x y) @@ -10710,7 +11268,7 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v.AddArg(v0) v1 := b.NewValue0(v.Line, OpAMD64MOVOconst, TypeInvalid) v1.AuxInt = 0 - v1.Type = config.fe.TypeFloat64() + v1.Type = TypeInt128 v.AddArg(v1) v.AddArg(mem) return true diff --git a/src/cmd/compile/internal/ssa/type.go b/src/cmd/compile/internal/ssa/type.go index 8b6098f65f..9a692dcfb0 100644 --- a/src/cmd/compile/internal/ssa/type.go +++ b/src/cmd/compile/internal/ssa/type.go @@ -48,6 +48,7 @@ type CompilerType struct { Memory bool Flags bool Void bool + Int128 bool } func (t *CompilerType) Size() int64 { return 0 } // Size in bytes @@ -88,4 +89,5 @@ var ( TypeMem = &CompilerType{Name: "mem", Memory: true} TypeFlags = &CompilerType{Name: "flags", Flags: true} TypeVoid = &CompilerType{Name: "void", Void: true} + TypeInt128 = &CompilerType{Name: "int128", Int128: true} ) -- cgit v1.3 From 129261ae834fa27307f0ed0363b5f719147f2378 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Tue, 27 Oct 2015 10:15:02 -0700 Subject: [dev.ssa] cmd/compile: give GetClosurePtr pointer type If the closure pointer gets spilled, we need to spill it with pointer type to make stack copy and GC happy. Change-Id: Ic108748e6b9caecd45522141f02c9422567376e3 Reviewed-on: https://go-review.googlesource.com/16363 Run-TryBot: Keith Randall Reviewed-by: David Chase --- src/cmd/compile/internal/gc/ssa.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 96c9a5fc9c..d4001146b6 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -2335,7 +2335,7 @@ func (s *state) addr(n *Node, bounded bool) *ssa.Value { return s.newValue2(ssa.OpAddPtr, p.Type, p, s.constIntPtr(Types[TUINTPTR], n.Xoffset)) case OCLOSUREVAR: return s.newValue2(ssa.OpAddPtr, Ptrto(n.Type), - s.entryNewValue0(ssa.OpGetClosurePtr, Types[TUINTPTR]), + s.entryNewValue0(ssa.OpGetClosurePtr, Ptrto(Types[TUINT8])), s.constIntPtr(Types[TUINTPTR], n.Xoffset)) case OPARAM: p := n.Left -- cgit v1.3 From cd01c0be267da70abe8bd6f53109fa2c70e581dc Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Mon, 26 Oct 2015 20:57:53 -0500 Subject: [dev.ssa] cmd/compile/internal/ssa: reorder fuse and dse deadstore elimination currently works in a block, fusing before performing dse eliminates ~1% more stores for make.bash Change-Id: If5bbddac76bf42616938a8e8e84cb7441fa02f73 Reviewed-on: https://go-review.googlesource.com/16350 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/compile.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/compile.go b/src/cmd/compile/internal/ssa/compile.go index 1c2b7ac2a8..af672eea99 100644 --- a/src/cmd/compile/internal/ssa/compile.go +++ b/src/cmd/compile/internal/ssa/compile.go @@ -90,8 +90,8 @@ var passes = [...]pass{ {"generic cse", cse}, {"nilcheckelim", nilcheckelim}, {"generic deadcode", deadcode}, - {"dse", dse}, {"fuse", fuse}, + {"dse", dse}, {"tighten", tighten}, // move values closer to their uses {"lower", lower}, {"lowered cse", cse}, -- cgit v1.3 From d43f2e37edf4115e31a0c9218d87182d0aa1c4f0 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Wed, 21 Oct 2015 13:13:56 -0700 Subject: [dev.ssa] cmd/compile: introduce storeconst ops Introduce opcodes that store a constant value. AuxInt now needs to hold both the value to be stored and the constant offset at which to store it. Introduce a StoreConst type to help encode/decode these parts to/from an AuxInt. Change-Id: I1631883abe035cff4b16368683e1eb3d2ccb674d Reviewed-on: https://go-review.googlesource.com/16170 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/gc/ssa.go | 28 +- src/cmd/compile/internal/ssa/gen/AMD64.rules | 73 ++- src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 13 +- src/cmd/compile/internal/ssa/op.go | 55 +++ src/cmd/compile/internal/ssa/opGen.go | 40 ++ src/cmd/compile/internal/ssa/rewriteAMD64.go | 694 ++++++++++++++++++--------- 6 files changed, 650 insertions(+), 253 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index d4001146b6..f7100fefbe 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -3747,6 +3747,24 @@ func (s *genState) genValue(v *ssa.Value) { p.To.Scale = 4 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 := ssa.StoreConst(v.AuxInt) + 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.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, @@ -3990,6 +4008,11 @@ func (s *genState) genValue(v *ssa.Value) { if w.Args[0] == v.Args[0] && w.Aux == nil && w.AuxInt >= 0 && w.AuxInt < minZeroPage { return } + case ssa.OpAMD64MOVQstoreconst, ssa.OpAMD64MOVLstoreconst, ssa.OpAMD64MOVWstoreconst, ssa.OpAMD64MOVBstoreconst: + off := ssa.StoreConst(v.AuxInt).Off() + if w.Args[0] == v.Args[0] && w.Aux == nil && off >= 0 && off < minZeroPage { + return + } } if w.Type.IsMemory() { // We can't delay the nil check past the next store. @@ -4202,11 +4225,14 @@ func (s *genState) deferReturn() { // 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 += v.AuxInt + a.Offset += offset // If no additional symbol offset, we're done. if v.Aux == nil { diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index a6ea970fdb..bcd5ba9a8a 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -557,6 +557,26 @@ (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) && validStoreConst(c,off) -> + (MOVQstoreconst [makeStoreConst(c,off)] {sym} ptr mem) +(MOVLstore [off] {sym} ptr (MOVLconst [c]) mem) && validStoreConstOff(off) -> + (MOVLstoreconst [makeStoreConst(int64(int32(c)),off)] {sym} ptr mem) +(MOVWstore [off] {sym} ptr (MOVWconst [c]) mem) && validStoreConstOff(off) -> + (MOVWstoreconst [makeStoreConst(int64(int16(c)),off)] {sym} ptr mem) +(MOVBstore [off] {sym} ptr (MOVBconst [c]) mem) && validStoreConstOff(off) -> + (MOVBstoreconst [makeStoreConst(int64(int8(c)),off)] {sym} ptr mem) + +// Fold address offsets into constant stores. +(MOVQstoreconst [sc] {s} (ADDQconst [off] ptr) mem) && StoreConst(sc).canAdd(off) -> + (MOVQstoreconst [StoreConst(sc).add(off)] {s} ptr mem) +(MOVLstoreconst [sc] {s} (ADDQconst [off] ptr) mem) && StoreConst(sc).canAdd(off) -> + (MOVLstoreconst [StoreConst(sc).add(off)] {s} ptr mem) +(MOVWstoreconst [sc] {s} (ADDQconst [off] ptr) mem) && StoreConst(sc).canAdd(off) -> + (MOVWstoreconst [StoreConst(sc).add(off)] {s} ptr mem) +(MOVBstoreconst [sc] {s} (ADDQconst [off] ptr) mem) && StoreConst(sc).canAdd(off) -> + (MOVBstoreconst [StoreConst(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) -> @@ -589,6 +609,15 @@ (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) && StoreConst(sc).canAdd(off) -> + (MOVQstoreconst [StoreConst(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem) +(MOVLstoreconst [sc] {sym1} (LEAQ [off] {sym2} ptr) mem) && canMergeSym(sym1, sym2) && StoreConst(sc).canAdd(off) -> + (MOVLstoreconst [StoreConst(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem) +(MOVWstoreconst [sc] {sym1} (LEAQ [off] {sym2} ptr) mem) && canMergeSym(sym1, sym2) && StoreConst(sc).canAdd(off) -> + (MOVWstoreconst [StoreConst(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem) +(MOVBstoreconst [sc] {sym1} (LEAQ [off] {sym2} ptr) mem) && canMergeSym(sym1, sym2) && StoreConst(sc).canAdd(off) -> + (MOVBstoreconst [StoreConst(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem) + // indexed loads and stores (MOVQloadidx8 [off1] {sym} (ADDQconst [off2] ptr) idx mem) -> (MOVQloadidx8 [addOff(off1, off2)] {sym} ptr idx mem) (MOVQstoreidx8 [off1] {sym} (ADDQconst [off2] ptr) idx val mem) -> (MOVQstoreidx8 [addOff(off1, off2)] {sym} ptr idx val mem) @@ -616,42 +645,42 @@ // lower Zero instructions with word sizes (Zero [0] _ mem) -> mem -(Zero [1] destptr mem) -> (MOVBstore destptr (MOVBconst [0]) mem) -(Zero [2] destptr mem) -> (MOVWstore destptr (MOVWconst [0]) mem) -(Zero [4] destptr mem) -> (MOVLstore destptr (MOVLconst [0]) mem) -(Zero [8] destptr mem) -> (MOVQstore destptr (MOVQconst [0]) 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) -> - (MOVBstore (ADDQconst [2] destptr) (MOVBconst [0]) - (MOVWstore destptr (MOVWconst [0]) mem)) + (MOVBstoreconst [makeStoreConst(0,2)] destptr + (MOVWstoreconst [0] destptr mem)) (Zero [5] destptr mem) -> - (MOVBstore (ADDQconst [4] destptr) (MOVBconst [0]) - (MOVLstore destptr (MOVLconst [0]) mem)) + (MOVBstoreconst [makeStoreConst(0,4)] destptr + (MOVLstoreconst [0] destptr mem)) (Zero [6] destptr mem) -> - (MOVWstore (ADDQconst [4] destptr) (MOVWconst [0]) - (MOVLstore destptr (MOVLconst [0]) mem)) + (MOVWstoreconst [makeStoreConst(0,4)] destptr + (MOVLstoreconst [0] destptr mem)) (Zero [7] destptr mem) -> - (MOVLstore (ADDQconst [3] destptr) (MOVLconst [0]) - (MOVLstore destptr (MOVLconst [0]) mem)) + (MOVLstoreconst [makeStoreConst(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]) - (MOVQstore destptr (MOVQconst [0]) mem)) + (MOVQstoreconst [0] destptr mem)) // Zero small numbers of words directly. (Zero [16] destptr mem) -> - (MOVQstore (ADDQconst [8] destptr) (MOVQconst [0]) - (MOVQstore destptr (MOVQconst [0]) mem)) + (MOVQstoreconst [makeStoreConst(0,8)] destptr + (MOVQstoreconst [0] destptr mem)) (Zero [24] destptr mem) -> - (MOVQstore (ADDQconst [16] destptr) (MOVQconst [0]) - (MOVQstore (ADDQconst [8] destptr) (MOVQconst [0]) - (MOVQstore destptr (MOVQconst [0]) mem))) + (MOVQstoreconst [makeStoreConst(0,16)] destptr + (MOVQstoreconst [makeStoreConst(0,8)] destptr + (MOVQstoreconst [0] destptr mem))) (Zero [32] destptr mem) -> - (MOVQstore (ADDQconst [24] destptr) (MOVQconst [0]) - (MOVQstore (ADDQconst [16] destptr) (MOVQconst [0]) - (MOVQstore (ADDQconst [8] destptr) (MOVQconst [0]) - (MOVQstore destptr (MOVQconst [0]) mem)))) + (MOVQstoreconst [makeStoreConst(0,24)] destptr + (MOVQstoreconst [makeStoreConst(0,16)] destptr + (MOVQstoreconst [makeStoreConst(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 -> diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 80f7096f80..fa5072f7c5 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -116,8 +116,9 @@ func init() { gpload = regInfo{inputs: []regMask{gpspsb, 0}, outputs: gponly} gploadidx = regInfo{inputs: []regMask{gpspsb, gpsp, 0}, outputs: gponly} - gpstore = regInfo{inputs: []regMask{gpspsb, gpsp, 0}} - gpstoreidx = regInfo{inputs: []regMask{gpspsb, gpsp, gpsp, 0}} + gpstore = regInfo{inputs: []regMask{gpspsb, gpsp, 0}} + gpstoreconst = regInfo{inputs: []regMask{gpspsb, 0}} + gpstoreidx = regInfo{inputs: []regMask{gpspsb, gpsp, gpsp, 0}} fp01 = regInfo{inputs: []regMask{}, outputs: fponly} fp21 = regInfo{inputs: []regMask{fp, fp}, outputs: fponly} @@ -382,6 +383,14 @@ func init() { {name: "MOVOload", reg: fpload, asm: "MOVUPS", typ: "Int128"}, // load 16 bytes from arg0+auxint+aux. arg1=mem {name: "MOVOstore", reg: fpstore, asm: "MOVUPS", typ: "Mem"}, // store 16 bytes in arg1 to arg0+auxint+aux. arg2=mem + // For storeconst ops, the AuxInt field encodes both + // the value to store and an address offset of the store. + // Cast AuxInt to a StoreConst to extract Val and Off fields. + {name: "MOVBstoreconst", reg: gpstoreconst, asm: "MOVB", typ: "Mem"}, // store low byte of StoreConst(AuxInt).Val() to arg0+StoreConst(AuxInt).Off()+aux. arg1=mem + {name: "MOVWstoreconst", reg: gpstoreconst, asm: "MOVW", typ: "Mem"}, // store low 2 bytes of ... + {name: "MOVLstoreconst", reg: gpstoreconst, asm: "MOVL", typ: "Mem"}, // store low 4 bytes of ... + {name: "MOVQstoreconst", reg: gpstoreconst, asm: "MOVQ", typ: "Mem"}, // store 8 bytes of ... + // arg0 = (duff-adjusted) pointer to start of memory to zero // arg1 = value to store (will always be zero) // arg2 = mem diff --git a/src/cmd/compile/internal/ssa/op.go b/src/cmd/compile/internal/ssa/op.go index 356084fb02..78cca9e0b8 100644 --- a/src/cmd/compile/internal/ssa/op.go +++ b/src/cmd/compile/internal/ssa/op.go @@ -29,3 +29,58 @@ type regInfo struct { clobbers regMask outputs []regMask // NOTE: values can only have 1 output for now. } + +// A StoreConst is used by the MOVXstoreconst opcodes. It holds +// both the value to store and an offset from the store pointer. +// A StoreConst is intended to be encoded into an AuxInt field. +// The zero StoreConst encodes a value of 0 and an offset of 0. +// The high 32 bits hold a value to be stored. +// The low 32 bits hold a pointer offset. +type StoreConst int64 + +func (sc StoreConst) Val() int64 { + return int64(sc) >> 32 +} +func (sc StoreConst) Off() int64 { + return int64(int32(sc)) +} +func (sc StoreConst) Int64() int64 { + return int64(sc) +} + +// validStoreConstOff reports whether the offset can be used +// as an argument to makeStoreConst. +func validStoreConstOff(off int64) bool { + return off == int64(int32(off)) +} + +// validStoreConst reports whether we can fit the value and offset into +// a StoreConst value. +func validStoreConst(val, off int64) bool { + if val != int64(int32(val)) { + return false + } + if !validStoreConstOff(off) { + return false + } + return true +} + +// encode encodes a StoreConst into an int64 suitable for storing in an AuxInt field. +func makeStoreConst(val, off int64) int64 { + if !validStoreConst(val, off) { + panic("invalid makeStoreConst") + } + return StoreConst(val<<32 + int64(uint32(off))).Int64() +} + +func (sc StoreConst) canAdd(off int64) bool { + newoff := sc.Off() + off + return newoff == int64(int32(newoff)) +} +func (sc StoreConst) add(off int64) int64 { + if !sc.canAdd(off) { + panic("invalid StoreConst.add") + } + return makeStoreConst(sc.Val(), sc.Off()+off) +} diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index a1a2ce9e49..6db7a43106 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -264,6 +264,10 @@ const ( OpAMD64MOVQstoreidx8 OpAMD64MOVOload OpAMD64MOVOstore + OpAMD64MOVBstoreconst + OpAMD64MOVWstoreconst + OpAMD64MOVLstoreconst + OpAMD64MOVQstoreconst OpAMD64DUFFZERO OpAMD64MOVOconst OpAMD64REPSTOSQ @@ -3064,6 +3068,42 @@ var opcodeTable = [...]opInfo{ }, }, }, + { + name: "MOVBstoreconst", + 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", + 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", + 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", + 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: "DUFFZERO", reg: regInfo{ diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 1d7695fa4b..7880f7ffbb 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -4181,6 +4181,34 @@ func rewriteValueAMD64(v *Value, config *Config) bool { } goto ende6347ac19d0469ee59d2e7f2e18d1070 ende6347ac19d0469ee59d2e7f2e18d1070: + ; + // match: (MOVBstore [off] {sym} ptr (MOVBconst [c]) mem) + // cond: validStoreConstOff(off) + // result: (MOVBstoreconst [makeStoreConst(int64(int8(c)),off)] {sym} ptr mem) + { + off := v.AuxInt + sym := v.Aux + ptr := v.Args[0] + if v.Args[1].Op != OpAMD64MOVBconst { + goto enda8ebda583a842dae6377b7f562040318 + } + c := v.Args[1].AuxInt + mem := v.Args[2] + if !(validStoreConstOff(off)) { + goto enda8ebda583a842dae6377b7f562040318 + } + v.Op = OpAMD64MOVBstoreconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = makeStoreConst(int64(int8(c)), off) + v.Aux = sym + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto enda8ebda583a842dae6377b7f562040318 + enda8ebda583a842dae6377b7f562040318: ; // match: (MOVBstore [off1] {sym1} (LEAQ [off2] {sym2} base) val mem) // cond: canMergeSym(sym1, sym2) @@ -4213,6 +4241,64 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto enda7086cf7f6b8cf81972e2c3d4b12f3fc enda7086cf7f6b8cf81972e2c3d4b12f3fc: ; + case OpAMD64MOVBstoreconst: + // match: (MOVBstoreconst [sc] {s} (ADDQconst [off] ptr) mem) + // cond: StoreConst(sc).canAdd(off) + // result: (MOVBstoreconst [StoreConst(sc).add(off)] {s} ptr mem) + { + sc := v.AuxInt + s := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto ende1cdf6d463f91ba4dd1956f8ba4cb128 + } + off := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + mem := v.Args[1] + if !(StoreConst(sc).canAdd(off)) { + goto ende1cdf6d463f91ba4dd1956f8ba4cb128 + } + v.Op = OpAMD64MOVBstoreconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = StoreConst(sc).add(off) + v.Aux = s + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto ende1cdf6d463f91ba4dd1956f8ba4cb128 + ende1cdf6d463f91ba4dd1956f8ba4cb128: + ; + // match: (MOVBstoreconst [sc] {sym1} (LEAQ [off] {sym2} ptr) mem) + // cond: canMergeSym(sym1, sym2) && StoreConst(sc).canAdd(off) + // result: (MOVBstoreconst [StoreConst(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem) + { + sc := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ { + goto end5feed29bca3ce7d5fccda89acf71c855 + } + off := v.Args[0].AuxInt + sym2 := v.Args[0].Aux + ptr := v.Args[0].Args[0] + mem := v.Args[1] + if !(canMergeSym(sym1, sym2) && StoreConst(sc).canAdd(off)) { + goto end5feed29bca3ce7d5fccda89acf71c855 + } + v.Op = OpAMD64MOVBstoreconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = StoreConst(sc).add(off) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto end5feed29bca3ce7d5fccda89acf71c855 + end5feed29bca3ce7d5fccda89acf71c855: + ; case OpAMD64MOVLload: // match: (MOVLload [off1] {sym} (ADDQconst [off2] ptr) mem) // cond: @@ -4347,6 +4433,34 @@ func rewriteValueAMD64(v *Value, config *Config) bool { } goto end43bffdb8d9c1fc85a95778d4911955f1 end43bffdb8d9c1fc85a95778d4911955f1: + ; + // match: (MOVLstore [off] {sym} ptr (MOVLconst [c]) mem) + // cond: validStoreConstOff(off) + // result: (MOVLstoreconst [makeStoreConst(int64(int32(c)),off)] {sym} ptr mem) + { + off := v.AuxInt + sym := v.Aux + ptr := v.Args[0] + if v.Args[1].Op != OpAMD64MOVLconst { + goto end14bc0c027d67d279cf3ef2038b759ce2 + } + c := v.Args[1].AuxInt + mem := v.Args[2] + if !(validStoreConstOff(off)) { + goto end14bc0c027d67d279cf3ef2038b759ce2 + } + v.Op = OpAMD64MOVLstoreconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = makeStoreConst(int64(int32(c)), off) + v.Aux = sym + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto end14bc0c027d67d279cf3ef2038b759ce2 + end14bc0c027d67d279cf3ef2038b759ce2: ; // match: (MOVLstore [off1] {sym1} (LEAQ [off2] {sym2} base) val mem) // cond: canMergeSym(sym1, sym2) @@ -4379,6 +4493,64 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto endd57b1e4313fc7a3331340a9af00ba116 endd57b1e4313fc7a3331340a9af00ba116: ; + case OpAMD64MOVLstoreconst: + // match: (MOVLstoreconst [sc] {s} (ADDQconst [off] ptr) mem) + // cond: StoreConst(sc).canAdd(off) + // result: (MOVLstoreconst [StoreConst(sc).add(off)] {s} ptr mem) + { + sc := v.AuxInt + s := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto end7665f96d0aaa57009bf98632f19bf8e7 + } + off := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + mem := v.Args[1] + if !(StoreConst(sc).canAdd(off)) { + goto end7665f96d0aaa57009bf98632f19bf8e7 + } + v.Op = OpAMD64MOVLstoreconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = StoreConst(sc).add(off) + v.Aux = s + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto end7665f96d0aaa57009bf98632f19bf8e7 + end7665f96d0aaa57009bf98632f19bf8e7: + ; + // match: (MOVLstoreconst [sc] {sym1} (LEAQ [off] {sym2} ptr) mem) + // cond: canMergeSym(sym1, sym2) && StoreConst(sc).canAdd(off) + // result: (MOVLstoreconst [StoreConst(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem) + { + sc := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ { + goto end1664c6056a9c65fcbe30eca273e8ee64 + } + off := v.Args[0].AuxInt + sym2 := v.Args[0].Aux + ptr := v.Args[0].Args[0] + mem := v.Args[1] + if !(canMergeSym(sym1, sym2) && StoreConst(sc).canAdd(off)) { + goto end1664c6056a9c65fcbe30eca273e8ee64 + } + v.Op = OpAMD64MOVLstoreconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = StoreConst(sc).add(off) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto end1664c6056a9c65fcbe30eca273e8ee64 + end1664c6056a9c65fcbe30eca273e8ee64: + ; case OpAMD64MOVOload: // match: (MOVOload [off1] {sym} (ADDQconst [off2] ptr) mem) // cond: @@ -4634,6 +4806,34 @@ func rewriteValueAMD64(v *Value, config *Config) bool { } goto end0a110b5e42a4576c32fda50590092848 end0a110b5e42a4576c32fda50590092848: + ; + // match: (MOVQstore [off] {sym} ptr (MOVQconst [c]) mem) + // cond: validStoreConst(c,off) + // result: (MOVQstoreconst [makeStoreConst(c,off)] {sym} ptr mem) + { + off := v.AuxInt + sym := v.Aux + ptr := v.Args[0] + if v.Args[1].Op != OpAMD64MOVQconst { + goto end8368f37d24b6a2f59c3d00966c4d4111 + } + c := v.Args[1].AuxInt + mem := v.Args[2] + if !(validStoreConst(c, off)) { + goto end8368f37d24b6a2f59c3d00966c4d4111 + } + v.Op = OpAMD64MOVQstoreconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = makeStoreConst(c, off) + v.Aux = sym + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto end8368f37d24b6a2f59c3d00966c4d4111 + end8368f37d24b6a2f59c3d00966c4d4111: ; // match: (MOVQstore [off1] {sym1} (LEAQ [off2] {sym2} base) val mem) // cond: canMergeSym(sym1, sym2) @@ -4699,6 +4899,64 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end442c322e6719e280b6be1c12858e49d7 end442c322e6719e280b6be1c12858e49d7: ; + case OpAMD64MOVQstoreconst: + // match: (MOVQstoreconst [sc] {s} (ADDQconst [off] ptr) mem) + // cond: StoreConst(sc).canAdd(off) + // result: (MOVQstoreconst [StoreConst(sc).add(off)] {s} ptr mem) + { + sc := v.AuxInt + s := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto end5826e30265c68ea8c4cd595ceedf9405 + } + off := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + mem := v.Args[1] + if !(StoreConst(sc).canAdd(off)) { + goto end5826e30265c68ea8c4cd595ceedf9405 + } + v.Op = OpAMD64MOVQstoreconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = StoreConst(sc).add(off) + v.Aux = s + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto end5826e30265c68ea8c4cd595ceedf9405 + end5826e30265c68ea8c4cd595ceedf9405: + ; + // match: (MOVQstoreconst [sc] {sym1} (LEAQ [off] {sym2} ptr) mem) + // cond: canMergeSym(sym1, sym2) && StoreConst(sc).canAdd(off) + // result: (MOVQstoreconst [StoreConst(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem) + { + sc := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ { + goto endb9c7f7a9dbc6b885d84f851c74b018e5 + } + off := v.Args[0].AuxInt + sym2 := v.Args[0].Aux + ptr := v.Args[0].Args[0] + mem := v.Args[1] + if !(canMergeSym(sym1, sym2) && StoreConst(sc).canAdd(off)) { + goto endb9c7f7a9dbc6b885d84f851c74b018e5 + } + v.Op = OpAMD64MOVQstoreconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = StoreConst(sc).add(off) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto endb9c7f7a9dbc6b885d84f851c74b018e5 + endb9c7f7a9dbc6b885d84f851c74b018e5: + ; case OpAMD64MOVQstoreidx8: // match: (MOVQstoreidx8 [off1] {sym} (ADDQconst [off2] ptr) idx val mem) // cond: @@ -5347,6 +5605,34 @@ func rewriteValueAMD64(v *Value, config *Config) bool { } goto endda15fdd59aa956ded0440188f38de1aa endda15fdd59aa956ded0440188f38de1aa: + ; + // match: (MOVWstore [off] {sym} ptr (MOVWconst [c]) mem) + // cond: validStoreConstOff(off) + // result: (MOVWstoreconst [makeStoreConst(int64(int16(c)),off)] {sym} ptr mem) + { + off := v.AuxInt + sym := v.Aux + ptr := v.Args[0] + if v.Args[1].Op != OpAMD64MOVWconst { + goto end226f449215b8ea54ac24fb8d52356ffa + } + c := v.Args[1].AuxInt + mem := v.Args[2] + if !(validStoreConstOff(off)) { + goto end226f449215b8ea54ac24fb8d52356ffa + } + v.Op = OpAMD64MOVWstoreconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = makeStoreConst(int64(int16(c)), off) + v.Aux = sym + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto end226f449215b8ea54ac24fb8d52356ffa + end226f449215b8ea54ac24fb8d52356ffa: ; // match: (MOVWstore [off1] {sym1} (LEAQ [off2] {sym2} base) val mem) // cond: canMergeSym(sym1, sym2) @@ -5379,6 +5665,64 @@ func rewriteValueAMD64(v *Value, config *Config) bool { goto end4cc466ede8e64e415c899ccac81c0f27 end4cc466ede8e64e415c899ccac81c0f27: ; + case OpAMD64MOVWstoreconst: + // match: (MOVWstoreconst [sc] {s} (ADDQconst [off] ptr) mem) + // cond: StoreConst(sc).canAdd(off) + // result: (MOVWstoreconst [StoreConst(sc).add(off)] {s} ptr mem) + { + sc := v.AuxInt + s := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto end2b764f9cf1bb32af25ba4e70a6705b91 + } + off := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + mem := v.Args[1] + if !(StoreConst(sc).canAdd(off)) { + goto end2b764f9cf1bb32af25ba4e70a6705b91 + } + v.Op = OpAMD64MOVWstoreconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = StoreConst(sc).add(off) + v.Aux = s + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto end2b764f9cf1bb32af25ba4e70a6705b91 + end2b764f9cf1bb32af25ba4e70a6705b91: + ; + // match: (MOVWstoreconst [sc] {sym1} (LEAQ [off] {sym2} ptr) mem) + // cond: canMergeSym(sym1, sym2) && StoreConst(sc).canAdd(off) + // result: (MOVWstoreconst [StoreConst(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem) + { + sc := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ { + goto enda15bfd8d540015b2245c65be486d2ffd + } + off := v.Args[0].AuxInt + sym2 := v.Args[0].Aux + ptr := v.Args[0].Args[0] + mem := v.Args[1] + if !(canMergeSym(sym1, sym2) && StoreConst(sc).canAdd(off)) { + goto enda15bfd8d540015b2245c65be486d2ffd + } + v.Op = OpAMD64MOVWstoreconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = StoreConst(sc).add(off) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto enda15bfd8d540015b2245c65be486d2ffd + enda15bfd8d540015b2245c65be486d2ffd: + ; case OpAMD64MULB: // match: (MULB x (MOVBconst [c])) // cond: @@ -10796,253 +11140,201 @@ func rewriteValueAMD64(v *Value, config *Config) bool { ; // match: (Zero [1] destptr mem) // cond: - // result: (MOVBstore destptr (MOVBconst [0]) mem) + // result: (MOVBstoreconst [0] destptr mem) { if v.AuxInt != 1 { - goto endf7c8ca6a444f19e1142977e2ac42ab24 + goto ende0161981658beee468c9e2368fe31eb8 } destptr := v.Args[0] mem := v.Args[1] - v.Op = OpAMD64MOVBstore + v.Op = OpAMD64MOVBstoreconst v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.AuxInt = 0 v.AddArg(destptr) - v0 := b.NewValue0(v.Line, OpAMD64MOVBconst, TypeInvalid) - v0.AuxInt = 0 - v0.Type = config.fe.TypeUInt8() - v.AddArg(v0) v.AddArg(mem) return true } - goto endf7c8ca6a444f19e1142977e2ac42ab24 - endf7c8ca6a444f19e1142977e2ac42ab24: + goto ende0161981658beee468c9e2368fe31eb8 + ende0161981658beee468c9e2368fe31eb8: ; // match: (Zero [2] destptr mem) // cond: - // result: (MOVWstore destptr (MOVWconst [0]) mem) + // result: (MOVWstoreconst [0] destptr mem) { if v.AuxInt != 2 { - goto end7609a67450ab21eba86f456886fc8496 + goto end4e4aaf641bf2818bb71f1397e4685bdd } destptr := v.Args[0] mem := v.Args[1] - v.Op = OpAMD64MOVWstore + v.Op = OpAMD64MOVWstoreconst v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.AuxInt = 0 v.AddArg(destptr) - v0 := b.NewValue0(v.Line, OpAMD64MOVWconst, TypeInvalid) - v0.AuxInt = 0 - v0.Type = config.fe.TypeUInt16() - v.AddArg(v0) v.AddArg(mem) return true } - goto end7609a67450ab21eba86f456886fc8496 - end7609a67450ab21eba86f456886fc8496: + goto end4e4aaf641bf2818bb71f1397e4685bdd + end4e4aaf641bf2818bb71f1397e4685bdd: ; // match: (Zero [4] destptr mem) // cond: - // result: (MOVLstore destptr (MOVLconst [0]) mem) + // result: (MOVLstoreconst [0] destptr mem) { if v.AuxInt != 4 { - goto enda8e1cf1298794cc3cb79cab108e33007 + goto end7612f59dd66ebfc632ea5bc85f5437b5 } destptr := v.Args[0] mem := v.Args[1] - v.Op = OpAMD64MOVLstore + v.Op = OpAMD64MOVLstoreconst v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.AuxInt = 0 v.AddArg(destptr) - v0 := b.NewValue0(v.Line, OpAMD64MOVLconst, TypeInvalid) - v0.AuxInt = 0 - v0.Type = config.fe.TypeUInt32() - v.AddArg(v0) v.AddArg(mem) return true } - goto enda8e1cf1298794cc3cb79cab108e33007 - enda8e1cf1298794cc3cb79cab108e33007: + goto end7612f59dd66ebfc632ea5bc85f5437b5 + end7612f59dd66ebfc632ea5bc85f5437b5: ; // match: (Zero [8] destptr mem) // cond: - // result: (MOVQstore destptr (MOVQconst [0]) mem) + // result: (MOVQstoreconst [0] destptr mem) { if v.AuxInt != 8 { - goto end1791556f0b03ea065d38a3267fbe01c6 + goto end07aaaebfa15a48c52cd79b68e28d266f } destptr := v.Args[0] mem := v.Args[1] - v.Op = OpAMD64MOVQstore + v.Op = OpAMD64MOVQstoreconst v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.AuxInt = 0 v.AddArg(destptr) - v0 := b.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) - v0.AuxInt = 0 - v0.Type = config.fe.TypeUInt64() - v.AddArg(v0) v.AddArg(mem) return true } - goto end1791556f0b03ea065d38a3267fbe01c6 - end1791556f0b03ea065d38a3267fbe01c6: + goto end07aaaebfa15a48c52cd79b68e28d266f + end07aaaebfa15a48c52cd79b68e28d266f: ; // match: (Zero [3] destptr mem) // cond: - // result: (MOVBstore (ADDQconst [2] destptr) (MOVBconst [0]) (MOVWstore destptr (MOVWconst [0]) mem)) + // result: (MOVBstoreconst [makeStoreConst(0,2)] destptr (MOVWstoreconst [0] destptr mem)) { if v.AuxInt != 3 { - goto end7f8f5c8214f8b81a73fdde78b03ce53c + goto end03b2ae08f901891919e454f05273fb4e } destptr := v.Args[0] mem := v.Args[1] - v.Op = OpAMD64MOVBstore + v.Op = OpAMD64MOVBstoreconst v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) - v0.AuxInt = 2 + v.AuxInt = makeStoreConst(0, 2) + v.AddArg(destptr) + v0 := b.NewValue0(v.Line, OpAMD64MOVWstoreconst, TypeInvalid) + v0.AuxInt = 0 v0.AddArg(destptr) - v0.Type = config.fe.TypeUInt64() + v0.AddArg(mem) + v0.Type = TypeMem v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64MOVBconst, TypeInvalid) - v1.AuxInt = 0 - v1.Type = config.fe.TypeUInt8() - v.AddArg(v1) - v2 := b.NewValue0(v.Line, OpAMD64MOVWstore, TypeInvalid) - v2.AddArg(destptr) - v3 := b.NewValue0(v.Line, OpAMD64MOVWconst, TypeInvalid) - v3.AuxInt = 0 - v3.Type = config.fe.TypeUInt16() - v2.AddArg(v3) - v2.AddArg(mem) - v2.Type = TypeMem - v.AddArg(v2) return true } - goto end7f8f5c8214f8b81a73fdde78b03ce53c - end7f8f5c8214f8b81a73fdde78b03ce53c: + goto end03b2ae08f901891919e454f05273fb4e + end03b2ae08f901891919e454f05273fb4e: ; // match: (Zero [5] destptr mem) // cond: - // result: (MOVBstore (ADDQconst [4] destptr) (MOVBconst [0]) (MOVLstore destptr (MOVLconst [0]) mem)) + // result: (MOVBstoreconst [makeStoreConst(0,4)] destptr (MOVLstoreconst [0] destptr mem)) { if v.AuxInt != 5 { - goto end54466baa4eac09020bee720efbb82d0f + goto endc473059deb6291d483262b08312eab48 } destptr := v.Args[0] mem := v.Args[1] - v.Op = OpAMD64MOVBstore + v.Op = OpAMD64MOVBstoreconst v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) - v0.AuxInt = 4 + v.AuxInt = makeStoreConst(0, 4) + v.AddArg(destptr) + v0 := b.NewValue0(v.Line, OpAMD64MOVLstoreconst, TypeInvalid) + v0.AuxInt = 0 v0.AddArg(destptr) - v0.Type = config.fe.TypeUInt64() + v0.AddArg(mem) + v0.Type = TypeMem v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64MOVBconst, TypeInvalid) - v1.AuxInt = 0 - v1.Type = config.fe.TypeUInt8() - v.AddArg(v1) - v2 := b.NewValue0(v.Line, OpAMD64MOVLstore, TypeInvalid) - v2.AddArg(destptr) - v3 := b.NewValue0(v.Line, OpAMD64MOVLconst, TypeInvalid) - v3.AuxInt = 0 - v3.Type = config.fe.TypeUInt32() - v2.AddArg(v3) - v2.AddArg(mem) - v2.Type = TypeMem - v.AddArg(v2) return true } - goto end54466baa4eac09020bee720efbb82d0f - end54466baa4eac09020bee720efbb82d0f: + goto endc473059deb6291d483262b08312eab48 + endc473059deb6291d483262b08312eab48: ; // match: (Zero [6] destptr mem) // cond: - // result: (MOVWstore (ADDQconst [4] destptr) (MOVWconst [0]) (MOVLstore destptr (MOVLconst [0]) mem)) + // result: (MOVWstoreconst [makeStoreConst(0,4)] destptr (MOVLstoreconst [0] destptr mem)) { if v.AuxInt != 6 { - goto end3a37ae6095ddc37646d6ad6eeda986e2 + goto end41b38839f25e3749384d53b5945bd56b } destptr := v.Args[0] mem := v.Args[1] - v.Op = OpAMD64MOVWstore + v.Op = OpAMD64MOVWstoreconst v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) - v0.AuxInt = 4 + v.AuxInt = makeStoreConst(0, 4) + v.AddArg(destptr) + v0 := b.NewValue0(v.Line, OpAMD64MOVLstoreconst, TypeInvalid) + v0.AuxInt = 0 v0.AddArg(destptr) - v0.Type = config.fe.TypeUInt64() + v0.AddArg(mem) + v0.Type = TypeMem v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64MOVWconst, TypeInvalid) - v1.AuxInt = 0 - v1.Type = config.fe.TypeUInt16() - v.AddArg(v1) - v2 := b.NewValue0(v.Line, OpAMD64MOVLstore, TypeInvalid) - v2.AddArg(destptr) - v3 := b.NewValue0(v.Line, OpAMD64MOVLconst, TypeInvalid) - v3.AuxInt = 0 - v3.Type = config.fe.TypeUInt32() - v2.AddArg(v3) - v2.AddArg(mem) - v2.Type = TypeMem - v.AddArg(v2) return true } - goto end3a37ae6095ddc37646d6ad6eeda986e2 - end3a37ae6095ddc37646d6ad6eeda986e2: + goto end41b38839f25e3749384d53b5945bd56b + end41b38839f25e3749384d53b5945bd56b: ; // match: (Zero [7] destptr mem) // cond: - // result: (MOVLstore (ADDQconst [3] destptr) (MOVLconst [0]) (MOVLstore destptr (MOVLconst [0]) mem)) + // result: (MOVLstoreconst [makeStoreConst(0,3)] destptr (MOVLstoreconst [0] destptr mem)) { if v.AuxInt != 7 { - goto endd53a750fa01c5a5a238ba8fcabb416b2 + goto end06e677d4c1ac43e08783eb8117a589b6 } destptr := v.Args[0] mem := v.Args[1] - v.Op = OpAMD64MOVLstore + v.Op = OpAMD64MOVLstoreconst v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) - v0.AuxInt = 3 + v.AuxInt = makeStoreConst(0, 3) + v.AddArg(destptr) + v0 := b.NewValue0(v.Line, OpAMD64MOVLstoreconst, TypeInvalid) + v0.AuxInt = 0 v0.AddArg(destptr) - v0.Type = config.fe.TypeUInt64() + v0.AddArg(mem) + v0.Type = TypeMem v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64MOVLconst, TypeInvalid) - v1.AuxInt = 0 - v1.Type = config.fe.TypeUInt32() - v.AddArg(v1) - v2 := b.NewValue0(v.Line, OpAMD64MOVLstore, TypeInvalid) - v2.AddArg(destptr) - v3 := b.NewValue0(v.Line, OpAMD64MOVLconst, TypeInvalid) - v3.AuxInt = 0 - v3.Type = config.fe.TypeUInt32() - v2.AddArg(v3) - v2.AddArg(mem) - v2.Type = TypeMem - v.AddArg(v2) return true } - goto endd53a750fa01c5a5a238ba8fcabb416b2 - endd53a750fa01c5a5a238ba8fcabb416b2: + goto end06e677d4c1ac43e08783eb8117a589b6 + end06e677d4c1ac43e08783eb8117a589b6: ; // match: (Zero [size] destptr mem) // cond: size%8 != 0 && size > 8 - // result: (Zero [size-size%8] (ADDQconst destptr [size%8]) (MOVQstore destptr (MOVQconst [0]) mem)) + // result: (Zero [size-size%8] (ADDQconst destptr [size%8]) (MOVQstoreconst [0] destptr mem)) { size := v.AuxInt destptr := v.Args[0] mem := v.Args[1] if !(size%8 != 0 && size > 8) { - goto end5efefe1d9cca07e7ad6f4832f774b938 + goto endc8760f86b83b1372fce0042ab5200fc1 } v.Op = OpZero v.AuxInt = 0 @@ -11054,163 +11346,109 @@ func rewriteValueAMD64(v *Value, config *Config) bool { v0.AuxInt = size % 8 v0.Type = config.fe.TypeUInt64() v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64MOVQstore, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeInvalid) + v1.AuxInt = 0 v1.AddArg(destptr) - v2 := b.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) - v2.AuxInt = 0 - v2.Type = config.fe.TypeUInt64() - v1.AddArg(v2) v1.AddArg(mem) v1.Type = TypeMem v.AddArg(v1) return true } - goto end5efefe1d9cca07e7ad6f4832f774b938 - end5efefe1d9cca07e7ad6f4832f774b938: + goto endc8760f86b83b1372fce0042ab5200fc1 + endc8760f86b83b1372fce0042ab5200fc1: ; // match: (Zero [16] destptr mem) // cond: - // result: (MOVQstore (ADDQconst [8] destptr) (MOVQconst [0]) (MOVQstore destptr (MOVQconst [0]) mem)) + // result: (MOVQstoreconst [makeStoreConst(0,8)] destptr (MOVQstoreconst [0] destptr mem)) { if v.AuxInt != 16 { - goto endad489c16378959a764292e8b1cb72ba2 + goto endce0bdb028011236be9f04fb53462204d } destptr := v.Args[0] mem := v.Args[1] - v.Op = OpAMD64MOVQstore + v.Op = OpAMD64MOVQstoreconst v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) - v0.AuxInt = 8 + v.AuxInt = makeStoreConst(0, 8) + v.AddArg(destptr) + v0 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeInvalid) + v0.AuxInt = 0 v0.AddArg(destptr) - v0.Type = config.fe.TypeUInt64() + v0.AddArg(mem) + v0.Type = TypeMem v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) - v1.AuxInt = 0 - v1.Type = config.fe.TypeUInt64() - v.AddArg(v1) - v2 := b.NewValue0(v.Line, OpAMD64MOVQstore, TypeInvalid) - v2.AddArg(destptr) - v3 := b.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) - v3.AuxInt = 0 - v3.Type = config.fe.TypeUInt64() - v2.AddArg(v3) - v2.AddArg(mem) - v2.Type = TypeMem - v.AddArg(v2) return true } - goto endad489c16378959a764292e8b1cb72ba2 - endad489c16378959a764292e8b1cb72ba2: + goto endce0bdb028011236be9f04fb53462204d + endce0bdb028011236be9f04fb53462204d: ; // match: (Zero [24] destptr mem) // cond: - // result: (MOVQstore (ADDQconst [16] destptr) (MOVQconst [0]) (MOVQstore (ADDQconst [8] destptr) (MOVQconst [0]) (MOVQstore destptr (MOVQconst [0]) mem))) + // result: (MOVQstoreconst [makeStoreConst(0,16)] destptr (MOVQstoreconst [makeStoreConst(0,8)] destptr (MOVQstoreconst [0] destptr mem))) { if v.AuxInt != 24 { - goto enddc443320a1be0b3c2e213bd6778197dd + goto end859fe3911b36516ea096299b2a85350e } destptr := v.Args[0] mem := v.Args[1] - v.Op = OpAMD64MOVQstore + v.Op = OpAMD64MOVQstoreconst v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) - v0.AuxInt = 16 + v.AuxInt = makeStoreConst(0, 16) + v.AddArg(destptr) + v0 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeInvalid) + v0.AuxInt = makeStoreConst(0, 8) v0.AddArg(destptr) - v0.Type = config.fe.TypeUInt64() - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeInvalid) v1.AuxInt = 0 - v1.Type = config.fe.TypeUInt64() - v.AddArg(v1) - v2 := b.NewValue0(v.Line, OpAMD64MOVQstore, TypeInvalid) - v3 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) - v3.AuxInt = 8 - v3.AddArg(destptr) - v3.Type = config.fe.TypeUInt64() - v2.AddArg(v3) - v4 := b.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) - v4.AuxInt = 0 - v4.Type = config.fe.TypeUInt64() - v2.AddArg(v4) - v5 := b.NewValue0(v.Line, OpAMD64MOVQstore, TypeInvalid) - v5.AddArg(destptr) - v6 := b.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) - v6.AuxInt = 0 - v6.Type = config.fe.TypeUInt64() - v5.AddArg(v6) - v5.AddArg(mem) - v5.Type = TypeMem - v2.AddArg(v5) - v2.Type = TypeMem - v.AddArg(v2) + v1.AddArg(destptr) + v1.AddArg(mem) + v1.Type = TypeMem + v0.AddArg(v1) + v0.Type = TypeMem + v.AddArg(v0) return true } - goto enddc443320a1be0b3c2e213bd6778197dd - enddc443320a1be0b3c2e213bd6778197dd: + goto end859fe3911b36516ea096299b2a85350e + end859fe3911b36516ea096299b2a85350e: ; // match: (Zero [32] destptr mem) // cond: - // result: (MOVQstore (ADDQconst [24] destptr) (MOVQconst [0]) (MOVQstore (ADDQconst [16] destptr) (MOVQconst [0]) (MOVQstore (ADDQconst [8] destptr) (MOVQconst [0]) (MOVQstore destptr (MOVQconst [0]) mem)))) + // result: (MOVQstoreconst [makeStoreConst(0,24)] destptr (MOVQstoreconst [makeStoreConst(0,16)] destptr (MOVQstoreconst [makeStoreConst(0,8)] destptr (MOVQstoreconst [0] destptr mem)))) { if v.AuxInt != 32 { - goto end282b5e36693f06e2cd1ac563e0d419b5 + goto end2c246614f6a9a07f1a683691b3f5780f } destptr := v.Args[0] mem := v.Args[1] - v.Op = OpAMD64MOVQstore + v.Op = OpAMD64MOVQstoreconst v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) - v0.AuxInt = 24 + v.AuxInt = makeStoreConst(0, 24) + v.AddArg(destptr) + v0 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeInvalid) + v0.AuxInt = makeStoreConst(0, 16) v0.AddArg(destptr) - v0.Type = config.fe.TypeUInt64() - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) - v1.AuxInt = 0 - v1.Type = config.fe.TypeUInt64() - v.AddArg(v1) - v2 := b.NewValue0(v.Line, OpAMD64MOVQstore, TypeInvalid) - v3 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) - v3.AuxInt = 16 - v3.AddArg(destptr) - v3.Type = config.fe.TypeUInt64() - v2.AddArg(v3) - v4 := b.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) - v4.AuxInt = 0 - v4.Type = config.fe.TypeUInt64() - v2.AddArg(v4) - v5 := b.NewValue0(v.Line, OpAMD64MOVQstore, TypeInvalid) - v6 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) - v6.AuxInt = 8 - v6.AddArg(destptr) - v6.Type = config.fe.TypeUInt64() - v5.AddArg(v6) - v7 := b.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) - v7.AuxInt = 0 - v7.Type = config.fe.TypeUInt64() - v5.AddArg(v7) - v8 := b.NewValue0(v.Line, OpAMD64MOVQstore, TypeInvalid) - v8.AddArg(destptr) - v9 := b.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) - v9.AuxInt = 0 - v9.Type = config.fe.TypeUInt64() - v8.AddArg(v9) - v8.AddArg(mem) - v8.Type = TypeMem - v5.AddArg(v8) - v5.Type = TypeMem - v2.AddArg(v5) + v1 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeInvalid) + v1.AuxInt = makeStoreConst(0, 8) + v1.AddArg(destptr) + v2 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeInvalid) + v2.AuxInt = 0 + v2.AddArg(destptr) + v2.AddArg(mem) v2.Type = TypeMem - v.AddArg(v2) + v1.AddArg(v2) + v1.Type = TypeMem + v0.AddArg(v1) + v0.Type = TypeMem + v.AddArg(v0) return true } - goto end282b5e36693f06e2cd1ac563e0d419b5 - end282b5e36693f06e2cd1ac563e0d419b5: + goto end2c246614f6a9a07f1a683691b3f5780f + end2c246614f6a9a07f1a683691b3f5780f: ; // match: (Zero [size] destptr mem) // cond: size <= 1024 && size%8 == 0 && size%16 != 0 -- cgit v1.3 From c24681ae2e1c96bd67c149cffa8f5ed394e68453 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Thu, 22 Oct 2015 14:22:38 -0700 Subject: [dev.ssa] cmd/compile: remember names of values For debugging, spill values to named variables instead of autotmp_ variables if possible. We do this by keeping a name -> value map for each function, keep it up-to-date during deadcode elim, and use it to override spill decisions in stackalloc. It might even make stack frames a bit smaller, as it makes it easy to identify a set of spills which are likely not to interfere. This just works for one-word variables for now. Strings/slices will be a separate CL. Change-Id: Ie89eba8cab16bcd41b311c479ec46dd7e64cdb67 Reviewed-on: https://go-review.googlesource.com/16336 Run-TryBot: Keith Randall Reviewed-by: David Chase --- src/cmd/compile/internal/gc/closure.go | 1 + src/cmd/compile/internal/gc/ssa.go | 73 +++++++++++++++++++++-------- src/cmd/compile/internal/ssa/config.go | 16 ++++--- src/cmd/compile/internal/ssa/deadcode.go | 19 ++++++++ src/cmd/compile/internal/ssa/decompose.go | 4 +- src/cmd/compile/internal/ssa/export_test.go | 3 +- src/cmd/compile/internal/ssa/func.go | 7 +++ src/cmd/compile/internal/ssa/location.go | 6 +-- src/cmd/compile/internal/ssa/stackalloc.go | 63 +++++++++++++++++++++++-- src/cmd/compile/internal/ssa/value.go | 8 ++-- 10 files changed, 156 insertions(+), 44 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/closure.go b/src/cmd/compile/internal/gc/closure.go index e7bece8bd9..8ebdd66553 100644 --- a/src/cmd/compile/internal/gc/closure.go +++ b/src/cmd/compile/internal/gc/closure.go @@ -604,6 +604,7 @@ func makepartialcall(fn *Node, t0 *Type, meth *Node) *Node { ptr.Ullman = 1 ptr.Used = true ptr.Name.Curfn = xfunc + ptr.Xoffset = 0 xfunc.Func.Dcl = list(xfunc.Func.Dcl, ptr) var body *NodeList if Isptr[rcvrtype.Etype] || Isinter(rcvrtype) { diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index f7100fefbe..c988465e9f 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -304,14 +304,14 @@ func (s *state) Unimplementedf(msg string, args ...interface{}) { s.config.Unimp var ( // dummy node for the memory variable - memVar = Node{Op: ONAME, Sym: &Sym{Name: "mem"}} + memVar = Node{Op: ONAME, Class: Pxxx, Sym: &Sym{Name: "mem"}} // dummy nodes for temporary variables - ptrVar = Node{Op: ONAME, Sym: &Sym{Name: "ptr"}} - capVar = Node{Op: ONAME, Sym: &Sym{Name: "cap"}} - typVar = Node{Op: ONAME, Sym: &Sym{Name: "typ"}} - idataVar = Node{Op: ONAME, Sym: &Sym{Name: "idata"}} - okVar = Node{Op: ONAME, Sym: &Sym{Name: "ok"}} + 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. @@ -2021,6 +2021,7 @@ func (s *state) assign(left *Node, right *ssa.Value, wb bool) { if left.Op == ONAME && canSSA(left) { // Update variable assignment. s.vars[left] = right + s.addNamedValue(left, right) return } // not ssa-able. Treat as a store. @@ -2245,13 +2246,14 @@ func (s *state) lookupSymbol(n *Node, sym interface{}) interface{} { // 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 := &ssa.ExternSymbol{n.Type, n.Sym} - v := s.entryNewValue1A(ssa.OpAddr, Ptrto(n.Type), aux, s.sb) + 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) @@ -2277,12 +2279,12 @@ func (s *state) addr(n *Node, bounded bool) *ssa.Value { // 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, Ptrto(n.Type), aux, s.sp) + 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, Ptrto(n.Type), aux, s.sp) + return s.newValue1A(ssa.OpAddr, t, aux, s.sp) case PAUTO | PHEAP, PPARAM | PHEAP, PPARAMOUT | PHEAP, PPARAMREF: return s.expr(n.Name.Heapaddr) default: @@ -2296,18 +2298,18 @@ func (s *state) addr(n *Node, bounded bool) *ssa.Value { s.Unimplementedf("OINDREG of non-SP register %s in addr: %v", obj.Rconv(int(n.Reg)), n) return nil } - return s.entryNewValue1I(ssa.OpOffPtr, Ptrto(n.Type), n.Xoffset, s.sp) + 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[TUINTPTR], a) + len := s.newValue1(ssa.OpSliceLen, Types[TINT], a) if !n.Bounded { s.boundsCheck(i, len) } - p := s.newValue1(ssa.OpSlicePtr, Ptrto(n.Left.Type.Type), a) - return s.newValue2(ssa.OpPtrIndex, Ptrto(n.Left.Type.Type), p, i) + 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) @@ -2326,15 +2328,15 @@ func (s *state) addr(n *Node, bounded bool) *ssa.Value { return p case ODOT: p := s.addr(n.Left, bounded) - return s.newValue2(ssa.OpAddPtr, p.Type, p, s.constIntPtr(Types[TUINTPTR], n.Xoffset)) + return s.newValue2(ssa.OpAddPtr, t, p, s.constIntPtr(Types[TUINTPTR], n.Xoffset)) case ODOTPTR: p := s.expr(n.Left) if !bounded { s.nilCheck(p) } - return s.newValue2(ssa.OpAddPtr, p.Type, p, s.constIntPtr(Types[TUINTPTR], n.Xoffset)) + return s.newValue2(ssa.OpAddPtr, t, p, s.constIntPtr(Types[TUINTPTR], n.Xoffset)) case OCLOSUREVAR: - return s.newValue2(ssa.OpAddPtr, Ptrto(n.Type), + return s.newValue2(ssa.OpAddPtr, t, s.entryNewValue0(ssa.OpGetClosurePtr, Ptrto(Types[TUINT8])), s.constIntPtr(Types[TUINTPTR], n.Xoffset)) case OPARAM: @@ -2347,11 +2349,10 @@ func (s *state) addr(n *Node, bounded bool) *ssa.Value { original_p := *p original_p.Xoffset = n.Xoffset aux := &ssa.ArgSymbol{Typ: n.Type, Node: &original_p} - return s.entryNewValue1A(ssa.OpAddr, Ptrto(n.Type), aux, s.sp) + return s.entryNewValue1A(ssa.OpAddr, t, aux, s.sp) case OCONVNOP: addr := s.addr(n.Left, bounded) - to := Ptrto(n.Type) - return s.newValue1(ssa.OpCopy, to, addr) // ensure that addr has the right type + return s.newValue1(ssa.OpCopy, t, addr) // ensure that addr has the right type default: s.Unimplementedf("unhandled addr %v", Oconv(int(n.Op), 0)) @@ -3155,6 +3156,7 @@ func (s *state) lookupVarIncoming(b *ssa.Block, t ssa.Type, name *Node) *ssa.Val // need a phi value v := b.NewValue0(s.peekLine(), ssa.OpPhi, t) v.AddArgs(vals...) + s.addNamedValue(name, v) return v } } @@ -3182,6 +3184,33 @@ func (s *state) lookupVarOutgoing(b *ssa.Block, t ssa.Type, name *Node) *ssa.Val // TODO: the above mutually recursive functions can lead to very deep stacks. Fix that. +func (s *state) addNamedValue(n *Node, v *ssa.Value) { + if n.Class == Pxxx { + // Don't track our dummy nodes (&memVar etc.). + return + } + if n.Sym == nil { + // TODO: What the heck is this? + return + } + if strings.HasPrefix(n.Sym.Name, "autotmp_") { + // Don't track autotmp_ variables. + return + } + if n.Class == PPARAM || n.Class == PPARAMOUT { + // TODO: Remove this + return + } + if n.Class == PAUTO && n.Xoffset != 0 { + s.Fatalf("AUTO var with offset %s %d", n, n.Xoffset) + } + values, ok := s.f.NamedValues[n] + if !ok { + s.f.Names = append(s.f.Names, n) + } + s.f.NamedValues[n] = append(values, v) +} + // an unresolved branch type branch struct { p *obj.Prog // branch instruction @@ -4441,7 +4470,7 @@ func (*ssaExport) StringData(s string) interface{} { return &ssa.ExternSymbol{Typ: idealstring, Sym: data} } -func (e *ssaExport) Auto(t ssa.Type) fmt.Stringer { +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 @@ -4480,3 +4509,7 @@ func (e *ssaExport) Unimplementedf(msg string, args ...interface{}) { } e.unimplemented = true } + +func (n *Node) Typ() ssa.Type { + return n.Type +} diff --git a/src/cmd/compile/internal/ssa/config.go b/src/cmd/compile/internal/ssa/config.go index efb8b146a1..cfba10bc24 100644 --- a/src/cmd/compile/internal/ssa/config.go +++ b/src/cmd/compile/internal/ssa/config.go @@ -4,10 +4,7 @@ package ssa -import ( - "cmd/internal/obj" - "fmt" -) +import "cmd/internal/obj" type Config struct { arch string // "amd64", etc. @@ -63,7 +60,14 @@ type Frontend interface { // 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) fmt.Stringer // returns *gc.Node + Auto(Type) GCNode +} + +// 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. @@ -93,7 +97,7 @@ func (c *Config) Frontend() Frontend { return c.fe } // NewFunc returns a new, empty function object func (c *Config) NewFunc() *Func { // TODO(khr): should this function take name, type, etc. as arguments? - return &Func{Config: c} + return &Func{Config: c, NamedValues: map[GCNode][]*Value{}} } func (c *Config) Logf(msg string, args ...interface{}) { c.fe.Logf(msg, args...) } diff --git a/src/cmd/compile/internal/ssa/deadcode.go b/src/cmd/compile/internal/ssa/deadcode.go index be25eddb47..3351589fda 100644 --- a/src/cmd/compile/internal/ssa/deadcode.go +++ b/src/cmd/compile/internal/ssa/deadcode.go @@ -162,6 +162,25 @@ func deadcode(f *Func) { } f.Blocks = f.Blocks[:i] + // Remove dead entries from namedValues map. + for name, values := range f.NamedValues { + i := 0 + for _, v := range values { + for v.Op == OpCopy { + v = v.Args[0] + } + if live[v.ID] { + values[i] = v + i++ + } + } + f.NamedValues[name] = values[:i] + tail := values[i:] + for j := range tail { + tail[j] = nil + } + } + // TODO: renumber Blocks and Values densely? // TODO: save dead Values and Blocks for reuse? Or should we just let GC handle it? } diff --git a/src/cmd/compile/internal/ssa/decompose.go b/src/cmd/compile/internal/ssa/decompose.go index 3ef20ef34f..2057d8ea5c 100644 --- a/src/cmd/compile/internal/ssa/decompose.go +++ b/src/cmd/compile/internal/ssa/decompose.go @@ -36,7 +36,7 @@ func decompose(f *Func) { func decomposeStringPhi(v *Value) { fe := v.Block.Func.Config.fe ptrType := fe.TypeBytePtr() - lenType := fe.TypeUintptr() + lenType := fe.TypeInt() ptr := v.Block.NewValue0(v.Line, OpPhi, ptrType) len := v.Block.NewValue0(v.Line, OpPhi, lenType) @@ -55,7 +55,7 @@ func decomposeStringPhi(v *Value) { func decomposeSlicePhi(v *Value) { fe := v.Block.Func.Config.fe ptrType := fe.TypeBytePtr() - lenType := fe.TypeUintptr() + lenType := fe.TypeInt() ptr := v.Block.NewValue0(v.Line, OpPhi, ptrType) len := v.Block.NewValue0(v.Line, OpPhi, lenType) diff --git a/src/cmd/compile/internal/ssa/export_test.go b/src/cmd/compile/internal/ssa/export_test.go index 76a05f91d9..d0ba7b1c09 100644 --- a/src/cmd/compile/internal/ssa/export_test.go +++ b/src/cmd/compile/internal/ssa/export_test.go @@ -6,7 +6,6 @@ package ssa import ( "cmd/internal/obj" - "fmt" "testing" ) @@ -29,7 +28,7 @@ type DummyFrontend struct { func (DummyFrontend) StringData(s string) interface{} { return nil } -func (DummyFrontend) Auto(t Type) fmt.Stringer { +func (DummyFrontend) Auto(t Type) GCNode { return nil } diff --git a/src/cmd/compile/internal/ssa/func.go b/src/cmd/compile/internal/ssa/func.go index 1ea7c2e2de..772fffce33 100644 --- a/src/cmd/compile/internal/ssa/func.go +++ b/src/cmd/compile/internal/ssa/func.go @@ -25,6 +25,13 @@ type Func struct { // when register allocation is done, maps value ids to locations RegAlloc []Location + + // map from *gc.Node to set of Values that represent that Node. + // The Node must be an ONAME with PPARAM, PPARAMOUT, or PAUTO class. + NamedValues map[GCNode][]*Value + // Names is a copy of NamedValues.Keys. We keep a separate list + // of keys to make iteration order deterministic. + Names []GCNode } // NumBlocks returns an integer larger than the id of any Block in the Func. diff --git a/src/cmd/compile/internal/ssa/location.go b/src/cmd/compile/internal/ssa/location.go index 9f445e5b5a..0f9fb33eeb 100644 --- a/src/cmd/compile/internal/ssa/location.go +++ b/src/cmd/compile/internal/ssa/location.go @@ -4,10 +4,6 @@ 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), ... @@ -26,7 +22,7 @@ func (r *Register) Name() string { // A LocalSlot is a location in the stack frame. type LocalSlot struct { - N fmt.Stringer // a *gc.Node for an auto variable + N GCNode // a *gc.Node for an auto variable } func (s *LocalSlot) Name() string { diff --git a/src/cmd/compile/internal/ssa/stackalloc.go b/src/cmd/compile/internal/ssa/stackalloc.go index 17d1f66cea..793162a797 100644 --- a/src/cmd/compile/internal/ssa/stackalloc.go +++ b/src/cmd/compile/internal/ssa/stackalloc.go @@ -36,7 +36,8 @@ func stackalloc(f *Func) { case v.Op == OpStoreReg, v.isStackPhi(): s.remove(v.ID) for _, id := range s.contents() { - if v.Type == types[id] { + if v.Type.Equal(types[id]) { + // Only need interferences between equivalent types. interfere[v.ID] = append(interfere[v.ID], id) interfere[id] = append(interfere[id], v.ID) } @@ -47,6 +48,18 @@ func stackalloc(f *Func) { } } + // 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([]GCNode, 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 + } + } + // Figure out which StoreReg ops are phi args. We don't pick slots for // phi args because a stack phi and its args must all use the same stack slot. phiArg := make([]bool, f.NumValues()) @@ -67,6 +80,7 @@ func stackalloc(f *Func) { // Each time we assign a stack slot to a value v, we remember // the slot we used via an index into locations[v.Type]. + // TODO: share slots among equivalent types. slots := make([]int, f.NumValues()) for i := f.NumValues() - 1; i >= 0; i-- { slots[i] = -1 @@ -82,6 +96,45 @@ func stackalloc(f *Func) { if phiArg[v.ID] { continue } + + // If this is a named value, try to use the name as + // the spill location. + var name GCNode + if v.Op == OpStoreReg { + name = names[v.Args[0].ID] + } else { + name = names[v.ID] + } + if name != nil && v.Type.Equal(name.Typ()) { + for _, id := range interfere[v.ID] { + h := f.getHome(id) + if h != nil && h.(*LocalSlot).N == name { + // A variable can interfere with itself. + // It is rare, but but it can happen. + goto noname + } + } + if v.Op == OpPhi { + for _, a := range v.Args { + for _, id := range interfere[a.ID] { + h := f.getHome(id) + if h != nil && h.(*LocalSlot).N == name { + goto noname + } + } + } + } + loc := &LocalSlot{name} + f.setHome(v, loc) + if v.Op == OpPhi { + for _, a := range v.Args { + f.setHome(a, loc) + } + } + continue + } + + noname: // Set of stack slots we could reuse. locs := locations[v.Type] // Mark all positions in locs used by interfering values. @@ -96,7 +149,7 @@ func stackalloc(f *Func) { } if v.Op == OpPhi { // Stack phi and args must get the same stack slot, so - // anything they interfere with is something v the phi + // anything the args interfere with is something the phi // interferes with. for _, a := range v.Args { for _, xid := range interfere[a.ID] { @@ -209,11 +262,11 @@ func (f *Func) liveSpills() [][][]ID { return live } -func (f *Func) getHome(v *Value) Location { - if int(v.ID) >= len(f.RegAlloc) { +func (f *Func) getHome(vid ID) Location { + if int(vid) >= len(f.RegAlloc) { return nil } - return f.RegAlloc[v.ID] + return f.RegAlloc[vid] } func (f *Func) setHome(v *Value, loc Location) { diff --git a/src/cmd/compile/internal/ssa/value.go b/src/cmd/compile/internal/ssa/value.go index a5915da025..661a05989a 100644 --- a/src/cmd/compile/internal/ssa/value.go +++ b/src/cmd/compile/internal/ssa/value.go @@ -142,15 +142,15 @@ type ExternSymbol struct { // 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 fmt.Stringer // A *gc.Node referring to the argument/result variable. + 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 fmt.Stringer // A *gc.Node referring to a local (auto) variable. + Typ Type // Go type + Node GCNode // A *gc.Node referring to a local (auto) variable. } func (s *ExternSymbol) String() string { -- cgit v1.3 From 18559e2da7a2698ad9e35072cbcba1a05ed73836 Mon Sep 17 00:00:00 2001 From: David Chase Date: Wed, 28 Oct 2015 13:55:46 -0400 Subject: [dev.ssa] cmd/compile: make zero-divide panic from div/mod explicit Added an explicit compare-zero and branch-to-panic for integer division and mod so that other optimizations will not be fooled by their implicit panics. Change-Id: Ibf96f636b541c0088861907c537a6beb4b99fa4c Reviewed-on: https://go-review.googlesource.com/16450 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/go.go | 2 ++ src/cmd/compile/internal/gc/pgen.go | 1 + src/cmd/compile/internal/gc/ssa.go | 17 +++++++++++++++-- 3 files changed, 18 insertions(+), 2 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/go.go b/src/cmd/compile/internal/gc/go.go index dcc16d0934..7b73380cd1 100644 --- a/src/cmd/compile/internal/gc/go.go +++ b/src/cmd/compile/internal/gc/go.go @@ -858,6 +858,8 @@ var Panicindex *Node var panicslice *Node +var panicdivide *Node + var throwreturn *Node var growslice *Node diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/pgen.go index b3ba2fbb46..87e99df2e6 100644 --- a/src/cmd/compile/internal/gc/pgen.go +++ b/src/cmd/compile/internal/gc/pgen.go @@ -339,6 +339,7 @@ func compile(fn *Node) { Deferreturn = Sysfunc("deferreturn") Panicindex = Sysfunc("panicindex") panicslice = Sysfunc("panicslice") + panicdivide = Sysfunc("panicdivide") throwreturn = Sysfunc("throwreturn") growslice = Sysfunc("growslice") typedmemmove_nostore = Sysfunc("typedmemmove_nostore") diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index c988465e9f..4b4dc09f11 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1655,9 +1655,22 @@ func (s *state) expr(n *Node) *ssa.Value { 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) @@ -1670,7 +1683,7 @@ func (s *state) expr(n *Node) *ssa.Value { 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, OMOD, OHMUL, OXOR: + 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) -- cgit v1.3 From e514021153f81c30b4a483079379c343916bcb0f Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Wed, 28 Oct 2015 10:40:47 -0700 Subject: [dev.ssa] cmd/compile: fix printing of live information SSA generates ACALL assembly with the target in a *Sym. The old compiler generates both that *Sym and a *Node. Use the *Sym to print the live info so it works with both compilers. Change-Id: I0b12a161f83e76638604358c21b9f5abb31ce950 Reviewed-on: https://go-review.googlesource.com/16432 Run-TryBot: Keith Randall Reviewed-by: David Chase --- src/cmd/compile/internal/gc/plive.go | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/plive.go b/src/cmd/compile/internal/gc/plive.go index 00ae807609..a09247b8a3 100644 --- a/src/cmd/compile/internal/gc/plive.go +++ b/src/cmd/compile/internal/gc/plive.go @@ -19,6 +19,7 @@ import ( "cmd/internal/obj" "fmt" "sort" + "strings" ) const ( @@ -1393,8 +1394,13 @@ func livenessepilogue(lv *Liveness) { 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 { -- cgit v1.3 From a347ab7cd160cfc7a58d7c074d4fdc2806f83e9d Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Mon, 26 Oct 2015 21:49:31 -0700 Subject: [dev.ssa] cmd/compile: split op rewrites into separate functions The single value rewrite function is too big. Some compilers fail on it (out of memory, branch offset too large). Break it up into a rewrite function per op. Change-Id: Iede697c8a1a3a22b485cd0dc85d3e233160c89c2 Reviewed-on: https://go-review.googlesource.com/16347 Run-TryBot: Keith Randall TryBot-Result: Gobot Gobot Reviewed-by: Todd Neal --- src/cmd/compile/internal/ssa/gen/rulegen.go | 36 +- src/cmd/compile/internal/ssa/rewriteAMD64.go | 24642 ++++++++++++----------- src/cmd/compile/internal/ssa/rewritegeneric.go | 3644 ++-- 3 files changed, 15373 insertions(+), 12949 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/gen/rulegen.go b/src/cmd/compile/internal/ssa/gen/rulegen.go index 1aef1dab8f..91fdff0784 100644 --- a/src/cmd/compile/internal/ssa/gen/rulegen.go +++ b/src/cmd/compile/internal/ssa/gen/rulegen.go @@ -134,6 +134,13 @@ func genRules(arch arch) { 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) @@ -145,18 +152,23 @@ func genRules(arch arch) { 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.Fprintln(w, "b := v.Block") - - // generate code for each rule fmt.Fprintf(w, "switch v.Op {\n") - var ops []string - for op := range oprules { - ops = append(ops, op) - } - sort.Strings(ops) 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] { // Note: we use a hash to identify the rule so that its // identity is invariant to adding/removing rules elsewhere @@ -188,12 +200,12 @@ func genRules(arch arch) { fmt.Fprintf(w, "goto end%s\n", rulehash) // use label fmt.Fprintf(w, "end%s:;\n", rulehash) } + fmt.Fprintf(w, "return false\n") + fmt.Fprintf(w, "}\n") } - fmt.Fprintf(w, "}\n") - fmt.Fprintf(w, "return false\n") - fmt.Fprintf(w, "}\n") - // Generate block rewrite function. + // 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 diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 7880f7ffbb..da152b0e12 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -6,11639 +6,13709 @@ import "math" var _ = math.MinInt8 // in case not otherwise used func rewriteValueAMD64(v *Value, config *Config) bool { - b := v.Block switch v.Op { case OpAMD64ADDB: - // match: (ADDB x (MOVBconst [c])) - // cond: - // result: (ADDBconst [c] x) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64MOVBconst { - goto endab690db69bfd8192eea57a2f9f76bf84 - } - c := v.Args[1].AuxInt - v.Op = OpAMD64ADDBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c - v.AddArg(x) - return true - } - goto endab690db69bfd8192eea57a2f9f76bf84 - endab690db69bfd8192eea57a2f9f76bf84: - ; - // match: (ADDB (MOVBconst [c]) x) - // cond: - // result: (ADDBconst [c] x) - { - if v.Args[0].Op != OpAMD64MOVBconst { - goto end28aa1a4abe7e1abcdd64135e9967d39d - } - c := v.Args[0].AuxInt - x := v.Args[1] - v.Op = OpAMD64ADDBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c - v.AddArg(x) - return true - } - goto end28aa1a4abe7e1abcdd64135e9967d39d - end28aa1a4abe7e1abcdd64135e9967d39d: - ; - // match: (ADDB x (NEGB y)) - // cond: - // result: (SUBB x y) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64NEGB { - goto end9464509b8874ffb00b43b843da01f0bc - } - y := v.Args[1].Args[0] - v.Op = OpAMD64SUBB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto end9464509b8874ffb00b43b843da01f0bc - end9464509b8874ffb00b43b843da01f0bc: - ; + return rewriteValueAMD64_OpAMD64ADDB(v, config) case OpAMD64ADDBconst: - // match: (ADDBconst [c] (MOVBconst [d])) - // cond: - // result: (MOVBconst [c+d]) - { - c := v.AuxInt - if v.Args[0].Op != OpAMD64MOVBconst { - goto enda9b1e9e31ccdf0af5f4fe57bf4b1343f - } - d := v.Args[0].AuxInt - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c + d - return true - } - goto enda9b1e9e31ccdf0af5f4fe57bf4b1343f - enda9b1e9e31ccdf0af5f4fe57bf4b1343f: - ; - // match: (ADDBconst [c] (ADDBconst [d] x)) - // cond: - // result: (ADDBconst [c+d] x) - { - c := v.AuxInt - if v.Args[0].Op != OpAMD64ADDBconst { - goto end9b1e6890adbf9d9e447d591b4148cbd0 - } - d := v.Args[0].AuxInt - x := v.Args[0].Args[0] - v.Op = OpAMD64ADDBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c + d - v.AddArg(x) - return true - } - goto end9b1e6890adbf9d9e447d591b4148cbd0 - end9b1e6890adbf9d9e447d591b4148cbd0: - ; + return rewriteValueAMD64_OpAMD64ADDBconst(v, config) case OpAMD64ADDL: - // match: (ADDL x (MOVLconst [c])) - // cond: - // result: (ADDLconst [c] x) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64MOVLconst { - goto end8d6d3b99a7be8da6b7a254b7e709cc95 - } - c := v.Args[1].AuxInt - v.Op = OpAMD64ADDLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c - v.AddArg(x) - return true - } - goto end8d6d3b99a7be8da6b7a254b7e709cc95 - end8d6d3b99a7be8da6b7a254b7e709cc95: - ; - // match: (ADDL (MOVLconst [c]) x) - // cond: - // result: (ADDLconst [c] x) - { - if v.Args[0].Op != OpAMD64MOVLconst { - goto end739561e08a561e26ce3634dc0d5ec733 - } - c := v.Args[0].AuxInt - x := v.Args[1] - v.Op = OpAMD64ADDLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c - v.AddArg(x) - return true - } - goto end739561e08a561e26ce3634dc0d5ec733 - end739561e08a561e26ce3634dc0d5ec733: - ; - // match: (ADDL x (NEGL y)) - // cond: - // result: (SUBL x y) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64NEGL { - goto end9596df31f2685a49df67c6fb912a521d - } - y := v.Args[1].Args[0] - v.Op = OpAMD64SUBL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto end9596df31f2685a49df67c6fb912a521d - end9596df31f2685a49df67c6fb912a521d: - ; + return rewriteValueAMD64_OpAMD64ADDL(v, config) case OpAMD64ADDLconst: - // match: (ADDLconst [c] (MOVLconst [d])) - // cond: - // result: (MOVLconst [c+d]) - { - c := v.AuxInt - if v.Args[0].Op != OpAMD64MOVLconst { - goto ende04850e987890abf1d66199042a19c23 - } - d := v.Args[0].AuxInt - v.Op = OpAMD64MOVLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c + d - return true - } - goto ende04850e987890abf1d66199042a19c23 - ende04850e987890abf1d66199042a19c23: - ; - // match: (ADDLconst [c] (ADDLconst [d] x)) - // cond: - // result: (ADDLconst [c+d] x) - { - c := v.AuxInt - if v.Args[0].Op != OpAMD64ADDLconst { - goto endf1dd8673b2fef4950aec87aa7523a236 - } - d := v.Args[0].AuxInt - x := v.Args[0].Args[0] - v.Op = OpAMD64ADDLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c + d - v.AddArg(x) - return true - } - goto endf1dd8673b2fef4950aec87aa7523a236 - endf1dd8673b2fef4950aec87aa7523a236: - ; + return rewriteValueAMD64_OpAMD64ADDLconst(v, config) case OpAMD64ADDQ: - // match: (ADDQ x (MOVQconst [c])) - // cond: is32Bit(c) - // result: (ADDQconst [c] x) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64MOVQconst { - goto end1de8aeb1d043e0dadcffd169a99ce5c0 - } - c := v.Args[1].AuxInt - if !(is32Bit(c)) { - goto end1de8aeb1d043e0dadcffd169a99ce5c0 - } - v.Op = OpAMD64ADDQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c - v.AddArg(x) - return true - } - goto end1de8aeb1d043e0dadcffd169a99ce5c0 - end1de8aeb1d043e0dadcffd169a99ce5c0: - ; - // match: (ADDQ (MOVQconst [c]) x) - // cond: is32Bit(c) - // result: (ADDQconst [c] x) - { - if v.Args[0].Op != OpAMD64MOVQconst { - goto endca635e3bdecd9e3aeb892f841021dfaa - } - c := v.Args[0].AuxInt - x := v.Args[1] - if !(is32Bit(c)) { - goto endca635e3bdecd9e3aeb892f841021dfaa - } - v.Op = OpAMD64ADDQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c - v.AddArg(x) - return true - } - goto endca635e3bdecd9e3aeb892f841021dfaa - endca635e3bdecd9e3aeb892f841021dfaa: - ; - // match: (ADDQ x (SHLQconst [3] y)) - // cond: - // result: (LEAQ8 x y) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64SHLQconst { - goto endc02313d35a0525d1d680cd58992e820d - } - if v.Args[1].AuxInt != 3 { - goto endc02313d35a0525d1d680cd58992e820d - } - y := v.Args[1].Args[0] - v.Op = OpAMD64LEAQ8 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto endc02313d35a0525d1d680cd58992e820d - endc02313d35a0525d1d680cd58992e820d: - ; - // match: (ADDQ x (NEGQ y)) - // cond: - // result: (SUBQ x y) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64NEGQ { - goto endec8f899c6e175a0147a90750f9bfe0a2 - } - y := v.Args[1].Args[0] - v.Op = OpAMD64SUBQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto endec8f899c6e175a0147a90750f9bfe0a2 - endec8f899c6e175a0147a90750f9bfe0a2: - ; + return rewriteValueAMD64_OpAMD64ADDQ(v, config) case OpAMD64ADDQconst: - // match: (ADDQconst [c] (LEAQ8 [d] x y)) - // cond: - // result: (LEAQ8 [addOff(c, d)] x y) - { - c := v.AuxInt - if v.Args[0].Op != OpAMD64LEAQ8 { - goto ende2cc681c9abf9913288803fb1b39e639 - } - d := v.Args[0].AuxInt - x := v.Args[0].Args[0] - y := v.Args[0].Args[1] - v.Op = OpAMD64LEAQ8 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = addOff(c, d) - v.AddArg(x) - v.AddArg(y) - return true - } - goto ende2cc681c9abf9913288803fb1b39e639 - ende2cc681c9abf9913288803fb1b39e639: - ; - // match: (ADDQconst [0] x) - // cond: - // result: x - { - if v.AuxInt != 0 { - goto end03d9f5a3e153048b0afa781401e2a849 - } - x := v.Args[0] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = x.Type - v.AddArg(x) - return true - } - goto end03d9f5a3e153048b0afa781401e2a849 - end03d9f5a3e153048b0afa781401e2a849: - ; - // match: (ADDQconst [c] (MOVQconst [d])) - // cond: - // result: (MOVQconst [c+d]) - { - c := v.AuxInt - if v.Args[0].Op != OpAMD64MOVQconst { - goto end09dc54395b4e96e8332cf8e4e7481c52 - } - d := v.Args[0].AuxInt - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c + d - return true - } - goto end09dc54395b4e96e8332cf8e4e7481c52 - end09dc54395b4e96e8332cf8e4e7481c52: - ; - // match: (ADDQconst [c] (ADDQconst [d] x)) - // cond: - // result: (ADDQconst [c+d] x) - { - c := v.AuxInt - if v.Args[0].Op != OpAMD64ADDQconst { - goto endd4cb539641f0dc40bfd0cb7fbb9b0405 - } - d := v.Args[0].AuxInt - x := v.Args[0].Args[0] - v.Op = OpAMD64ADDQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c + d - v.AddArg(x) - return true - } - goto endd4cb539641f0dc40bfd0cb7fbb9b0405 - endd4cb539641f0dc40bfd0cb7fbb9b0405: - ; + return rewriteValueAMD64_OpAMD64ADDQconst(v, config) case OpAMD64ADDW: - // match: (ADDW x (MOVWconst [c])) - // cond: - // result: (ADDWconst [c] x) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64MOVWconst { - goto end1aabd2317de77c7dfc4876fd7e4c5011 - } - c := v.Args[1].AuxInt - v.Op = OpAMD64ADDWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c - v.AddArg(x) - return true - } - goto end1aabd2317de77c7dfc4876fd7e4c5011 - end1aabd2317de77c7dfc4876fd7e4c5011: - ; - // match: (ADDW (MOVWconst [c]) x) - // cond: - // result: (ADDWconst [c] x) - { - if v.Args[0].Op != OpAMD64MOVWconst { - goto ende3aede99966f388afc624f9e86676fd2 - } - c := v.Args[0].AuxInt - x := v.Args[1] - v.Op = OpAMD64ADDWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c - v.AddArg(x) - return true - } - goto ende3aede99966f388afc624f9e86676fd2 - ende3aede99966f388afc624f9e86676fd2: - ; - // match: (ADDW x (NEGW y)) - // cond: - // result: (SUBW x y) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64NEGW { - goto end55cf2af0d75f3ec413528eeb799e94d5 - } - y := v.Args[1].Args[0] - v.Op = OpAMD64SUBW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto end55cf2af0d75f3ec413528eeb799e94d5 - end55cf2af0d75f3ec413528eeb799e94d5: - ; + return rewriteValueAMD64_OpAMD64ADDW(v, config) case OpAMD64ADDWconst: - // match: (ADDWconst [c] (MOVWconst [d])) - // cond: - // result: (MOVWconst [c+d]) - { - c := v.AuxInt - if v.Args[0].Op != OpAMD64MOVWconst { - goto end32541920f2f5a920dfae41d8ebbef00f - } - d := v.Args[0].AuxInt - v.Op = OpAMD64MOVWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c + d - return true - } - goto end32541920f2f5a920dfae41d8ebbef00f - end32541920f2f5a920dfae41d8ebbef00f: - ; - // match: (ADDWconst [c] (ADDWconst [d] x)) - // cond: - // result: (ADDWconst [c+d] x) - { - c := v.AuxInt - if v.Args[0].Op != OpAMD64ADDWconst { - goto end73944f6ddda7e4c050f11d17484ff9a5 - } - d := v.Args[0].AuxInt - x := v.Args[0].Args[0] - v.Op = OpAMD64ADDWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c + d - v.AddArg(x) - return true - } - goto end73944f6ddda7e4c050f11d17484ff9a5 - end73944f6ddda7e4c050f11d17484ff9a5: - ; + return rewriteValueAMD64_OpAMD64ADDWconst(v, config) case OpAMD64ANDB: - // match: (ANDB x (MOVLconst [c])) - // cond: - // result: (ANDBconst [c] x) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64MOVLconst { - goto end01100cd255396e29bfdb130f4fbc9bbc - } - c := v.Args[1].AuxInt - v.Op = OpAMD64ANDBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c - v.AddArg(x) - return true - } - goto end01100cd255396e29bfdb130f4fbc9bbc - end01100cd255396e29bfdb130f4fbc9bbc: - ; - // match: (ANDB (MOVLconst [c]) x) - // cond: - // result: (ANDBconst [c] x) - { - if v.Args[0].Op != OpAMD64MOVLconst { - goto end70830ce2834dc5f8d786fa6789460926 - } - c := v.Args[0].AuxInt - x := v.Args[1] - v.Op = OpAMD64ANDBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c - v.AddArg(x) - return true - } - goto end70830ce2834dc5f8d786fa6789460926 - end70830ce2834dc5f8d786fa6789460926: - ; - // match: (ANDB x (MOVBconst [c])) - // cond: - // result: (ANDBconst [c] x) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64MOVBconst { - goto endd275ec2e73768cb3d201478fc934e06c - } - c := v.Args[1].AuxInt - v.Op = OpAMD64ANDBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c - v.AddArg(x) - return true - } - goto endd275ec2e73768cb3d201478fc934e06c - endd275ec2e73768cb3d201478fc934e06c: - ; - // match: (ANDB (MOVBconst [c]) x) - // cond: - // result: (ANDBconst [c] x) - { - if v.Args[0].Op != OpAMD64MOVBconst { - goto end4068edac2ae0f354cf581db210288b98 - } - c := v.Args[0].AuxInt - x := v.Args[1] - v.Op = OpAMD64ANDBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c - v.AddArg(x) - return true - } - goto end4068edac2ae0f354cf581db210288b98 - end4068edac2ae0f354cf581db210288b98: - ; - // match: (ANDB x x) - // cond: - // result: x - { - x := v.Args[0] - if v.Args[1] != x { - goto endb8ff272a1456513da708603abe37541c - } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = x.Type - v.AddArg(x) - return true - } - goto endb8ff272a1456513da708603abe37541c - endb8ff272a1456513da708603abe37541c: - ; + return rewriteValueAMD64_OpAMD64ANDB(v, config) case OpAMD64ANDBconst: - // match: (ANDBconst [c] _) - // cond: int8(c)==0 - // result: (MOVBconst [0]) - { - c := v.AuxInt - if !(int8(c) == 0) { - goto end2106d410c949da14d7c00041f40eca76 - } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 0 - return true - } - goto end2106d410c949da14d7c00041f40eca76 - end2106d410c949da14d7c00041f40eca76: - ; - // match: (ANDBconst [c] x) - // cond: int8(c)==-1 - // result: x - { - c := v.AuxInt - x := v.Args[0] - if !(int8(c) == -1) { - goto enda0b78503c204c8225de1433949a71fe4 - } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = x.Type - v.AddArg(x) - return true - } - goto enda0b78503c204c8225de1433949a71fe4 - enda0b78503c204c8225de1433949a71fe4: - ; - // match: (ANDBconst [c] (MOVBconst [d])) - // cond: - // result: (MOVBconst [c&d]) - { - c := v.AuxInt - if v.Args[0].Op != OpAMD64MOVBconst { - goto end946312b1f216933da86febe293eb956f - } - d := v.Args[0].AuxInt - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c & d - return true - } - goto end946312b1f216933da86febe293eb956f - end946312b1f216933da86febe293eb956f: - ; + return rewriteValueAMD64_OpAMD64ANDBconst(v, config) case OpAMD64ANDL: - // match: (ANDL x (MOVLconst [c])) - // cond: - // result: (ANDLconst [c] x) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64MOVLconst { - goto end0a4c49d9a26759c0fd21369dafcd7abb - } - c := v.Args[1].AuxInt - v.Op = OpAMD64ANDLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c - v.AddArg(x) - return true - } - goto end0a4c49d9a26759c0fd21369dafcd7abb - end0a4c49d9a26759c0fd21369dafcd7abb: - ; - // match: (ANDL (MOVLconst [c]) x) - // cond: - // result: (ANDLconst [c] x) - { - if v.Args[0].Op != OpAMD64MOVLconst { - goto end0529ba323d9b6f15c41add401ef67959 - } - c := v.Args[0].AuxInt - x := v.Args[1] - v.Op = OpAMD64ANDLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c - v.AddArg(x) - return true - } - goto end0529ba323d9b6f15c41add401ef67959 - end0529ba323d9b6f15c41add401ef67959: - ; - // match: (ANDL x x) - // cond: - // result: x - { - x := v.Args[0] - if v.Args[1] != x { - goto enddfb08a0d0c262854db3905cb323388c7 - } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = x.Type - v.AddArg(x) - return true - } - goto enddfb08a0d0c262854db3905cb323388c7 - enddfb08a0d0c262854db3905cb323388c7: - ; + return rewriteValueAMD64_OpAMD64ANDL(v, config) case OpAMD64ANDLconst: - // match: (ANDLconst [c] _) - // cond: int32(c)==0 - // result: (MOVLconst [0]) - { - c := v.AuxInt - if !(int32(c) == 0) { - goto end5efb241208aef28c950b7bcf8d85d5de - } - v.Op = OpAMD64MOVLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 0 - return true - } - goto end5efb241208aef28c950b7bcf8d85d5de - end5efb241208aef28c950b7bcf8d85d5de: - ; - // match: (ANDLconst [c] x) - // cond: int32(c)==-1 - // result: x - { - c := v.AuxInt - x := v.Args[0] - if !(int32(c) == -1) { - goto end0e852ae30bb8289d6ffee0c9267e3e0c - } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = x.Type - v.AddArg(x) - return true - } - goto end0e852ae30bb8289d6ffee0c9267e3e0c - end0e852ae30bb8289d6ffee0c9267e3e0c: - ; - // match: (ANDLconst [c] (MOVLconst [d])) - // cond: - // result: (MOVLconst [c&d]) - { - c := v.AuxInt - if v.Args[0].Op != OpAMD64MOVLconst { - goto end7bfd24059369753eadd235f07e2dd7b8 - } - d := v.Args[0].AuxInt - v.Op = OpAMD64MOVLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c & d - return true - } - goto end7bfd24059369753eadd235f07e2dd7b8 - end7bfd24059369753eadd235f07e2dd7b8: - ; + return rewriteValueAMD64_OpAMD64ANDLconst(v, config) case OpAMD64ANDQ: - // match: (ANDQ x (MOVQconst [c])) - // cond: is32Bit(c) - // result: (ANDQconst [c] x) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64MOVQconst { - goto end048fadc69e81103480015b84b9cafff7 - } - c := v.Args[1].AuxInt - if !(is32Bit(c)) { - goto end048fadc69e81103480015b84b9cafff7 - } - v.Op = OpAMD64ANDQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c - v.AddArg(x) - return true - } - goto end048fadc69e81103480015b84b9cafff7 - end048fadc69e81103480015b84b9cafff7: - ; - // match: (ANDQ (MOVQconst [c]) x) - // cond: is32Bit(c) - // result: (ANDQconst [c] x) - { - if v.Args[0].Op != OpAMD64MOVQconst { - goto end3035a3bf650b708705fd27dd857ab0a4 - } - c := v.Args[0].AuxInt - x := v.Args[1] - if !(is32Bit(c)) { - goto end3035a3bf650b708705fd27dd857ab0a4 - } - v.Op = OpAMD64ANDQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c - v.AddArg(x) - return true - } - goto end3035a3bf650b708705fd27dd857ab0a4 - end3035a3bf650b708705fd27dd857ab0a4: - ; - // match: (ANDQ x x) - // cond: - // result: x - { - x := v.Args[0] - if v.Args[1] != x { - goto end06b5ec19efdd4e79f03a5e4a2c3c3427 - } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = x.Type - v.AddArg(x) - return true - } - goto end06b5ec19efdd4e79f03a5e4a2c3c3427 - end06b5ec19efdd4e79f03a5e4a2c3c3427: - ; + return rewriteValueAMD64_OpAMD64ANDQ(v, config) case OpAMD64ANDQconst: - // match: (ANDQconst [0] _) - // cond: - // result: (MOVQconst [0]) - { - if v.AuxInt != 0 { - goto end57018c1d0f54fd721521095b4832bab2 - } - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 0 - return true - } - goto end57018c1d0f54fd721521095b4832bab2 - end57018c1d0f54fd721521095b4832bab2: - ; - // match: (ANDQconst [-1] x) - // cond: - // result: x - { - if v.AuxInt != -1 { - goto endb542c4b42ab94a7bedb32dec8f610d67 - } - x := v.Args[0] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = x.Type - v.AddArg(x) - return true - } - goto endb542c4b42ab94a7bedb32dec8f610d67 - endb542c4b42ab94a7bedb32dec8f610d67: - ; - // match: (ANDQconst [c] (MOVQconst [d])) - // cond: - // result: (MOVQconst [c&d]) - { - c := v.AuxInt - if v.Args[0].Op != OpAMD64MOVQconst { - goto end67ca66494705b0345a5f22c710225292 - } - d := v.Args[0].AuxInt - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c & d - return true - } - goto end67ca66494705b0345a5f22c710225292 - end67ca66494705b0345a5f22c710225292: - ; + return rewriteValueAMD64_OpAMD64ANDQconst(v, config) case OpAMD64ANDW: - // match: (ANDW x (MOVLconst [c])) - // cond: - // result: (ANDWconst [c] x) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64MOVLconst { - goto endce6f557823ee2fdd7a8f47b6f925fc7c - } - c := v.Args[1].AuxInt - v.Op = OpAMD64ANDWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c - v.AddArg(x) - return true - } - goto endce6f557823ee2fdd7a8f47b6f925fc7c - endce6f557823ee2fdd7a8f47b6f925fc7c: - ; - // match: (ANDW (MOVLconst [c]) x) - // cond: - // result: (ANDWconst [c] x) - { - if v.Args[0].Op != OpAMD64MOVLconst { - goto endc46af0d9265c08b09f1f1fba24feda80 - } - c := v.Args[0].AuxInt - x := v.Args[1] - v.Op = OpAMD64ANDWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c - v.AddArg(x) - return true - } - goto endc46af0d9265c08b09f1f1fba24feda80 - endc46af0d9265c08b09f1f1fba24feda80: - ; - // match: (ANDW x (MOVWconst [c])) - // cond: - // result: (ANDWconst [c] x) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64MOVWconst { - goto enda77a39f65a5eb3436a5842eab69a3103 - } - c := v.Args[1].AuxInt - v.Op = OpAMD64ANDWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c - v.AddArg(x) - return true - } - goto enda77a39f65a5eb3436a5842eab69a3103 - enda77a39f65a5eb3436a5842eab69a3103: - ; - // match: (ANDW (MOVWconst [c]) x) - // cond: - // result: (ANDWconst [c] x) - { - if v.Args[0].Op != OpAMD64MOVWconst { - goto endea2a25eb525a5dbf6d5132d84ea4e7a5 - } - c := v.Args[0].AuxInt - x := v.Args[1] - v.Op = OpAMD64ANDWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c - v.AddArg(x) - return true - } - goto endea2a25eb525a5dbf6d5132d84ea4e7a5 - endea2a25eb525a5dbf6d5132d84ea4e7a5: - ; - // match: (ANDW x x) - // cond: - // result: x - { - x := v.Args[0] - if v.Args[1] != x { - goto end3a26cf52dd1b77f07cc9e005760dbb11 - } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = x.Type - v.AddArg(x) - return true - } - goto end3a26cf52dd1b77f07cc9e005760dbb11 - end3a26cf52dd1b77f07cc9e005760dbb11: - ; + return rewriteValueAMD64_OpAMD64ANDW(v, config) case OpAMD64ANDWconst: - // match: (ANDWconst [c] _) - // cond: int16(c)==0 - // result: (MOVWconst [0]) - { - c := v.AuxInt - if !(int16(c) == 0) { - goto end336ece33b4f0fb44dfe1f24981df7b74 - } - v.Op = OpAMD64MOVWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 0 - return true - } - goto end336ece33b4f0fb44dfe1f24981df7b74 - end336ece33b4f0fb44dfe1f24981df7b74: - ; - // match: (ANDWconst [c] x) - // cond: int16(c)==-1 - // result: x - { - c := v.AuxInt - x := v.Args[0] - if !(int16(c) == -1) { - goto endfb111c3afa8c5c4040fa6000fadee810 - } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = x.Type - v.AddArg(x) - return true - } - goto endfb111c3afa8c5c4040fa6000fadee810 - endfb111c3afa8c5c4040fa6000fadee810: - ; - // match: (ANDWconst [c] (MOVWconst [d])) - // cond: - // result: (MOVWconst [c&d]) - { - c := v.AuxInt - if v.Args[0].Op != OpAMD64MOVWconst { - goto end250eb27fcac10bf6c0d96ce66a21726e - } - d := v.Args[0].AuxInt - v.Op = OpAMD64MOVWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c & d - return true - } - goto end250eb27fcac10bf6c0d96ce66a21726e - end250eb27fcac10bf6c0d96ce66a21726e: - ; + return rewriteValueAMD64_OpAMD64ANDWconst(v, config) case OpAdd16: - // match: (Add16 x y) - // cond: - // result: (ADDW x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ADDW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto ende604481c6de9fe4574cb2954ba2ddc67 - ende604481c6de9fe4574cb2954ba2ddc67: - ; + return rewriteValueAMD64_OpAdd16(v, config) case OpAdd32: - // match: (Add32 x y) - // cond: - // result: (ADDL x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ADDL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto endc445ea2a65385445676cd684ae9a42b5 - endc445ea2a65385445676cd684ae9a42b5: - ; + return rewriteValueAMD64_OpAdd32(v, config) case OpAdd32F: - // match: (Add32F x y) - // cond: - // result: (ADDSS x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ADDSS - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto end5d82e1c10823774894c036b7c5b8fed4 - end5d82e1c10823774894c036b7c5b8fed4: - ; + return rewriteValueAMD64_OpAdd32F(v, config) case OpAdd64: - // match: (Add64 x y) - // cond: - // result: (ADDQ x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ADDQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto endd88f18b3f39e3ccc201477a616f0abc0 - endd88f18b3f39e3ccc201477a616f0abc0: - ; + return rewriteValueAMD64_OpAdd64(v, config) case OpAdd64F: - // match: (Add64F x y) - // cond: - // result: (ADDSD x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ADDSD - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto end62f2de6c70abd214e6987ee37976653a - end62f2de6c70abd214e6987ee37976653a: - ; + return rewriteValueAMD64_OpAdd64F(v, config) case OpAdd8: - // match: (Add8 x y) - // cond: - // result: (ADDB x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ADDB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto end6117c84a6b75c1b816b3fb095bc5f656 - end6117c84a6b75c1b816b3fb095bc5f656: - ; + return rewriteValueAMD64_OpAdd8(v, config) case OpAddPtr: - // match: (AddPtr x y) - // cond: - // result: (ADDQ x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ADDQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto enda1d5640788c7157996f9d4af602dec1c - enda1d5640788c7157996f9d4af602dec1c: - ; + return rewriteValueAMD64_OpAddPtr(v, config) case OpAddr: - // match: (Addr {sym} base) - // cond: - // result: (LEAQ {sym} base) - { - sym := v.Aux - base := v.Args[0] - v.Op = OpAMD64LEAQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Aux = sym - v.AddArg(base) - return true - } - goto end53cad0c3c9daa5575680e77c14e05e72 - end53cad0c3c9daa5575680e77c14e05e72: - ; + return rewriteValueAMD64_OpAddr(v, config) case OpAnd16: - // match: (And16 x y) - // cond: - // result: (ANDW x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ANDW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto end1c01f04a173d86ce1a6d1ef59e753014 - end1c01f04a173d86ce1a6d1ef59e753014: - ; + return rewriteValueAMD64_OpAnd16(v, config) case OpAnd32: - // match: (And32 x y) - // cond: - // result: (ANDL x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ANDL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto end6b9eb9375b3a859028a6ba6bf6b8ec88 - end6b9eb9375b3a859028a6ba6bf6b8ec88: - ; + return rewriteValueAMD64_OpAnd32(v, config) case OpAnd64: - // match: (And64 x y) - // cond: - // result: (ANDQ x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ANDQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto enda0bde5853819d05fa2b7d3b723629552 - enda0bde5853819d05fa2b7d3b723629552: - ; + return rewriteValueAMD64_OpAnd64(v, config) case OpAnd8: - // match: (And8 x y) - // cond: - // result: (ANDB x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ANDB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto end0f53bee6291f1229b43aa1b5f977b4f2 - end0f53bee6291f1229b43aa1b5f977b4f2: - ; + return rewriteValueAMD64_OpAnd8(v, config) case OpAMD64CMPB: - // match: (CMPB x (MOVBconst [c])) - // cond: - // result: (CMPBconst x [c]) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64MOVBconst { - goto end52190c0b8759133aa6c540944965c4c0 - } - c := v.Args[1].AuxInt - v.Op = OpAMD64CMPBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AuxInt = c - return true - } - goto end52190c0b8759133aa6c540944965c4c0 - end52190c0b8759133aa6c540944965c4c0: - ; - // match: (CMPB (MOVBconst [c]) x) - // cond: - // result: (InvertFlags (CMPBconst x [c])) - { - if v.Args[0].Op != OpAMD64MOVBconst { - goto end25ab646f9eb8749ea58c8fbbb4bf6bcd - } - c := v.Args[0].AuxInt - x := v.Args[1] - v.Op = OpAMD64InvertFlags - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) - v0.AddArg(x) - v0.AuxInt = c - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto end25ab646f9eb8749ea58c8fbbb4bf6bcd - end25ab646f9eb8749ea58c8fbbb4bf6bcd: - ; + return rewriteValueAMD64_OpAMD64CMPB(v, config) case OpAMD64CMPL: - // match: (CMPL x (MOVLconst [c])) - // cond: - // result: (CMPLconst x [c]) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64MOVLconst { - goto end49ff4559c4bdecb2aef0c905e2d9a6cf - } - c := v.Args[1].AuxInt - v.Op = OpAMD64CMPLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AuxInt = c - return true - } - goto end49ff4559c4bdecb2aef0c905e2d9a6cf - end49ff4559c4bdecb2aef0c905e2d9a6cf: - ; - // match: (CMPL (MOVLconst [c]) x) - // cond: - // result: (InvertFlags (CMPLconst x [c])) - { - if v.Args[0].Op != OpAMD64MOVLconst { - goto end7d89230086678ab4ed5cc96a3ae358d6 - } - c := v.Args[0].AuxInt - x := v.Args[1] - v.Op = OpAMD64InvertFlags - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) - v0.AddArg(x) - v0.AuxInt = c - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto end7d89230086678ab4ed5cc96a3ae358d6 - end7d89230086678ab4ed5cc96a3ae358d6: - ; + return rewriteValueAMD64_OpAMD64CMPL(v, config) case OpAMD64CMPQ: - // match: (CMPQ x (MOVQconst [c])) - // cond: is32Bit(c) - // result: (CMPQconst x [c]) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64MOVQconst { - goto end3bbb2c6caa57853a7561738ce3c0c630 - } - c := v.Args[1].AuxInt - if !(is32Bit(c)) { - goto end3bbb2c6caa57853a7561738ce3c0c630 - } - v.Op = OpAMD64CMPQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AuxInt = c - return true - } - goto end3bbb2c6caa57853a7561738ce3c0c630 - end3bbb2c6caa57853a7561738ce3c0c630: - ; - // match: (CMPQ (MOVQconst [c]) x) - // cond: is32Bit(c) - // result: (InvertFlags (CMPQconst x [c])) - { - if v.Args[0].Op != OpAMD64MOVQconst { - goto end153e951c4d9890ee40bf6f189ff6280e - } - c := v.Args[0].AuxInt - x := v.Args[1] - if !(is32Bit(c)) { - goto end153e951c4d9890ee40bf6f189ff6280e - } - v.Op = OpAMD64InvertFlags - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) - v0.AddArg(x) - v0.AuxInt = c - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto end153e951c4d9890ee40bf6f189ff6280e - end153e951c4d9890ee40bf6f189ff6280e: - ; + return rewriteValueAMD64_OpAMD64CMPQ(v, config) case OpAMD64CMPW: - // match: (CMPW x (MOVWconst [c])) - // cond: - // result: (CMPWconst x [c]) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64MOVWconst { - goto end310a9ba58ac35c97587e08c63fe8a46c - } - c := v.Args[1].AuxInt - v.Op = OpAMD64CMPWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AuxInt = c - return true - } - goto end310a9ba58ac35c97587e08c63fe8a46c - end310a9ba58ac35c97587e08c63fe8a46c: - ; - // match: (CMPW (MOVWconst [c]) x) - // cond: - // result: (InvertFlags (CMPWconst x [c])) - { - if v.Args[0].Op != OpAMD64MOVWconst { - goto end3c52d0ae6e3d186bf131b41276c21889 - } - c := v.Args[0].AuxInt - x := v.Args[1] - v.Op = OpAMD64InvertFlags - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) - v0.AddArg(x) - v0.AuxInt = c - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto end3c52d0ae6e3d186bf131b41276c21889 - end3c52d0ae6e3d186bf131b41276c21889: - ; + return rewriteValueAMD64_OpAMD64CMPW(v, config) case OpClosureCall: - // match: (ClosureCall [argwid] entry closure mem) - // cond: - // result: (CALLclosure [argwid] entry closure mem) - { - argwid := v.AuxInt - entry := v.Args[0] - closure := v.Args[1] - mem := v.Args[2] - v.Op = OpAMD64CALLclosure - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = argwid - v.AddArg(entry) - v.AddArg(closure) - v.AddArg(mem) - return true - } - goto endfd75d26316012d86cb71d0dd1214259b - endfd75d26316012d86cb71d0dd1214259b: - ; + return rewriteValueAMD64_OpClosureCall(v, config) case OpCom16: - // match: (Com16 x) - // cond: - // result: (NOTW x) - { - x := v.Args[0] - v.Op = OpAMD64NOTW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto end1b14ba8d7d7aa585ec0a211827f280ae - end1b14ba8d7d7aa585ec0a211827f280ae: - ; + return rewriteValueAMD64_OpCom16(v, config) case OpCom32: - // match: (Com32 x) - // cond: - // result: (NOTL x) - { - x := v.Args[0] - v.Op = OpAMD64NOTL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto end6eb124ba3bdb3fd6031414370852feb6 - end6eb124ba3bdb3fd6031414370852feb6: - ; + return rewriteValueAMD64_OpCom32(v, config) case OpCom64: - // match: (Com64 x) - // cond: - // result: (NOTQ x) - { - x := v.Args[0] - v.Op = OpAMD64NOTQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto endf5f3b355a87779c347e305719dddda05 - endf5f3b355a87779c347e305719dddda05: - ; + return rewriteValueAMD64_OpCom64(v, config) case OpCom8: - // match: (Com8 x) - // cond: - // result: (NOTB x) - { - x := v.Args[0] - v.Op = OpAMD64NOTB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto end1c7c5c055d663ccf1f05fbc4883030c6 - end1c7c5c055d663ccf1f05fbc4883030c6: - ; + return rewriteValueAMD64_OpCom8(v, config) case OpConst16: - // match: (Const16 [val]) - // cond: - // result: (MOVWconst [val]) - { - val := v.AuxInt - v.Op = OpAMD64MOVWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = val - return true - } - goto end2c6c92f297873b8ac12bd035d56d001e - end2c6c92f297873b8ac12bd035d56d001e: - ; + return rewriteValueAMD64_OpConst16(v, config) case OpConst32: - // match: (Const32 [val]) - // cond: - // result: (MOVLconst [val]) - { - val := v.AuxInt - v.Op = OpAMD64MOVLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = val - return true - } - goto enddae5807662af67143a3ac3ad9c63bae5 - enddae5807662af67143a3ac3ad9c63bae5: - ; + return rewriteValueAMD64_OpConst32(v, config) case OpConst32F: - // match: (Const32F [val]) - // cond: - // result: (MOVSSconst [val]) - { - val := v.AuxInt - v.Op = OpAMD64MOVSSconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = val - return true - } - goto endfabcef2d57a8f36eaa6041de6f112b89 - endfabcef2d57a8f36eaa6041de6f112b89: - ; + return rewriteValueAMD64_OpConst32F(v, config) case OpConst64: - // match: (Const64 [val]) - // cond: - // result: (MOVQconst [val]) - { - val := v.AuxInt - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = val - return true - } - goto endc630434ae7f143ab69d5f482a9b52b5f - endc630434ae7f143ab69d5f482a9b52b5f: - ; + return rewriteValueAMD64_OpConst64(v, config) case OpConst64F: - // match: (Const64F [val]) - // cond: - // result: (MOVSDconst [val]) - { - val := v.AuxInt - v.Op = OpAMD64MOVSDconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = val - return true - } - goto endae6cf7189e464bbde17b98635a20f0ff - endae6cf7189e464bbde17b98635a20f0ff: - ; + return rewriteValueAMD64_OpConst64F(v, config) case OpConst8: - // match: (Const8 [val]) - // cond: - // result: (MOVBconst [val]) - { - val := v.AuxInt - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = val - return true - } - goto end200524c722ed14ca935ba47f8f30327d - end200524c722ed14ca935ba47f8f30327d: - ; + return rewriteValueAMD64_OpConst8(v, config) case OpConstBool: - // match: (ConstBool [b]) - // cond: - // result: (MOVBconst [b]) - { - b := v.AuxInt - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = b - return true - } - goto end6d919011283330dcbcb3826f0adc6793 - end6d919011283330dcbcb3826f0adc6793: - ; + return rewriteValueAMD64_OpConstBool(v, config) case OpConstNil: - // match: (ConstNil) - // cond: - // result: (MOVQconst [0]) - { - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 0 - return true - } - goto endea557d921056c25b945a49649e4b9b91 - endea557d921056c25b945a49649e4b9b91: - ; + return rewriteValueAMD64_OpConstNil(v, config) case OpConstPtr: - // match: (ConstPtr [val]) - // cond: - // result: (MOVQconst [val]) - { - val := v.AuxInt - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = val - return true - } - goto endc395c0a53eeccf597e225a07b53047d1 - endc395c0a53eeccf597e225a07b53047d1: - ; + return rewriteValueAMD64_OpConstPtr(v, config) case OpConvert: - // match: (Convert x) - // cond: - // result: (LEAQ x) - { - t := v.Type - x := v.Args[0] - v.Op = OpAMD64LEAQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = t - v.AddArg(x) - return true - } - goto end1cac40a6074914d6ae3d4aa039a625ed - end1cac40a6074914d6ae3d4aa039a625ed: - ; + return rewriteValueAMD64_OpConvert(v, config) case OpCvt32Fto32: - // match: (Cvt32Fto32 x) - // cond: - // result: (CVTTSS2SL x) - { - x := v.Args[0] - v.Op = OpAMD64CVTTSS2SL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto enda410209d31804e1bce7bdc235fc62342 - enda410209d31804e1bce7bdc235fc62342: - ; + return rewriteValueAMD64_OpCvt32Fto32(v, config) case OpCvt32Fto64: - // match: (Cvt32Fto64 x) - // cond: - // result: (CVTTSS2SQ x) - { - x := v.Args[0] - v.Op = OpAMD64CVTTSS2SQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto enddb02fa4f3230a14d557d6c90cdadd523 - enddb02fa4f3230a14d557d6c90cdadd523: - ; + return rewriteValueAMD64_OpCvt32Fto64(v, config) case OpCvt32Fto64F: - // match: (Cvt32Fto64F x) - // cond: - // result: (CVTSS2SD x) - { - x := v.Args[0] - v.Op = OpAMD64CVTSS2SD - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto end0bf5d6f8d182ee2b3ab7d7c2f8ff7790 - end0bf5d6f8d182ee2b3ab7d7c2f8ff7790: - ; + return rewriteValueAMD64_OpCvt32Fto64F(v, config) case OpCvt32to32F: - // match: (Cvt32to32F x) - // cond: - // result: (CVTSL2SS x) - { - x := v.Args[0] - v.Op = OpAMD64CVTSL2SS - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto ende0bdea2b21aecdb8399d6fd80ddc97d6 - ende0bdea2b21aecdb8399d6fd80ddc97d6: - ; + return rewriteValueAMD64_OpCvt32to32F(v, config) case OpCvt32to64F: - // match: (Cvt32to64F x) - // cond: - // result: (CVTSL2SD x) - { - x := v.Args[0] - v.Op = OpAMD64CVTSL2SD - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto ende06cbe745112bcf0e6612788ef71c958 - ende06cbe745112bcf0e6612788ef71c958: - ; + return rewriteValueAMD64_OpCvt32to64F(v, config) case OpCvt64Fto32: - // match: (Cvt64Fto32 x) - // cond: - // result: (CVTTSD2SL x) - { - x := v.Args[0] - v.Op = OpAMD64CVTTSD2SL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto endc213dd690dfe568607dec717b2c385b7 - endc213dd690dfe568607dec717b2c385b7: - ; + return rewriteValueAMD64_OpCvt64Fto32(v, config) case OpCvt64Fto32F: - // match: (Cvt64Fto32F x) - // cond: - // result: (CVTSD2SS x) - { - x := v.Args[0] - v.Op = OpAMD64CVTSD2SS - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto endfd70158a96824ced99712d606c607d94 - endfd70158a96824ced99712d606c607d94: - ; + return rewriteValueAMD64_OpCvt64Fto32F(v, config) case OpCvt64Fto64: - // match: (Cvt64Fto64 x) - // cond: - // result: (CVTTSD2SQ x) - { - x := v.Args[0] - v.Op = OpAMD64CVTTSD2SQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto end0bf3e4468047fd20714266ff05797454 - end0bf3e4468047fd20714266ff05797454: - ; + return rewriteValueAMD64_OpCvt64Fto64(v, config) case OpCvt64to32F: - // match: (Cvt64to32F x) - // cond: - // result: (CVTSQ2SS x) - { - x := v.Args[0] - v.Op = OpAMD64CVTSQ2SS - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto endfecc08b8a8cbd2bf3be21a077c4d0d40 - endfecc08b8a8cbd2bf3be21a077c4d0d40: - ; + return rewriteValueAMD64_OpCvt64to32F(v, config) case OpCvt64to64F: - // match: (Cvt64to64F x) - // cond: - // result: (CVTSQ2SD x) - { - x := v.Args[0] - v.Op = OpAMD64CVTSQ2SD - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto endf74ce5df659f385f75c61187b515a5d0 - endf74ce5df659f385f75c61187b515a5d0: - ; + return rewriteValueAMD64_OpCvt64to64F(v, config) case OpDeferCall: - // match: (DeferCall [argwid] mem) - // cond: - // result: (CALLdefer [argwid] mem) - { - argwid := v.AuxInt - mem := v.Args[0] - v.Op = OpAMD64CALLdefer - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = argwid - v.AddArg(mem) - return true - } - goto end1c408581037450df959dd1fb7554a022 - end1c408581037450df959dd1fb7554a022: - ; + return rewriteValueAMD64_OpDeferCall(v, config) case OpDiv16: - // match: (Div16 x y) - // cond: - // result: (DIVW x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64DIVW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto endb60a86e606726640c84d3e1e5a5ce890 - endb60a86e606726640c84d3e1e5a5ce890: - ; + return rewriteValueAMD64_OpDiv16(v, config) case OpDiv16u: - // match: (Div16u x y) - // cond: - // result: (DIVWU x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64DIVWU - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto end6af9e212a865593e506bfdf7db67c9ec - end6af9e212a865593e506bfdf7db67c9ec: - ; + return rewriteValueAMD64_OpDiv16u(v, config) case OpDiv32: - // match: (Div32 x y) - // cond: - // result: (DIVL x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64DIVL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto endf20ac71407e57c2904684d3cc33cf697 - endf20ac71407e57c2904684d3cc33cf697: - ; + return rewriteValueAMD64_OpDiv32(v, config) case OpDiv32F: - // match: (Div32F x y) - // cond: - // result: (DIVSS x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64DIVSS - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto enddca0462c7b176c4138854d7d5627ab5b - enddca0462c7b176c4138854d7d5627ab5b: - ; + return rewriteValueAMD64_OpDiv32F(v, config) case OpDiv32u: - // match: (Div32u x y) - // cond: - // result: (DIVLU x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64DIVLU - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto enda22604d23eeb1298008c97b817f60bbd - enda22604d23eeb1298008c97b817f60bbd: - ; + return rewriteValueAMD64_OpDiv32u(v, config) case OpDiv64: - // match: (Div64 x y) - // cond: - // result: (DIVQ x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64DIVQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto end86490d9b337333dfc09a413e1e0120a9 - end86490d9b337333dfc09a413e1e0120a9: - ; + return rewriteValueAMD64_OpDiv64(v, config) case OpDiv64F: - // match: (Div64F x y) - // cond: - // result: (DIVSD x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64DIVSD - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto end12299d76db5144a60f564d34ba97eb43 - end12299d76db5144a60f564d34ba97eb43: - ; + return rewriteValueAMD64_OpDiv64F(v, config) case OpDiv64u: - // match: (Div64u x y) - // cond: - // result: (DIVQU x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64DIVQU - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto endf871d8b397e5fad6a5b500cc0c759a8d - endf871d8b397e5fad6a5b500cc0c759a8d: - ; + return rewriteValueAMD64_OpDiv64u(v, config) case OpDiv8: - // match: (Div8 x y) - // cond: - // result: (DIVW (SignExt8to16 x) (SignExt8to16 y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64DIVW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpSignExt8to16, TypeInvalid) - v0.AddArg(x) - v0.Type = config.fe.TypeInt16() - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpSignExt8to16, TypeInvalid) - v1.AddArg(y) - v1.Type = config.fe.TypeInt16() - v.AddArg(v1) - return true - } - goto endeee2bc780a73ec2ccb1a66c527816ee0 - endeee2bc780a73ec2ccb1a66c527816ee0: - ; + return rewriteValueAMD64_OpDiv8(v, config) case OpDiv8u: - // match: (Div8u x y) - // cond: - // result: (DIVWU (ZeroExt8to16 x) (ZeroExt8to16 y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64DIVWU - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpZeroExt8to16, TypeInvalid) - v0.AddArg(x) - v0.Type = config.fe.TypeUInt16() - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpZeroExt8to16, TypeInvalid) - v1.AddArg(y) - v1.Type = config.fe.TypeUInt16() - v.AddArg(v1) - return true - } - goto end39da6664d6434d844303f6924cc875dd - end39da6664d6434d844303f6924cc875dd: - ; + return rewriteValueAMD64_OpDiv8u(v, config) case OpEq16: - // match: (Eq16 x y) - // cond: - // result: (SETEQ (CMPW x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETEQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto endd7f668b1d23603b0949953ee8dec8107 - endd7f668b1d23603b0949953ee8dec8107: - ; + return rewriteValueAMD64_OpEq16(v, config) case OpEq32: - // match: (Eq32 x y) - // cond: - // result: (SETEQ (CMPL x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETEQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto endf28041ae0c73fb341cc0d2f4903fb2fb - endf28041ae0c73fb341cc0d2f4903fb2fb: - ; + return rewriteValueAMD64_OpEq32(v, config) case OpEq32F: - // match: (Eq32F x y) - // cond: - // result: (SETEQF (UCOMISS x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETEQF - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto endb2c12933769e5faa8fc238048e113dee - endb2c12933769e5faa8fc238048e113dee: - ; + return rewriteValueAMD64_OpEq32F(v, config) case OpEq64: - // match: (Eq64 x y) - // cond: - // result: (SETEQ (CMPQ x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETEQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto ende07a380487b710b51bcd5aa6d3144b8c - ende07a380487b710b51bcd5aa6d3144b8c: - ; + return rewriteValueAMD64_OpEq64(v, config) case OpEq64F: - // match: (Eq64F x y) - // cond: - // result: (SETEQF (UCOMISD x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETEQF - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto end68e20c0c1b3ee62fbd17af07ac100704 - end68e20c0c1b3ee62fbd17af07ac100704: - ; + return rewriteValueAMD64_OpEq64F(v, config) case OpEq8: - // match: (Eq8 x y) - // cond: - // result: (SETEQ (CMPB x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETEQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto end359e5a51d2ab928a455f0ae5adb42ab0 - end359e5a51d2ab928a455f0ae5adb42ab0: - ; + return rewriteValueAMD64_OpEq8(v, config) case OpEqPtr: - // match: (EqPtr x y) - // cond: - // result: (SETEQ (CMPQ x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETEQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto endf19bd3c0eb99d15718bef4066d62560c - endf19bd3c0eb99d15718bef4066d62560c: - ; + return rewriteValueAMD64_OpEqPtr(v, config) case OpGeq16: - // match: (Geq16 x y) - // cond: - // result: (SETGE (CMPW x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETGE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto end0a3f723d5c0b877c473b0043d814867b - end0a3f723d5c0b877c473b0043d814867b: - ; + return rewriteValueAMD64_OpGeq16(v, config) case OpGeq16U: - // match: (Geq16U x y) - // cond: - // result: (SETAE (CMPW x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETAE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto end79d754a28ee34eff95140635b26f0248 - end79d754a28ee34eff95140635b26f0248: - ; + return rewriteValueAMD64_OpGeq16U(v, config) case OpGeq32: - // match: (Geq32 x y) - // cond: - // result: (SETGE (CMPL x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETGE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto endfb1f6286a1b153b2a3f5b8548a782c8c - endfb1f6286a1b153b2a3f5b8548a782c8c: - ; + return rewriteValueAMD64_OpGeq32(v, config) case OpGeq32F: - // match: (Geq32F x y) - // cond: - // result: (SETGEF (UCOMISS x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETGEF - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto end7a8d6107a945410e64db06669a61da97 - end7a8d6107a945410e64db06669a61da97: - ; + return rewriteValueAMD64_OpGeq32F(v, config) case OpGeq32U: - // match: (Geq32U x y) - // cond: - // result: (SETAE (CMPL x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETAE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto endc5d3478a626df01ede063564f4cb80d0 - endc5d3478a626df01ede063564f4cb80d0: - ; + return rewriteValueAMD64_OpGeq32U(v, config) case OpGeq64: - // match: (Geq64 x y) - // cond: - // result: (SETGE (CMPQ x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETGE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto end74bddb7905ab865de5b041e7e4789911 - end74bddb7905ab865de5b041e7e4789911: - ; + return rewriteValueAMD64_OpGeq64(v, config) case OpGeq64F: - // match: (Geq64F x y) - // cond: - // result: (SETGEF (UCOMISD x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETGEF - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto end9fac9bd98ef58b7fbbe1a31f84bdcccf - end9fac9bd98ef58b7fbbe1a31f84bdcccf: - ; + return rewriteValueAMD64_OpGeq64F(v, config) case OpGeq64U: - // match: (Geq64U x y) - // cond: - // result: (SETAE (CMPQ x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETAE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto end95101721fc8f5be9969e50e364143e7f - end95101721fc8f5be9969e50e364143e7f: - ; + return rewriteValueAMD64_OpGeq64U(v, config) case OpGeq8: - // match: (Geq8 x y) - // cond: - // result: (SETGE (CMPB x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETGE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto end983070a3db317bdb64b5a0fb104d267c - end983070a3db317bdb64b5a0fb104d267c: - ; + return rewriteValueAMD64_OpGeq8(v, config) case OpGeq8U: - // match: (Geq8U x y) - // cond: - // result: (SETAE (CMPB x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETAE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto enda617119faaccc0f0c2d23548116cf331 - enda617119faaccc0f0c2d23548116cf331: - ; + return rewriteValueAMD64_OpGeq8U(v, config) case OpGetClosurePtr: - // match: (GetClosurePtr) - // cond: - // result: (LoweredGetClosurePtr) - { - v.Op = OpAMD64LoweredGetClosurePtr - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - return true - } - goto end6fd0b53f0acb4d35e7d7fa78d2ca1392 - end6fd0b53f0acb4d35e7d7fa78d2ca1392: - ; + return rewriteValueAMD64_OpGetClosurePtr(v, config) case OpGetG: - // match: (GetG mem) - // cond: - // result: (LoweredGetG mem) - { - mem := v.Args[0] - v.Op = OpAMD64LoweredGetG - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(mem) - return true - } - goto endf543eaaf68c4bef1d4cdc8ba19683723 - endf543eaaf68c4bef1d4cdc8ba19683723: - ; + return rewriteValueAMD64_OpGetG(v, config) case OpGoCall: - // match: (GoCall [argwid] mem) - // cond: - // result: (CALLgo [argwid] mem) - { - argwid := v.AuxInt - mem := v.Args[0] - v.Op = OpAMD64CALLgo - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = argwid - v.AddArg(mem) - return true - } - goto end1cef0f92c46e6aaa2c7abdf5f2794baf - end1cef0f92c46e6aaa2c7abdf5f2794baf: - ; + return rewriteValueAMD64_OpGoCall(v, config) case OpGreater16: - // match: (Greater16 x y) - // cond: - // result: (SETG (CMPW x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETG - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto end4e4a1307c61240af9a86d8fe4f834ee8 - end4e4a1307c61240af9a86d8fe4f834ee8: - ; + return rewriteValueAMD64_OpGreater16(v, config) case OpGreater16U: - // match: (Greater16U x y) - // cond: - // result: (SETA (CMPW x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETA - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto end7c66c75f4b8ec1db593f3e60cfba9592 - end7c66c75f4b8ec1db593f3e60cfba9592: - ; + return rewriteValueAMD64_OpGreater16U(v, config) case OpGreater32: - // match: (Greater32 x y) - // cond: - // result: (SETG (CMPL x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETG - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto end6fb0eae4a0e0e81b4afb085d398d873b - end6fb0eae4a0e0e81b4afb085d398d873b: - ; + return rewriteValueAMD64_OpGreater32(v, config) case OpGreater32F: - // match: (Greater32F x y) - // cond: - // result: (SETGF (UCOMISS x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETGF - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto end94df0bd5cedad8ce8021df1b24da40c6 - end94df0bd5cedad8ce8021df1b24da40c6: - ; + return rewriteValueAMD64_OpGreater32F(v, config) case OpGreater32U: - // match: (Greater32U x y) - // cond: - // result: (SETA (CMPL x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETA - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto end18da022a28eae8bd0771e0c948aadaf8 - end18da022a28eae8bd0771e0c948aadaf8: - ; + return rewriteValueAMD64_OpGreater32U(v, config) case OpGreater64: - // match: (Greater64 x y) - // cond: - // result: (SETG (CMPQ x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETG - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto endc025c908708f939780fba0da0c1148b4 - endc025c908708f939780fba0da0c1148b4: - ; + return rewriteValueAMD64_OpGreater64(v, config) case OpGreater64F: - // match: (Greater64F x y) - // cond: - // result: (SETGF (UCOMISD x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETGF - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto end033ca5181b18376e7215c02812ef5a6b - end033ca5181b18376e7215c02812ef5a6b: - ; + return rewriteValueAMD64_OpGreater64F(v, config) case OpGreater64U: - // match: (Greater64U x y) - // cond: - // result: (SETA (CMPQ x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETA - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto endb3e25347041760a04d3fc8321c3f3d00 - endb3e25347041760a04d3fc8321c3f3d00: - ; + return rewriteValueAMD64_OpGreater64U(v, config) case OpGreater8: - // match: (Greater8 x y) - // cond: - // result: (SETG (CMPB x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETG - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto enda3eeb5da2e69cb54a1515601d4b360d4 - enda3eeb5da2e69cb54a1515601d4b360d4: - ; + return rewriteValueAMD64_OpGreater8(v, config) case OpGreater8U: - // match: (Greater8U x y) - // cond: - // result: (SETA (CMPB x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETA - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto endd2027f3b6471262f42b90c8cc0413667 - endd2027f3b6471262f42b90c8cc0413667: - ; + return rewriteValueAMD64_OpGreater8U(v, config) case OpHmul16: - // match: (Hmul16 x y) - // cond: - // result: (HMULW x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64HMULW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto end1b9ff394bb3b06fc109637656b6875f5 - end1b9ff394bb3b06fc109637656b6875f5: - ; + return rewriteValueAMD64_OpHmul16(v, config) case OpHmul16u: - // match: (Hmul16u x y) - // cond: - // result: (HMULWU x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64HMULWU - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto endee9089e794a43f2ce1619a6ef61670f4 - endee9089e794a43f2ce1619a6ef61670f4: - ; + return rewriteValueAMD64_OpHmul16u(v, config) case OpHmul32: - // match: (Hmul32 x y) - // cond: - // result: (HMULL x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64HMULL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto end7c83c91ef2634f0b1da4f49350b437b1 - end7c83c91ef2634f0b1da4f49350b437b1: - ; + return rewriteValueAMD64_OpHmul32(v, config) case OpHmul32u: - // match: (Hmul32u x y) - // cond: - // result: (HMULLU x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64HMULLU - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto end3c4f36611dc8815aa2a63d4ec0eaa06d - end3c4f36611dc8815aa2a63d4ec0eaa06d: - ; + return rewriteValueAMD64_OpHmul32u(v, config) case OpHmul8: - // match: (Hmul8 x y) - // cond: - // result: (HMULB x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64HMULB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto end51b2cc9f1ed15314e68fc81024f281a7 - end51b2cc9f1ed15314e68fc81024f281a7: - ; + return rewriteValueAMD64_OpHmul8(v, config) case OpHmul8u: - // match: (Hmul8u x y) - // cond: - // result: (HMULBU x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64HMULBU - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto ende68d7b3a3c774cedc3522af9d635c39d - ende68d7b3a3c774cedc3522af9d635c39d: - ; + return rewriteValueAMD64_OpHmul8u(v, config) case OpITab: - // match: (ITab (Load ptr mem)) - // cond: - // result: (MOVQload ptr mem) - { - if v.Args[0].Op != OpLoad { - goto enda49fcae3630a097c78aa58189c90a97a - } - ptr := v.Args[0].Args[0] - mem := v.Args[0].Args[1] - v.Op = OpAMD64MOVQload - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(ptr) - v.AddArg(mem) - return true - } - goto enda49fcae3630a097c78aa58189c90a97a - enda49fcae3630a097c78aa58189c90a97a: - ; + return rewriteValueAMD64_OpITab(v, config) case OpInterCall: - // match: (InterCall [argwid] entry mem) - // cond: - // result: (CALLinter [argwid] entry mem) - { - argwid := v.AuxInt - entry := v.Args[0] - mem := v.Args[1] - v.Op = OpAMD64CALLinter - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = argwid - v.AddArg(entry) - v.AddArg(mem) - return true - } - goto endc04351e492ed362efc6aa75121bca305 - endc04351e492ed362efc6aa75121bca305: - ; + return rewriteValueAMD64_OpInterCall(v, config) case OpIsInBounds: - // match: (IsInBounds idx len) - // cond: - // result: (SETB (CMPQ idx len)) - { - idx := v.Args[0] - len := v.Args[1] - v.Op = OpAMD64SETB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) - v0.AddArg(idx) - v0.AddArg(len) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto endfff988d5f1912886d73be3bb563c37d9 - endfff988d5f1912886d73be3bb563c37d9: - ; + return rewriteValueAMD64_OpIsInBounds(v, config) case OpIsNonNil: - // match: (IsNonNil p) - // cond: - // result: (SETNE (TESTQ p p)) - { - p := v.Args[0] - v.Op = OpAMD64SETNE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64TESTQ, TypeInvalid) - v0.AddArg(p) - v0.AddArg(p) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto end0af5ec868ede9ea73fb0602d54b863e9 - end0af5ec868ede9ea73fb0602d54b863e9: - ; + return rewriteValueAMD64_OpIsNonNil(v, config) case OpIsSliceInBounds: - // match: (IsSliceInBounds idx len) - // cond: - // result: (SETBE (CMPQ idx len)) - { - idx := v.Args[0] - len := v.Args[1] - v.Op = OpAMD64SETBE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) - v0.AddArg(idx) - v0.AddArg(len) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto end02799ad95fe7fb5ce3c2c8ab313b737c - end02799ad95fe7fb5ce3c2c8ab313b737c: - ; + return rewriteValueAMD64_OpIsSliceInBounds(v, config) case OpLeq16: - // match: (Leq16 x y) - // cond: - // result: (SETLE (CMPW x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETLE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto end586c647ca6bb8ec725eea917c743d1ea - end586c647ca6bb8ec725eea917c743d1ea: - ; + return rewriteValueAMD64_OpLeq16(v, config) case OpLeq16U: - // match: (Leq16U x y) - // cond: - // result: (SETBE (CMPW x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETBE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto end9c24a81bc6a4a92267bd6638362dfbfc - end9c24a81bc6a4a92267bd6638362dfbfc: - ; + return rewriteValueAMD64_OpLeq16U(v, config) case OpLeq32: - // match: (Leq32 x y) - // cond: - // result: (SETLE (CMPL x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETLE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto end595ee99a9fc3460b2748b9129b139f88 - end595ee99a9fc3460b2748b9129b139f88: - ; + return rewriteValueAMD64_OpLeq32(v, config) case OpLeq32F: - // match: (Leq32F x y) - // cond: - // result: (SETGEF (UCOMISS y x)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETGEF - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeInvalid) - v0.AddArg(y) - v0.AddArg(x) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto endfee4b989a80cc43328b24f7017e80a17 - endfee4b989a80cc43328b24f7017e80a17: - ; + return rewriteValueAMD64_OpLeq32F(v, config) case OpLeq32U: - // match: (Leq32U x y) - // cond: - // result: (SETBE (CMPL x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETBE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto end1a59850aad6cb17c295d0dc359013420 - end1a59850aad6cb17c295d0dc359013420: - ; + return rewriteValueAMD64_OpLeq32U(v, config) case OpLeq64: - // match: (Leq64 x y) - // cond: - // result: (SETLE (CMPQ x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETLE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto end406def83fcbf29cd8fa306170b512de2 - end406def83fcbf29cd8fa306170b512de2: - ; + return rewriteValueAMD64_OpLeq64(v, config) case OpLeq64F: - // match: (Leq64F x y) - // cond: - // result: (SETGEF (UCOMISD y x)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETGEF - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeInvalid) - v0.AddArg(y) - v0.AddArg(x) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto end6e3de6d4b5668f673e3822d5947edbd0 - end6e3de6d4b5668f673e3822d5947edbd0: - ; + return rewriteValueAMD64_OpLeq64F(v, config) case OpLeq64U: - // match: (Leq64U x y) - // cond: - // result: (SETBE (CMPQ x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETBE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto end52f23c145b80639c8d60420ad4057bc7 - end52f23c145b80639c8d60420ad4057bc7: - ; + return rewriteValueAMD64_OpLeq64U(v, config) case OpLeq8: - // match: (Leq8 x y) - // cond: - // result: (SETLE (CMPB x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETLE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto end72ecba6f2a7062cb266923dfec811f79 - end72ecba6f2a7062cb266923dfec811f79: - ; + return rewriteValueAMD64_OpLeq8(v, config) case OpLeq8U: - // match: (Leq8U x y) - // cond: - // result: (SETBE (CMPB x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETBE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto endb043b338cced4f15400d8d6e584ebea7 - endb043b338cced4f15400d8d6e584ebea7: - ; + return rewriteValueAMD64_OpLeq8U(v, config) case OpLess16: - // match: (Less16 x y) - // cond: - // result: (SETL (CMPW x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto end2f6c6ba80eda8d68e77a58cba13d3f16 - end2f6c6ba80eda8d68e77a58cba13d3f16: - ; + return rewriteValueAMD64_OpLess16(v, config) case OpLess16U: - // match: (Less16U x y) - // cond: - // result: (SETB (CMPW x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto end9f65eefe7b83a3c436b5c16664c93703 - end9f65eefe7b83a3c436b5c16664c93703: - ; + return rewriteValueAMD64_OpLess16U(v, config) case OpLess32: - // match: (Less32 x y) - // cond: - // result: (SETL (CMPL x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto end6632ff4ee994eb5b14cdf60c99ac3798 - end6632ff4ee994eb5b14cdf60c99ac3798: - ; + return rewriteValueAMD64_OpLess32(v, config) case OpLess32F: - // match: (Less32F x y) - // cond: - // result: (SETGF (UCOMISS y x)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETGF - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeInvalid) - v0.AddArg(y) - v0.AddArg(x) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto end5b3b0c96a7fc2ede81bc89c9abaac9d0 - end5b3b0c96a7fc2ede81bc89c9abaac9d0: - ; + return rewriteValueAMD64_OpLess32F(v, config) case OpLess32U: - // match: (Less32U x y) - // cond: - // result: (SETB (CMPL x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto end39e5a513c7fb0a42817a6cf9c6143b60 - end39e5a513c7fb0a42817a6cf9c6143b60: - ; + return rewriteValueAMD64_OpLess32U(v, config) case OpLess64: - // match: (Less64 x y) - // cond: - // result: (SETL (CMPQ x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto enddce827d3e922e8487b61a88c2b1510f2 - enddce827d3e922e8487b61a88c2b1510f2: - ; + return rewriteValueAMD64_OpLess64(v, config) case OpLess64F: - // match: (Less64F x y) - // cond: - // result: (SETGF (UCOMISD y x)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETGF - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeInvalid) - v0.AddArg(y) - v0.AddArg(x) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto endf2be3d2dcb6543d2159e7fff5ccbbb55 - endf2be3d2dcb6543d2159e7fff5ccbbb55: - ; + return rewriteValueAMD64_OpLess64F(v, config) case OpLess64U: - // match: (Less64U x y) - // cond: - // result: (SETB (CMPQ x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto endb76d7768f175a44baf6d63d12ab6e81d - endb76d7768f175a44baf6d63d12ab6e81d: - ; + return rewriteValueAMD64_OpLess64U(v, config) case OpLess8: - // match: (Less8 x y) - // cond: - // result: (SETL (CMPB x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto end314fbffe99f3bd4b07857a80c0b914cd - end314fbffe99f3bd4b07857a80c0b914cd: - ; + return rewriteValueAMD64_OpLess8(v, config) case OpLess8U: - // match: (Less8U x y) - // cond: - // result: (SETB (CMPB x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto endadccc5d80fd053a33004ed0759f64d93 - endadccc5d80fd053a33004ed0759f64d93: - ; + return rewriteValueAMD64_OpLess8U(v, config) case OpLoad: - // match: (Load ptr mem) - // cond: (is64BitInt(t) || isPtr(t)) - // result: (MOVQload ptr mem) - { - t := v.Type - ptr := v.Args[0] - mem := v.Args[1] - if !(is64BitInt(t) || isPtr(t)) { - goto end7c4c53acf57ebc5f03273652ba1d5934 - } - v.Op = OpAMD64MOVQload - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(ptr) - v.AddArg(mem) - return true - } - goto end7c4c53acf57ebc5f03273652ba1d5934 - end7c4c53acf57ebc5f03273652ba1d5934: - ; - // match: (Load ptr mem) - // cond: is32BitInt(t) - // result: (MOVLload ptr mem) - { - t := v.Type - ptr := v.Args[0] - mem := v.Args[1] - if !(is32BitInt(t)) { - goto ende1cfcb15bfbcfd448ce303d0882a4057 - } - v.Op = OpAMD64MOVLload - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(ptr) - v.AddArg(mem) - return true - } - goto ende1cfcb15bfbcfd448ce303d0882a4057 - ende1cfcb15bfbcfd448ce303d0882a4057: - ; - // match: (Load ptr mem) - // cond: is16BitInt(t) - // result: (MOVWload ptr mem) - { - t := v.Type - ptr := v.Args[0] - mem := v.Args[1] - if !(is16BitInt(t)) { - goto end2d0a1304501ed9f4e9e2d288505a9c7c - } - v.Op = OpAMD64MOVWload - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(ptr) - v.AddArg(mem) - return true - } - goto end2d0a1304501ed9f4e9e2d288505a9c7c - end2d0a1304501ed9f4e9e2d288505a9c7c: - ; - // match: (Load ptr mem) - // cond: (t.IsBoolean() || is8BitInt(t)) - // result: (MOVBload ptr mem) - { - t := v.Type - ptr := v.Args[0] - mem := v.Args[1] - if !(t.IsBoolean() || is8BitInt(t)) { - goto end8f83bf72293670e75b22d6627bd13f0b - } - v.Op = OpAMD64MOVBload - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(ptr) - v.AddArg(mem) - return true - } - goto end8f83bf72293670e75b22d6627bd13f0b - end8f83bf72293670e75b22d6627bd13f0b: - ; - // match: (Load ptr mem) - // cond: is32BitFloat(t) - // result: (MOVSSload ptr mem) - { - t := v.Type - ptr := v.Args[0] - mem := v.Args[1] - if !(is32BitFloat(t)) { - goto end63383c4895805881aabceebea3c4c533 - } - v.Op = OpAMD64MOVSSload - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(ptr) - v.AddArg(mem) - return true - } - goto end63383c4895805881aabceebea3c4c533 - end63383c4895805881aabceebea3c4c533: - ; - // match: (Load ptr mem) - // cond: is64BitFloat(t) - // result: (MOVSDload ptr mem) - { - t := v.Type - ptr := v.Args[0] - mem := v.Args[1] - if !(is64BitFloat(t)) { - goto end99d0858c0a5bb72f0fe4decc748da812 - } - v.Op = OpAMD64MOVSDload - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(ptr) - v.AddArg(mem) - return true - } - goto end99d0858c0a5bb72f0fe4decc748da812 - end99d0858c0a5bb72f0fe4decc748da812: - ; + return rewriteValueAMD64_OpLoad(v, config) case OpLrot16: - // match: (Lrot16 x [c]) - // cond: - // result: (ROLWconst [c&15] x) - { - t := v.Type - x := v.Args[0] - c := v.AuxInt - v.Op = OpAMD64ROLWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = t - v.AuxInt = c & 15 - v.AddArg(x) - return true - } - goto endb23dfa24c619d0068f925899d53ee7fd - endb23dfa24c619d0068f925899d53ee7fd: - ; + return rewriteValueAMD64_OpLrot16(v, config) case OpLrot32: - // match: (Lrot32 x [c]) - // cond: - // result: (ROLLconst [c&31] x) - { - t := v.Type - x := v.Args[0] - c := v.AuxInt - v.Op = OpAMD64ROLLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = t - v.AuxInt = c & 31 - v.AddArg(x) - return true - } - goto end38b2215c011896c36845f72ecb72b1b0 - end38b2215c011896c36845f72ecb72b1b0: - ; + return rewriteValueAMD64_OpLrot32(v, config) case OpLrot64: - // match: (Lrot64 x [c]) - // cond: - // result: (ROLQconst [c&63] x) - { - t := v.Type - x := v.Args[0] - c := v.AuxInt - v.Op = OpAMD64ROLQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = t - v.AuxInt = c & 63 - v.AddArg(x) - return true - } - goto end5cb355e4f3ca387f252ef4f6a55f9f68 - end5cb355e4f3ca387f252ef4f6a55f9f68: - ; + return rewriteValueAMD64_OpLrot64(v, config) case OpLrot8: - // match: (Lrot8 x [c]) - // cond: - // result: (ROLBconst [c&7] x) - { - t := v.Type - x := v.Args[0] - c := v.AuxInt - v.Op = OpAMD64ROLBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = t - v.AuxInt = c & 7 - v.AddArg(x) - return true - } - goto end26bfb3dd5b537cf13ac9f2978d94ed71 - end26bfb3dd5b537cf13ac9f2978d94ed71: - ; + return rewriteValueAMD64_OpLrot8(v, config) case OpLsh16x16: - // match: (Lsh16x16 x y) - // cond: - // result: (ANDW (SHLW x y) (SBBLcarrymask (CMPWconst [16] y))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ANDW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHLW, TypeInvalid) - v0.Type = t - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) - v2.AuxInt = 16 - v2.AddArg(y) - v2.Type = TypeFlags - v1.AddArg(v2) - v.AddArg(v1) - return true - } - goto end7ffc4f31c526f7fcb2283215b458f589 - end7ffc4f31c526f7fcb2283215b458f589: - ; + return rewriteValueAMD64_OpLsh16x16(v, config) case OpLsh16x32: - // match: (Lsh16x32 x y) - // cond: - // result: (ANDW (SHLW x y) (SBBLcarrymask (CMPLconst [16] y))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ANDW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHLW, TypeInvalid) - v0.Type = t - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) - v2.AuxInt = 16 - v2.AddArg(y) - v2.Type = TypeFlags - v1.AddArg(v2) - v.AddArg(v1) - return true - } - goto enddcc0e751d315967423c99518c0cc065e - enddcc0e751d315967423c99518c0cc065e: - ; + return rewriteValueAMD64_OpLsh16x32(v, config) case OpLsh16x64: - // match: (Lsh16x64 x y) - // cond: - // result: (ANDW (SHLW x y) (SBBLcarrymask (CMPQconst [16] y))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ANDW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHLW, TypeInvalid) - v0.Type = t - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) - v2.AuxInt = 16 - v2.AddArg(y) - v2.Type = TypeFlags - v1.AddArg(v2) - v.AddArg(v1) - return true - } - goto endf6368b59d046ca83050cd75fbe8715d2 - endf6368b59d046ca83050cd75fbe8715d2: - ; + return rewriteValueAMD64_OpLsh16x64(v, config) case OpLsh16x8: - // match: (Lsh16x8 x y) - // cond: - // result: (ANDW (SHLW x y) (SBBLcarrymask (CMPBconst [16] y))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ANDW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHLW, TypeInvalid) - v0.Type = t - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) - v2.AuxInt = 16 - v2.AddArg(y) - v2.Type = TypeFlags - v1.AddArg(v2) - v.AddArg(v1) - return true - } - goto end8730d944c8fb358001ba2d165755bdc4 - end8730d944c8fb358001ba2d165755bdc4: - ; + return rewriteValueAMD64_OpLsh16x8(v, config) case OpLsh32x16: - // match: (Lsh32x16 x y) - // cond: - // result: (ANDL (SHLL x y) (SBBLcarrymask (CMPWconst [32] y))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ANDL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHLL, TypeInvalid) - v0.Type = t - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) - v2.AuxInt = 32 - v2.AddArg(y) - v2.Type = TypeFlags - v1.AddArg(v2) - v.AddArg(v1) - return true - } - goto end5a43b7e9b0780e62f622bac0a68524d2 - end5a43b7e9b0780e62f622bac0a68524d2: - ; + return rewriteValueAMD64_OpLsh32x16(v, config) case OpLsh32x32: - // match: (Lsh32x32 x y) - // cond: - // result: (ANDL (SHLL x y) (SBBLcarrymask (CMPLconst [32] y))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ANDL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHLL, TypeInvalid) - v0.Type = t - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) - v2.AuxInt = 32 - v2.AddArg(y) - v2.Type = TypeFlags - v1.AddArg(v2) - v.AddArg(v1) - return true - } - goto end9ce0ab6f9095c24ea46ca8fe2d7e5507 - end9ce0ab6f9095c24ea46ca8fe2d7e5507: - ; + return rewriteValueAMD64_OpLsh32x32(v, config) case OpLsh32x64: - // match: (Lsh32x64 x y) - // cond: - // result: (ANDL (SHLL x y) (SBBLcarrymask (CMPQconst [32] y))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ANDL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHLL, TypeInvalid) - v0.Type = t - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) - v2.AuxInt = 32 - v2.AddArg(y) - v2.Type = TypeFlags - v1.AddArg(v2) - v.AddArg(v1) - return true - } - goto end646b5471b709d5ea6c21f49a2815236f - end646b5471b709d5ea6c21f49a2815236f: - ; + return rewriteValueAMD64_OpLsh32x64(v, config) case OpLsh32x8: - // match: (Lsh32x8 x y) - // cond: - // result: (ANDL (SHLL x y) (SBBLcarrymask (CMPBconst [32] y))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ANDL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHLL, TypeInvalid) - v0.Type = t - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) - v2.AuxInt = 32 - v2.AddArg(y) - v2.Type = TypeFlags - v1.AddArg(v2) - v.AddArg(v1) - return true - } - goto end96a677c71370e7c9179125f92cbdfda8 - end96a677c71370e7c9179125f92cbdfda8: - ; + return rewriteValueAMD64_OpLsh32x8(v, config) case OpLsh64x16: - // match: (Lsh64x16 x y) - // cond: - // result: (ANDQ (SHLQ x y) (SBBQcarrymask (CMPWconst [64] y))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ANDQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHLQ, TypeInvalid) - v0.Type = t - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) - v2.AuxInt = 64 - v2.AddArg(y) - v2.Type = TypeFlags - v1.AddArg(v2) - v.AddArg(v1) - return true - } - goto end5f88f241d68d38954222d81559cd7f9f - end5f88f241d68d38954222d81559cd7f9f: - ; + return rewriteValueAMD64_OpLsh64x16(v, config) case OpLsh64x32: - // match: (Lsh64x32 x y) - // cond: - // result: (ANDQ (SHLQ x y) (SBBQcarrymask (CMPLconst [64] y))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ANDQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHLQ, TypeInvalid) - v0.Type = t - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) - v2.AuxInt = 64 - v2.AddArg(y) - v2.Type = TypeFlags - v1.AddArg(v2) - v.AddArg(v1) - return true - } - goto endae1705f03ed3d6f43cd63b53496a910a - endae1705f03ed3d6f43cd63b53496a910a: - ; + return rewriteValueAMD64_OpLsh64x32(v, config) case OpLsh64x64: - // match: (Lsh64x64 x y) - // cond: - // result: (ANDQ (SHLQ x y) (SBBQcarrymask (CMPQconst [64] y))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ANDQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHLQ, TypeInvalid) - v0.Type = t - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) - v2.AuxInt = 64 - v2.AddArg(y) - v2.Type = TypeFlags - v1.AddArg(v2) - v.AddArg(v1) - return true - } - goto end1f6f5f510c5c68e4ce4a78643e6d85a1 - end1f6f5f510c5c68e4ce4a78643e6d85a1: - ; + return rewriteValueAMD64_OpLsh64x64(v, config) case OpLsh64x8: - // match: (Lsh64x8 x y) - // cond: - // result: (ANDQ (SHLQ x y) (SBBQcarrymask (CMPBconst [64] y))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ANDQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHLQ, TypeInvalid) - v0.Type = t - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) - v2.AuxInt = 64 - v2.AddArg(y) - v2.Type = TypeFlags - v1.AddArg(v2) - v.AddArg(v1) - return true - } - goto endd14f5c89e3496b0e425aa1ae366f4b53 - endd14f5c89e3496b0e425aa1ae366f4b53: - ; + return rewriteValueAMD64_OpLsh64x8(v, config) case OpLsh8x16: - // match: (Lsh8x16 x y) - // cond: - // result: (ANDB (SHLB x y) (SBBLcarrymask (CMPWconst [8] y))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ANDB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHLB, TypeInvalid) - v0.Type = t - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) - v2.AuxInt = 8 - v2.AddArg(y) - v2.Type = TypeFlags - v1.AddArg(v2) - v.AddArg(v1) - return true - } - goto end0926c3d8b9a0776ba5058946f6e1a4b7 - end0926c3d8b9a0776ba5058946f6e1a4b7: - ; + return rewriteValueAMD64_OpLsh8x16(v, config) case OpLsh8x32: - // match: (Lsh8x32 x y) - // cond: - // result: (ANDB (SHLB x y) (SBBLcarrymask (CMPLconst [8] y))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ANDB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHLB, TypeInvalid) - v0.Type = t - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) - v2.AuxInt = 8 - v2.AddArg(y) - v2.Type = TypeFlags - v1.AddArg(v2) - v.AddArg(v1) - return true - } - goto end5987682d77f197ef0fd95251f413535a - end5987682d77f197ef0fd95251f413535a: - ; + return rewriteValueAMD64_OpLsh8x32(v, config) case OpLsh8x64: - // match: (Lsh8x64 x y) - // cond: - // result: (ANDB (SHLB x y) (SBBLcarrymask (CMPQconst [8] y))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ANDB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHLB, TypeInvalid) - v0.Type = t - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) - v2.AuxInt = 8 - v2.AddArg(y) - v2.Type = TypeFlags - v1.AddArg(v2) - v.AddArg(v1) - return true - } - goto end9ffe6731d7d6514b8c0482f1645eee18 - end9ffe6731d7d6514b8c0482f1645eee18: - ; + return rewriteValueAMD64_OpLsh8x64(v, config) case OpLsh8x8: - // match: (Lsh8x8 x y) - // cond: - // result: (ANDB (SHLB x y) (SBBLcarrymask (CMPBconst [8] y))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ANDB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHLB, TypeInvalid) - v0.Type = t - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) - v2.AuxInt = 8 - v2.AddArg(y) - v2.Type = TypeFlags - v1.AddArg(v2) - v.AddArg(v1) - return true - } - goto end2b75242a31c3713ffbfdd8f0288b1c12 - end2b75242a31c3713ffbfdd8f0288b1c12: - ; + return rewriteValueAMD64_OpLsh8x8(v, config) case OpAMD64MOVBQSX: - // match: (MOVBQSX (MOVBload [off] {sym} ptr mem)) - // cond: - // result: @v.Args[0].Block (MOVBQSXload [off] {sym} ptr mem) - { - if v.Args[0].Op != OpAMD64MOVBload { - goto end19c38f3a1a37dca50637c917fa26e4f7 - } - off := v.Args[0].AuxInt - sym := v.Args[0].Aux - ptr := v.Args[0].Args[0] - mem := v.Args[0].Args[1] - v0 := v.Args[0].Block.NewValue0(v.Line, OpAMD64MOVBQSXload, TypeInvalid) - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(v0) - v0.Type = v.Type - v0.AuxInt = off - v0.Aux = sym - v0.AddArg(ptr) - v0.AddArg(mem) - return true - } - goto end19c38f3a1a37dca50637c917fa26e4f7 - end19c38f3a1a37dca50637c917fa26e4f7: - ; + return rewriteValueAMD64_OpAMD64MOVBQSX(v, config) case OpAMD64MOVBQZX: - // match: (MOVBQZX (MOVBload [off] {sym} ptr mem)) - // cond: - // result: @v.Args[0].Block (MOVBQZXload [off] {sym} ptr mem) - { - if v.Args[0].Op != OpAMD64MOVBload { - goto end1169bcf3d56fa24321b002eaebd5a62d - } - off := v.Args[0].AuxInt - sym := v.Args[0].Aux - ptr := v.Args[0].Args[0] - mem := v.Args[0].Args[1] - v0 := v.Args[0].Block.NewValue0(v.Line, OpAMD64MOVBQZXload, TypeInvalid) - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(v0) - v0.Type = v.Type - v0.AuxInt = off - v0.Aux = sym - v0.AddArg(ptr) - v0.AddArg(mem) - return true - } - goto end1169bcf3d56fa24321b002eaebd5a62d - end1169bcf3d56fa24321b002eaebd5a62d: - ; + return rewriteValueAMD64_OpAMD64MOVBQZX(v, config) case OpAMD64MOVBload: - // match: (MOVBload [off1] {sym} (ADDQconst [off2] ptr) mem) - // cond: - // result: (MOVBload [addOff(off1, off2)] {sym} ptr mem) - { - off1 := v.AuxInt - sym := v.Aux - if v.Args[0].Op != OpAMD64ADDQconst { - goto end7ec9147ab863c1bd59190fed81f894b6 - } - off2 := v.Args[0].AuxInt - ptr := v.Args[0].Args[0] - mem := v.Args[1] - v.Op = OpAMD64MOVBload - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = addOff(off1, off2) - v.Aux = sym - v.AddArg(ptr) - v.AddArg(mem) - return true - } - goto end7ec9147ab863c1bd59190fed81f894b6 - end7ec9147ab863c1bd59190fed81f894b6: - ; - // match: (MOVBload [off1] {sym1} (LEAQ [off2] {sym2} base) mem) - // cond: canMergeSym(sym1, sym2) - // result: (MOVBload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem) - { - off1 := v.AuxInt - sym1 := v.Aux - if v.Args[0].Op != OpAMD64LEAQ { - goto end3771a59cf66b0df99120d76f4c358fab - } - off2 := v.Args[0].AuxInt - sym2 := v.Args[0].Aux - base := v.Args[0].Args[0] - mem := v.Args[1] - if !(canMergeSym(sym1, sym2)) { - goto end3771a59cf66b0df99120d76f4c358fab - } - v.Op = OpAMD64MOVBload - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = addOff(off1, off2) - v.Aux = mergeSym(sym1, sym2) - v.AddArg(base) - v.AddArg(mem) - return true - } - goto end3771a59cf66b0df99120d76f4c358fab - end3771a59cf66b0df99120d76f4c358fab: - ; + return rewriteValueAMD64_OpAMD64MOVBload(v, config) case OpAMD64MOVBstore: - // match: (MOVBstore [off] {sym} ptr (MOVBQSX x) mem) - // cond: - // result: (MOVBstore [off] {sym} ptr x mem) - { - off := v.AuxInt - sym := v.Aux - ptr := v.Args[0] - if v.Args[1].Op != OpAMD64MOVBQSX { - goto end5b3f41f0770d566ff1647dea1d4a40e8 - } - x := v.Args[1].Args[0] - mem := v.Args[2] - v.Op = OpAMD64MOVBstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = off - v.Aux = sym - v.AddArg(ptr) - v.AddArg(x) - v.AddArg(mem) - return true - } - goto end5b3f41f0770d566ff1647dea1d4a40e8 - end5b3f41f0770d566ff1647dea1d4a40e8: - ; - // match: (MOVBstore [off] {sym} ptr (MOVBQZX x) mem) - // cond: - // result: (MOVBstore [off] {sym} ptr x mem) - { - off := v.AuxInt - sym := v.Aux - ptr := v.Args[0] - if v.Args[1].Op != OpAMD64MOVBQZX { - goto end3a2e55db7e03920700c4875f6a55de3b - } - x := v.Args[1].Args[0] - mem := v.Args[2] - v.Op = OpAMD64MOVBstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = off - v.Aux = sym - v.AddArg(ptr) - v.AddArg(x) - v.AddArg(mem) - return true - } - goto end3a2e55db7e03920700c4875f6a55de3b - end3a2e55db7e03920700c4875f6a55de3b: - ; - // match: (MOVBstore [off1] {sym} (ADDQconst [off2] ptr) val mem) - // cond: - // result: (MOVBstore [addOff(off1, off2)] {sym} ptr val mem) - { - off1 := v.AuxInt - sym := v.Aux - if v.Args[0].Op != OpAMD64ADDQconst { - goto ende6347ac19d0469ee59d2e7f2e18d1070 - } - off2 := v.Args[0].AuxInt - ptr := v.Args[0].Args[0] - val := v.Args[1] - mem := v.Args[2] - v.Op = OpAMD64MOVBstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = addOff(off1, off2) - v.Aux = sym - v.AddArg(ptr) - v.AddArg(val) - v.AddArg(mem) - return true - } - goto ende6347ac19d0469ee59d2e7f2e18d1070 - ende6347ac19d0469ee59d2e7f2e18d1070: - ; - // match: (MOVBstore [off] {sym} ptr (MOVBconst [c]) mem) - // cond: validStoreConstOff(off) - // result: (MOVBstoreconst [makeStoreConst(int64(int8(c)),off)] {sym} ptr mem) - { - off := v.AuxInt - sym := v.Aux - ptr := v.Args[0] - if v.Args[1].Op != OpAMD64MOVBconst { - goto enda8ebda583a842dae6377b7f562040318 - } - c := v.Args[1].AuxInt - mem := v.Args[2] - if !(validStoreConstOff(off)) { - goto enda8ebda583a842dae6377b7f562040318 - } - v.Op = OpAMD64MOVBstoreconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = makeStoreConst(int64(int8(c)), off) - v.Aux = sym - v.AddArg(ptr) - v.AddArg(mem) - return true - } - goto enda8ebda583a842dae6377b7f562040318 - enda8ebda583a842dae6377b7f562040318: - ; - // 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) - { - off1 := v.AuxInt - sym1 := v.Aux - if v.Args[0].Op != OpAMD64LEAQ { - goto enda7086cf7f6b8cf81972e2c3d4b12f3fc - } - 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)) { - goto enda7086cf7f6b8cf81972e2c3d4b12f3fc - } - v.Op = OpAMD64MOVBstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = addOff(off1, off2) - v.Aux = mergeSym(sym1, sym2) - v.AddArg(base) - v.AddArg(val) - v.AddArg(mem) - return true - } - goto enda7086cf7f6b8cf81972e2c3d4b12f3fc - enda7086cf7f6b8cf81972e2c3d4b12f3fc: - ; + return rewriteValueAMD64_OpAMD64MOVBstore(v, config) case OpAMD64MOVBstoreconst: - // match: (MOVBstoreconst [sc] {s} (ADDQconst [off] ptr) mem) - // cond: StoreConst(sc).canAdd(off) - // result: (MOVBstoreconst [StoreConst(sc).add(off)] {s} ptr mem) - { - sc := v.AuxInt - s := v.Aux - if v.Args[0].Op != OpAMD64ADDQconst { - goto ende1cdf6d463f91ba4dd1956f8ba4cb128 - } - off := v.Args[0].AuxInt - ptr := v.Args[0].Args[0] - mem := v.Args[1] - if !(StoreConst(sc).canAdd(off)) { - goto ende1cdf6d463f91ba4dd1956f8ba4cb128 - } - v.Op = OpAMD64MOVBstoreconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = StoreConst(sc).add(off) - v.Aux = s - v.AddArg(ptr) - v.AddArg(mem) - return true - } - goto ende1cdf6d463f91ba4dd1956f8ba4cb128 - ende1cdf6d463f91ba4dd1956f8ba4cb128: - ; - // match: (MOVBstoreconst [sc] {sym1} (LEAQ [off] {sym2} ptr) mem) - // cond: canMergeSym(sym1, sym2) && StoreConst(sc).canAdd(off) - // result: (MOVBstoreconst [StoreConst(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem) - { - sc := v.AuxInt - sym1 := v.Aux - if v.Args[0].Op != OpAMD64LEAQ { - goto end5feed29bca3ce7d5fccda89acf71c855 - } - off := v.Args[0].AuxInt - sym2 := v.Args[0].Aux - ptr := v.Args[0].Args[0] - mem := v.Args[1] - if !(canMergeSym(sym1, sym2) && StoreConst(sc).canAdd(off)) { - goto end5feed29bca3ce7d5fccda89acf71c855 - } - v.Op = OpAMD64MOVBstoreconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = StoreConst(sc).add(off) - v.Aux = mergeSym(sym1, sym2) - v.AddArg(ptr) - v.AddArg(mem) - return true - } - goto end5feed29bca3ce7d5fccda89acf71c855 - end5feed29bca3ce7d5fccda89acf71c855: - ; + return rewriteValueAMD64_OpAMD64MOVBstoreconst(v, config) case OpAMD64MOVLload: - // match: (MOVLload [off1] {sym} (ADDQconst [off2] ptr) mem) - // cond: - // result: (MOVLload [addOff(off1, off2)] {sym} ptr mem) - { - off1 := v.AuxInt - sym := v.Aux - if v.Args[0].Op != OpAMD64ADDQconst { - goto end0c8b8a40360c5c581d92723eca04d340 - } - off2 := v.Args[0].AuxInt - ptr := v.Args[0].Args[0] - mem := v.Args[1] - v.Op = OpAMD64MOVLload - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = addOff(off1, off2) - v.Aux = sym - v.AddArg(ptr) - v.AddArg(mem) - return true - } - goto end0c8b8a40360c5c581d92723eca04d340 - end0c8b8a40360c5c581d92723eca04d340: - ; - // match: (MOVLload [off1] {sym1} (LEAQ [off2] {sym2} base) mem) - // cond: canMergeSym(sym1, sym2) - // result: (MOVLload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem) - { - off1 := v.AuxInt - sym1 := v.Aux - if v.Args[0].Op != OpAMD64LEAQ { - goto enddb9e59335876d8a565c425731438a1b3 - } - off2 := v.Args[0].AuxInt - sym2 := v.Args[0].Aux - base := v.Args[0].Args[0] - mem := v.Args[1] - if !(canMergeSym(sym1, sym2)) { - goto enddb9e59335876d8a565c425731438a1b3 - } - v.Op = OpAMD64MOVLload - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = addOff(off1, off2) - v.Aux = mergeSym(sym1, sym2) - v.AddArg(base) - v.AddArg(mem) - return true - } - goto enddb9e59335876d8a565c425731438a1b3 - enddb9e59335876d8a565c425731438a1b3: - ; + return rewriteValueAMD64_OpAMD64MOVLload(v, config) case OpAMD64MOVLstore: - // match: (MOVLstore [off] {sym} ptr (MOVLQSX x) mem) - // cond: - // result: (MOVLstore [off] {sym} ptr x mem) - { - off := v.AuxInt - sym := v.Aux - ptr := v.Args[0] - if v.Args[1].Op != OpAMD64MOVLQSX { - goto end1fb7b2ae707c76d30927c21f85d77472 - } - x := v.Args[1].Args[0] - mem := v.Args[2] - v.Op = OpAMD64MOVLstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = off - v.Aux = sym - v.AddArg(ptr) - v.AddArg(x) - v.AddArg(mem) - return true - } - goto end1fb7b2ae707c76d30927c21f85d77472 - end1fb7b2ae707c76d30927c21f85d77472: - ; - // match: (MOVLstore [off] {sym} ptr (MOVLQZX x) mem) - // cond: - // result: (MOVLstore [off] {sym} ptr x mem) - { - off := v.AuxInt - sym := v.Aux - ptr := v.Args[0] - if v.Args[1].Op != OpAMD64MOVLQZX { - goto end199e8c23a5e7e99728a43d6a83b2c2cf - } - x := v.Args[1].Args[0] - mem := v.Args[2] - v.Op = OpAMD64MOVLstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = off - v.Aux = sym - v.AddArg(ptr) - v.AddArg(x) - v.AddArg(mem) - return true - } - goto end199e8c23a5e7e99728a43d6a83b2c2cf - end199e8c23a5e7e99728a43d6a83b2c2cf: - ; - // match: (MOVLstore [off1] {sym} (ADDQconst [off2] ptr) val mem) - // cond: - // result: (MOVLstore [addOff(off1, off2)] {sym} ptr val mem) - { - off1 := v.AuxInt - sym := v.Aux - if v.Args[0].Op != OpAMD64ADDQconst { - goto end43bffdb8d9c1fc85a95778d4911955f1 - } - off2 := v.Args[0].AuxInt - ptr := v.Args[0].Args[0] - val := v.Args[1] - mem := v.Args[2] - v.Op = OpAMD64MOVLstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = addOff(off1, off2) - v.Aux = sym - v.AddArg(ptr) - v.AddArg(val) - v.AddArg(mem) - return true - } - goto end43bffdb8d9c1fc85a95778d4911955f1 - end43bffdb8d9c1fc85a95778d4911955f1: - ; - // match: (MOVLstore [off] {sym} ptr (MOVLconst [c]) mem) - // cond: validStoreConstOff(off) - // result: (MOVLstoreconst [makeStoreConst(int64(int32(c)),off)] {sym} ptr mem) - { - off := v.AuxInt - sym := v.Aux - ptr := v.Args[0] - if v.Args[1].Op != OpAMD64MOVLconst { - goto end14bc0c027d67d279cf3ef2038b759ce2 - } - c := v.Args[1].AuxInt - mem := v.Args[2] - if !(validStoreConstOff(off)) { - goto end14bc0c027d67d279cf3ef2038b759ce2 - } - v.Op = OpAMD64MOVLstoreconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = makeStoreConst(int64(int32(c)), off) - v.Aux = sym - v.AddArg(ptr) - v.AddArg(mem) - return true - } - goto end14bc0c027d67d279cf3ef2038b759ce2 - end14bc0c027d67d279cf3ef2038b759ce2: - ; - // 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) - { - off1 := v.AuxInt - sym1 := v.Aux - if v.Args[0].Op != OpAMD64LEAQ { - goto endd57b1e4313fc7a3331340a9af00ba116 - } - 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)) { - goto endd57b1e4313fc7a3331340a9af00ba116 - } - v.Op = OpAMD64MOVLstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = addOff(off1, off2) - v.Aux = mergeSym(sym1, sym2) - v.AddArg(base) - v.AddArg(val) - v.AddArg(mem) - return true - } - goto endd57b1e4313fc7a3331340a9af00ba116 - endd57b1e4313fc7a3331340a9af00ba116: - ; + return rewriteValueAMD64_OpAMD64MOVLstore(v, config) case OpAMD64MOVLstoreconst: - // match: (MOVLstoreconst [sc] {s} (ADDQconst [off] ptr) mem) - // cond: StoreConst(sc).canAdd(off) - // result: (MOVLstoreconst [StoreConst(sc).add(off)] {s} ptr mem) - { - sc := v.AuxInt - s := v.Aux - if v.Args[0].Op != OpAMD64ADDQconst { - goto end7665f96d0aaa57009bf98632f19bf8e7 - } - off := v.Args[0].AuxInt - ptr := v.Args[0].Args[0] - mem := v.Args[1] - if !(StoreConst(sc).canAdd(off)) { - goto end7665f96d0aaa57009bf98632f19bf8e7 - } - v.Op = OpAMD64MOVLstoreconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = StoreConst(sc).add(off) - v.Aux = s - v.AddArg(ptr) - v.AddArg(mem) - return true - } - goto end7665f96d0aaa57009bf98632f19bf8e7 - end7665f96d0aaa57009bf98632f19bf8e7: - ; - // match: (MOVLstoreconst [sc] {sym1} (LEAQ [off] {sym2} ptr) mem) - // cond: canMergeSym(sym1, sym2) && StoreConst(sc).canAdd(off) - // result: (MOVLstoreconst [StoreConst(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem) - { - sc := v.AuxInt - sym1 := v.Aux - if v.Args[0].Op != OpAMD64LEAQ { - goto end1664c6056a9c65fcbe30eca273e8ee64 - } - off := v.Args[0].AuxInt - sym2 := v.Args[0].Aux - ptr := v.Args[0].Args[0] - mem := v.Args[1] - if !(canMergeSym(sym1, sym2) && StoreConst(sc).canAdd(off)) { - goto end1664c6056a9c65fcbe30eca273e8ee64 - } - v.Op = OpAMD64MOVLstoreconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = StoreConst(sc).add(off) - v.Aux = mergeSym(sym1, sym2) - v.AddArg(ptr) - v.AddArg(mem) - return true - } - goto end1664c6056a9c65fcbe30eca273e8ee64 - end1664c6056a9c65fcbe30eca273e8ee64: - ; + return rewriteValueAMD64_OpAMD64MOVLstoreconst(v, config) case OpAMD64MOVOload: - // match: (MOVOload [off1] {sym} (ADDQconst [off2] ptr) mem) - // cond: - // result: (MOVOload [addOff(off1, off2)] {sym} ptr mem) - { - off1 := v.AuxInt - sym := v.Aux - if v.Args[0].Op != OpAMD64ADDQconst { - goto endf1e8fcf569ddd8b3f7a2f61696971913 - } - off2 := v.Args[0].AuxInt - ptr := v.Args[0].Args[0] - mem := v.Args[1] - v.Op = OpAMD64MOVOload - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = addOff(off1, off2) - v.Aux = sym - v.AddArg(ptr) - v.AddArg(mem) - return true - } - goto endf1e8fcf569ddd8b3f7a2f61696971913 - endf1e8fcf569ddd8b3f7a2f61696971913: - ; - // match: (MOVOload [off1] {sym1} (LEAQ [off2] {sym2} base) mem) - // cond: canMergeSym(sym1, sym2) - // result: (MOVOload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem) - { - off1 := v.AuxInt - sym1 := v.Aux - if v.Args[0].Op != OpAMD64LEAQ { - goto endd36cf9b00af7a8f44fb8c60067a8efb2 - } - off2 := v.Args[0].AuxInt - sym2 := v.Args[0].Aux - base := v.Args[0].Args[0] - mem := v.Args[1] - if !(canMergeSym(sym1, sym2)) { - goto endd36cf9b00af7a8f44fb8c60067a8efb2 - } - v.Op = OpAMD64MOVOload - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = addOff(off1, off2) - v.Aux = mergeSym(sym1, sym2) - v.AddArg(base) - v.AddArg(mem) - return true - } - goto endd36cf9b00af7a8f44fb8c60067a8efb2 - endd36cf9b00af7a8f44fb8c60067a8efb2: - ; + return rewriteValueAMD64_OpAMD64MOVOload(v, config) case OpAMD64MOVOstore: - // match: (MOVOstore [off1] {sym} (ADDQconst [off2] ptr) val mem) - // cond: - // result: (MOVOstore [addOff(off1, off2)] {sym} ptr val mem) - { - off1 := v.AuxInt - sym := v.Aux - if v.Args[0].Op != OpAMD64ADDQconst { - goto end2be573aa1bd919e567e6156a4ee36517 - } - off2 := v.Args[0].AuxInt - ptr := v.Args[0].Args[0] - val := v.Args[1] - mem := v.Args[2] - v.Op = OpAMD64MOVOstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = addOff(off1, off2) - v.Aux = sym - v.AddArg(ptr) - v.AddArg(val) - v.AddArg(mem) - return true - } - goto end2be573aa1bd919e567e6156a4ee36517 - end2be573aa1bd919e567e6156a4ee36517: - ; - // 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) - { - off1 := v.AuxInt - sym1 := v.Aux - if v.Args[0].Op != OpAMD64LEAQ { - goto endc28b9b3efe9eb235e1586c4555280c20 - } - 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)) { - goto endc28b9b3efe9eb235e1586c4555280c20 - } - v.Op = OpAMD64MOVOstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = addOff(off1, off2) - v.Aux = mergeSym(sym1, sym2) - v.AddArg(base) - v.AddArg(val) - v.AddArg(mem) - return true - } - goto endc28b9b3efe9eb235e1586c4555280c20 - endc28b9b3efe9eb235e1586c4555280c20: - ; + return rewriteValueAMD64_OpAMD64MOVOstore(v, config) case OpAMD64MOVQload: - // match: (MOVQload [off1] {sym} (ADDQconst [off2] ptr) mem) - // cond: - // result: (MOVQload [addOff(off1, off2)] {sym} ptr mem) - { - off1 := v.AuxInt - sym := v.Aux - if v.Args[0].Op != OpAMD64ADDQconst { - goto end0b8c50dd7faefb7d046f9a27e054df77 - } - off2 := v.Args[0].AuxInt - ptr := v.Args[0].Args[0] - mem := v.Args[1] - v.Op = OpAMD64MOVQload - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = addOff(off1, off2) - v.Aux = sym - v.AddArg(ptr) - v.AddArg(mem) - return true - } - goto end0b8c50dd7faefb7d046f9a27e054df77 - end0b8c50dd7faefb7d046f9a27e054df77: - ; - // match: (MOVQload [off1] {sym1} (LEAQ [off2] {sym2} base) mem) - // cond: canMergeSym(sym1, sym2) - // result: (MOVQload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem) - { - off1 := v.AuxInt - sym1 := v.Aux - if v.Args[0].Op != OpAMD64LEAQ { - goto endd0c093adc4f05f2037005734c77d3cc4 - } - off2 := v.Args[0].AuxInt - sym2 := v.Args[0].Aux - base := v.Args[0].Args[0] - mem := v.Args[1] - if !(canMergeSym(sym1, sym2)) { - goto endd0c093adc4f05f2037005734c77d3cc4 - } - v.Op = OpAMD64MOVQload - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = addOff(off1, off2) - v.Aux = mergeSym(sym1, sym2) - v.AddArg(base) - v.AddArg(mem) - return true - } - goto endd0c093adc4f05f2037005734c77d3cc4 - endd0c093adc4f05f2037005734c77d3cc4: - ; - // 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) - { - off1 := v.AuxInt - sym1 := v.Aux - if v.Args[0].Op != OpAMD64LEAQ8 { - goto end74a50d810fb3945e809f608cd094a59c - } - 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)) { - goto end74a50d810fb3945e809f608cd094a59c - } - v.Op = OpAMD64MOVQloadidx8 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = addOff(off1, off2) - v.Aux = mergeSym(sym1, sym2) - v.AddArg(ptr) - v.AddArg(idx) - v.AddArg(mem) - return true - } - goto end74a50d810fb3945e809f608cd094a59c - end74a50d810fb3945e809f608cd094a59c: - ; + return rewriteValueAMD64_OpAMD64MOVQload(v, config) case OpAMD64MOVQloadidx8: - // match: (MOVQloadidx8 [off1] {sym} (ADDQconst [off2] ptr) idx mem) - // cond: - // result: (MOVQloadidx8 [addOff(off1, off2)] {sym} ptr idx mem) - { - off1 := v.AuxInt - sym := v.Aux - if v.Args[0].Op != OpAMD64ADDQconst { - goto endb138bf9b0b33ec824bf0aff619f8bafa - } - off2 := v.Args[0].AuxInt - ptr := v.Args[0].Args[0] - idx := v.Args[1] - mem := v.Args[2] - v.Op = OpAMD64MOVQloadidx8 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = addOff(off1, off2) - v.Aux = sym - v.AddArg(ptr) - v.AddArg(idx) - v.AddArg(mem) - return true - } - goto endb138bf9b0b33ec824bf0aff619f8bafa - endb138bf9b0b33ec824bf0aff619f8bafa: - ; + return rewriteValueAMD64_OpAMD64MOVQloadidx8(v, config) case OpAMD64MOVQstore: - // match: (MOVQstore [off1] {sym} (ADDQconst [off2] ptr) val mem) - // cond: - // result: (MOVQstore [addOff(off1, off2)] {sym} ptr val mem) - { - off1 := v.AuxInt - sym := v.Aux - if v.Args[0].Op != OpAMD64ADDQconst { - goto end0a110b5e42a4576c32fda50590092848 - } - off2 := v.Args[0].AuxInt - ptr := v.Args[0].Args[0] - val := v.Args[1] - mem := v.Args[2] - v.Op = OpAMD64MOVQstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = addOff(off1, off2) - v.Aux = sym - v.AddArg(ptr) - v.AddArg(val) - v.AddArg(mem) - return true - } - goto end0a110b5e42a4576c32fda50590092848 - end0a110b5e42a4576c32fda50590092848: - ; - // match: (MOVQstore [off] {sym} ptr (MOVQconst [c]) mem) - // cond: validStoreConst(c,off) - // result: (MOVQstoreconst [makeStoreConst(c,off)] {sym} ptr mem) - { - off := v.AuxInt - sym := v.Aux - ptr := v.Args[0] - if v.Args[1].Op != OpAMD64MOVQconst { - goto end8368f37d24b6a2f59c3d00966c4d4111 - } - c := v.Args[1].AuxInt - mem := v.Args[2] - if !(validStoreConst(c, off)) { - goto end8368f37d24b6a2f59c3d00966c4d4111 - } - v.Op = OpAMD64MOVQstoreconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = makeStoreConst(c, off) - v.Aux = sym - v.AddArg(ptr) - v.AddArg(mem) - return true - } - goto end8368f37d24b6a2f59c3d00966c4d4111 - end8368f37d24b6a2f59c3d00966c4d4111: - ; - // 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) - { - off1 := v.AuxInt - sym1 := v.Aux - if v.Args[0].Op != OpAMD64LEAQ { - goto end9a0cfe20b3b0f587e252760907c1b5c0 - } - 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)) { - goto end9a0cfe20b3b0f587e252760907c1b5c0 - } - v.Op = OpAMD64MOVQstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = addOff(off1, off2) - v.Aux = mergeSym(sym1, sym2) - v.AddArg(base) - v.AddArg(val) - v.AddArg(mem) - return true - } - goto end9a0cfe20b3b0f587e252760907c1b5c0 - end9a0cfe20b3b0f587e252760907c1b5c0: - ; - // 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) - { - off1 := v.AuxInt - sym1 := v.Aux - if v.Args[0].Op != OpAMD64LEAQ8 { - goto end442c322e6719e280b6be1c12858e49d7 - } - 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)) { - goto end442c322e6719e280b6be1c12858e49d7 - } - v.Op = OpAMD64MOVQstoreidx8 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = addOff(off1, off2) - v.Aux = mergeSym(sym1, sym2) - v.AddArg(ptr) - v.AddArg(idx) - v.AddArg(val) - v.AddArg(mem) - return true - } - goto end442c322e6719e280b6be1c12858e49d7 - end442c322e6719e280b6be1c12858e49d7: - ; + return rewriteValueAMD64_OpAMD64MOVQstore(v, config) case OpAMD64MOVQstoreconst: - // match: (MOVQstoreconst [sc] {s} (ADDQconst [off] ptr) mem) - // cond: StoreConst(sc).canAdd(off) - // result: (MOVQstoreconst [StoreConst(sc).add(off)] {s} ptr mem) - { - sc := v.AuxInt - s := v.Aux - if v.Args[0].Op != OpAMD64ADDQconst { - goto end5826e30265c68ea8c4cd595ceedf9405 - } - off := v.Args[0].AuxInt - ptr := v.Args[0].Args[0] - mem := v.Args[1] - if !(StoreConst(sc).canAdd(off)) { - goto end5826e30265c68ea8c4cd595ceedf9405 - } - v.Op = OpAMD64MOVQstoreconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = StoreConst(sc).add(off) - v.Aux = s - v.AddArg(ptr) - v.AddArg(mem) - return true - } - goto end5826e30265c68ea8c4cd595ceedf9405 - end5826e30265c68ea8c4cd595ceedf9405: - ; - // match: (MOVQstoreconst [sc] {sym1} (LEAQ [off] {sym2} ptr) mem) - // cond: canMergeSym(sym1, sym2) && StoreConst(sc).canAdd(off) - // result: (MOVQstoreconst [StoreConst(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem) - { - sc := v.AuxInt - sym1 := v.Aux - if v.Args[0].Op != OpAMD64LEAQ { - goto endb9c7f7a9dbc6b885d84f851c74b018e5 - } - off := v.Args[0].AuxInt - sym2 := v.Args[0].Aux - ptr := v.Args[0].Args[0] - mem := v.Args[1] - if !(canMergeSym(sym1, sym2) && StoreConst(sc).canAdd(off)) { - goto endb9c7f7a9dbc6b885d84f851c74b018e5 - } - v.Op = OpAMD64MOVQstoreconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = StoreConst(sc).add(off) - v.Aux = mergeSym(sym1, sym2) - v.AddArg(ptr) - v.AddArg(mem) - return true - } - goto endb9c7f7a9dbc6b885d84f851c74b018e5 - endb9c7f7a9dbc6b885d84f851c74b018e5: - ; + return rewriteValueAMD64_OpAMD64MOVQstoreconst(v, config) case OpAMD64MOVQstoreidx8: - // match: (MOVQstoreidx8 [off1] {sym} (ADDQconst [off2] ptr) idx val mem) - // cond: - // result: (MOVQstoreidx8 [addOff(off1, off2)] {sym} ptr idx val mem) - { - off1 := v.AuxInt - sym := v.Aux - if v.Args[0].Op != OpAMD64ADDQconst { - goto end50671766fdab364c1edbd2072fb8e525 - } - off2 := v.Args[0].AuxInt - ptr := v.Args[0].Args[0] - idx := v.Args[1] - val := v.Args[2] - mem := v.Args[3] - v.Op = OpAMD64MOVQstoreidx8 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = addOff(off1, off2) - v.Aux = sym - v.AddArg(ptr) - v.AddArg(idx) - v.AddArg(val) - v.AddArg(mem) - return true - } - goto end50671766fdab364c1edbd2072fb8e525 - end50671766fdab364c1edbd2072fb8e525: - ; + return rewriteValueAMD64_OpAMD64MOVQstoreidx8(v, config) case OpAMD64MOVSDload: - // match: (MOVSDload [off1] {sym} (ADDQconst [off2] ptr) mem) - // cond: - // result: (MOVSDload [addOff(off1, off2)] {sym} ptr mem) - { - off1 := v.AuxInt - sym := v.Aux - if v.Args[0].Op != OpAMD64ADDQconst { - goto end6dad9bf78e7368bb095eb2dfba7e244a - } - off2 := v.Args[0].AuxInt - ptr := v.Args[0].Args[0] - mem := v.Args[1] - v.Op = OpAMD64MOVSDload - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = addOff(off1, off2) - v.Aux = sym - v.AddArg(ptr) - v.AddArg(mem) - return true - } - goto end6dad9bf78e7368bb095eb2dfba7e244a - end6dad9bf78e7368bb095eb2dfba7e244a: - ; - // match: (MOVSDload [off1] {sym1} (LEAQ [off2] {sym2} base) mem) - // cond: canMergeSym(sym1, sym2) - // result: (MOVSDload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem) - { - off1 := v.AuxInt - sym1 := v.Aux - if v.Args[0].Op != OpAMD64LEAQ { - goto end96fa9c439e31050aa91582bc2a9f2c20 - } - off2 := v.Args[0].AuxInt - sym2 := v.Args[0].Aux - base := v.Args[0].Args[0] - mem := v.Args[1] - if !(canMergeSym(sym1, sym2)) { - goto end96fa9c439e31050aa91582bc2a9f2c20 - } - v.Op = OpAMD64MOVSDload - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = addOff(off1, off2) - v.Aux = mergeSym(sym1, sym2) - v.AddArg(base) - v.AddArg(mem) - return true - } - goto end96fa9c439e31050aa91582bc2a9f2c20 - end96fa9c439e31050aa91582bc2a9f2c20: - ; - // 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) - { - off1 := v.AuxInt - sym1 := v.Aux - if v.Args[0].Op != OpAMD64LEAQ8 { - goto endbcb2ce441824d0e3a4b501018cfa7f60 - } - 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)) { - goto endbcb2ce441824d0e3a4b501018cfa7f60 - } - v.Op = OpAMD64MOVSDloadidx8 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = addOff(off1, off2) - v.Aux = mergeSym(sym1, sym2) - v.AddArg(ptr) - v.AddArg(idx) - v.AddArg(mem) - return true - } - goto endbcb2ce441824d0e3a4b501018cfa7f60 - endbcb2ce441824d0e3a4b501018cfa7f60: - ; + return rewriteValueAMD64_OpAMD64MOVSDload(v, config) case OpAMD64MOVSDloadidx8: - // match: (MOVSDloadidx8 [off1] {sym} (ADDQconst [off2] {sym} ptr) idx mem) - // cond: - // result: (MOVSDloadidx8 [addOff(off1, off2)] {sym} ptr idx mem) - { - off1 := v.AuxInt - sym := v.Aux - if v.Args[0].Op != OpAMD64ADDQconst { - goto end84f0f457e271104a92343e3b1d2804c6 - } - off2 := v.Args[0].AuxInt - if v.Args[0].Aux != v.Aux { - goto end84f0f457e271104a92343e3b1d2804c6 - } - ptr := v.Args[0].Args[0] - idx := v.Args[1] - mem := v.Args[2] - v.Op = OpAMD64MOVSDloadidx8 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = addOff(off1, off2) - v.Aux = sym - v.AddArg(ptr) - v.AddArg(idx) - v.AddArg(mem) - return true - } - goto end84f0f457e271104a92343e3b1d2804c6 - end84f0f457e271104a92343e3b1d2804c6: - ; + return rewriteValueAMD64_OpAMD64MOVSDloadidx8(v, config) case OpAMD64MOVSDstore: - // match: (MOVSDstore [off1] {sym} (ADDQconst [off2] ptr) val mem) - // cond: - // result: (MOVSDstore [addOff(off1, off2)] {sym} ptr val mem) - { - off1 := v.AuxInt - sym := v.Aux - if v.Args[0].Op != OpAMD64ADDQconst { - goto end6c6160664143cc66e63e67b9aa43a7ef - } - off2 := v.Args[0].AuxInt - ptr := v.Args[0].Args[0] - val := v.Args[1] - mem := v.Args[2] - v.Op = OpAMD64MOVSDstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = addOff(off1, off2) - v.Aux = sym - v.AddArg(ptr) - v.AddArg(val) - v.AddArg(mem) - return true - } - goto end6c6160664143cc66e63e67b9aa43a7ef - end6c6160664143cc66e63e67b9aa43a7ef: - ; - // 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) - { - off1 := v.AuxInt - sym1 := v.Aux - if v.Args[0].Op != OpAMD64LEAQ { - goto end415dde14f3400bec1b2756174a5d7179 - } - 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)) { - goto end415dde14f3400bec1b2756174a5d7179 - } - v.Op = OpAMD64MOVSDstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = addOff(off1, off2) - v.Aux = mergeSym(sym1, sym2) - v.AddArg(base) - v.AddArg(val) - v.AddArg(mem) - return true - } - goto end415dde14f3400bec1b2756174a5d7179 - end415dde14f3400bec1b2756174a5d7179: - ; - // 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) - { - off1 := v.AuxInt - sym1 := v.Aux - if v.Args[0].Op != OpAMD64LEAQ8 { - goto end1ad6fc0c5b59610dabf7f9595a48a230 - } - 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)) { - goto end1ad6fc0c5b59610dabf7f9595a48a230 - } - v.Op = OpAMD64MOVSDstoreidx8 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = addOff(off1, off2) - v.Aux = mergeSym(sym1, sym2) - v.AddArg(ptr) - v.AddArg(idx) - v.AddArg(val) - v.AddArg(mem) - return true - } - goto end1ad6fc0c5b59610dabf7f9595a48a230 - end1ad6fc0c5b59610dabf7f9595a48a230: - ; + return rewriteValueAMD64_OpAMD64MOVSDstore(v, config) case OpAMD64MOVSDstoreidx8: - // match: (MOVSDstoreidx8 [off1] {sym} (ADDQconst [off2] {sym} ptr) idx val mem) - // cond: - // result: (MOVSDstoreidx8 [addOff(off1, off2)] {sym} ptr idx val mem) - { - off1 := v.AuxInt - sym := v.Aux - if v.Args[0].Op != OpAMD64ADDQconst { - goto endc0e28f57697cb6038d5d09eafe26c947 - } - off2 := v.Args[0].AuxInt - if v.Args[0].Aux != v.Aux { - goto endc0e28f57697cb6038d5d09eafe26c947 - } - ptr := v.Args[0].Args[0] - idx := v.Args[1] - val := v.Args[2] - mem := v.Args[3] - v.Op = OpAMD64MOVSDstoreidx8 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = addOff(off1, off2) - v.Aux = sym - v.AddArg(ptr) - v.AddArg(idx) - v.AddArg(val) - v.AddArg(mem) - return true - } - goto endc0e28f57697cb6038d5d09eafe26c947 - endc0e28f57697cb6038d5d09eafe26c947: - ; + return rewriteValueAMD64_OpAMD64MOVSDstoreidx8(v, config) case OpAMD64MOVSSload: - // match: (MOVSSload [off1] {sym} (ADDQconst [off2] ptr) mem) - // cond: - // result: (MOVSSload [addOff(off1, off2)] {sym} ptr mem) - { - off1 := v.AuxInt - sym := v.Aux - if v.Args[0].Op != OpAMD64ADDQconst { - goto end96d63dbb64b0adfa944684c9e939c972 - } - off2 := v.Args[0].AuxInt - ptr := v.Args[0].Args[0] - mem := v.Args[1] - v.Op = OpAMD64MOVSSload - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = addOff(off1, off2) - v.Aux = sym - v.AddArg(ptr) - v.AddArg(mem) - return true - } - goto end96d63dbb64b0adfa944684c9e939c972 - end96d63dbb64b0adfa944684c9e939c972: - ; - // match: (MOVSSload [off1] {sym1} (LEAQ [off2] {sym2} base) mem) - // cond: canMergeSym(sym1, sym2) - // result: (MOVSSload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem) - { - off1 := v.AuxInt - sym1 := v.Aux - if v.Args[0].Op != OpAMD64LEAQ { - goto end15f2583bd72ad7fc077b3952634a1c85 - } - off2 := v.Args[0].AuxInt - sym2 := v.Args[0].Aux - base := v.Args[0].Args[0] - mem := v.Args[1] - if !(canMergeSym(sym1, sym2)) { - goto end15f2583bd72ad7fc077b3952634a1c85 - } - v.Op = OpAMD64MOVSSload - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = addOff(off1, off2) - v.Aux = mergeSym(sym1, sym2) - v.AddArg(base) - v.AddArg(mem) - return true - } - goto end15f2583bd72ad7fc077b3952634a1c85 - end15f2583bd72ad7fc077b3952634a1c85: - ; - // 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) - { - off1 := v.AuxInt - sym1 := v.Aux - if v.Args[0].Op != OpAMD64LEAQ4 { - goto end49722f4a0adba31bb143601ce1d2aae0 - } - 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)) { - goto end49722f4a0adba31bb143601ce1d2aae0 - } - v.Op = OpAMD64MOVSSloadidx4 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = addOff(off1, off2) - v.Aux = mergeSym(sym1, sym2) - v.AddArg(ptr) - v.AddArg(idx) - v.AddArg(mem) - return true - } - goto end49722f4a0adba31bb143601ce1d2aae0 - end49722f4a0adba31bb143601ce1d2aae0: - ; + return rewriteValueAMD64_OpAMD64MOVSSload(v, config) case OpAMD64MOVSSloadidx4: - // match: (MOVSSloadidx4 [off1] {sym} (ADDQconst [off2] {sym} ptr) idx mem) - // cond: - // result: (MOVSSloadidx4 [addOff(off1, off2)] {sym} ptr idx mem) - { - off1 := v.AuxInt - sym := v.Aux - if v.Args[0].Op != OpAMD64ADDQconst { - goto end7eb5a1ab1e2508683d879ec25286754b - } - off2 := v.Args[0].AuxInt - if v.Args[0].Aux != v.Aux { - goto end7eb5a1ab1e2508683d879ec25286754b - } - ptr := v.Args[0].Args[0] - idx := v.Args[1] - mem := v.Args[2] - v.Op = OpAMD64MOVSSloadidx4 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = addOff(off1, off2) - v.Aux = sym - v.AddArg(ptr) - v.AddArg(idx) - v.AddArg(mem) - return true - } - goto end7eb5a1ab1e2508683d879ec25286754b - end7eb5a1ab1e2508683d879ec25286754b: - ; + return rewriteValueAMD64_OpAMD64MOVSSloadidx4(v, config) case OpAMD64MOVSSstore: - // match: (MOVSSstore [off1] {sym} (ADDQconst [off2] ptr) val mem) - // cond: - // result: (MOVSSstore [addOff(off1, off2)] {sym} ptr val mem) - { - off1 := v.AuxInt - sym := v.Aux - if v.Args[0].Op != OpAMD64ADDQconst { - goto endf711aa4081a9b2924b55387d4f70cfd6 - } - off2 := v.Args[0].AuxInt - ptr := v.Args[0].Args[0] - val := v.Args[1] - mem := v.Args[2] - v.Op = OpAMD64MOVSSstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = addOff(off1, off2) - v.Aux = sym - v.AddArg(ptr) - v.AddArg(val) - v.AddArg(mem) - return true - } - goto endf711aa4081a9b2924b55387d4f70cfd6 - endf711aa4081a9b2924b55387d4f70cfd6: - ; - // 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) - { - off1 := v.AuxInt - sym1 := v.Aux - if v.Args[0].Op != OpAMD64LEAQ { - goto end70ebc170131920e515e3f416a6b952c5 - } - 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)) { - goto end70ebc170131920e515e3f416a6b952c5 - } - v.Op = OpAMD64MOVSSstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = addOff(off1, off2) - v.Aux = mergeSym(sym1, sym2) - v.AddArg(base) - v.AddArg(val) - v.AddArg(mem) - return true - } - goto end70ebc170131920e515e3f416a6b952c5 - end70ebc170131920e515e3f416a6b952c5: - ; - // 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) - { - off1 := v.AuxInt - sym1 := v.Aux - if v.Args[0].Op != OpAMD64LEAQ4 { - goto end1622dc435e45833eda4d29d44df7cc34 - } - 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)) { - goto end1622dc435e45833eda4d29d44df7cc34 - } - v.Op = OpAMD64MOVSSstoreidx4 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = addOff(off1, off2) - v.Aux = mergeSym(sym1, sym2) - v.AddArg(ptr) - v.AddArg(idx) - v.AddArg(val) - v.AddArg(mem) - return true - } - goto end1622dc435e45833eda4d29d44df7cc34 - end1622dc435e45833eda4d29d44df7cc34: - ; + return rewriteValueAMD64_OpAMD64MOVSSstore(v, config) case OpAMD64MOVSSstoreidx4: - // match: (MOVSSstoreidx4 [off1] {sym} (ADDQconst [off2] {sym} ptr) idx val mem) - // cond: - // result: (MOVSSstoreidx4 [addOff(off1, off2)] {sym} ptr idx val mem) - { - off1 := v.AuxInt - sym := v.Aux - if v.Args[0].Op != OpAMD64ADDQconst { - goto end66e4853026306cd46f414c22d281254f - } - off2 := v.Args[0].AuxInt - if v.Args[0].Aux != v.Aux { - goto end66e4853026306cd46f414c22d281254f - } - ptr := v.Args[0].Args[0] - idx := v.Args[1] - val := v.Args[2] - mem := v.Args[3] - v.Op = OpAMD64MOVSSstoreidx4 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = addOff(off1, off2) - v.Aux = sym - v.AddArg(ptr) - v.AddArg(idx) - v.AddArg(val) - v.AddArg(mem) - return true - } - goto end66e4853026306cd46f414c22d281254f - end66e4853026306cd46f414c22d281254f: - ; + return rewriteValueAMD64_OpAMD64MOVSSstoreidx4(v, config) case OpAMD64MOVWload: - // match: (MOVWload [off1] {sym} (ADDQconst [off2] ptr) mem) - // cond: - // result: (MOVWload [addOff(off1, off2)] {sym} ptr mem) - { - off1 := v.AuxInt - sym := v.Aux - if v.Args[0].Op != OpAMD64ADDQconst { - goto endfcb0ce76f96e8b0c2eb19a9b827c1b73 - } - off2 := v.Args[0].AuxInt - ptr := v.Args[0].Args[0] - mem := v.Args[1] - v.Op = OpAMD64MOVWload - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = addOff(off1, off2) - v.Aux = sym - v.AddArg(ptr) - v.AddArg(mem) - return true - } - goto endfcb0ce76f96e8b0c2eb19a9b827c1b73 - endfcb0ce76f96e8b0c2eb19a9b827c1b73: - ; - // match: (MOVWload [off1] {sym1} (LEAQ [off2] {sym2} base) mem) - // cond: canMergeSym(sym1, sym2) - // result: (MOVWload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem) - { - off1 := v.AuxInt - sym1 := v.Aux - if v.Args[0].Op != OpAMD64LEAQ { - goto end7a79314cb49bf53d79c38c3077d87457 - } - off2 := v.Args[0].AuxInt - sym2 := v.Args[0].Aux - base := v.Args[0].Args[0] - mem := v.Args[1] - if !(canMergeSym(sym1, sym2)) { - goto end7a79314cb49bf53d79c38c3077d87457 - } - v.Op = OpAMD64MOVWload - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = addOff(off1, off2) - v.Aux = mergeSym(sym1, sym2) - v.AddArg(base) - v.AddArg(mem) - return true - } - goto end7a79314cb49bf53d79c38c3077d87457 - end7a79314cb49bf53d79c38c3077d87457: - ; + return rewriteValueAMD64_OpAMD64MOVWload(v, config) case OpAMD64MOVWstore: - // match: (MOVWstore [off] {sym} ptr (MOVWQSX x) mem) - // cond: - // result: (MOVWstore [off] {sym} ptr x mem) - { - off := v.AuxInt - sym := v.Aux - ptr := v.Args[0] - if v.Args[1].Op != OpAMD64MOVWQSX { - goto endca90c534e75c7f5cb803504d119a853f - } - x := v.Args[1].Args[0] - mem := v.Args[2] - v.Op = OpAMD64MOVWstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = off - v.Aux = sym - v.AddArg(ptr) - v.AddArg(x) - v.AddArg(mem) - return true - } - goto endca90c534e75c7f5cb803504d119a853f - endca90c534e75c7f5cb803504d119a853f: - ; - // match: (MOVWstore [off] {sym} ptr (MOVWQZX x) mem) - // cond: - // result: (MOVWstore [off] {sym} ptr x mem) - { - off := v.AuxInt - sym := v.Aux - ptr := v.Args[0] - if v.Args[1].Op != OpAMD64MOVWQZX { - goto end187fe73dfaf9cf5f4c349283b4dfd9d1 - } - x := v.Args[1].Args[0] - mem := v.Args[2] - v.Op = OpAMD64MOVWstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = off - v.Aux = sym - v.AddArg(ptr) - v.AddArg(x) - v.AddArg(mem) - return true - } - goto end187fe73dfaf9cf5f4c349283b4dfd9d1 - end187fe73dfaf9cf5f4c349283b4dfd9d1: - ; - // match: (MOVWstore [off1] {sym} (ADDQconst [off2] ptr) val mem) - // cond: - // result: (MOVWstore [addOff(off1, off2)] {sym} ptr val mem) - { - off1 := v.AuxInt - sym := v.Aux - if v.Args[0].Op != OpAMD64ADDQconst { - goto endda15fdd59aa956ded0440188f38de1aa - } - off2 := v.Args[0].AuxInt - ptr := v.Args[0].Args[0] - val := v.Args[1] - mem := v.Args[2] - v.Op = OpAMD64MOVWstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = addOff(off1, off2) - v.Aux = sym - v.AddArg(ptr) - v.AddArg(val) - v.AddArg(mem) - return true - } - goto endda15fdd59aa956ded0440188f38de1aa - endda15fdd59aa956ded0440188f38de1aa: - ; - // match: (MOVWstore [off] {sym} ptr (MOVWconst [c]) mem) - // cond: validStoreConstOff(off) - // result: (MOVWstoreconst [makeStoreConst(int64(int16(c)),off)] {sym} ptr mem) - { - off := v.AuxInt - sym := v.Aux - ptr := v.Args[0] - if v.Args[1].Op != OpAMD64MOVWconst { - goto end226f449215b8ea54ac24fb8d52356ffa - } - c := v.Args[1].AuxInt - mem := v.Args[2] - if !(validStoreConstOff(off)) { - goto end226f449215b8ea54ac24fb8d52356ffa - } - v.Op = OpAMD64MOVWstoreconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = makeStoreConst(int64(int16(c)), off) - v.Aux = sym - v.AddArg(ptr) - v.AddArg(mem) - return true - } - goto end226f449215b8ea54ac24fb8d52356ffa - end226f449215b8ea54ac24fb8d52356ffa: - ; - // 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) - { - off1 := v.AuxInt - sym1 := v.Aux - if v.Args[0].Op != OpAMD64LEAQ { - goto end4cc466ede8e64e415c899ccac81c0f27 - } - 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)) { - goto end4cc466ede8e64e415c899ccac81c0f27 - } - v.Op = OpAMD64MOVWstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = addOff(off1, off2) - v.Aux = mergeSym(sym1, sym2) - v.AddArg(base) - v.AddArg(val) - v.AddArg(mem) - return true - } - goto end4cc466ede8e64e415c899ccac81c0f27 - end4cc466ede8e64e415c899ccac81c0f27: - ; + return rewriteValueAMD64_OpAMD64MOVWstore(v, config) case OpAMD64MOVWstoreconst: - // match: (MOVWstoreconst [sc] {s} (ADDQconst [off] ptr) mem) - // cond: StoreConst(sc).canAdd(off) - // result: (MOVWstoreconst [StoreConst(sc).add(off)] {s} ptr mem) - { - sc := v.AuxInt - s := v.Aux - if v.Args[0].Op != OpAMD64ADDQconst { - goto end2b764f9cf1bb32af25ba4e70a6705b91 - } - off := v.Args[0].AuxInt - ptr := v.Args[0].Args[0] - mem := v.Args[1] - if !(StoreConst(sc).canAdd(off)) { - goto end2b764f9cf1bb32af25ba4e70a6705b91 - } - v.Op = OpAMD64MOVWstoreconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = StoreConst(sc).add(off) - v.Aux = s - v.AddArg(ptr) - v.AddArg(mem) - return true - } - goto end2b764f9cf1bb32af25ba4e70a6705b91 - end2b764f9cf1bb32af25ba4e70a6705b91: - ; - // match: (MOVWstoreconst [sc] {sym1} (LEAQ [off] {sym2} ptr) mem) - // cond: canMergeSym(sym1, sym2) && StoreConst(sc).canAdd(off) - // result: (MOVWstoreconst [StoreConst(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem) - { - sc := v.AuxInt - sym1 := v.Aux - if v.Args[0].Op != OpAMD64LEAQ { - goto enda15bfd8d540015b2245c65be486d2ffd - } - off := v.Args[0].AuxInt - sym2 := v.Args[0].Aux - ptr := v.Args[0].Args[0] - mem := v.Args[1] - if !(canMergeSym(sym1, sym2) && StoreConst(sc).canAdd(off)) { - goto enda15bfd8d540015b2245c65be486d2ffd - } - v.Op = OpAMD64MOVWstoreconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = StoreConst(sc).add(off) - v.Aux = mergeSym(sym1, sym2) - v.AddArg(ptr) - v.AddArg(mem) - return true - } - goto enda15bfd8d540015b2245c65be486d2ffd - enda15bfd8d540015b2245c65be486d2ffd: - ; + return rewriteValueAMD64_OpAMD64MOVWstoreconst(v, config) case OpAMD64MULB: - // match: (MULB x (MOVBconst [c])) - // cond: - // result: (MULBconst [c] x) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64MOVBconst { - goto end66c6419213ddeb52b1c53fb589a70e5f - } - c := v.Args[1].AuxInt - v.Op = OpAMD64MULBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c - v.AddArg(x) - return true - } - goto end66c6419213ddeb52b1c53fb589a70e5f - end66c6419213ddeb52b1c53fb589a70e5f: - ; - // match: (MULB (MOVBconst [c]) x) - // cond: - // result: (MULBconst [c] x) - { - if v.Args[0].Op != OpAMD64MOVBconst { - goto end7e82c8dbbba265b78035ca7df394bb06 - } - c := v.Args[0].AuxInt - x := v.Args[1] - v.Op = OpAMD64MULBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c - v.AddArg(x) - return true - } - goto end7e82c8dbbba265b78035ca7df394bb06 - end7e82c8dbbba265b78035ca7df394bb06: - ; + return rewriteValueAMD64_OpAMD64MULB(v, config) case OpAMD64MULBconst: - // match: (MULBconst [c] (MOVBconst [d])) - // cond: - // result: (MOVBconst [c*d]) - { - c := v.AuxInt - if v.Args[0].Op != OpAMD64MOVBconst { - goto endf2db9f96016085f8cb4082b4af01b2aa - } - d := v.Args[0].AuxInt - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c * d - return true - } - goto endf2db9f96016085f8cb4082b4af01b2aa - endf2db9f96016085f8cb4082b4af01b2aa: - ; + return rewriteValueAMD64_OpAMD64MULBconst(v, config) case OpAMD64MULL: - // match: (MULL x (MOVLconst [c])) - // cond: - // result: (MULLconst [c] x) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64MOVLconst { - goto end893477a261bcad6c2821b77c83075c6c - } - c := v.Args[1].AuxInt - v.Op = OpAMD64MULLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c - v.AddArg(x) - return true - } - goto end893477a261bcad6c2821b77c83075c6c - end893477a261bcad6c2821b77c83075c6c: - ; - // match: (MULL (MOVLconst [c]) x) - // cond: - // result: (MULLconst [c] x) - { - if v.Args[0].Op != OpAMD64MOVLconst { - goto end8a0f957c528a54eecb0dbfc5d96e017a - } - c := v.Args[0].AuxInt - x := v.Args[1] - v.Op = OpAMD64MULLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c - v.AddArg(x) - return true - } - goto end8a0f957c528a54eecb0dbfc5d96e017a - end8a0f957c528a54eecb0dbfc5d96e017a: - ; + return rewriteValueAMD64_OpAMD64MULL(v, config) case OpAMD64MULLconst: - // match: (MULLconst [c] (MOVLconst [d])) - // cond: - // result: (MOVLconst [c*d]) - { - c := v.AuxInt - if v.Args[0].Op != OpAMD64MOVLconst { - goto endd5732835ed1276ef8b728bcfc1289f73 - } - d := v.Args[0].AuxInt - v.Op = OpAMD64MOVLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c * d - return true - } - goto endd5732835ed1276ef8b728bcfc1289f73 - endd5732835ed1276ef8b728bcfc1289f73: - ; + return rewriteValueAMD64_OpAMD64MULLconst(v, config) case OpAMD64MULQ: - // match: (MULQ x (MOVQconst [c])) - // cond: is32Bit(c) - // result: (MULQconst [c] x) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64MOVQconst { - goto endb38c6e3e0ddfa25ba0ef9684ac1528c0 - } - c := v.Args[1].AuxInt - if !(is32Bit(c)) { - goto endb38c6e3e0ddfa25ba0ef9684ac1528c0 - } - v.Op = OpAMD64MULQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c - v.AddArg(x) - return true - } - goto endb38c6e3e0ddfa25ba0ef9684ac1528c0 - endb38c6e3e0ddfa25ba0ef9684ac1528c0: - ; - // match: (MULQ (MOVQconst [c]) x) - // cond: is32Bit(c) - // result: (MULQconst [c] x) - { - if v.Args[0].Op != OpAMD64MOVQconst { - goto end9cb4f29b0bd7141639416735dcbb3b87 - } - c := v.Args[0].AuxInt - x := v.Args[1] - if !(is32Bit(c)) { - goto end9cb4f29b0bd7141639416735dcbb3b87 - } - v.Op = OpAMD64MULQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c - v.AddArg(x) - return true - } - goto end9cb4f29b0bd7141639416735dcbb3b87 - end9cb4f29b0bd7141639416735dcbb3b87: - ; + return rewriteValueAMD64_OpAMD64MULQ(v, config) case OpAMD64MULQconst: - // match: (MULQconst [-1] x) - // cond: - // result: (NEGQ x) - { - if v.AuxInt != -1 { - goto end82501cca6b5fb121a7f8b197e55f2fec - } - x := v.Args[0] - v.Op = OpAMD64NEGQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto end82501cca6b5fb121a7f8b197e55f2fec - end82501cca6b5fb121a7f8b197e55f2fec: - ; - // match: (MULQconst [0] _) - // cond: - // result: (MOVQconst [0]) - { - if v.AuxInt != 0 { - goto endcb9faa068e3558ff44daaf1d47d091b5 - } - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 0 - return true - } - goto endcb9faa068e3558ff44daaf1d47d091b5 - endcb9faa068e3558ff44daaf1d47d091b5: - ; - // match: (MULQconst [1] x) - // cond: - // result: x - { - if v.AuxInt != 1 { - goto end0b527e71db2b288b2841a1f757aa580d - } - x := v.Args[0] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = x.Type - v.AddArg(x) - return true - } - goto end0b527e71db2b288b2841a1f757aa580d - end0b527e71db2b288b2841a1f757aa580d: - ; - // match: (MULQconst [3] x) - // cond: - // result: (LEAQ2 x x) - { - if v.AuxInt != 3 { - goto end34a86f261671b5852bec6c57155fe0da - } - x := v.Args[0] - v.Op = OpAMD64LEAQ2 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(x) - return true - } - goto end34a86f261671b5852bec6c57155fe0da - end34a86f261671b5852bec6c57155fe0da: - ; - // match: (MULQconst [5] x) - // cond: - // result: (LEAQ4 x x) - { - if v.AuxInt != 5 { - goto end534601906c45a9171a9fec3e4b82b189 - } - x := v.Args[0] - v.Op = OpAMD64LEAQ4 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(x) - return true - } - goto end534601906c45a9171a9fec3e4b82b189 - end534601906c45a9171a9fec3e4b82b189: - ; - // match: (MULQconst [9] x) - // cond: - // result: (LEAQ8 x x) - { - if v.AuxInt != 9 { - goto end48a2280b6459821289c56073b8354997 - } - x := v.Args[0] - v.Op = OpAMD64LEAQ8 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(x) - return true - } - goto end48a2280b6459821289c56073b8354997 - end48a2280b6459821289c56073b8354997: - ; - // match: (MULQconst [c] x) - // cond: isPowerOfTwo(c) - // result: (SHLQconst [log2(c)] x) - { - c := v.AuxInt - x := v.Args[0] - if !(isPowerOfTwo(c)) { - goto end75076953dbfe022526a153eda99b39b2 - } - v.Op = OpAMD64SHLQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = log2(c) - v.AddArg(x) - return true - } - goto end75076953dbfe022526a153eda99b39b2 - end75076953dbfe022526a153eda99b39b2: - ; - // match: (MULQconst [c] (MOVQconst [d])) - // cond: - // result: (MOVQconst [c*d]) - { - c := v.AuxInt - if v.Args[0].Op != OpAMD64MOVQconst { - goto end55c38c5c405101e610d7ba7fc702ddc0 - } - d := v.Args[0].AuxInt - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c * d - return true - } - goto end55c38c5c405101e610d7ba7fc702ddc0 - end55c38c5c405101e610d7ba7fc702ddc0: - ; + return rewriteValueAMD64_OpAMD64MULQconst(v, config) case OpAMD64MULW: - // match: (MULW x (MOVWconst [c])) - // cond: - // result: (MULWconst [c] x) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64MOVWconst { - goto end542112cc08217d4bdffc1a645d290ffb - } - c := v.Args[1].AuxInt - v.Op = OpAMD64MULWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c - v.AddArg(x) - return true - } - goto end542112cc08217d4bdffc1a645d290ffb - end542112cc08217d4bdffc1a645d290ffb: - ; - // match: (MULW (MOVWconst [c]) x) - // cond: - // result: (MULWconst [c] x) - { - if v.Args[0].Op != OpAMD64MOVWconst { - goto endd97b4245ced2b3d27d8c555b06281de4 - } - c := v.Args[0].AuxInt - x := v.Args[1] - v.Op = OpAMD64MULWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c - v.AddArg(x) - return true - } - goto endd97b4245ced2b3d27d8c555b06281de4 - endd97b4245ced2b3d27d8c555b06281de4: - ; + return rewriteValueAMD64_OpAMD64MULW(v, config) case OpAMD64MULWconst: - // match: (MULWconst [c] (MOVWconst [d])) - // cond: - // result: (MOVWconst [c*d]) - { - c := v.AuxInt - if v.Args[0].Op != OpAMD64MOVWconst { - goto end61dbc9d9e93dd6946a20a1f475b3f74b - } - d := v.Args[0].AuxInt - v.Op = OpAMD64MOVWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c * d - return true - } - goto end61dbc9d9e93dd6946a20a1f475b3f74b - end61dbc9d9e93dd6946a20a1f475b3f74b: - ; + return rewriteValueAMD64_OpAMD64MULWconst(v, config) case OpMod16: - // match: (Mod16 x y) - // cond: - // result: (MODW x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64MODW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto end036bac694be9fe0d6b00b86c2e625990 - end036bac694be9fe0d6b00b86c2e625990: - ; + return rewriteValueAMD64_OpMod16(v, config) case OpMod16u: - // match: (Mod16u x y) - // cond: - // result: (MODWU x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64MODWU - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto enda75d900097f1510ca1c6df786bef0c24 - enda75d900097f1510ca1c6df786bef0c24: - ; + return rewriteValueAMD64_OpMod16u(v, config) case OpMod32: - // match: (Mod32 x y) - // cond: - // result: (MODL x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64MODL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto end12c8c0ecf3296810b8217cd4e40f7707 - end12c8c0ecf3296810b8217cd4e40f7707: - ; + return rewriteValueAMD64_OpMod32(v, config) case OpMod32u: - // match: (Mod32u x y) - // cond: - // result: (MODLU x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64MODLU - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto end1f0892076cfd58733a08d3ab175a3c1c - end1f0892076cfd58733a08d3ab175a3c1c: - ; + return rewriteValueAMD64_OpMod32u(v, config) case OpMod64: - // match: (Mod64 x y) - // cond: - // result: (MODQ x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64MODQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto endaae75f449baf5dc108be4e0439af97f2 - endaae75f449baf5dc108be4e0439af97f2: - ; + return rewriteValueAMD64_OpMod64(v, config) case OpMod64u: - // match: (Mod64u x y) - // cond: - // result: (MODQU x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64MODQU - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto end0d4c8b9df77e59289fb14e2496559d1d - end0d4c8b9df77e59289fb14e2496559d1d: - ; + return rewriteValueAMD64_OpMod64u(v, config) case OpMod8: - // match: (Mod8 x y) - // cond: - // result: (MODW (SignExt8to16 x) (SignExt8to16 y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64MODW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpSignExt8to16, TypeInvalid) - v0.AddArg(x) - v0.Type = config.fe.TypeInt16() - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpSignExt8to16, TypeInvalid) - v1.AddArg(y) - v1.Type = config.fe.TypeInt16() - v.AddArg(v1) - return true - } - goto endf959fc16e72bc6dc47ab7c9ee3778901 - endf959fc16e72bc6dc47ab7c9ee3778901: - ; + return rewriteValueAMD64_OpMod8(v, config) case OpMod8u: - // match: (Mod8u x y) - // cond: - // result: (MODWU (ZeroExt8to16 x) (ZeroExt8to16 y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64MODWU - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpZeroExt8to16, TypeInvalid) - v0.AddArg(x) - v0.Type = config.fe.TypeUInt16() - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpZeroExt8to16, TypeInvalid) - v1.AddArg(y) - v1.Type = config.fe.TypeUInt16() - v.AddArg(v1) - return true - } - goto end9b3274d9dd7f1e91c75ce5e7b548fe97 - end9b3274d9dd7f1e91c75ce5e7b548fe97: - ; + return rewriteValueAMD64_OpMod8u(v, config) case OpMove: - // match: (Move [0] _ _ mem) - // cond: - // result: mem - { - if v.AuxInt != 0 { - goto end0961cbfe144a616cba75190d07d65e41 - } - mem := v.Args[2] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = mem.Type - v.AddArg(mem) - return true - } - goto end0961cbfe144a616cba75190d07d65e41 - end0961cbfe144a616cba75190d07d65e41: - ; - // match: (Move [1] dst src mem) - // cond: - // result: (MOVBstore dst (MOVBload src mem) mem) - { - if v.AuxInt != 1 { - goto end72e5dd27e999493b67ea3af4ecc60d48 - } - dst := v.Args[0] - src := v.Args[1] - mem := v.Args[2] - v.Op = OpAMD64MOVBstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(dst) - v0 := b.NewValue0(v.Line, OpAMD64MOVBload, TypeInvalid) - v0.AddArg(src) - v0.AddArg(mem) - v0.Type = config.fe.TypeUInt8() - v.AddArg(v0) - v.AddArg(mem) - return true - } - goto end72e5dd27e999493b67ea3af4ecc60d48 - end72e5dd27e999493b67ea3af4ecc60d48: - ; - // match: (Move [2] dst src mem) - // cond: - // result: (MOVWstore dst (MOVWload src mem) mem) - { - if v.AuxInt != 2 { - goto end017f774e406d4578b4bcefcd8db8ec1e - } - dst := v.Args[0] - src := v.Args[1] - mem := v.Args[2] - v.Op = OpAMD64MOVWstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(dst) - v0 := b.NewValue0(v.Line, OpAMD64MOVWload, TypeInvalid) - v0.AddArg(src) - v0.AddArg(mem) - v0.Type = config.fe.TypeUInt16() - v.AddArg(v0) - v.AddArg(mem) - return true - } - goto end017f774e406d4578b4bcefcd8db8ec1e - end017f774e406d4578b4bcefcd8db8ec1e: - ; - // match: (Move [4] dst src mem) - // cond: - // result: (MOVLstore dst (MOVLload src mem) mem) - { - if v.AuxInt != 4 { - goto end938ec47a2ddf8e9b4bf71ffade6e5b3f - } - dst := v.Args[0] - src := v.Args[1] - mem := v.Args[2] - v.Op = OpAMD64MOVLstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(dst) - v0 := b.NewValue0(v.Line, OpAMD64MOVLload, TypeInvalid) - v0.AddArg(src) - v0.AddArg(mem) - v0.Type = config.fe.TypeUInt32() - v.AddArg(v0) - v.AddArg(mem) - return true - } - goto end938ec47a2ddf8e9b4bf71ffade6e5b3f - end938ec47a2ddf8e9b4bf71ffade6e5b3f: - ; - // match: (Move [8] dst src mem) - // cond: - // result: (MOVQstore dst (MOVQload src mem) mem) - { - if v.AuxInt != 8 { - goto end696b3498f5fee17f49ae0f708d3dfe4b - } - dst := v.Args[0] - src := v.Args[1] - mem := v.Args[2] - v.Op = OpAMD64MOVQstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(dst) - v0 := b.NewValue0(v.Line, OpAMD64MOVQload, TypeInvalid) - v0.AddArg(src) - v0.AddArg(mem) - v0.Type = config.fe.TypeUInt64() - v.AddArg(v0) - v.AddArg(mem) - return true - } - goto end696b3498f5fee17f49ae0f708d3dfe4b - end696b3498f5fee17f49ae0f708d3dfe4b: - ; - // match: (Move [16] dst src mem) - // cond: - // result: (MOVOstore dst (MOVOload src mem) mem) - { - if v.AuxInt != 16 { - goto end4894ace925d468c10a5b0c5b91fc4c1c - } - dst := v.Args[0] - src := v.Args[1] - mem := v.Args[2] - v.Op = OpAMD64MOVOstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(dst) - v0 := b.NewValue0(v.Line, OpAMD64MOVOload, TypeInvalid) - v0.AddArg(src) - v0.AddArg(mem) - v0.Type = TypeInt128 - v.AddArg(v0) - v.AddArg(mem) - return true - } - goto end4894ace925d468c10a5b0c5b91fc4c1c - end4894ace925d468c10a5b0c5b91fc4c1c: - ; - // match: (Move [3] dst src mem) - // cond: - // result: (MOVBstore [2] dst (MOVBload [2] src mem) (MOVWstore dst (MOVWload src mem) mem)) - { - if v.AuxInt != 3 { - goto end76ce0004999139fe4608c3c5356eb364 - } - dst := v.Args[0] - src := v.Args[1] - mem := v.Args[2] - v.Op = OpAMD64MOVBstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 2 - v.AddArg(dst) - v0 := b.NewValue0(v.Line, OpAMD64MOVBload, TypeInvalid) - v0.AuxInt = 2 - v0.AddArg(src) - v0.AddArg(mem) - v0.Type = config.fe.TypeUInt8() - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64MOVWstore, TypeInvalid) - v1.AddArg(dst) - v2 := b.NewValue0(v.Line, OpAMD64MOVWload, TypeInvalid) - v2.AddArg(src) - v2.AddArg(mem) - v2.Type = config.fe.TypeUInt16() - v1.AddArg(v2) - v1.AddArg(mem) - v1.Type = TypeMem - v.AddArg(v1) - return true - } - goto end76ce0004999139fe4608c3c5356eb364 - end76ce0004999139fe4608c3c5356eb364: - ; - // match: (Move [5] dst src mem) - // cond: - // result: (MOVBstore [4] dst (MOVBload [4] src mem) (MOVLstore dst (MOVLload src mem) mem)) - { - if v.AuxInt != 5 { - goto end21378690c0f39bdd6b46566d57da34e3 - } - dst := v.Args[0] - src := v.Args[1] - mem := v.Args[2] - v.Op = OpAMD64MOVBstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 4 - v.AddArg(dst) - v0 := b.NewValue0(v.Line, OpAMD64MOVBload, TypeInvalid) - v0.AuxInt = 4 - v0.AddArg(src) - v0.AddArg(mem) - v0.Type = config.fe.TypeUInt8() - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64MOVLstore, TypeInvalid) - v1.AddArg(dst) - v2 := b.NewValue0(v.Line, OpAMD64MOVLload, TypeInvalid) - v2.AddArg(src) - v2.AddArg(mem) - v2.Type = config.fe.TypeUInt32() - v1.AddArg(v2) - v1.AddArg(mem) - v1.Type = TypeMem - v.AddArg(v1) - return true - } - goto end21378690c0f39bdd6b46566d57da34e3 - end21378690c0f39bdd6b46566d57da34e3: - ; - // match: (Move [6] dst src mem) - // cond: - // result: (MOVWstore [4] dst (MOVWload [4] src mem) (MOVLstore dst (MOVLload src mem) mem)) - { - if v.AuxInt != 6 { - goto endcb6e509881d8638d8cae3af4f2b19a8e - } - dst := v.Args[0] - src := v.Args[1] - mem := v.Args[2] - v.Op = OpAMD64MOVWstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 4 - v.AddArg(dst) - v0 := b.NewValue0(v.Line, OpAMD64MOVWload, TypeInvalid) - v0.AuxInt = 4 - v0.AddArg(src) - v0.AddArg(mem) - v0.Type = config.fe.TypeUInt16() - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64MOVLstore, TypeInvalid) - v1.AddArg(dst) - v2 := b.NewValue0(v.Line, OpAMD64MOVLload, TypeInvalid) - v2.AddArg(src) - v2.AddArg(mem) - v2.Type = config.fe.TypeUInt32() - v1.AddArg(v2) - v1.AddArg(mem) - v1.Type = TypeMem - v.AddArg(v1) - return true - } - goto endcb6e509881d8638d8cae3af4f2b19a8e - endcb6e509881d8638d8cae3af4f2b19a8e: - ; - // match: (Move [7] dst src mem) - // cond: - // result: (MOVLstore [3] dst (MOVLload [3] src mem) (MOVLstore dst (MOVLload src mem) mem)) - { - if v.AuxInt != 7 { - goto end3429ae54bc071c0856ad366c79b7ab97 - } - dst := v.Args[0] - src := v.Args[1] - mem := v.Args[2] - v.Op = OpAMD64MOVLstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 3 - v.AddArg(dst) - v0 := b.NewValue0(v.Line, OpAMD64MOVLload, TypeInvalid) - v0.AuxInt = 3 - v0.AddArg(src) - v0.AddArg(mem) - v0.Type = config.fe.TypeUInt32() - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64MOVLstore, TypeInvalid) - v1.AddArg(dst) - v2 := b.NewValue0(v.Line, OpAMD64MOVLload, TypeInvalid) - v2.AddArg(src) - v2.AddArg(mem) - v2.Type = config.fe.TypeUInt32() - v1.AddArg(v2) - v1.AddArg(mem) - v1.Type = TypeMem - v.AddArg(v1) - return true - } - goto end3429ae54bc071c0856ad366c79b7ab97 - end3429ae54bc071c0856ad366c79b7ab97: - ; - // 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)) - { - size := v.AuxInt - dst := v.Args[0] - src := v.Args[1] - mem := v.Args[2] - if !(size > 8 && size < 16) { - goto endc90f121709d5411d389649dea89a2251 - } - v.Op = OpAMD64MOVQstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = size - 8 - v.AddArg(dst) - v0 := b.NewValue0(v.Line, OpAMD64MOVQload, TypeInvalid) - v0.AuxInt = size - 8 - v0.AddArg(src) - v0.AddArg(mem) - v0.Type = config.fe.TypeUInt64() - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64MOVQstore, TypeInvalid) - v1.AddArg(dst) - v2 := b.NewValue0(v.Line, OpAMD64MOVQload, TypeInvalid) - v2.AddArg(src) - v2.AddArg(mem) - v2.Type = config.fe.TypeUInt64() - v1.AddArg(v2) - v1.AddArg(mem) - v1.Type = TypeMem - v.AddArg(v1) - return true - } - goto endc90f121709d5411d389649dea89a2251 - endc90f121709d5411d389649dea89a2251: - ; - // match: (Move [size] dst src mem) - // cond: size > 16 && size%16 != 0 && size%16 <= 8 - // result: (Move [size-size%16] (ADDQconst dst [size%16]) (ADDQconst src [size%16]) (MOVQstore dst (MOVQload src mem) mem)) - { - size := v.AuxInt - dst := v.Args[0] - src := v.Args[1] - mem := v.Args[2] - if !(size > 16 && size%16 != 0 && size%16 <= 8) { - goto end376c57db23b866866f23677c6cde43ba - } - v.Op = OpMove - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = size - size%16 - v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) - v0.Type = dst.Type - v0.AddArg(dst) - v0.AuxInt = size % 16 - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) - v1.Type = src.Type - v1.AddArg(src) - v1.AuxInt = size % 16 - v.AddArg(v1) - v2 := b.NewValue0(v.Line, OpAMD64MOVQstore, TypeInvalid) - v2.AddArg(dst) - v3 := b.NewValue0(v.Line, OpAMD64MOVQload, TypeInvalid) - v3.AddArg(src) - v3.AddArg(mem) - v3.Type = config.fe.TypeUInt64() - v2.AddArg(v3) - v2.AddArg(mem) - v2.Type = TypeMem - v.AddArg(v2) - return true - } - goto end376c57db23b866866f23677c6cde43ba - end376c57db23b866866f23677c6cde43ba: - ; - // match: (Move [size] dst src mem) - // cond: size > 16 && size%16 != 0 && size%16 > 8 - // result: (Move [size-size%16] (ADDQconst dst [size%16]) (ADDQconst src [size%16]) (MOVOstore dst (MOVOload src mem) mem)) - { - size := v.AuxInt - dst := v.Args[0] - src := v.Args[1] - mem := v.Args[2] - if !(size > 16 && size%16 != 0 && size%16 > 8) { - goto end2f82f76766a21f8802768380cf10a497 - } - v.Op = OpMove - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = size - size%16 - v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) - v0.Type = dst.Type - v0.AddArg(dst) - v0.AuxInt = size % 16 - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) - v1.Type = src.Type - v1.AddArg(src) - v1.AuxInt = size % 16 - v.AddArg(v1) - v2 := b.NewValue0(v.Line, OpAMD64MOVOstore, TypeInvalid) - v2.AddArg(dst) - v3 := b.NewValue0(v.Line, OpAMD64MOVOload, TypeInvalid) - v3.AddArg(src) - v3.AddArg(mem) - v3.Type = TypeInt128 - v2.AddArg(v3) - v2.AddArg(mem) - v2.Type = TypeMem - v.AddArg(v2) - return true - } - goto end2f82f76766a21f8802768380cf10a497 - end2f82f76766a21f8802768380cf10a497: - ; - // match: (Move [size] dst src mem) - // cond: size >= 32 && size <= 16*64 && size%16 == 0 - // result: (DUFFCOPY [14*(64-size/16)] dst src mem) - { - size := v.AuxInt - dst := v.Args[0] - src := v.Args[1] - mem := v.Args[2] - if !(size >= 32 && size <= 16*64 && size%16 == 0) { - goto endcb66da6685f0079ee1f84d10fa561f22 - } - v.Op = OpAMD64DUFFCOPY - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 14 * (64 - size/16) - v.AddArg(dst) - v.AddArg(src) - v.AddArg(mem) - return true - } - goto endcb66da6685f0079ee1f84d10fa561f22 - endcb66da6685f0079ee1f84d10fa561f22: - ; - // match: (Move [size] dst src mem) - // cond: size > 16*64 && size%8 == 0 - // result: (REPMOVSQ dst src (MOVQconst [size/8]) mem) - { - size := v.AuxInt - dst := v.Args[0] - src := v.Args[1] - mem := v.Args[2] - if !(size > 16*64 && size%8 == 0) { - goto end7ae25ff1bbdcf34efef09613745e9d6e - } - v.Op = OpAMD64REPMOVSQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(dst) - v.AddArg(src) - v0 := b.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) - v0.AuxInt = size / 8 - v0.Type = config.fe.TypeUInt64() - v.AddArg(v0) - v.AddArg(mem) - return true - } - goto end7ae25ff1bbdcf34efef09613745e9d6e - end7ae25ff1bbdcf34efef09613745e9d6e: - ; + return rewriteValueAMD64_OpMove(v, config) case OpMul16: - // match: (Mul16 x y) - // cond: - // result: (MULW x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64MULW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto end1addf5ea2c885aa1729b8f944859d00c - end1addf5ea2c885aa1729b8f944859d00c: - ; + return rewriteValueAMD64_OpMul16(v, config) case OpMul32: - // match: (Mul32 x y) - // cond: - // result: (MULL x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64MULL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto ende144381f85808e5144782804768e2859 - ende144381f85808e5144782804768e2859: - ; + return rewriteValueAMD64_OpMul32(v, config) case OpMul32F: - // match: (Mul32F x y) - // cond: - // result: (MULSS x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64MULSS - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto end32105a3bfe0237b799b69d83b3f171ca - end32105a3bfe0237b799b69d83b3f171ca: - ; + return rewriteValueAMD64_OpMul32F(v, config) case OpMul64: - // match: (Mul64 x y) - // cond: - // result: (MULQ x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64MULQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto end38da21e77ac329eb643b20e7d97d5853 - end38da21e77ac329eb643b20e7d97d5853: - ; + return rewriteValueAMD64_OpMul64(v, config) case OpMul64F: - // match: (Mul64F x y) - // cond: - // result: (MULSD x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64MULSD - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto end0ff6e1919fb0a3e549eb82b43edf1f52 - end0ff6e1919fb0a3e549eb82b43edf1f52: - ; + return rewriteValueAMD64_OpMul64F(v, config) case OpMul8: - // match: (Mul8 x y) - // cond: - // result: (MULB x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64MULB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto endd876d6bc42a2285b801f42dadbd8757c - endd876d6bc42a2285b801f42dadbd8757c: - ; + return rewriteValueAMD64_OpMul8(v, config) case OpMulPtr: - // match: (MulPtr x y) - // cond: - // result: (MULQ x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64MULQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto endbbedad106c011a93243e2062afdcc75f - endbbedad106c011a93243e2062afdcc75f: - ; + return rewriteValueAMD64_OpMulPtr(v, config) case OpAMD64NEGB: - // match: (NEGB (MOVBconst [c])) - // cond: - // result: (MOVBconst [-c]) - { - if v.Args[0].Op != OpAMD64MOVBconst { - goto end36d0300ba9eab8c9da86246ff653ca96 - } - c := v.Args[0].AuxInt - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = -c - return true - } - goto end36d0300ba9eab8c9da86246ff653ca96 - end36d0300ba9eab8c9da86246ff653ca96: - ; + return rewriteValueAMD64_OpAMD64NEGB(v, config) case OpAMD64NEGL: - // match: (NEGL (MOVLconst [c])) - // cond: - // result: (MOVLconst [-c]) - { - if v.Args[0].Op != OpAMD64MOVLconst { - goto end7a245ec67e56bd51911e5ba2d0aa0a16 - } - c := v.Args[0].AuxInt - v.Op = OpAMD64MOVLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = -c - return true - } - goto end7a245ec67e56bd51911e5ba2d0aa0a16 - end7a245ec67e56bd51911e5ba2d0aa0a16: - ; + return rewriteValueAMD64_OpAMD64NEGL(v, config) case OpAMD64NEGQ: - // match: (NEGQ (MOVQconst [c])) - // cond: - // result: (MOVQconst [-c]) - { - if v.Args[0].Op != OpAMD64MOVQconst { - goto end04ddd98bc6724ecb85c80c2a4e2bca5a - } - c := v.Args[0].AuxInt - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = -c - return true - } - goto end04ddd98bc6724ecb85c80c2a4e2bca5a - end04ddd98bc6724ecb85c80c2a4e2bca5a: - ; + return rewriteValueAMD64_OpAMD64NEGQ(v, config) case OpAMD64NEGW: - // match: (NEGW (MOVWconst [c])) - // cond: - // result: (MOVWconst [-c]) - { - if v.Args[0].Op != OpAMD64MOVWconst { - goto end1db6636f0a51848d8a34f6561ecfe7ae - } - c := v.Args[0].AuxInt - v.Op = OpAMD64MOVWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = -c - return true - } - goto end1db6636f0a51848d8a34f6561ecfe7ae - end1db6636f0a51848d8a34f6561ecfe7ae: - ; + return rewriteValueAMD64_OpAMD64NEGW(v, config) case OpAMD64NOTB: - // match: (NOTB (MOVBconst [c])) - // cond: - // result: (MOVBconst [^c]) - { - if v.Args[0].Op != OpAMD64MOVBconst { - goto end9e383a9ceb29a9e2bf890ec6a67212a8 - } - c := v.Args[0].AuxInt - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = ^c - return true - } - goto end9e383a9ceb29a9e2bf890ec6a67212a8 - end9e383a9ceb29a9e2bf890ec6a67212a8: - ; + return rewriteValueAMD64_OpAMD64NOTB(v, config) case OpAMD64NOTL: - // match: (NOTL (MOVLconst [c])) - // cond: - // result: (MOVLconst [^c]) - { - if v.Args[0].Op != OpAMD64MOVLconst { - goto endcc73972c088d5e652a1370a96e56502d - } - c := v.Args[0].AuxInt - v.Op = OpAMD64MOVLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = ^c - return true - } - goto endcc73972c088d5e652a1370a96e56502d - endcc73972c088d5e652a1370a96e56502d: - ; + return rewriteValueAMD64_OpAMD64NOTL(v, config) case OpAMD64NOTQ: - // match: (NOTQ (MOVQconst [c])) - // cond: - // result: (MOVQconst [^c]) - { - if v.Args[0].Op != OpAMD64MOVQconst { - goto endb39ddb6bf7339d46f74114baad4333b6 - } - c := v.Args[0].AuxInt - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = ^c - return true - } - goto endb39ddb6bf7339d46f74114baad4333b6 - endb39ddb6bf7339d46f74114baad4333b6: - ; + return rewriteValueAMD64_OpAMD64NOTQ(v, config) case OpAMD64NOTW: - // match: (NOTW (MOVWconst [c])) - // cond: - // result: (MOVWconst [^c]) - { - if v.Args[0].Op != OpAMD64MOVWconst { - goto end35848095ebcf894c6957ad3be5f82c43 - } - c := v.Args[0].AuxInt - v.Op = OpAMD64MOVWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = ^c - return true - } - goto end35848095ebcf894c6957ad3be5f82c43 - end35848095ebcf894c6957ad3be5f82c43: - ; + return rewriteValueAMD64_OpAMD64NOTW(v, config) case OpNeg16: - // match: (Neg16 x) - // cond: - // result: (NEGW x) - { - x := v.Args[0] - v.Op = OpAMD64NEGW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto end7a8c652f4ffeb49656119af69512edb2 - end7a8c652f4ffeb49656119af69512edb2: - ; + return rewriteValueAMD64_OpNeg16(v, config) case OpNeg32: - // match: (Neg32 x) - // cond: - // result: (NEGL x) - { - x := v.Args[0] - v.Op = OpAMD64NEGL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto endce1f7e17fc193f6c076e47d5e401e126 - endce1f7e17fc193f6c076e47d5e401e126: - ; + return rewriteValueAMD64_OpNeg32(v, config) case OpNeg32F: - // match: (Neg32F x) - // cond: - // result: (PXOR x (MOVSSconst [f2i(math.Copysign(0, -1))])) - { - x := v.Args[0] - v.Op = OpAMD64PXOR - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v0 := b.NewValue0(v.Line, OpAMD64MOVSSconst, TypeInvalid) - v0.Type = config.Frontend().TypeFloat32() - v0.AuxInt = f2i(math.Copysign(0, -1)) - v.AddArg(v0) - return true - } - goto end685a5fc899e195b9091afbe2a7146051 - end685a5fc899e195b9091afbe2a7146051: - ; + return rewriteValueAMD64_OpNeg32F(v, config) case OpNeg64: - // match: (Neg64 x) - // cond: - // result: (NEGQ x) - { - x := v.Args[0] - v.Op = OpAMD64NEGQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto enda06c5b1718f2b96aba10bf5a5c437c6c - enda06c5b1718f2b96aba10bf5a5c437c6c: - ; + return rewriteValueAMD64_OpNeg64(v, config) case OpNeg64F: - // match: (Neg64F x) - // cond: - // result: (PXOR x (MOVSDconst [f2i(math.Copysign(0, -1))])) - { - x := v.Args[0] - v.Op = OpAMD64PXOR - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v0 := b.NewValue0(v.Line, OpAMD64MOVSDconst, TypeInvalid) - v0.Type = config.Frontend().TypeFloat64() - v0.AuxInt = f2i(math.Copysign(0, -1)) - v.AddArg(v0) - return true - } - goto ende85ae82b7a51e75000eb9158d584acb2 - ende85ae82b7a51e75000eb9158d584acb2: - ; + return rewriteValueAMD64_OpNeg64F(v, config) case OpNeg8: - // match: (Neg8 x) - // cond: - // result: (NEGB x) - { - x := v.Args[0] - v.Op = OpAMD64NEGB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto end1e5f495a2ac6cdea47b1ae5ba62aa95d - end1e5f495a2ac6cdea47b1ae5ba62aa95d: - ; + return rewriteValueAMD64_OpNeg8(v, config) case OpNeq16: - // match: (Neq16 x y) - // cond: - // result: (SETNE (CMPW x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETNE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto end6413ee42d523a005cce9e3372ff2c8e9 - end6413ee42d523a005cce9e3372ff2c8e9: - ; + return rewriteValueAMD64_OpNeq16(v, config) case OpNeq32: - // match: (Neq32 x y) - // cond: - // result: (SETNE (CMPL x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETNE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto endb1a3ad499a09d8262952e6cbc47a23a8 - endb1a3ad499a09d8262952e6cbc47a23a8: - ; + return rewriteValueAMD64_OpNeq32(v, config) case OpNeq32F: - // match: (Neq32F x y) - // cond: - // result: (SETNEF (UCOMISS x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETNEF - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto end2a001b2774f58aaf8c1e9efce6ae59e7 - end2a001b2774f58aaf8c1e9efce6ae59e7: - ; + return rewriteValueAMD64_OpNeq32F(v, config) case OpNeq64: - // match: (Neq64 x y) - // cond: - // result: (SETNE (CMPQ x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETNE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto end092b9159bce08d2ef7896f7d3da5a595 - end092b9159bce08d2ef7896f7d3da5a595: - ; + return rewriteValueAMD64_OpNeq64(v, config) case OpNeq64F: - // match: (Neq64F x y) - // cond: - // result: (SETNEF (UCOMISD x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETNEF - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto endb9c010023c38bd2fee7800fbefc85d98 - endb9c010023c38bd2fee7800fbefc85d98: - ; + return rewriteValueAMD64_OpNeq64F(v, config) case OpNeq8: - // match: (Neq8 x y) - // cond: - // result: (SETNE (CMPB x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETNE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto end89e59f45e068c89458cc4db1692bf3bb - end89e59f45e068c89458cc4db1692bf3bb: - ; + return rewriteValueAMD64_OpNeq8(v, config) case OpNeqPtr: - // match: (NeqPtr x y) - // cond: - // result: (SETNE (CMPQ x y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETNE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) - return true - } - goto end3b8bb3b4952011d1d40f993d8717cf16 - end3b8bb3b4952011d1d40f993d8717cf16: - ; + return rewriteValueAMD64_OpNeqPtr(v, config) case OpNilCheck: - // match: (NilCheck ptr mem) - // cond: - // result: (LoweredNilCheck ptr mem) - { - ptr := v.Args[0] - mem := v.Args[1] - v.Op = OpAMD64LoweredNilCheck - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(ptr) - v.AddArg(mem) - return true - } - goto end75520e60179564948a625707b84e8a8d - end75520e60179564948a625707b84e8a8d: - ; + return rewriteValueAMD64_OpNilCheck(v, config) case OpNot: - // match: (Not x) - // cond: - // result: (XORBconst [1] x) - { - x := v.Args[0] - v.Op = OpAMD64XORBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 1 - v.AddArg(x) - return true - } - goto end73973101aad60079c62fa64624e21db1 - end73973101aad60079c62fa64624e21db1: - ; + return rewriteValueAMD64_OpNot(v, config) case OpAMD64ORB: - // match: (ORB x (MOVBconst [c])) - // cond: - // result: (ORBconst [c] x) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64MOVBconst { - goto end7b63870decde2515cb77ec4f8f76817c - } - c := v.Args[1].AuxInt - v.Op = OpAMD64ORBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c - v.AddArg(x) - return true - } - goto end7b63870decde2515cb77ec4f8f76817c - end7b63870decde2515cb77ec4f8f76817c: - ; - // match: (ORB (MOVBconst [c]) x) - // cond: - // result: (ORBconst [c] x) - { - if v.Args[0].Op != OpAMD64MOVBconst { - goto end70b43d531e2097a4f6293f66256a642e - } - c := v.Args[0].AuxInt - x := v.Args[1] - v.Op = OpAMD64ORBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c - v.AddArg(x) - return true - } - goto end70b43d531e2097a4f6293f66256a642e - end70b43d531e2097a4f6293f66256a642e: - ; - // match: (ORB x x) - // cond: - // result: x - { - x := v.Args[0] - if v.Args[1] != x { - goto enddca5ce800a9eca157f243cb2fdb1408a - } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = x.Type - v.AddArg(x) - return true - } - goto enddca5ce800a9eca157f243cb2fdb1408a - enddca5ce800a9eca157f243cb2fdb1408a: - ; + return rewriteValueAMD64_OpAMD64ORB(v, config) case OpAMD64ORBconst: - // match: (ORBconst [c] x) - // cond: int8(c)==0 - // result: x - { - c := v.AuxInt - x := v.Args[0] - if !(int8(c) == 0) { - goto end565f78e3a843dc73943b59227b39a1b3 - } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = x.Type - v.AddArg(x) - return true - } - goto end565f78e3a843dc73943b59227b39a1b3 - end565f78e3a843dc73943b59227b39a1b3: - ; - // match: (ORBconst [c] _) - // cond: int8(c)==-1 - // result: (MOVBconst [-1]) - { - c := v.AuxInt - if !(int8(c) == -1) { - goto end6033c7910d8cd536b31446e179e4610d - } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = -1 - return true - } - goto end6033c7910d8cd536b31446e179e4610d - end6033c7910d8cd536b31446e179e4610d: - ; - // match: (ORBconst [c] (MOVBconst [d])) - // cond: - // result: (MOVBconst [c|d]) - { - c := v.AuxInt - if v.Args[0].Op != OpAMD64MOVBconst { - goto endbe5263f022dc10a5cf53c118937d79dd - } - d := v.Args[0].AuxInt - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c | d - return true - } - goto endbe5263f022dc10a5cf53c118937d79dd - endbe5263f022dc10a5cf53c118937d79dd: - ; + return rewriteValueAMD64_OpAMD64ORBconst(v, config) case OpAMD64ORL: - // match: (ORL x (MOVLconst [c])) - // cond: - // result: (ORLconst [c] x) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64MOVLconst { - goto end1b883e30d860b6fac14ae98462c4f61a - } - c := v.Args[1].AuxInt - v.Op = OpAMD64ORLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c - v.AddArg(x) - return true - } - goto end1b883e30d860b6fac14ae98462c4f61a - end1b883e30d860b6fac14ae98462c4f61a: - ; - // match: (ORL (MOVLconst [c]) x) - // cond: - // result: (ORLconst [c] x) - { - if v.Args[0].Op != OpAMD64MOVLconst { - goto enda5bc49524a0cbd2241f792837d0a48a8 - } - c := v.Args[0].AuxInt - x := v.Args[1] - v.Op = OpAMD64ORLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c - v.AddArg(x) - return true - } - goto enda5bc49524a0cbd2241f792837d0a48a8 - enda5bc49524a0cbd2241f792837d0a48a8: - ; - // match: (ORL x x) - // cond: - // result: x - { - x := v.Args[0] - if v.Args[1] != x { - goto end2dd719b68f4938777ef0d820aab93659 - } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = x.Type - v.AddArg(x) - return true - } - goto end2dd719b68f4938777ef0d820aab93659 - end2dd719b68f4938777ef0d820aab93659: - ; + return rewriteValueAMD64_OpAMD64ORL(v, config) case OpAMD64ORLconst: - // match: (ORLconst [c] x) - // cond: int32(c)==0 - // result: x - { - c := v.AuxInt - x := v.Args[0] - if !(int32(c) == 0) { - goto end5b52623a724e8a7167c71289fb7192f1 - } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = x.Type - v.AddArg(x) - return true - } - goto end5b52623a724e8a7167c71289fb7192f1 - end5b52623a724e8a7167c71289fb7192f1: - ; - // match: (ORLconst [c] _) - // cond: int32(c)==-1 - // result: (MOVLconst [-1]) - { - c := v.AuxInt - if !(int32(c) == -1) { - goto end345a8ea439ef2ef54bd84fc8a0f73e97 - } - v.Op = OpAMD64MOVLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = -1 - return true - } - goto end345a8ea439ef2ef54bd84fc8a0f73e97 - end345a8ea439ef2ef54bd84fc8a0f73e97: - ; - // match: (ORLconst [c] (MOVLconst [d])) - // cond: - // result: (MOVLconst [c|d]) - { - c := v.AuxInt - if v.Args[0].Op != OpAMD64MOVLconst { - goto ende9ca05024248f782c88084715f81d727 - } - d := v.Args[0].AuxInt - v.Op = OpAMD64MOVLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c | d - return true - } - goto ende9ca05024248f782c88084715f81d727 - ende9ca05024248f782c88084715f81d727: - ; + return rewriteValueAMD64_OpAMD64ORLconst(v, config) case OpAMD64ORQ: - // match: (ORQ x (MOVQconst [c])) - // cond: is32Bit(c) - // result: (ORQconst [c] x) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64MOVQconst { - goto end601f2bb3ccda102e484ff60adeaf6d26 - } - c := v.Args[1].AuxInt - if !(is32Bit(c)) { - goto end601f2bb3ccda102e484ff60adeaf6d26 - } - v.Op = OpAMD64ORQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c - v.AddArg(x) - return true - } - goto end601f2bb3ccda102e484ff60adeaf6d26 - end601f2bb3ccda102e484ff60adeaf6d26: - ; - // match: (ORQ (MOVQconst [c]) x) - // cond: is32Bit(c) - // result: (ORQconst [c] x) - { - if v.Args[0].Op != OpAMD64MOVQconst { - goto end010afbebcd314e288509d79a16a6d5cc - } - c := v.Args[0].AuxInt - x := v.Args[1] - if !(is32Bit(c)) { - goto end010afbebcd314e288509d79a16a6d5cc - } - v.Op = OpAMD64ORQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c - v.AddArg(x) - return true - } - goto end010afbebcd314e288509d79a16a6d5cc - end010afbebcd314e288509d79a16a6d5cc: - ; - // match: (ORQ x x) - // cond: - // result: x - { - x := v.Args[0] - if v.Args[1] != x { - goto end47a27d30b82db576978c5a3a57b520fb - } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = x.Type - v.AddArg(x) - return true - } - goto end47a27d30b82db576978c5a3a57b520fb - end47a27d30b82db576978c5a3a57b520fb: - ; + return rewriteValueAMD64_OpAMD64ORQ(v, config) case OpAMD64ORQconst: - // match: (ORQconst [0] x) - // cond: - // result: x - { - if v.AuxInt != 0 { - goto end44534da6b9ce98d33fad7e20f0be1fbd - } - x := v.Args[0] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = x.Type - v.AddArg(x) - return true - } - goto end44534da6b9ce98d33fad7e20f0be1fbd - end44534da6b9ce98d33fad7e20f0be1fbd: - ; - // match: (ORQconst [-1] _) - // cond: - // result: (MOVQconst [-1]) - { - if v.AuxInt != -1 { - goto endcde9b9d7c4527eaa5d50b252f50b43c1 - } - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = -1 - return true - } - goto endcde9b9d7c4527eaa5d50b252f50b43c1 - endcde9b9d7c4527eaa5d50b252f50b43c1: - ; - // match: (ORQconst [c] (MOVQconst [d])) - // cond: - // result: (MOVQconst [c|d]) - { - c := v.AuxInt - if v.Args[0].Op != OpAMD64MOVQconst { - goto enda2488509b71db9abcb06a5115c4ddc2c - } - d := v.Args[0].AuxInt - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c | d - return true - } - goto enda2488509b71db9abcb06a5115c4ddc2c - enda2488509b71db9abcb06a5115c4ddc2c: - ; + return rewriteValueAMD64_OpAMD64ORQconst(v, config) case OpAMD64ORW: - // match: (ORW x (MOVWconst [c])) - // cond: - // result: (ORWconst [c] x) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64MOVWconst { - goto end9f98df10892dbf170b49aace86ee0d7f - } - c := v.Args[1].AuxInt - v.Op = OpAMD64ORWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c - v.AddArg(x) - return true - } - goto end9f98df10892dbf170b49aace86ee0d7f - end9f98df10892dbf170b49aace86ee0d7f: - ; - // match: (ORW (MOVWconst [c]) x) - // cond: - // result: (ORWconst [c] x) - { - if v.Args[0].Op != OpAMD64MOVWconst { - goto end96405942c9ceb5fcb0ddb85a8709d015 - } - c := v.Args[0].AuxInt - x := v.Args[1] - v.Op = OpAMD64ORWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c - v.AddArg(x) - return true - } - goto end96405942c9ceb5fcb0ddb85a8709d015 - end96405942c9ceb5fcb0ddb85a8709d015: - ; - // match: (ORW x x) - // cond: - // result: x - { - x := v.Args[0] - if v.Args[1] != x { - goto endc6a23b64e541dc9cfc6a90fd7028e8c1 - } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = x.Type - v.AddArg(x) - return true - } - goto endc6a23b64e541dc9cfc6a90fd7028e8c1 - endc6a23b64e541dc9cfc6a90fd7028e8c1: - ; + return rewriteValueAMD64_OpAMD64ORW(v, config) case OpAMD64ORWconst: - // match: (ORWconst [c] x) - // cond: int16(c)==0 - // result: x - { - c := v.AuxInt - x := v.Args[0] - if !(int16(c) == 0) { - goto endbbbdec9091c8b4c58e587eac8a43402d - } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = x.Type - v.AddArg(x) - return true - } - goto endbbbdec9091c8b4c58e587eac8a43402d - endbbbdec9091c8b4c58e587eac8a43402d: - ; - // match: (ORWconst [c] _) - // cond: int16(c)==-1 - // result: (MOVWconst [-1]) - { - c := v.AuxInt - if !(int16(c) == -1) { - goto ended87a5775f5e04b2d2a117a63d82dd9b - } - v.Op = OpAMD64MOVWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = -1 - return true - } - goto ended87a5775f5e04b2d2a117a63d82dd9b - ended87a5775f5e04b2d2a117a63d82dd9b: - ; - // match: (ORWconst [c] (MOVWconst [d])) - // cond: - // result: (MOVWconst [c|d]) - { - c := v.AuxInt - if v.Args[0].Op != OpAMD64MOVWconst { - goto endba9221a8462b5c62e8d7c686f64c2778 - } - d := v.Args[0].AuxInt - v.Op = OpAMD64MOVWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c | d - return true - } - goto endba9221a8462b5c62e8d7c686f64c2778 - endba9221a8462b5c62e8d7c686f64c2778: - ; + return rewriteValueAMD64_OpAMD64ORWconst(v, config) case OpOffPtr: - // match: (OffPtr [off] ptr) - // cond: - // result: (ADDQconst [off] ptr) - { - off := v.AuxInt - ptr := v.Args[0] - v.Op = OpAMD64ADDQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = off - v.AddArg(ptr) - return true - } - goto end0429f947ee7ac49ff45a243e461a5290 - end0429f947ee7ac49ff45a243e461a5290: - ; + return rewriteValueAMD64_OpOffPtr(v, config) case OpOr16: - // match: (Or16 x y) - // cond: - // result: (ORW x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ORW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto end8fedf2c79d5607b7056b0ff015199cbd - end8fedf2c79d5607b7056b0ff015199cbd: - ; + return rewriteValueAMD64_OpOr16(v, config) case OpOr32: - // match: (Or32 x y) - // cond: - // result: (ORL x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ORL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto endea45bed9ca97d2995b68b53e6012d384 - endea45bed9ca97d2995b68b53e6012d384: - ; + return rewriteValueAMD64_OpOr32(v, config) case OpOr64: - // match: (Or64 x y) - // cond: - // result: (ORQ x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ORQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto end3a446becaf2461f4f1a41faeef313f41 - end3a446becaf2461f4f1a41faeef313f41: - ; + return rewriteValueAMD64_OpOr64(v, config) case OpOr8: - // match: (Or8 x y) - // cond: - // result: (ORB x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ORB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto end6f8a8c559a167d1f0a5901d09a1fb248 - end6f8a8c559a167d1f0a5901d09a1fb248: - ; + return rewriteValueAMD64_OpOr8(v, config) case OpRsh16Ux16: - // match: (Rsh16Ux16 x y) - // cond: - // result: (ANDW (SHRW x y) (SBBLcarrymask (CMPWconst [16] y))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ANDW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHRW, TypeInvalid) - v0.Type = t - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) - v2.AuxInt = 16 - v2.AddArg(y) - v2.Type = TypeFlags - v1.AddArg(v2) - v.AddArg(v1) - return true - } - goto end4d5e000764dcea396f2d86472c2af6eb - end4d5e000764dcea396f2d86472c2af6eb: - ; + return rewriteValueAMD64_OpRsh16Ux16(v, config) case OpRsh16Ux32: - // match: (Rsh16Ux32 x y) - // cond: - // result: (ANDW (SHRW x y) (SBBLcarrymask (CMPLconst [16] y))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ANDW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHRW, TypeInvalid) - v0.Type = t - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) - v2.AuxInt = 16 - v2.AddArg(y) - v2.Type = TypeFlags - v1.AddArg(v2) - v.AddArg(v1) - return true - } - goto end9ef4fe2ea4565865cd4b3aa9c7596c00 - end9ef4fe2ea4565865cd4b3aa9c7596c00: - ; + return rewriteValueAMD64_OpRsh16Ux32(v, config) case OpRsh16Ux64: - // match: (Rsh16Ux64 x y) - // cond: - // result: (ANDW (SHRW x y) (SBBLcarrymask (CMPQconst [16] y))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ANDW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHRW, TypeInvalid) - v0.Type = t - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) - v2.AuxInt = 16 - v2.AddArg(y) - v2.Type = TypeFlags - v1.AddArg(v2) - v.AddArg(v1) - return true - } - goto end48bc94b9a68aad454eaabc42b2e1d646 - end48bc94b9a68aad454eaabc42b2e1d646: - ; + return rewriteValueAMD64_OpRsh16Ux64(v, config) case OpRsh16Ux8: - // match: (Rsh16Ux8 x y) - // cond: - // result: (ANDW (SHRW x y) (SBBLcarrymask (CMPBconst [16] y))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ANDW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHRW, TypeInvalid) - v0.Type = t - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) - v2.AuxInt = 16 - v2.AddArg(y) - v2.Type = TypeFlags - v1.AddArg(v2) - v.AddArg(v1) - return true - } - goto ende98f618fa53b1f1d5d3f79781d5cb2cc - ende98f618fa53b1f1d5d3f79781d5cb2cc: - ; + return rewriteValueAMD64_OpRsh16Ux8(v, config) case OpRsh16x16: - // match: (Rsh16x16 x y) - // cond: - // result: (SARW x (ORW y (NOTL (SBBLcarrymask (CMPWconst [16] y))))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SARW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = t - v.AddArg(x) - v0 := b.NewValue0(v.Line, OpAMD64ORW, TypeInvalid) - v0.Type = y.Type - v0.AddArg(y) - v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) - v1.Type = y.Type - v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v2.Type = y.Type - v3 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) - v3.AuxInt = 16 - v3.AddArg(y) - v3.Type = TypeFlags - v2.AddArg(v3) - v1.AddArg(v2) - v0.AddArg(v1) - v.AddArg(v0) - return true - } - goto end1de548dcf8d7c7222c7a739809597526 - end1de548dcf8d7c7222c7a739809597526: - ; + return rewriteValueAMD64_OpRsh16x16(v, config) case OpRsh16x32: - // match: (Rsh16x32 x y) - // cond: - // result: (SARW x (ORL y (NOTL (SBBLcarrymask (CMPLconst [16] y))))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SARW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = t - v.AddArg(x) - v0 := b.NewValue0(v.Line, OpAMD64ORL, TypeInvalid) - v0.Type = y.Type - v0.AddArg(y) - v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) - v1.Type = y.Type - v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v2.Type = y.Type - v3 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) - v3.AuxInt = 16 - v3.AddArg(y) - v3.Type = TypeFlags - v2.AddArg(v3) - v1.AddArg(v2) - v0.AddArg(v1) - v.AddArg(v0) - return true - } - goto end74419e1036ea7e0c3a09d05b1eabad22 - end74419e1036ea7e0c3a09d05b1eabad22: - ; + return rewriteValueAMD64_OpRsh16x32(v, config) case OpRsh16x64: - // match: (Rsh16x64 x y) - // cond: - // result: (SARW x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst [16] y))))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SARW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = t - v.AddArg(x) - v0 := b.NewValue0(v.Line, OpAMD64ORQ, TypeInvalid) - v0.Type = y.Type - v0.AddArg(y) - v1 := b.NewValue0(v.Line, OpAMD64NOTQ, TypeInvalid) - v1.Type = y.Type - v2 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) - v2.Type = y.Type - v3 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) - v3.AuxInt = 16 - v3.AddArg(y) - v3.Type = TypeFlags - v2.AddArg(v3) - v1.AddArg(v2) - v0.AddArg(v1) - v.AddArg(v0) - return true - } - goto ende35d1c2918196fae04fca22e80936bab - ende35d1c2918196fae04fca22e80936bab: - ; + return rewriteValueAMD64_OpRsh16x64(v, config) case OpRsh16x8: - // match: (Rsh16x8 x y) - // cond: - // result: (SARW x (ORB y (NOTL (SBBLcarrymask (CMPBconst [16] y))))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SARW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = t - v.AddArg(x) - v0 := b.NewValue0(v.Line, OpAMD64ORB, TypeInvalid) - v0.Type = y.Type - v0.AddArg(y) - v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) - v1.Type = y.Type - v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v2.Type = y.Type - v3 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) - v3.AuxInt = 16 - v3.AddArg(y) - v3.Type = TypeFlags - v2.AddArg(v3) - v1.AddArg(v2) - v0.AddArg(v1) - v.AddArg(v0) - return true - } - goto endaa6a45afc4c6552c1a90a13160578fba - endaa6a45afc4c6552c1a90a13160578fba: - ; + return rewriteValueAMD64_OpRsh16x8(v, config) case OpRsh32Ux16: - // match: (Rsh32Ux16 x y) - // cond: - // result: (ANDL (SHRL x y) (SBBLcarrymask (CMPWconst [32] y))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ANDL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHRL, TypeInvalid) - v0.Type = t - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) - v2.AuxInt = 32 - v2.AddArg(y) - v2.Type = TypeFlags - v1.AddArg(v2) - v.AddArg(v1) - return true - } - goto end74495683df77023ed619b4ecee98d94a - end74495683df77023ed619b4ecee98d94a: - ; + return rewriteValueAMD64_OpRsh32Ux16(v, config) case OpRsh32Ux32: - // match: (Rsh32Ux32 x y) - // cond: - // result: (ANDL (SHRL x y) (SBBLcarrymask (CMPLconst [32] y))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ANDL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHRL, TypeInvalid) - v0.Type = t - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) - v2.AuxInt = 32 - v2.AddArg(y) - v2.Type = TypeFlags - v1.AddArg(v2) - v.AddArg(v1) - return true - } - goto enda7d6c92ab2d7467102db447d6b431b28 - enda7d6c92ab2d7467102db447d6b431b28: - ; + return rewriteValueAMD64_OpRsh32Ux32(v, config) case OpRsh32Ux64: - // match: (Rsh32Ux64 x y) - // cond: - // result: (ANDL (SHRL x y) (SBBLcarrymask (CMPQconst [32] y))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ANDL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHRL, TypeInvalid) - v0.Type = t - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) - v2.AuxInt = 32 - v2.AddArg(y) - v2.Type = TypeFlags - v1.AddArg(v2) - v.AddArg(v1) - return true - } - goto end7c0829166a6219a15de2c0aa688a9bb3 - end7c0829166a6219a15de2c0aa688a9bb3: - ; + return rewriteValueAMD64_OpRsh32Ux64(v, config) case OpRsh32Ux8: - // match: (Rsh32Ux8 x y) - // cond: - // result: (ANDL (SHRL x y) (SBBLcarrymask (CMPBconst [32] y))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ANDL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHRL, TypeInvalid) - v0.Type = t - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) - v2.AuxInt = 32 - v2.AddArg(y) - v2.Type = TypeFlags - v1.AddArg(v2) - v.AddArg(v1) - return true - } - goto end221315aa8a09c9d8d2f243bf445446ea - end221315aa8a09c9d8d2f243bf445446ea: - ; + return rewriteValueAMD64_OpRsh32Ux8(v, config) case OpRsh32x16: - // match: (Rsh32x16 x y) - // cond: - // result: (SARL x (ORW y (NOTL (SBBLcarrymask (CMPWconst [32] y))))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SARL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = t - v.AddArg(x) - v0 := b.NewValue0(v.Line, OpAMD64ORW, TypeInvalid) - v0.Type = y.Type - v0.AddArg(y) - v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) - v1.Type = y.Type - v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v2.Type = y.Type - v3 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) - v3.AuxInt = 32 - v3.AddArg(y) - v3.Type = TypeFlags - v2.AddArg(v3) - v1.AddArg(v2) - v0.AddArg(v1) - v.AddArg(v0) - return true - } - goto end521b60d91648f07fe1be359f1cdbde29 - end521b60d91648f07fe1be359f1cdbde29: - ; + return rewriteValueAMD64_OpRsh32x16(v, config) case OpRsh32x32: - // match: (Rsh32x32 x y) - // cond: - // result: (SARL x (ORL y (NOTL (SBBLcarrymask (CMPLconst [32] y))))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SARL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = t - v.AddArg(x) - v0 := b.NewValue0(v.Line, OpAMD64ORL, TypeInvalid) - v0.Type = y.Type - v0.AddArg(y) - v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) - v1.Type = y.Type - v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v2.Type = y.Type - v3 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) - v3.AuxInt = 32 - v3.AddArg(y) - v3.Type = TypeFlags - v2.AddArg(v3) - v1.AddArg(v2) - v0.AddArg(v1) - v.AddArg(v0) - return true - } - goto end0fc03188975afbca2139e28c38b7cd17 - end0fc03188975afbca2139e28c38b7cd17: - ; + return rewriteValueAMD64_OpRsh32x32(v, config) case OpRsh32x64: - // match: (Rsh32x64 x y) - // cond: - // result: (SARL x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst [32] y))))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SARL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = t - v.AddArg(x) - v0 := b.NewValue0(v.Line, OpAMD64ORQ, TypeInvalid) - v0.Type = y.Type - v0.AddArg(y) - v1 := b.NewValue0(v.Line, OpAMD64NOTQ, TypeInvalid) - v1.Type = y.Type - v2 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) - v2.Type = y.Type - v3 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) - v3.AuxInt = 32 - v3.AddArg(y) - v3.Type = TypeFlags - v2.AddArg(v3) - v1.AddArg(v2) - v0.AddArg(v1) - v.AddArg(v0) - return true - } - goto endf36790cc7ba330d448b403a450a7c1d4 - endf36790cc7ba330d448b403a450a7c1d4: - ; + return rewriteValueAMD64_OpRsh32x64(v, config) case OpRsh32x8: - // match: (Rsh32x8 x y) - // cond: - // result: (SARL x (ORB y (NOTL (SBBLcarrymask (CMPBconst [32] y))))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SARL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = t - v.AddArg(x) - v0 := b.NewValue0(v.Line, OpAMD64ORB, TypeInvalid) - v0.Type = y.Type - v0.AddArg(y) - v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) - v1.Type = y.Type - v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v2.Type = y.Type - v3 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) - v3.AuxInt = 32 - v3.AddArg(y) - v3.Type = TypeFlags - v2.AddArg(v3) - v1.AddArg(v2) - v0.AddArg(v1) - v.AddArg(v0) - return true - } - goto end1242709228488be2f2505ead8eabb871 - end1242709228488be2f2505ead8eabb871: - ; + return rewriteValueAMD64_OpRsh32x8(v, config) case OpRsh64Ux16: - // match: (Rsh64Ux16 x y) - // cond: - // result: (ANDQ (SHRQ x y) (SBBQcarrymask (CMPWconst [64] y))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ANDQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHRQ, TypeInvalid) - v0.Type = t - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) - v2.AuxInt = 64 - v2.AddArg(y) - v2.Type = TypeFlags - v1.AddArg(v2) - v.AddArg(v1) - return true - } - goto end0bc6c36a57ebaf0b90fc418f976fe210 - end0bc6c36a57ebaf0b90fc418f976fe210: - ; + return rewriteValueAMD64_OpRsh64Ux16(v, config) case OpRsh64Ux32: - // match: (Rsh64Ux32 x y) - // cond: - // result: (ANDQ (SHRQ x y) (SBBQcarrymask (CMPLconst [64] y))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ANDQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHRQ, TypeInvalid) - v0.Type = t - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) - v2.AuxInt = 64 - v2.AddArg(y) - v2.Type = TypeFlags - v1.AddArg(v2) - v.AddArg(v1) - return true - } - goto ende3f52062f53bc3b5aa0461a644e38a1b - ende3f52062f53bc3b5aa0461a644e38a1b: - ; + return rewriteValueAMD64_OpRsh64Ux32(v, config) case OpRsh64Ux64: - // match: (Rsh64Ux64 x y) - // cond: - // result: (ANDQ (SHRQ x y) (SBBQcarrymask (CMPQconst [64] y))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ANDQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHRQ, TypeInvalid) - v0.Type = t - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) - v2.AuxInt = 64 - v2.AddArg(y) - v2.Type = TypeFlags - v1.AddArg(v2) - v.AddArg(v1) - return true - } - goto endaec410d0544f817303c79bad739c50fd - endaec410d0544f817303c79bad739c50fd: - ; + return rewriteValueAMD64_OpRsh64Ux64(v, config) case OpRsh64Ux8: - // match: (Rsh64Ux8 x y) - // cond: - // result: (ANDQ (SHRQ x y) (SBBQcarrymask (CMPBconst [64] y))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ANDQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHRQ, TypeInvalid) - v0.Type = t - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) - v2.AuxInt = 64 - v2.AddArg(y) - v2.Type = TypeFlags - v1.AddArg(v2) - v.AddArg(v1) - return true - } - goto end0318851ecb02e4ad8a2669034adf7862 - end0318851ecb02e4ad8a2669034adf7862: - ; + return rewriteValueAMD64_OpRsh64Ux8(v, config) case OpRsh64x16: - // match: (Rsh64x16 x y) - // cond: - // result: (SARQ x (ORW y (NOTL (SBBLcarrymask (CMPWconst [64] y))))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SARQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = t - v.AddArg(x) - v0 := b.NewValue0(v.Line, OpAMD64ORW, TypeInvalid) - v0.Type = y.Type - v0.AddArg(y) - v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) - v1.Type = y.Type - v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v2.Type = y.Type - v3 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) - v3.AuxInt = 64 - v3.AddArg(y) - v3.Type = TypeFlags - v2.AddArg(v3) - v1.AddArg(v2) - v0.AddArg(v1) - v.AddArg(v0) - return true - } - goto endcf8bbca9a7a848fbebaaaa8b699cd086 - endcf8bbca9a7a848fbebaaaa8b699cd086: - ; + return rewriteValueAMD64_OpRsh64x16(v, config) case OpRsh64x32: - // match: (Rsh64x32 x y) - // cond: - // result: (SARQ x (ORL y (NOTL (SBBLcarrymask (CMPLconst [64] y))))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SARQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = t - v.AddArg(x) - v0 := b.NewValue0(v.Line, OpAMD64ORL, TypeInvalid) - v0.Type = y.Type - v0.AddArg(y) - v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) - v1.Type = y.Type - v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v2.Type = y.Type - v3 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) - v3.AuxInt = 64 - v3.AddArg(y) - v3.Type = TypeFlags - v2.AddArg(v3) - v1.AddArg(v2) - v0.AddArg(v1) - v.AddArg(v0) - return true - } - goto end7604d45b06ee69bf2feddf88b2f33cb6 - end7604d45b06ee69bf2feddf88b2f33cb6: - ; + return rewriteValueAMD64_OpRsh64x32(v, config) case OpRsh64x64: - // match: (Rsh64x64 x y) - // cond: - // result: (SARQ x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst [64] y))))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SARQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = t - v.AddArg(x) - v0 := b.NewValue0(v.Line, OpAMD64ORQ, TypeInvalid) - v0.Type = y.Type - v0.AddArg(y) - v1 := b.NewValue0(v.Line, OpAMD64NOTQ, TypeInvalid) - v1.Type = y.Type - v2 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) - v2.Type = y.Type - v3 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) - v3.AuxInt = 64 - v3.AddArg(y) - v3.Type = TypeFlags - v2.AddArg(v3) - v1.AddArg(v2) - v0.AddArg(v1) - v.AddArg(v0) - return true - } - goto end12a3b44af604b515ad5530502336486f - end12a3b44af604b515ad5530502336486f: - ; + return rewriteValueAMD64_OpRsh64x64(v, config) case OpRsh64x8: - // match: (Rsh64x8 x y) - // cond: - // result: (SARQ x (ORB y (NOTL (SBBLcarrymask (CMPBconst [64] y))))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SARQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = t - v.AddArg(x) - v0 := b.NewValue0(v.Line, OpAMD64ORB, TypeInvalid) - v0.Type = y.Type - v0.AddArg(y) - v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) - v1.Type = y.Type - v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v2.Type = y.Type - v3 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) - v3.AuxInt = 64 - v3.AddArg(y) - v3.Type = TypeFlags - v2.AddArg(v3) - v1.AddArg(v2) - v0.AddArg(v1) - v.AddArg(v0) - return true - } - goto end4e2a83809914aad301a2f74d3c38fbbb - end4e2a83809914aad301a2f74d3c38fbbb: - ; + return rewriteValueAMD64_OpRsh64x8(v, config) case OpRsh8Ux16: - // match: (Rsh8Ux16 x y) - // cond: - // result: (ANDB (SHRB x y) (SBBLcarrymask (CMPWconst [8] y))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ANDB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHRB, TypeInvalid) - v0.Type = t - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) - v2.AuxInt = 8 - v2.AddArg(y) - v2.Type = TypeFlags - v1.AddArg(v2) - v.AddArg(v1) - return true - } - goto end724175a51b6efac60c6bb9d83d81215a - end724175a51b6efac60c6bb9d83d81215a: - ; + return rewriteValueAMD64_OpRsh8Ux16(v, config) case OpRsh8Ux32: - // match: (Rsh8Ux32 x y) - // cond: - // result: (ANDB (SHRB x y) (SBBLcarrymask (CMPLconst [8] y))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ANDB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHRB, TypeInvalid) - v0.Type = t - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) - v2.AuxInt = 8 - v2.AddArg(y) - v2.Type = TypeFlags - v1.AddArg(v2) - v.AddArg(v1) - return true - } - goto end9d973431bed6682c1d557a535cf440ed - end9d973431bed6682c1d557a535cf440ed: - ; + return rewriteValueAMD64_OpRsh8Ux32(v, config) case OpRsh8Ux64: - // match: (Rsh8Ux64 x y) - // cond: - // result: (ANDB (SHRB x y) (SBBLcarrymask (CMPQconst [8] y))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ANDB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHRB, TypeInvalid) - v0.Type = t - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) - v2.AuxInt = 8 - v2.AddArg(y) - v2.Type = TypeFlags - v1.AddArg(v2) - v.AddArg(v1) - return true - } - goto end9586937cdeb7946c337d46cd30cb9a11 - end9586937cdeb7946c337d46cd30cb9a11: - ; + return rewriteValueAMD64_OpRsh8Ux64(v, config) case OpRsh8Ux8: - // match: (Rsh8Ux8 x y) - // cond: - // result: (ANDB (SHRB x y) (SBBLcarrymask (CMPBconst [8] y))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64ANDB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHRB, TypeInvalid) - v0.Type = t - v0.AddArg(x) - v0.AddArg(y) - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) - v2.AuxInt = 8 - v2.AddArg(y) - v2.Type = TypeFlags - v1.AddArg(v2) - v.AddArg(v1) - return true - } - goto endc5a55ef63d86e6b8d4d366a947bf563d - endc5a55ef63d86e6b8d4d366a947bf563d: - ; + return rewriteValueAMD64_OpRsh8Ux8(v, config) case OpRsh8x16: - // match: (Rsh8x16 x y) - // cond: - // result: (SARB x (ORW y (NOTL (SBBLcarrymask (CMPWconst [8] y))))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SARB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = t - v.AddArg(x) - v0 := b.NewValue0(v.Line, OpAMD64ORW, TypeInvalid) - v0.Type = y.Type - v0.AddArg(y) - v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) - v1.Type = y.Type - v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v2.Type = y.Type - v3 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) - v3.AuxInt = 8 - v3.AddArg(y) - v3.Type = TypeFlags - v2.AddArg(v3) - v1.AddArg(v2) - v0.AddArg(v1) - v.AddArg(v0) - return true - } - goto endfa967d6583c1bb9644514c2013b919f8 - endfa967d6583c1bb9644514c2013b919f8: - ; + return rewriteValueAMD64_OpRsh8x16(v, config) case OpRsh8x32: - // match: (Rsh8x32 x y) - // cond: - // result: (SARB x (ORL y (NOTL (SBBLcarrymask (CMPLconst [8] y))))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SARB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = t - v.AddArg(x) - v0 := b.NewValue0(v.Line, OpAMD64ORL, TypeInvalid) - v0.Type = y.Type - v0.AddArg(y) - v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) - v1.Type = y.Type - v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v2.Type = y.Type - v3 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) - v3.AuxInt = 8 - v3.AddArg(y) - v3.Type = TypeFlags - v2.AddArg(v3) - v1.AddArg(v2) - v0.AddArg(v1) - v.AddArg(v0) - return true - } - goto ende5a630810624a1bd3677618c2cbc8619 - ende5a630810624a1bd3677618c2cbc8619: - ; + return rewriteValueAMD64_OpRsh8x32(v, config) case OpRsh8x64: - // match: (Rsh8x64 x y) - // cond: - // result: (SARB x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst [8] y))))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SARB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = t - v.AddArg(x) - v0 := b.NewValue0(v.Line, OpAMD64ORQ, TypeInvalid) - v0.Type = y.Type - v0.AddArg(y) - v1 := b.NewValue0(v.Line, OpAMD64NOTQ, TypeInvalid) - v1.Type = y.Type - v2 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) - v2.Type = y.Type - v3 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) - v3.AuxInt = 8 - v3.AddArg(y) - v3.Type = TypeFlags - v2.AddArg(v3) - v1.AddArg(v2) - v0.AddArg(v1) - v.AddArg(v0) - return true - } - goto end23c55e49d8bc44afc680b2a4eade5af6 - end23c55e49d8bc44afc680b2a4eade5af6: - ; + return rewriteValueAMD64_OpRsh8x64(v, config) case OpRsh8x8: - // match: (Rsh8x8 x y) - // cond: - // result: (SARB x (ORB y (NOTL (SBBLcarrymask (CMPBconst [8] y))))) - { - t := v.Type - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SARB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = t - v.AddArg(x) - v0 := b.NewValue0(v.Line, OpAMD64ORB, TypeInvalid) - v0.Type = y.Type - v0.AddArg(y) - v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) - v1.Type = y.Type - v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v2.Type = y.Type - v3 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) - v3.AuxInt = 8 - v3.AddArg(y) - v3.Type = TypeFlags - v2.AddArg(v3) - v1.AddArg(v2) - v0.AddArg(v1) - v.AddArg(v0) - return true - } - goto enddab0c33c56e2e9434b880e1718621979 - enddab0c33c56e2e9434b880e1718621979: - ; + return rewriteValueAMD64_OpRsh8x8(v, config) case OpAMD64SARB: - // match: (SARB x (MOVBconst [c])) - // cond: - // result: (SARBconst [c&31] x) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64MOVBconst { - goto end3bf3d17717aa6c04462e56d1c87902ce - } - c := v.Args[1].AuxInt - v.Op = OpAMD64SARBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c & 31 - v.AddArg(x) - return true - } - goto end3bf3d17717aa6c04462e56d1c87902ce - end3bf3d17717aa6c04462e56d1c87902ce: - ; + return rewriteValueAMD64_OpAMD64SARB(v, config) case OpAMD64SARBconst: - // match: (SARBconst [c] (MOVQconst [d])) - // cond: - // result: (MOVQconst [d>>uint64(c)]) - { - c := v.AuxInt - if v.Args[0].Op != OpAMD64MOVQconst { - goto end06e0e38775f0650ed672427d19cd8fff - } - d := v.Args[0].AuxInt - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = d >> uint64(c) - return true - } - goto end06e0e38775f0650ed672427d19cd8fff - end06e0e38775f0650ed672427d19cd8fff: - ; + return rewriteValueAMD64_OpAMD64SARBconst(v, config) case OpAMD64SARL: - // match: (SARL x (MOVLconst [c])) - // cond: - // result: (SARLconst [c&31] x) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64MOVLconst { - goto ende586a72c1b232ee0b63e37c71eeb8470 - } - c := v.Args[1].AuxInt - v.Op = OpAMD64SARLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c & 31 - v.AddArg(x) - return true - } - goto ende586a72c1b232ee0b63e37c71eeb8470 - ende586a72c1b232ee0b63e37c71eeb8470: - ; + return rewriteValueAMD64_OpAMD64SARL(v, config) case OpAMD64SARLconst: - // match: (SARLconst [c] (MOVQconst [d])) - // cond: - // result: (MOVQconst [d>>uint64(c)]) - { - c := v.AuxInt - if v.Args[0].Op != OpAMD64MOVQconst { - goto end8f34dc94323303e75b7bcc8e731cf1db - } - d := v.Args[0].AuxInt - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = d >> uint64(c) - return true - } - goto end8f34dc94323303e75b7bcc8e731cf1db - end8f34dc94323303e75b7bcc8e731cf1db: - ; + return rewriteValueAMD64_OpAMD64SARLconst(v, config) case OpAMD64SARQ: - // match: (SARQ x (MOVQconst [c])) - // cond: - // result: (SARQconst [c&63] x) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64MOVQconst { - goto end25e720ab203be2745dded5550e6d8a7c - } - c := v.Args[1].AuxInt - v.Op = OpAMD64SARQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c & 63 - v.AddArg(x) - return true - } - goto end25e720ab203be2745dded5550e6d8a7c - end25e720ab203be2745dded5550e6d8a7c: - ; + return rewriteValueAMD64_OpAMD64SARQ(v, config) case OpAMD64SARQconst: - // match: (SARQconst [c] (MOVQconst [d])) - // cond: - // result: (MOVQconst [d>>uint64(c)]) - { - c := v.AuxInt - if v.Args[0].Op != OpAMD64MOVQconst { - goto endd949ba69a1ff71ba62c49b39c68f269e - } - d := v.Args[0].AuxInt - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = d >> uint64(c) - return true - } - goto endd949ba69a1ff71ba62c49b39c68f269e - endd949ba69a1ff71ba62c49b39c68f269e: - ; + return rewriteValueAMD64_OpAMD64SARQconst(v, config) case OpAMD64SARW: - // match: (SARW x (MOVWconst [c])) - // cond: - // result: (SARWconst [c&31] x) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64MOVWconst { - goto endc46e3f211f94238f9a0aec3c498af490 - } - c := v.Args[1].AuxInt - v.Op = OpAMD64SARWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c & 31 - v.AddArg(x) - return true - } - goto endc46e3f211f94238f9a0aec3c498af490 - endc46e3f211f94238f9a0aec3c498af490: - ; + return rewriteValueAMD64_OpAMD64SARW(v, config) case OpAMD64SARWconst: - // match: (SARWconst [c] (MOVQconst [d])) - // cond: - // result: (MOVQconst [d>>uint64(c)]) - { - c := v.AuxInt - if v.Args[0].Op != OpAMD64MOVQconst { - goto endca23e80dba22ab574f843c7a4cef24ab - } - d := v.Args[0].AuxInt - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = d >> uint64(c) - return true - } - goto endca23e80dba22ab574f843c7a4cef24ab - endca23e80dba22ab574f843c7a4cef24ab: - ; + return rewriteValueAMD64_OpAMD64SARWconst(v, config) case OpAMD64SBBLcarrymask: - // match: (SBBLcarrymask (CMPQconst [c] (MOVQconst [d]))) - // cond: inBounds64(d, c) - // result: (MOVLconst [-1]) - { - if v.Args[0].Op != OpAMD64CMPQconst { - goto end490c8a7039bab41e90e564fbb8500233 - } - c := v.Args[0].AuxInt - if v.Args[0].Args[0].Op != OpAMD64MOVQconst { - goto end490c8a7039bab41e90e564fbb8500233 - } - d := v.Args[0].Args[0].AuxInt - if !(inBounds64(d, c)) { - goto end490c8a7039bab41e90e564fbb8500233 - } - v.Op = OpAMD64MOVLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = -1 - return true - } - goto end490c8a7039bab41e90e564fbb8500233 - end490c8a7039bab41e90e564fbb8500233: - ; - // match: (SBBLcarrymask (CMPQconst [c] (MOVQconst [d]))) - // cond: !inBounds64(d, c) - // result: (MOVLconst [0]) - { - if v.Args[0].Op != OpAMD64CMPQconst { - goto end95e703eabe71d831b7a3d2f9fabe7de9 - } - c := v.Args[0].AuxInt - if v.Args[0].Args[0].Op != OpAMD64MOVQconst { - goto end95e703eabe71d831b7a3d2f9fabe7de9 - } - d := v.Args[0].Args[0].AuxInt - if !(!inBounds64(d, c)) { - goto end95e703eabe71d831b7a3d2f9fabe7de9 - } - v.Op = OpAMD64MOVLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 0 - return true - } - goto end95e703eabe71d831b7a3d2f9fabe7de9 - end95e703eabe71d831b7a3d2f9fabe7de9: - ; - // match: (SBBLcarrymask (CMPLconst [c] (MOVLconst [d]))) - // cond: inBounds32(d, c) - // result: (MOVLconst [-1]) - { - if v.Args[0].Op != OpAMD64CMPLconst { - goto end00c0a561340b0172c9a21f63648b86e2 - } - c := v.Args[0].AuxInt - if v.Args[0].Args[0].Op != OpAMD64MOVLconst { - goto end00c0a561340b0172c9a21f63648b86e2 - } - d := v.Args[0].Args[0].AuxInt - if !(inBounds32(d, c)) { - goto end00c0a561340b0172c9a21f63648b86e2 - } - v.Op = OpAMD64MOVLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = -1 - return true - } - goto end00c0a561340b0172c9a21f63648b86e2 - end00c0a561340b0172c9a21f63648b86e2: - ; - // match: (SBBLcarrymask (CMPLconst [c] (MOVLconst [d]))) - // cond: !inBounds32(d, c) - // result: (MOVLconst [0]) - { - if v.Args[0].Op != OpAMD64CMPLconst { - goto enda73c8bf14f7b45dd97c6a006e317b0b8 - } - c := v.Args[0].AuxInt - if v.Args[0].Args[0].Op != OpAMD64MOVLconst { - goto enda73c8bf14f7b45dd97c6a006e317b0b8 - } - d := v.Args[0].Args[0].AuxInt - if !(!inBounds32(d, c)) { - goto enda73c8bf14f7b45dd97c6a006e317b0b8 - } - v.Op = OpAMD64MOVLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 0 - return true - } - goto enda73c8bf14f7b45dd97c6a006e317b0b8 - enda73c8bf14f7b45dd97c6a006e317b0b8: - ; - // match: (SBBLcarrymask (CMPWconst [c] (MOVWconst [d]))) - // cond: inBounds16(d, c) - // result: (MOVLconst [-1]) - { - if v.Args[0].Op != OpAMD64CMPWconst { - goto endb94dc44cd77f66ed3bf3742874b666fc - } - c := v.Args[0].AuxInt - if v.Args[0].Args[0].Op != OpAMD64MOVWconst { - goto endb94dc44cd77f66ed3bf3742874b666fc - } - d := v.Args[0].Args[0].AuxInt - if !(inBounds16(d, c)) { - goto endb94dc44cd77f66ed3bf3742874b666fc - } - v.Op = OpAMD64MOVLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = -1 - return true - } - goto endb94dc44cd77f66ed3bf3742874b666fc - endb94dc44cd77f66ed3bf3742874b666fc: - ; - // match: (SBBLcarrymask (CMPWconst [c] (MOVWconst [d]))) - // cond: !inBounds16(d, c) - // result: (MOVLconst [0]) - { - if v.Args[0].Op != OpAMD64CMPWconst { - goto end7a02def6194822f7ab937d78088504d2 - } - c := v.Args[0].AuxInt - if v.Args[0].Args[0].Op != OpAMD64MOVWconst { - goto end7a02def6194822f7ab937d78088504d2 - } - d := v.Args[0].Args[0].AuxInt - if !(!inBounds16(d, c)) { - goto end7a02def6194822f7ab937d78088504d2 - } - v.Op = OpAMD64MOVLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 0 - return true - } - goto end7a02def6194822f7ab937d78088504d2 - end7a02def6194822f7ab937d78088504d2: - ; - // match: (SBBLcarrymask (CMPBconst [c] (MOVBconst [d]))) - // cond: inBounds8(d, c) - // result: (MOVLconst [-1]) - { - if v.Args[0].Op != OpAMD64CMPBconst { - goto end79c8e4a20761df731521e6cd956c4245 - } - c := v.Args[0].AuxInt - if v.Args[0].Args[0].Op != OpAMD64MOVBconst { - goto end79c8e4a20761df731521e6cd956c4245 - } - d := v.Args[0].Args[0].AuxInt - if !(inBounds8(d, c)) { - goto end79c8e4a20761df731521e6cd956c4245 - } - v.Op = OpAMD64MOVLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = -1 - return true - } - goto end79c8e4a20761df731521e6cd956c4245 - end79c8e4a20761df731521e6cd956c4245: - ; - // match: (SBBLcarrymask (CMPBconst [c] (MOVBconst [d]))) - // cond: !inBounds8(d, c) - // result: (MOVLconst [0]) - { - if v.Args[0].Op != OpAMD64CMPBconst { - goto end95b5b21dd7756ae41575759a1eff2bea - } - c := v.Args[0].AuxInt - if v.Args[0].Args[0].Op != OpAMD64MOVBconst { - goto end95b5b21dd7756ae41575759a1eff2bea - } - d := v.Args[0].Args[0].AuxInt - if !(!inBounds8(d, c)) { - goto end95b5b21dd7756ae41575759a1eff2bea - } - v.Op = OpAMD64MOVLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 0 - return true - } - goto end95b5b21dd7756ae41575759a1eff2bea - end95b5b21dd7756ae41575759a1eff2bea: - ; + return rewriteValueAMD64_OpAMD64SBBLcarrymask(v, config) case OpAMD64SBBQcarrymask: - // match: (SBBQcarrymask (CMPQconst [c] (MOVQconst [d]))) - // cond: inBounds64(d, c) - // result: (MOVQconst [-1]) - { - if v.Args[0].Op != OpAMD64CMPQconst { - goto end0c26df98feb38f149eca12f33c15de1b - } - c := v.Args[0].AuxInt - if v.Args[0].Args[0].Op != OpAMD64MOVQconst { - goto end0c26df98feb38f149eca12f33c15de1b - } - d := v.Args[0].Args[0].AuxInt - if !(inBounds64(d, c)) { - goto end0c26df98feb38f149eca12f33c15de1b - } - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = -1 - return true - } - goto end0c26df98feb38f149eca12f33c15de1b - end0c26df98feb38f149eca12f33c15de1b: - ; - // match: (SBBQcarrymask (CMPQconst [c] (MOVQconst [d]))) - // cond: !inBounds64(d, c) - // result: (MOVQconst [0]) - { - if v.Args[0].Op != OpAMD64CMPQconst { - goto end8965aa1e1153e5ecd123bbb31a618570 - } - c := v.Args[0].AuxInt - if v.Args[0].Args[0].Op != OpAMD64MOVQconst { - goto end8965aa1e1153e5ecd123bbb31a618570 - } - d := v.Args[0].Args[0].AuxInt - if !(!inBounds64(d, c)) { - goto end8965aa1e1153e5ecd123bbb31a618570 - } - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 0 - return true - } - goto end8965aa1e1153e5ecd123bbb31a618570 - end8965aa1e1153e5ecd123bbb31a618570: - ; - // match: (SBBQcarrymask (CMPLconst [c] (MOVLconst [d]))) - // cond: inBounds32(d, c) - // result: (MOVQconst [-1]) - { - if v.Args[0].Op != OpAMD64CMPLconst { - goto end8772ede6098981a61af0f478841d7d54 - } - c := v.Args[0].AuxInt - if v.Args[0].Args[0].Op != OpAMD64MOVLconst { - goto end8772ede6098981a61af0f478841d7d54 - } - d := v.Args[0].Args[0].AuxInt - if !(inBounds32(d, c)) { - goto end8772ede6098981a61af0f478841d7d54 - } - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = -1 - return true - } - goto end8772ede6098981a61af0f478841d7d54 - end8772ede6098981a61af0f478841d7d54: - ; - // match: (SBBQcarrymask (CMPLconst [c] (MOVLconst [d]))) - // cond: !inBounds32(d, c) - // result: (MOVQconst [0]) - { - if v.Args[0].Op != OpAMD64CMPLconst { - goto end2d535e90075ee777fc616e6b9847a384 - } - c := v.Args[0].AuxInt - if v.Args[0].Args[0].Op != OpAMD64MOVLconst { - goto end2d535e90075ee777fc616e6b9847a384 - } - d := v.Args[0].Args[0].AuxInt - if !(!inBounds32(d, c)) { - goto end2d535e90075ee777fc616e6b9847a384 - } - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 0 - return true - } - goto end2d535e90075ee777fc616e6b9847a384 - end2d535e90075ee777fc616e6b9847a384: - ; - // match: (SBBQcarrymask (CMPWconst [c] (MOVWconst [d]))) - // cond: inBounds16(d, c) - // result: (MOVQconst [-1]) - { - if v.Args[0].Op != OpAMD64CMPWconst { - goto end3103c51e14b4fc894b4170f16f37eebc - } - c := v.Args[0].AuxInt - if v.Args[0].Args[0].Op != OpAMD64MOVWconst { - goto end3103c51e14b4fc894b4170f16f37eebc - } - d := v.Args[0].Args[0].AuxInt - if !(inBounds16(d, c)) { - goto end3103c51e14b4fc894b4170f16f37eebc - } - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = -1 - return true - } - goto end3103c51e14b4fc894b4170f16f37eebc - end3103c51e14b4fc894b4170f16f37eebc: - ; - // match: (SBBQcarrymask (CMPWconst [c] (MOVWconst [d]))) - // cond: !inBounds16(d, c) - // result: (MOVQconst [0]) - { - if v.Args[0].Op != OpAMD64CMPWconst { - goto enddae2191a59cfef5efb04ebab9354745c - } - c := v.Args[0].AuxInt - if v.Args[0].Args[0].Op != OpAMD64MOVWconst { - goto enddae2191a59cfef5efb04ebab9354745c - } - d := v.Args[0].Args[0].AuxInt - if !(!inBounds16(d, c)) { - goto enddae2191a59cfef5efb04ebab9354745c - } - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 0 - return true - } - goto enddae2191a59cfef5efb04ebab9354745c - enddae2191a59cfef5efb04ebab9354745c: - ; - // match: (SBBQcarrymask (CMPBconst [c] (MOVBconst [d]))) - // cond: inBounds8(d, c) - // result: (MOVQconst [-1]) - { - if v.Args[0].Op != OpAMD64CMPBconst { - goto end72e088325ca005b0251b1ee82da3c5d9 - } - c := v.Args[0].AuxInt - if v.Args[0].Args[0].Op != OpAMD64MOVBconst { - goto end72e088325ca005b0251b1ee82da3c5d9 - } - d := v.Args[0].Args[0].AuxInt - if !(inBounds8(d, c)) { - goto end72e088325ca005b0251b1ee82da3c5d9 - } - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = -1 - return true - } - goto end72e088325ca005b0251b1ee82da3c5d9 - end72e088325ca005b0251b1ee82da3c5d9: - ; - // match: (SBBQcarrymask (CMPBconst [c] (MOVBconst [d]))) - // cond: !inBounds8(d, c) - // result: (MOVQconst [0]) - { - if v.Args[0].Op != OpAMD64CMPBconst { - goto endcb388100f5b933aa94095096d2bb425e - } - c := v.Args[0].AuxInt - if v.Args[0].Args[0].Op != OpAMD64MOVBconst { - goto endcb388100f5b933aa94095096d2bb425e - } - d := v.Args[0].Args[0].AuxInt - if !(!inBounds8(d, c)) { - goto endcb388100f5b933aa94095096d2bb425e - } - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 0 - return true - } - goto endcb388100f5b933aa94095096d2bb425e - endcb388100f5b933aa94095096d2bb425e: - ; + return rewriteValueAMD64_OpAMD64SBBQcarrymask(v, config) case OpAMD64SETA: - // match: (SETA (InvertFlags x)) - // cond: - // result: (SETB x) - { - if v.Args[0].Op != OpAMD64InvertFlags { - goto enda4ac36e94fc279d762b5a6c7c6cc665d - } - x := v.Args[0].Args[0] - v.Op = OpAMD64SETB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto enda4ac36e94fc279d762b5a6c7c6cc665d - enda4ac36e94fc279d762b5a6c7c6cc665d: - ; + return rewriteValueAMD64_OpAMD64SETA(v, config) case OpAMD64SETAE: - // match: (SETAE (InvertFlags x)) - // cond: - // result: (SETBE x) - { - if v.Args[0].Op != OpAMD64InvertFlags { - goto end0468f5be6caf682fdea6b91d6648991e - } - x := v.Args[0].Args[0] - v.Op = OpAMD64SETBE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto end0468f5be6caf682fdea6b91d6648991e - end0468f5be6caf682fdea6b91d6648991e: - ; + return rewriteValueAMD64_OpAMD64SETAE(v, config) case OpAMD64SETB: - // match: (SETB (InvertFlags x)) - // cond: - // result: (SETA x) - { - if v.Args[0].Op != OpAMD64InvertFlags { - goto endc9eba7aa1e54a228570d2f5cc96f3565 - } - x := v.Args[0].Args[0] - v.Op = OpAMD64SETA - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto endc9eba7aa1e54a228570d2f5cc96f3565 - endc9eba7aa1e54a228570d2f5cc96f3565: - ; + return rewriteValueAMD64_OpAMD64SETB(v, config) case OpAMD64SETBE: - // match: (SETBE (InvertFlags x)) - // cond: - // result: (SETAE x) - { - if v.Args[0].Op != OpAMD64InvertFlags { - goto end9d9031643469798b14b8cad1f5a7a1ba - } - x := v.Args[0].Args[0] - v.Op = OpAMD64SETAE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto end9d9031643469798b14b8cad1f5a7a1ba - end9d9031643469798b14b8cad1f5a7a1ba: - ; + return rewriteValueAMD64_OpAMD64SETBE(v, config) case OpAMD64SETEQ: - // match: (SETEQ (InvertFlags x)) - // cond: - // result: (SETEQ x) - { - if v.Args[0].Op != OpAMD64InvertFlags { - goto end5d2039c9368d8c0cfba23b5a85b459e1 - } - x := v.Args[0].Args[0] - v.Op = OpAMD64SETEQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto end5d2039c9368d8c0cfba23b5a85b459e1 - end5d2039c9368d8c0cfba23b5a85b459e1: - ; + return rewriteValueAMD64_OpAMD64SETEQ(v, config) case OpAMD64SETG: - // match: (SETG (InvertFlags x)) - // cond: - // result: (SETL x) - { - if v.Args[0].Op != OpAMD64InvertFlags { - goto endf7586738694c9cd0b74ae28bbadb649f - } - x := v.Args[0].Args[0] - v.Op = OpAMD64SETL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto endf7586738694c9cd0b74ae28bbadb649f - endf7586738694c9cd0b74ae28bbadb649f: - ; + return rewriteValueAMD64_OpAMD64SETG(v, config) case OpAMD64SETGE: - // match: (SETGE (InvertFlags x)) - // cond: - // result: (SETLE x) - { - if v.Args[0].Op != OpAMD64InvertFlags { - goto end82c11eff6f842159f564f2dad3d2eedc - } - x := v.Args[0].Args[0] - v.Op = OpAMD64SETLE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto end82c11eff6f842159f564f2dad3d2eedc - end82c11eff6f842159f564f2dad3d2eedc: - ; + return rewriteValueAMD64_OpAMD64SETGE(v, config) case OpAMD64SETL: - // match: (SETL (InvertFlags x)) - // cond: - // result: (SETG x) - { - if v.Args[0].Op != OpAMD64InvertFlags { - goto ende33160cd86b9d4d3b77e02fb4658d5d3 - } - x := v.Args[0].Args[0] - v.Op = OpAMD64SETG - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto ende33160cd86b9d4d3b77e02fb4658d5d3 - ende33160cd86b9d4d3b77e02fb4658d5d3: - ; + return rewriteValueAMD64_OpAMD64SETL(v, config) case OpAMD64SETLE: - // match: (SETLE (InvertFlags x)) - // cond: - // result: (SETGE x) - { - if v.Args[0].Op != OpAMD64InvertFlags { - goto end9307d96753efbeb888d1c98a6aba7a29 - } - x := v.Args[0].Args[0] - v.Op = OpAMD64SETGE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto end9307d96753efbeb888d1c98a6aba7a29 - end9307d96753efbeb888d1c98a6aba7a29: - ; + return rewriteValueAMD64_OpAMD64SETLE(v, config) case OpAMD64SETNE: - // match: (SETNE (InvertFlags x)) - // cond: - // result: (SETNE x) - { - if v.Args[0].Op != OpAMD64InvertFlags { - goto endbc71811b789475308014550f638026eb - } - x := v.Args[0].Args[0] - v.Op = OpAMD64SETNE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto endbc71811b789475308014550f638026eb - endbc71811b789475308014550f638026eb: - ; + return rewriteValueAMD64_OpAMD64SETNE(v, config) case OpAMD64SHLB: - // match: (SHLB x (MOVBconst [c])) - // cond: - // result: (SHLBconst [c&31] x) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64MOVBconst { - goto end2d0d0111d831d8a575b5627284a6337a - } - c := v.Args[1].AuxInt - v.Op = OpAMD64SHLBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c & 31 - v.AddArg(x) - return true - } - goto end2d0d0111d831d8a575b5627284a6337a - end2d0d0111d831d8a575b5627284a6337a: - ; + return rewriteValueAMD64_OpAMD64SHLB(v, config) case OpAMD64SHLL: - // match: (SHLL x (MOVLconst [c])) - // cond: - // result: (SHLLconst [c&31] x) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64MOVLconst { - goto end633f9ddcfbb63374c895a5f78da75d25 - } - c := v.Args[1].AuxInt - v.Op = OpAMD64SHLLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c & 31 - v.AddArg(x) - return true - } - goto end633f9ddcfbb63374c895a5f78da75d25 - end633f9ddcfbb63374c895a5f78da75d25: - ; + return rewriteValueAMD64_OpAMD64SHLL(v, config) case OpAMD64SHLQ: - // match: (SHLQ x (MOVQconst [c])) - // cond: - // result: (SHLQconst [c&63] x) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64MOVQconst { - goto end4d7e3a945cacdd6b6c8c0de6f465d4ae - } - c := v.Args[1].AuxInt - v.Op = OpAMD64SHLQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c & 63 - v.AddArg(x) - return true - } - goto end4d7e3a945cacdd6b6c8c0de6f465d4ae - end4d7e3a945cacdd6b6c8c0de6f465d4ae: - ; + return rewriteValueAMD64_OpAMD64SHLQ(v, config) case OpAMD64SHLW: - // match: (SHLW x (MOVWconst [c])) - // cond: - // result: (SHLWconst [c&31] x) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64MOVWconst { - goto endba96a52aa58d28b3357828051e0e695c - } - c := v.Args[1].AuxInt - v.Op = OpAMD64SHLWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c & 31 - v.AddArg(x) - return true - } - goto endba96a52aa58d28b3357828051e0e695c - endba96a52aa58d28b3357828051e0e695c: - ; + return rewriteValueAMD64_OpAMD64SHLW(v, config) case OpAMD64SHRB: - // match: (SHRB x (MOVBconst [c])) - // cond: - // result: (SHRBconst [c&31] x) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64MOVBconst { - goto enddb1cd5aaa826d43fa4f6d1b2b8795e58 - } - c := v.Args[1].AuxInt - v.Op = OpAMD64SHRBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c & 31 - v.AddArg(x) - return true - } - goto enddb1cd5aaa826d43fa4f6d1b2b8795e58 - enddb1cd5aaa826d43fa4f6d1b2b8795e58: - ; + return rewriteValueAMD64_OpAMD64SHRB(v, config) case OpAMD64SHRL: - // match: (SHRL x (MOVLconst [c])) - // cond: - // result: (SHRLconst [c&31] x) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64MOVLconst { - goto end344b8b9202e1925e8d0561f1c21412fc - } - c := v.Args[1].AuxInt - v.Op = OpAMD64SHRLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c & 31 - v.AddArg(x) - return true - } - goto end344b8b9202e1925e8d0561f1c21412fc - end344b8b9202e1925e8d0561f1c21412fc: - ; + return rewriteValueAMD64_OpAMD64SHRL(v, config) case OpAMD64SHRQ: - // match: (SHRQ x (MOVQconst [c])) - // cond: - // result: (SHRQconst [c&63] x) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64MOVQconst { - goto end699d35e2d5cfa08b8a3b1c8a183ddcf3 - } - c := v.Args[1].AuxInt - v.Op = OpAMD64SHRQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c & 63 - v.AddArg(x) - return true - } - goto end699d35e2d5cfa08b8a3b1c8a183ddcf3 - end699d35e2d5cfa08b8a3b1c8a183ddcf3: - ; + return rewriteValueAMD64_OpAMD64SHRQ(v, config) case OpAMD64SHRW: - // match: (SHRW x (MOVWconst [c])) - // cond: - // result: (SHRWconst [c&31] x) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64MOVWconst { - goto endd75ff1f9b3e9ec9c942a39b6179da1b3 - } - c := v.Args[1].AuxInt - v.Op = OpAMD64SHRWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c & 31 - v.AddArg(x) - return true - } - goto endd75ff1f9b3e9ec9c942a39b6179da1b3 - endd75ff1f9b3e9ec9c942a39b6179da1b3: - ; + return rewriteValueAMD64_OpAMD64SHRW(v, config) case OpAMD64SUBB: - // match: (SUBB x (MOVBconst [c])) - // cond: - // result: (SUBBconst x [c]) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64MOVBconst { - goto end9ca5d2a70e2df1a5a3ed6786bce1f7b2 - } - c := v.Args[1].AuxInt - v.Op = OpAMD64SUBBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AuxInt = c - return true - } - goto end9ca5d2a70e2df1a5a3ed6786bce1f7b2 - end9ca5d2a70e2df1a5a3ed6786bce1f7b2: - ; - // match: (SUBB (MOVBconst [c]) x) - // cond: - // result: (NEGB (SUBBconst x [c])) - { - if v.Args[0].Op != OpAMD64MOVBconst { - goto endc288755d69b04d24a6aac32a73956411 - } - c := v.Args[0].AuxInt - x := v.Args[1] - v.Op = OpAMD64NEGB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SUBBconst, TypeInvalid) - v0.Type = v.Type - v0.AddArg(x) - v0.AuxInt = c - v.AddArg(v0) - return true - } - goto endc288755d69b04d24a6aac32a73956411 - endc288755d69b04d24a6aac32a73956411: - ; - // match: (SUBB x x) - // cond: - // result: (MOVBconst [0]) - { - x := v.Args[0] - if v.Args[1] != x { - goto ende8904403d937d95b0d6133d3ec92bb45 - } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 0 - return true - } - goto ende8904403d937d95b0d6133d3ec92bb45 - ende8904403d937d95b0d6133d3ec92bb45: - ; + return rewriteValueAMD64_OpAMD64SUBB(v, config) case OpAMD64SUBBconst: - // match: (SUBBconst [c] (MOVBconst [d])) - // cond: - // result: (MOVBconst [d-c]) - { - c := v.AuxInt - if v.Args[0].Op != OpAMD64MOVBconst { - goto enddc5383558e2f3eae507afcb94eada964 - } - d := v.Args[0].AuxInt - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = d - c - return true - } - goto enddc5383558e2f3eae507afcb94eada964 - enddc5383558e2f3eae507afcb94eada964: - ; - // match: (SUBBconst [c] (SUBBconst [d] x)) - // cond: - // result: (ADDBconst [-c-d] x) - { - c := v.AuxInt - if v.Args[0].Op != OpAMD64SUBBconst { - goto end035c57413a46eb347ecb3736d1510915 - } - d := v.Args[0].AuxInt - x := v.Args[0].Args[0] - v.Op = OpAMD64ADDBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = -c - d - v.AddArg(x) - return true - } - goto end035c57413a46eb347ecb3736d1510915 - end035c57413a46eb347ecb3736d1510915: - ; + return rewriteValueAMD64_OpAMD64SUBBconst(v, config) case OpAMD64SUBL: - // match: (SUBL x (MOVLconst [c])) - // cond: - // result: (SUBLconst x [c]) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64MOVLconst { - goto end178c1d6c86f9c16f6497586c2f7d8625 - } - c := v.Args[1].AuxInt - v.Op = OpAMD64SUBLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AuxInt = c - return true - } - goto end178c1d6c86f9c16f6497586c2f7d8625 - end178c1d6c86f9c16f6497586c2f7d8625: - ; - // match: (SUBL (MOVLconst [c]) x) - // cond: - // result: (NEGL (SUBLconst x [c])) - { - if v.Args[0].Op != OpAMD64MOVLconst { - goto endb0efe6e15ec20486b849534a00483ae2 - } - c := v.Args[0].AuxInt - x := v.Args[1] - v.Op = OpAMD64NEGL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SUBLconst, TypeInvalid) - v0.Type = v.Type - v0.AddArg(x) - v0.AuxInt = c - v.AddArg(v0) - return true - } - goto endb0efe6e15ec20486b849534a00483ae2 - endb0efe6e15ec20486b849534a00483ae2: - ; - // match: (SUBL x x) - // cond: - // result: (MOVLconst [0]) - { - x := v.Args[0] - if v.Args[1] != x { - goto end332f1f641f875c69bea7289191e69133 - } - v.Op = OpAMD64MOVLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 0 - return true - } - goto end332f1f641f875c69bea7289191e69133 - end332f1f641f875c69bea7289191e69133: - ; + return rewriteValueAMD64_OpAMD64SUBL(v, config) case OpAMD64SUBLconst: - // match: (SUBLconst [c] (MOVLconst [d])) - // cond: - // result: (MOVLconst [d-c]) - { - c := v.AuxInt - if v.Args[0].Op != OpAMD64MOVLconst { - goto end6c5c6d58d4bdd0a5c2f7bf10b343b41e - } - d := v.Args[0].AuxInt - v.Op = OpAMD64MOVLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = d - c - return true - } - goto end6c5c6d58d4bdd0a5c2f7bf10b343b41e - end6c5c6d58d4bdd0a5c2f7bf10b343b41e: - ; - // match: (SUBLconst [c] (SUBLconst [d] x)) - // cond: - // result: (ADDLconst [-c-d] x) - { - c := v.AuxInt - if v.Args[0].Op != OpAMD64SUBLconst { - goto end0c9ffb11e8a56ced1b14dbf6bf9a6737 - } - d := v.Args[0].AuxInt - x := v.Args[0].Args[0] - v.Op = OpAMD64ADDLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = -c - d - v.AddArg(x) - return true - } - goto end0c9ffb11e8a56ced1b14dbf6bf9a6737 - end0c9ffb11e8a56ced1b14dbf6bf9a6737: - ; + return rewriteValueAMD64_OpAMD64SUBLconst(v, config) case OpAMD64SUBQ: - // match: (SUBQ x (MOVQconst [c])) - // cond: is32Bit(c) - // result: (SUBQconst x [c]) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64MOVQconst { - goto end9bbb7b20824a498752c605942fad89c2 - } - c := v.Args[1].AuxInt - if !(is32Bit(c)) { - goto end9bbb7b20824a498752c605942fad89c2 - } - v.Op = OpAMD64SUBQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AuxInt = c - return true - } - goto end9bbb7b20824a498752c605942fad89c2 - end9bbb7b20824a498752c605942fad89c2: - ; - // match: (SUBQ (MOVQconst [c]) x) - // cond: is32Bit(c) - // result: (NEGQ (SUBQconst x [c])) - { - if v.Args[0].Op != OpAMD64MOVQconst { - goto end8beb96de3efee9206d1bd4b7d777d2cb - } - c := v.Args[0].AuxInt - x := v.Args[1] - if !(is32Bit(c)) { - goto end8beb96de3efee9206d1bd4b7d777d2cb - } - v.Op = OpAMD64NEGQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SUBQconst, TypeInvalid) - v0.Type = v.Type - v0.AddArg(x) - v0.AuxInt = c - v.AddArg(v0) - return true - } - goto end8beb96de3efee9206d1bd4b7d777d2cb - end8beb96de3efee9206d1bd4b7d777d2cb: - ; - // match: (SUBQ x x) - // cond: - // result: (MOVQconst [0]) - { - x := v.Args[0] - if v.Args[1] != x { - goto endd87d1d839d2dc54d9c90fa4f73383480 - } - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 0 - return true - } - goto endd87d1d839d2dc54d9c90fa4f73383480 - endd87d1d839d2dc54d9c90fa4f73383480: - ; + return rewriteValueAMD64_OpAMD64SUBQ(v, config) case OpAMD64SUBQconst: - // match: (SUBQconst [c] (MOVQconst [d])) - // cond: - // result: (MOVQconst [d-c]) - { - c := v.AuxInt - if v.Args[0].Op != OpAMD64MOVQconst { - goto endb0daebe6831cf381377c3e4248070f25 - } - d := v.Args[0].AuxInt - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = d - c - return true - } - goto endb0daebe6831cf381377c3e4248070f25 - endb0daebe6831cf381377c3e4248070f25: - ; - // match: (SUBQconst [c] (SUBQconst [d] x)) - // cond: - // result: (ADDQconst [-c-d] x) - { - c := v.AuxInt - if v.Args[0].Op != OpAMD64SUBQconst { - goto end2d40ddb5ae9e90679456254c61858d9d - } - d := v.Args[0].AuxInt - x := v.Args[0].Args[0] - v.Op = OpAMD64ADDQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = -c - d - v.AddArg(x) - return true - } - goto end2d40ddb5ae9e90679456254c61858d9d - end2d40ddb5ae9e90679456254c61858d9d: - ; + return rewriteValueAMD64_OpAMD64SUBQconst(v, config) case OpAMD64SUBW: - // match: (SUBW x (MOVWconst [c])) - // cond: - // result: (SUBWconst x [c]) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64MOVWconst { - goto end135aa9100b2f61d58b37cede37b63731 - } - c := v.Args[1].AuxInt - v.Op = OpAMD64SUBWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AuxInt = c - return true - } - goto end135aa9100b2f61d58b37cede37b63731 - end135aa9100b2f61d58b37cede37b63731: - ; - // match: (SUBW (MOVWconst [c]) x) - // cond: - // result: (NEGW (SUBWconst x [c])) - { - if v.Args[0].Op != OpAMD64MOVWconst { - goto end44d23f7e65a4b1c42d0e6463f8e493b6 - } - c := v.Args[0].AuxInt - x := v.Args[1] - v.Op = OpAMD64NEGW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SUBWconst, TypeInvalid) - v0.Type = v.Type - v0.AddArg(x) - v0.AuxInt = c - v.AddArg(v0) - return true - } - goto end44d23f7e65a4b1c42d0e6463f8e493b6 - end44d23f7e65a4b1c42d0e6463f8e493b6: - ; - // match: (SUBW x x) - // cond: - // result: (MOVWconst [0]) - { - x := v.Args[0] - if v.Args[1] != x { - goto endb970e7c318d04a1afe1dfe08a7ca0d9c - } - v.Op = OpAMD64MOVWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 0 - return true - } - goto endb970e7c318d04a1afe1dfe08a7ca0d9c - endb970e7c318d04a1afe1dfe08a7ca0d9c: - ; + return rewriteValueAMD64_OpAMD64SUBW(v, config) case OpAMD64SUBWconst: - // match: (SUBWconst [c] (MOVWconst [d])) - // cond: - // result: (MOVWconst [d-c]) - { - c := v.AuxInt - if v.Args[0].Op != OpAMD64MOVWconst { - goto endae629a229c399eaed7dbb95b1b0e6f8a - } - d := v.Args[0].AuxInt - v.Op = OpAMD64MOVWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = d - c - return true - } - goto endae629a229c399eaed7dbb95b1b0e6f8a - endae629a229c399eaed7dbb95b1b0e6f8a: - ; - // match: (SUBWconst [c] (SUBWconst [d] x)) - // cond: - // result: (ADDWconst [-c-d] x) - { - c := v.AuxInt - if v.Args[0].Op != OpAMD64SUBWconst { - goto enda59f08d12aa08717b0443b7bb1b71374 - } - d := v.Args[0].AuxInt - x := v.Args[0].Args[0] - v.Op = OpAMD64ADDWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = -c - d - v.AddArg(x) - return true - } - goto enda59f08d12aa08717b0443b7bb1b71374 - enda59f08d12aa08717b0443b7bb1b71374: - ; + return rewriteValueAMD64_OpAMD64SUBWconst(v, config) case OpSignExt16to32: - // match: (SignExt16to32 x) - // cond: - // result: (MOVWQSX x) - { - x := v.Args[0] - v.Op = OpAMD64MOVWQSX - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto end21e4271c2b48a5aa3561ccfa8fa67cd9 - end21e4271c2b48a5aa3561ccfa8fa67cd9: - ; + return rewriteValueAMD64_OpSignExt16to32(v, config) case OpSignExt16to64: - // match: (SignExt16to64 x) - // cond: - // result: (MOVWQSX x) - { - x := v.Args[0] - v.Op = OpAMD64MOVWQSX - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto endc6d242ee3a3e195ef0f9e8dae47ada75 - endc6d242ee3a3e195ef0f9e8dae47ada75: - ; + return rewriteValueAMD64_OpSignExt16to64(v, config) case OpSignExt32to64: - // match: (SignExt32to64 x) - // cond: - // result: (MOVLQSX x) - { - x := v.Args[0] - v.Op = OpAMD64MOVLQSX - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto endb9f1a8b2d01eee44964a71a01bca165c - endb9f1a8b2d01eee44964a71a01bca165c: - ; + return rewriteValueAMD64_OpSignExt32to64(v, config) case OpSignExt8to16: - // match: (SignExt8to16 x) - // cond: - // result: (MOVBQSX x) - { - x := v.Args[0] - v.Op = OpAMD64MOVBQSX - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto end372869f08e147404b80634e5f83fd506 - end372869f08e147404b80634e5f83fd506: - ; + return rewriteValueAMD64_OpSignExt8to16(v, config) case OpSignExt8to32: - // match: (SignExt8to32 x) - // cond: - // result: (MOVBQSX x) - { - x := v.Args[0] - v.Op = OpAMD64MOVBQSX - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto end913e3575e5b4cf7f60585c108db40464 - end913e3575e5b4cf7f60585c108db40464: - ; + return rewriteValueAMD64_OpSignExt8to32(v, config) case OpSignExt8to64: - // match: (SignExt8to64 x) - // cond: - // result: (MOVBQSX x) - { - x := v.Args[0] - v.Op = OpAMD64MOVBQSX - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto endcef6d6001d3f25cf5dacee11a46e5c8c - endcef6d6001d3f25cf5dacee11a46e5c8c: - ; + return rewriteValueAMD64_OpSignExt8to64(v, config) case OpSqrt: - // match: (Sqrt x) - // cond: - // result: (SQRTSD x) - { - x := v.Args[0] - v.Op = OpAMD64SQRTSD - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto end72f79ca9ec139e15856aaa03338cf543 - end72f79ca9ec139e15856aaa03338cf543: - ; + return rewriteValueAMD64_OpSqrt(v, config) case OpStaticCall: - // match: (StaticCall [argwid] {target} mem) - // cond: - // result: (CALLstatic [argwid] {target} mem) - { - argwid := v.AuxInt - target := v.Aux - mem := v.Args[0] - v.Op = OpAMD64CALLstatic - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = argwid - v.Aux = target - v.AddArg(mem) - return true - } - goto end32c5cbec813d1c2ae94fc9b1090e4b2a - end32c5cbec813d1c2ae94fc9b1090e4b2a: - ; + return rewriteValueAMD64_OpStaticCall(v, config) case OpStore: - // match: (Store [8] ptr val mem) - // cond: is64BitFloat(val.Type) - // result: (MOVSDstore ptr val mem) - { - if v.AuxInt != 8 { - goto endaeec4f61bc8e67dbf3fa2f79fe4c2b9e - } - ptr := v.Args[0] - val := v.Args[1] - mem := v.Args[2] - if !(is64BitFloat(val.Type)) { - goto endaeec4f61bc8e67dbf3fa2f79fe4c2b9e - } - v.Op = OpAMD64MOVSDstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(ptr) - v.AddArg(val) - v.AddArg(mem) - return true - } - goto endaeec4f61bc8e67dbf3fa2f79fe4c2b9e - endaeec4f61bc8e67dbf3fa2f79fe4c2b9e: - ; - // match: (Store [4] ptr val mem) - // cond: is32BitFloat(val.Type) - // result: (MOVSSstore ptr val mem) - { - if v.AuxInt != 4 { - goto endf638ca0a75871b5062da15324d0e0384 - } - ptr := v.Args[0] - val := v.Args[1] - mem := v.Args[2] - if !(is32BitFloat(val.Type)) { - goto endf638ca0a75871b5062da15324d0e0384 - } - v.Op = OpAMD64MOVSSstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(ptr) - v.AddArg(val) - v.AddArg(mem) - return true - } - goto endf638ca0a75871b5062da15324d0e0384 - endf638ca0a75871b5062da15324d0e0384: - ; - // match: (Store [8] ptr val mem) - // cond: - // result: (MOVQstore ptr val mem) - { - if v.AuxInt != 8 { - goto endd1eb7c3ea0c806e7a53ff3be86186eb7 - } - ptr := v.Args[0] - val := v.Args[1] - mem := v.Args[2] - v.Op = OpAMD64MOVQstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(ptr) - v.AddArg(val) - v.AddArg(mem) - return true - } - goto endd1eb7c3ea0c806e7a53ff3be86186eb7 - endd1eb7c3ea0c806e7a53ff3be86186eb7: - ; - // match: (Store [4] ptr val mem) - // cond: - // result: (MOVLstore ptr val mem) - { - if v.AuxInt != 4 { - goto end44e3b22360da76ecd59be9a8c2dd1347 - } - ptr := v.Args[0] - val := v.Args[1] - mem := v.Args[2] - v.Op = OpAMD64MOVLstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(ptr) - v.AddArg(val) - v.AddArg(mem) - return true - } - goto end44e3b22360da76ecd59be9a8c2dd1347 - end44e3b22360da76ecd59be9a8c2dd1347: - ; - // match: (Store [2] ptr val mem) - // cond: - // result: (MOVWstore ptr val mem) - { - if v.AuxInt != 2 { - goto endd0342b7fd3d0713f3e26922660047c71 - } - ptr := v.Args[0] - val := v.Args[1] - mem := v.Args[2] - v.Op = OpAMD64MOVWstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(ptr) - v.AddArg(val) - v.AddArg(mem) - return true - } - goto endd0342b7fd3d0713f3e26922660047c71 - endd0342b7fd3d0713f3e26922660047c71: - ; - // match: (Store [1] ptr val mem) - // cond: - // result: (MOVBstore ptr val mem) - { - if v.AuxInt != 1 { - goto end8e76e20031197ca875889d2b4d0eb1d1 - } - ptr := v.Args[0] - val := v.Args[1] - mem := v.Args[2] - v.Op = OpAMD64MOVBstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(ptr) - v.AddArg(val) - v.AddArg(mem) - return true - } - goto end8e76e20031197ca875889d2b4d0eb1d1 - end8e76e20031197ca875889d2b4d0eb1d1: - ; + return rewriteValueAMD64_OpStore(v, config) case OpSub16: - // match: (Sub16 x y) - // cond: - // result: (SUBW x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SUBW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto end54adc5de883c0460ca71c6ee464d4244 - end54adc5de883c0460ca71c6ee464d4244: - ; + return rewriteValueAMD64_OpSub16(v, config) case OpSub32: - // match: (Sub32 x y) - // cond: - // result: (SUBL x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SUBL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto enddc3a2a488bda8c5856f93343e5ffe5f8 - enddc3a2a488bda8c5856f93343e5ffe5f8: - ; + return rewriteValueAMD64_OpSub32(v, config) case OpSub32F: - // match: (Sub32F x y) - // cond: - // result: (SUBSS x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SUBSS - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto end20193c1804b0e707702a884fb8abd60d - end20193c1804b0e707702a884fb8abd60d: - ; + return rewriteValueAMD64_OpSub32F(v, config) case OpSub64: - // match: (Sub64 x y) - // cond: - // result: (SUBQ x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SUBQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto endd88d5646309fd9174584888ecc8aca2c - endd88d5646309fd9174584888ecc8aca2c: - ; + return rewriteValueAMD64_OpSub64(v, config) case OpSub64F: - // match: (Sub64F x y) - // cond: - // result: (SUBSD x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SUBSD - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto end5d5af7b8a3326bf9151f00a0013b73d7 - end5d5af7b8a3326bf9151f00a0013b73d7: - ; + return rewriteValueAMD64_OpSub64F(v, config) case OpSub8: - // match: (Sub8 x y) - // cond: - // result: (SUBB x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SUBB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto end7d33bf9bdfa505f96b930563eca7955f - end7d33bf9bdfa505f96b930563eca7955f: - ; + return rewriteValueAMD64_OpSub8(v, config) case OpSubPtr: - // match: (SubPtr x y) - // cond: - // result: (SUBQ x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SUBQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto end748f63f755afe0b97a8f3cf7e4d9cbfe - end748f63f755afe0b97a8f3cf7e4d9cbfe: - ; + return rewriteValueAMD64_OpSubPtr(v, config) case OpTrunc16to8: - // match: (Trunc16to8 x) - // cond: - // result: x - { - x := v.Args[0] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = x.Type - v.AddArg(x) - return true - } - goto end8e2f5e0a6e3a06423c077747de6c2bdd - end8e2f5e0a6e3a06423c077747de6c2bdd: - ; + return rewriteValueAMD64_OpTrunc16to8(v, config) case OpTrunc32to16: - // match: (Trunc32to16 x) - // cond: - // result: x - { - x := v.Args[0] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = x.Type - v.AddArg(x) - return true - } - goto end5bed0e3a3c1c6374d86beb5a4397708c - end5bed0e3a3c1c6374d86beb5a4397708c: - ; + return rewriteValueAMD64_OpTrunc32to16(v, config) case OpTrunc32to8: - // match: (Trunc32to8 x) - // cond: - // result: x - { - x := v.Args[0] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = x.Type - v.AddArg(x) - return true - } - goto endef0b8032ce91979ce6cd0004260c04ee - endef0b8032ce91979ce6cd0004260c04ee: - ; + return rewriteValueAMD64_OpTrunc32to8(v, config) case OpTrunc64to16: - // match: (Trunc64to16 x) - // cond: - // result: x - { - x := v.Args[0] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = x.Type - v.AddArg(x) - return true - } - goto endd32fd6e0ce970c212835e6f71c3dcbfd - endd32fd6e0ce970c212835e6f71c3dcbfd: - ; + return rewriteValueAMD64_OpTrunc64to16(v, config) case OpTrunc64to32: - // match: (Trunc64to32 x) - // cond: - // result: x - { - x := v.Args[0] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = x.Type - v.AddArg(x) - return true - } - goto end1212c4e84153210aff7fd630fb3e1883 - end1212c4e84153210aff7fd630fb3e1883: - ; + return rewriteValueAMD64_OpTrunc64to32(v, config) case OpTrunc64to8: - // match: (Trunc64to8 x) - // cond: - // result: x - { - x := v.Args[0] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = x.Type - v.AddArg(x) - return true - } - goto end734f017d4b2810ca2288f7037365824c - end734f017d4b2810ca2288f7037365824c: - ; + return rewriteValueAMD64_OpTrunc64to8(v, config) case OpAMD64XORB: - // match: (XORB x (MOVBconst [c])) - // cond: - // result: (XORBconst [c] x) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64MOVBconst { - goto enda9ed9fdd115ffdffa8127c007c34d7b7 - } - c := v.Args[1].AuxInt - v.Op = OpAMD64XORBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c - v.AddArg(x) - return true - } - goto enda9ed9fdd115ffdffa8127c007c34d7b7 - enda9ed9fdd115ffdffa8127c007c34d7b7: - ; - // match: (XORB (MOVBconst [c]) x) - // cond: - // result: (XORBconst [c] x) - { - if v.Args[0].Op != OpAMD64MOVBconst { - goto endb02a07d9dc7b802c59f013116e952f3f - } - c := v.Args[0].AuxInt - x := v.Args[1] - v.Op = OpAMD64XORBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c - v.AddArg(x) - return true - } - goto endb02a07d9dc7b802c59f013116e952f3f - endb02a07d9dc7b802c59f013116e952f3f: - ; - // match: (XORB x x) - // cond: - // result: (MOVBconst [0]) - { - x := v.Args[0] - if v.Args[1] != x { - goto end2afddc39503d04d572a3a07878f6c9c9 - } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 0 - return true - } - goto end2afddc39503d04d572a3a07878f6c9c9 - end2afddc39503d04d572a3a07878f6c9c9: - ; + return rewriteValueAMD64_OpAMD64XORB(v, config) case OpAMD64XORBconst: - // match: (XORBconst [c] (MOVBconst [d])) - // cond: - // result: (MOVBconst [c^d]) - { - c := v.AuxInt - if v.Args[0].Op != OpAMD64MOVBconst { - goto end6d8d1b612af9d253605c8bc69b822903 - } - d := v.Args[0].AuxInt - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c ^ d - return true - } - goto end6d8d1b612af9d253605c8bc69b822903 - end6d8d1b612af9d253605c8bc69b822903: - ; + return rewriteValueAMD64_OpAMD64XORBconst(v, config) case OpAMD64XORL: - // match: (XORL x (MOVLconst [c])) - // cond: - // result: (XORLconst [c] x) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64MOVLconst { - goto enda9459d509d3416da67d13a22dd074a9c - } - c := v.Args[1].AuxInt - v.Op = OpAMD64XORLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c - v.AddArg(x) - return true - } - goto enda9459d509d3416da67d13a22dd074a9c - enda9459d509d3416da67d13a22dd074a9c: - ; - // match: (XORL (MOVLconst [c]) x) - // cond: - // result: (XORLconst [c] x) - { - if v.Args[0].Op != OpAMD64MOVLconst { - goto end9c1a0af00eeadd8aa325e55f1f3fb89c - } - c := v.Args[0].AuxInt - x := v.Args[1] - v.Op = OpAMD64XORLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c - v.AddArg(x) - return true - } - goto end9c1a0af00eeadd8aa325e55f1f3fb89c - end9c1a0af00eeadd8aa325e55f1f3fb89c: - ; - // match: (XORL x x) - // cond: - // result: (MOVLconst [0]) - { - x := v.Args[0] - if v.Args[1] != x { - goto end7bcf9cfeb69a0d7647389124eb53ce2a - } - v.Op = OpAMD64MOVLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 0 - return true - } - goto end7bcf9cfeb69a0d7647389124eb53ce2a - end7bcf9cfeb69a0d7647389124eb53ce2a: - ; + return rewriteValueAMD64_OpAMD64XORL(v, config) case OpAMD64XORLconst: - // match: (XORLconst [c] (MOVLconst [d])) - // cond: - // result: (MOVLconst [c^d]) - { - c := v.AuxInt - if v.Args[0].Op != OpAMD64MOVLconst { - goto end71238075b10b68a226903cc453c4715c - } - d := v.Args[0].AuxInt - v.Op = OpAMD64MOVLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c ^ d - return true - } - goto end71238075b10b68a226903cc453c4715c - end71238075b10b68a226903cc453c4715c: - ; + return rewriteValueAMD64_OpAMD64XORLconst(v, config) case OpAMD64XORQ: - // match: (XORQ x (MOVQconst [c])) - // cond: is32Bit(c) - // result: (XORQconst [c] x) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64MOVQconst { - goto end452341f950062e0483f16438fb9ec500 - } - c := v.Args[1].AuxInt - if !(is32Bit(c)) { - goto end452341f950062e0483f16438fb9ec500 - } - v.Op = OpAMD64XORQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c - v.AddArg(x) - return true - } - goto end452341f950062e0483f16438fb9ec500 - end452341f950062e0483f16438fb9ec500: - ; - // match: (XORQ (MOVQconst [c]) x) - // cond: is32Bit(c) - // result: (XORQconst [c] x) - { - if v.Args[0].Op != OpAMD64MOVQconst { - goto endd221a7e3daaaaa29ee385ad36e061b57 - } - c := v.Args[0].AuxInt - x := v.Args[1] - if !(is32Bit(c)) { - goto endd221a7e3daaaaa29ee385ad36e061b57 - } - v.Op = OpAMD64XORQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c - v.AddArg(x) - return true - } - goto endd221a7e3daaaaa29ee385ad36e061b57 - endd221a7e3daaaaa29ee385ad36e061b57: - ; - // match: (XORQ x x) - // cond: - // result: (MOVQconst [0]) - { - x := v.Args[0] - if v.Args[1] != x { - goto end10575a5d711cf14e6d4dffbb0e8dfaeb - } - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 0 - return true - } - goto end10575a5d711cf14e6d4dffbb0e8dfaeb - end10575a5d711cf14e6d4dffbb0e8dfaeb: - ; + return rewriteValueAMD64_OpAMD64XORQ(v, config) case OpAMD64XORQconst: - // match: (XORQconst [c] (MOVQconst [d])) - // cond: - // result: (MOVQconst [c^d]) - { - c := v.AuxInt - if v.Args[0].Op != OpAMD64MOVQconst { - goto end3f404d4f07362319fbad2e1ba0827a9f - } - d := v.Args[0].AuxInt - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c ^ d - return true - } - goto end3f404d4f07362319fbad2e1ba0827a9f - end3f404d4f07362319fbad2e1ba0827a9f: - ; + return rewriteValueAMD64_OpAMD64XORQconst(v, config) case OpAMD64XORW: - // match: (XORW x (MOVWconst [c])) - // cond: - // result: (XORWconst [c] x) - { - x := v.Args[0] - if v.Args[1].Op != OpAMD64MOVWconst { - goto end2ca109efd66c221a5691a4da95ec6c67 - } - c := v.Args[1].AuxInt - v.Op = OpAMD64XORWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c - v.AddArg(x) - return true - } - goto end2ca109efd66c221a5691a4da95ec6c67 - end2ca109efd66c221a5691a4da95ec6c67: - ; - // match: (XORW (MOVWconst [c]) x) - // cond: - // result: (XORWconst [c] x) - { - if v.Args[0].Op != OpAMD64MOVWconst { - goto end51ee62a06d4301e5a4aed7a6639b1d53 - } - c := v.Args[0].AuxInt - x := v.Args[1] - v.Op = OpAMD64XORWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c - v.AddArg(x) - return true - } - goto end51ee62a06d4301e5a4aed7a6639b1d53 - end51ee62a06d4301e5a4aed7a6639b1d53: - ; - // match: (XORW x x) - // cond: - // result: (MOVWconst [0]) - { - x := v.Args[0] - if v.Args[1] != x { - goto end07f332e857be0c2707797ed480a2faf4 - } - v.Op = OpAMD64MOVWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 0 - return true - } - goto end07f332e857be0c2707797ed480a2faf4 - end07f332e857be0c2707797ed480a2faf4: - ; + return rewriteValueAMD64_OpAMD64XORW(v, config) case OpAMD64XORWconst: - // match: (XORWconst [c] (MOVWconst [d])) - // cond: - // result: (MOVWconst [c^d]) - { - c := v.AuxInt - if v.Args[0].Op != OpAMD64MOVWconst { - goto ende24881ccdfa8486c4593fd9aa5df1ed6 - } - d := v.Args[0].AuxInt - v.Op = OpAMD64MOVWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c ^ d - return true - } - goto ende24881ccdfa8486c4593fd9aa5df1ed6 - ende24881ccdfa8486c4593fd9aa5df1ed6: - ; + return rewriteValueAMD64_OpAMD64XORWconst(v, config) case OpXor16: - // match: (Xor16 x y) - // cond: - // result: (XORW x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64XORW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto end20efdd5dfd5130abf818de5546a991a0 - end20efdd5dfd5130abf818de5546a991a0: - ; + return rewriteValueAMD64_OpXor16(v, config) case OpXor32: - // match: (Xor32 x y) - // cond: - // result: (XORL x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64XORL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto end9da6bce98b437e2609488346116a75d8 - end9da6bce98b437e2609488346116a75d8: - ; + return rewriteValueAMD64_OpXor32(v, config) case OpXor64: - // match: (Xor64 x y) - // cond: - // result: (XORQ x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64XORQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto endc88cd189c2a6f07ecff324ed94809f8f - endc88cd189c2a6f07ecff324ed94809f8f: - ; + return rewriteValueAMD64_OpXor64(v, config) case OpXor8: - // match: (Xor8 x y) - // cond: - // result: (XORB x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64XORB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto end50f4434ef96916d3e65ad3cc236d1723 - end50f4434ef96916d3e65ad3cc236d1723: - ; + return rewriteValueAMD64_OpXor8(v, config) case OpZero: - // match: (Zero [0] _ mem) - // cond: - // result: mem - { - if v.AuxInt != 0 { - goto endc9a38a60f0322f93682daa824611272c - } - mem := v.Args[1] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = mem.Type - v.AddArg(mem) - return true - } - goto endc9a38a60f0322f93682daa824611272c - endc9a38a60f0322f93682daa824611272c: - ; - // match: (Zero [1] destptr mem) - // cond: - // result: (MOVBstoreconst [0] destptr mem) - { - if v.AuxInt != 1 { - goto ende0161981658beee468c9e2368fe31eb8 - } - destptr := v.Args[0] - mem := v.Args[1] - v.Op = OpAMD64MOVBstoreconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 0 - v.AddArg(destptr) - v.AddArg(mem) - return true - } - goto ende0161981658beee468c9e2368fe31eb8 - ende0161981658beee468c9e2368fe31eb8: - ; - // match: (Zero [2] destptr mem) - // cond: - // result: (MOVWstoreconst [0] destptr mem) - { - if v.AuxInt != 2 { - goto end4e4aaf641bf2818bb71f1397e4685bdd - } - destptr := v.Args[0] - mem := v.Args[1] - v.Op = OpAMD64MOVWstoreconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 0 - v.AddArg(destptr) - v.AddArg(mem) - return true - } - goto end4e4aaf641bf2818bb71f1397e4685bdd - end4e4aaf641bf2818bb71f1397e4685bdd: - ; - // match: (Zero [4] destptr mem) - // cond: - // result: (MOVLstoreconst [0] destptr mem) - { - if v.AuxInt != 4 { - goto end7612f59dd66ebfc632ea5bc85f5437b5 - } - destptr := v.Args[0] - mem := v.Args[1] - v.Op = OpAMD64MOVLstoreconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 0 - v.AddArg(destptr) - v.AddArg(mem) - return true - } - goto end7612f59dd66ebfc632ea5bc85f5437b5 - end7612f59dd66ebfc632ea5bc85f5437b5: - ; - // match: (Zero [8] destptr mem) - // cond: - // result: (MOVQstoreconst [0] destptr mem) - { - if v.AuxInt != 8 { - goto end07aaaebfa15a48c52cd79b68e28d266f - } - destptr := v.Args[0] - mem := v.Args[1] - v.Op = OpAMD64MOVQstoreconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 0 - v.AddArg(destptr) - v.AddArg(mem) - return true - } - goto end07aaaebfa15a48c52cd79b68e28d266f - end07aaaebfa15a48c52cd79b68e28d266f: - ; - // match: (Zero [3] destptr mem) - // cond: - // result: (MOVBstoreconst [makeStoreConst(0,2)] destptr (MOVWstoreconst [0] destptr mem)) - { - if v.AuxInt != 3 { - goto end03b2ae08f901891919e454f05273fb4e - } - destptr := v.Args[0] - mem := v.Args[1] - v.Op = OpAMD64MOVBstoreconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = makeStoreConst(0, 2) - v.AddArg(destptr) - v0 := b.NewValue0(v.Line, OpAMD64MOVWstoreconst, TypeInvalid) - v0.AuxInt = 0 - v0.AddArg(destptr) - v0.AddArg(mem) - v0.Type = TypeMem - v.AddArg(v0) - return true - } - goto end03b2ae08f901891919e454f05273fb4e - end03b2ae08f901891919e454f05273fb4e: - ; - // match: (Zero [5] destptr mem) - // cond: - // result: (MOVBstoreconst [makeStoreConst(0,4)] destptr (MOVLstoreconst [0] destptr mem)) - { - if v.AuxInt != 5 { - goto endc473059deb6291d483262b08312eab48 - } - destptr := v.Args[0] - mem := v.Args[1] - v.Op = OpAMD64MOVBstoreconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = makeStoreConst(0, 4) - v.AddArg(destptr) - v0 := b.NewValue0(v.Line, OpAMD64MOVLstoreconst, TypeInvalid) - v0.AuxInt = 0 - v0.AddArg(destptr) - v0.AddArg(mem) - v0.Type = TypeMem - v.AddArg(v0) - return true - } - goto endc473059deb6291d483262b08312eab48 - endc473059deb6291d483262b08312eab48: - ; - // match: (Zero [6] destptr mem) - // cond: - // result: (MOVWstoreconst [makeStoreConst(0,4)] destptr (MOVLstoreconst [0] destptr mem)) - { - if v.AuxInt != 6 { - goto end41b38839f25e3749384d53b5945bd56b - } - destptr := v.Args[0] - mem := v.Args[1] - v.Op = OpAMD64MOVWstoreconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = makeStoreConst(0, 4) - v.AddArg(destptr) - v0 := b.NewValue0(v.Line, OpAMD64MOVLstoreconst, TypeInvalid) - v0.AuxInt = 0 - v0.AddArg(destptr) - v0.AddArg(mem) - v0.Type = TypeMem - v.AddArg(v0) - return true - } - goto end41b38839f25e3749384d53b5945bd56b - end41b38839f25e3749384d53b5945bd56b: - ; - // match: (Zero [7] destptr mem) - // cond: - // result: (MOVLstoreconst [makeStoreConst(0,3)] destptr (MOVLstoreconst [0] destptr mem)) - { - if v.AuxInt != 7 { - goto end06e677d4c1ac43e08783eb8117a589b6 - } - destptr := v.Args[0] - mem := v.Args[1] - v.Op = OpAMD64MOVLstoreconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = makeStoreConst(0, 3) - v.AddArg(destptr) - v0 := b.NewValue0(v.Line, OpAMD64MOVLstoreconst, TypeInvalid) - v0.AuxInt = 0 - v0.AddArg(destptr) - v0.AddArg(mem) - v0.Type = TypeMem - v.AddArg(v0) - return true - } - goto end06e677d4c1ac43e08783eb8117a589b6 - end06e677d4c1ac43e08783eb8117a589b6: - ; - // match: (Zero [size] destptr mem) - // cond: size%8 != 0 && size > 8 - // result: (Zero [size-size%8] (ADDQconst destptr [size%8]) (MOVQstoreconst [0] destptr mem)) - { - size := v.AuxInt - destptr := v.Args[0] - mem := v.Args[1] - if !(size%8 != 0 && size > 8) { - goto endc8760f86b83b1372fce0042ab5200fc1 - } - v.Op = OpZero - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = size - size%8 - v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) - v0.AddArg(destptr) - v0.AuxInt = size % 8 - v0.Type = config.fe.TypeUInt64() - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeInvalid) - v1.AuxInt = 0 - v1.AddArg(destptr) - v1.AddArg(mem) - v1.Type = TypeMem - v.AddArg(v1) - return true - } - goto endc8760f86b83b1372fce0042ab5200fc1 - endc8760f86b83b1372fce0042ab5200fc1: - ; - // match: (Zero [16] destptr mem) - // cond: - // result: (MOVQstoreconst [makeStoreConst(0,8)] destptr (MOVQstoreconst [0] destptr mem)) - { - if v.AuxInt != 16 { - goto endce0bdb028011236be9f04fb53462204d - } - destptr := v.Args[0] - mem := v.Args[1] - v.Op = OpAMD64MOVQstoreconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = makeStoreConst(0, 8) - v.AddArg(destptr) - v0 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeInvalid) - v0.AuxInt = 0 - v0.AddArg(destptr) - v0.AddArg(mem) - v0.Type = TypeMem - v.AddArg(v0) - return true - } - goto endce0bdb028011236be9f04fb53462204d - endce0bdb028011236be9f04fb53462204d: - ; - // match: (Zero [24] destptr mem) - // cond: - // result: (MOVQstoreconst [makeStoreConst(0,16)] destptr (MOVQstoreconst [makeStoreConst(0,8)] destptr (MOVQstoreconst [0] destptr mem))) - { - if v.AuxInt != 24 { - goto end859fe3911b36516ea096299b2a85350e - } - destptr := v.Args[0] - mem := v.Args[1] - v.Op = OpAMD64MOVQstoreconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = makeStoreConst(0, 16) - v.AddArg(destptr) - v0 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeInvalid) - v0.AuxInt = makeStoreConst(0, 8) - v0.AddArg(destptr) - v1 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeInvalid) - v1.AuxInt = 0 - v1.AddArg(destptr) - v1.AddArg(mem) - v1.Type = TypeMem - v0.AddArg(v1) - v0.Type = TypeMem - v.AddArg(v0) - return true - } - goto end859fe3911b36516ea096299b2a85350e - end859fe3911b36516ea096299b2a85350e: - ; - // match: (Zero [32] destptr mem) - // cond: - // result: (MOVQstoreconst [makeStoreConst(0,24)] destptr (MOVQstoreconst [makeStoreConst(0,16)] destptr (MOVQstoreconst [makeStoreConst(0,8)] destptr (MOVQstoreconst [0] destptr mem)))) - { - if v.AuxInt != 32 { - goto end2c246614f6a9a07f1a683691b3f5780f - } - destptr := v.Args[0] - mem := v.Args[1] - v.Op = OpAMD64MOVQstoreconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = makeStoreConst(0, 24) - v.AddArg(destptr) - v0 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeInvalid) - v0.AuxInt = makeStoreConst(0, 16) - v0.AddArg(destptr) - v1 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeInvalid) - v1.AuxInt = makeStoreConst(0, 8) - v1.AddArg(destptr) - v2 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeInvalid) - v2.AuxInt = 0 - v2.AddArg(destptr) - v2.AddArg(mem) - v2.Type = TypeMem - v1.AddArg(v2) - v1.Type = TypeMem - v0.AddArg(v1) - v0.Type = TypeMem - v.AddArg(v0) - return true - } - goto end2c246614f6a9a07f1a683691b3f5780f - end2c246614f6a9a07f1a683691b3f5780f: - ; - // 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)) - { - size := v.AuxInt - destptr := v.Args[0] - mem := v.Args[1] - if !(size <= 1024 && size%8 == 0 && size%16 != 0) { - goto end240266449c3e493db1c3b38a78682ff0 - } - v.Op = OpZero - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = size - 8 - v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) - v0.AuxInt = 8 - v0.AddArg(destptr) - v0.Type = config.fe.TypeUInt64() - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64MOVQstore, TypeInvalid) - v1.AddArg(destptr) - v2 := b.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) - v2.AuxInt = 0 - v2.Type = config.fe.TypeUInt64() - v1.AddArg(v2) - v1.AddArg(mem) - v1.Type = TypeMem - v.AddArg(v1) - return true - } - goto end240266449c3e493db1c3b38a78682ff0 - end240266449c3e493db1c3b38a78682ff0: - ; - // match: (Zero [size] destptr mem) - // cond: size <= 1024 && size%16 == 0 - // result: (DUFFZERO [duffStart(size)] (ADDQconst [duffAdj(size)] destptr) (MOVOconst [0]) mem) - { - size := v.AuxInt - destptr := v.Args[0] - mem := v.Args[1] - if !(size <= 1024 && size%16 == 0) { - goto endf508bb887eee9119069b22c23dbca138 - } - v.Op = OpAMD64DUFFZERO - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = duffStart(size) - v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) - v0.AuxInt = duffAdj(size) - v0.AddArg(destptr) - v0.Type = config.fe.TypeUInt64() - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64MOVOconst, TypeInvalid) - v1.AuxInt = 0 - v1.Type = TypeInt128 - v.AddArg(v1) - v.AddArg(mem) - return true - } - goto endf508bb887eee9119069b22c23dbca138 - endf508bb887eee9119069b22c23dbca138: - ; - // match: (Zero [size] destptr mem) - // cond: size > 1024 && size%8 == 0 - // result: (REPSTOSQ destptr (MOVQconst [size/8]) (MOVQconst [0]) mem) - { - size := v.AuxInt - destptr := v.Args[0] - mem := v.Args[1] - if !(size > 1024 && size%8 == 0) { - goto endb9d55d4ba0e70ed918e3ac757727441b - } - v.Op = OpAMD64REPSTOSQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(destptr) - v0 := b.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) - v0.AuxInt = size / 8 - v0.Type = config.fe.TypeUInt64() - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) - v1.AuxInt = 0 - v1.Type = config.fe.TypeUInt64() - v.AddArg(v1) - v.AddArg(mem) - return true - } - goto endb9d55d4ba0e70ed918e3ac757727441b - endb9d55d4ba0e70ed918e3ac757727441b: - ; + return rewriteValueAMD64_OpZero(v, config) case OpZeroExt16to32: - // match: (ZeroExt16to32 x) - // cond: - // result: (MOVWQZX x) - { - x := v.Args[0] - v.Op = OpAMD64MOVWQZX - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto endbfff79412a2cc96095069c66812844b4 - endbfff79412a2cc96095069c66812844b4: - ; + return rewriteValueAMD64_OpZeroExt16to32(v, config) case OpZeroExt16to64: - // match: (ZeroExt16to64 x) - // cond: - // result: (MOVWQZX x) - { - x := v.Args[0] - v.Op = OpAMD64MOVWQZX - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto end7a40262c5c856101058d2bd518ed0910 - end7a40262c5c856101058d2bd518ed0910: - ; + return rewriteValueAMD64_OpZeroExt16to64(v, config) case OpZeroExt32to64: - // match: (ZeroExt32to64 x) - // cond: - // result: (MOVLQZX x) - { - x := v.Args[0] - v.Op = OpAMD64MOVLQZX - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto enddf83bdc8cc6c5673a9ef7aca7affe45a - enddf83bdc8cc6c5673a9ef7aca7affe45a: - ; + return rewriteValueAMD64_OpZeroExt32to64(v, config) case OpZeroExt8to16: - // match: (ZeroExt8to16 x) - // cond: - // result: (MOVBQZX x) - { - x := v.Args[0] - v.Op = OpAMD64MOVBQZX - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto endd03d53d2a585727e4107ae1a3cc55479 - endd03d53d2a585727e4107ae1a3cc55479: - ; + return rewriteValueAMD64_OpZeroExt8to16(v, config) case OpZeroExt8to32: - // match: (ZeroExt8to32 x) - // cond: - // result: (MOVBQZX x) - { - x := v.Args[0] - v.Op = OpAMD64MOVBQZX - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto endcbd33e965b3dab14fced5ae93d8949de - endcbd33e965b3dab14fced5ae93d8949de: - ; + return rewriteValueAMD64_OpZeroExt8to32(v, config) case OpZeroExt8to64: - // match: (ZeroExt8to64 x) - // cond: - // result: (MOVBQZX x) - { - x := v.Args[0] - v.Op = OpAMD64MOVBQZX - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - return true - } - goto end63ae7cc15db9d15189b2f1342604b2cb - end63ae7cc15db9d15189b2f1342604b2cb: + 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) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVBconst { + goto endab690db69bfd8192eea57a2f9f76bf84 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64ADDBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto endab690db69bfd8192eea57a2f9f76bf84 +endab690db69bfd8192eea57a2f9f76bf84: + ; + // match: (ADDB (MOVBconst [c]) x) + // cond: + // result: (ADDBconst [c] x) + { + if v.Args[0].Op != OpAMD64MOVBconst { + goto end28aa1a4abe7e1abcdd64135e9967d39d + } + c := v.Args[0].AuxInt + x := v.Args[1] + v.Op = OpAMD64ADDBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end28aa1a4abe7e1abcdd64135e9967d39d +end28aa1a4abe7e1abcdd64135e9967d39d: + ; + // match: (ADDB x (NEGB y)) + // cond: + // result: (SUBB x y) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64NEGB { + goto end9464509b8874ffb00b43b843da01f0bc + } + y := v.Args[1].Args[0] + v.Op = OpAMD64SUBB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end9464509b8874ffb00b43b843da01f0bc +end9464509b8874ffb00b43b843da01f0bc: + ; + return false +} +func rewriteValueAMD64_OpAMD64ADDBconst(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (ADDBconst [c] (MOVBconst [d])) + // cond: + // result: (MOVBconst [c+d]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVBconst { + goto enda9b1e9e31ccdf0af5f4fe57bf4b1343f + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + d + return true + } + goto enda9b1e9e31ccdf0af5f4fe57bf4b1343f +enda9b1e9e31ccdf0af5f4fe57bf4b1343f: + ; + // match: (ADDBconst [c] (ADDBconst [d] x)) + // cond: + // result: (ADDBconst [c+d] x) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64ADDBconst { + goto end9b1e6890adbf9d9e447d591b4148cbd0 + } + d := v.Args[0].AuxInt + x := v.Args[0].Args[0] + v.Op = OpAMD64ADDBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + d + v.AddArg(x) + return true + } + goto end9b1e6890adbf9d9e447d591b4148cbd0 +end9b1e6890adbf9d9e447d591b4148cbd0: + ; + return false +} +func rewriteValueAMD64_OpAMD64ADDL(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (ADDL x (MOVLconst [c])) + // cond: + // result: (ADDLconst [c] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVLconst { + goto end8d6d3b99a7be8da6b7a254b7e709cc95 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64ADDLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end8d6d3b99a7be8da6b7a254b7e709cc95 +end8d6d3b99a7be8da6b7a254b7e709cc95: + ; + // match: (ADDL (MOVLconst [c]) x) + // cond: + // result: (ADDLconst [c] x) + { + if v.Args[0].Op != OpAMD64MOVLconst { + goto end739561e08a561e26ce3634dc0d5ec733 + } + c := v.Args[0].AuxInt + x := v.Args[1] + v.Op = OpAMD64ADDLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end739561e08a561e26ce3634dc0d5ec733 +end739561e08a561e26ce3634dc0d5ec733: + ; + // match: (ADDL x (NEGL y)) + // cond: + // result: (SUBL x y) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64NEGL { + goto end9596df31f2685a49df67c6fb912a521d + } + y := v.Args[1].Args[0] + v.Op = OpAMD64SUBL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end9596df31f2685a49df67c6fb912a521d +end9596df31f2685a49df67c6fb912a521d: + ; + return false +} +func rewriteValueAMD64_OpAMD64ADDLconst(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (ADDLconst [c] (MOVLconst [d])) + // cond: + // result: (MOVLconst [c+d]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVLconst { + goto ende04850e987890abf1d66199042a19c23 + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + d + return true + } + goto ende04850e987890abf1d66199042a19c23 +ende04850e987890abf1d66199042a19c23: + ; + // match: (ADDLconst [c] (ADDLconst [d] x)) + // cond: + // result: (ADDLconst [c+d] x) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64ADDLconst { + goto endf1dd8673b2fef4950aec87aa7523a236 + } + d := v.Args[0].AuxInt + x := v.Args[0].Args[0] + v.Op = OpAMD64ADDLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + d + v.AddArg(x) + return true + } + goto endf1dd8673b2fef4950aec87aa7523a236 +endf1dd8673b2fef4950aec87aa7523a236: + ; + 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) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVQconst { + goto end1de8aeb1d043e0dadcffd169a99ce5c0 + } + c := v.Args[1].AuxInt + if !(is32Bit(c)) { + goto end1de8aeb1d043e0dadcffd169a99ce5c0 + } + v.Op = OpAMD64ADDQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end1de8aeb1d043e0dadcffd169a99ce5c0 +end1de8aeb1d043e0dadcffd169a99ce5c0: + ; + // match: (ADDQ (MOVQconst [c]) x) + // cond: is32Bit(c) + // result: (ADDQconst [c] x) + { + if v.Args[0].Op != OpAMD64MOVQconst { + goto endca635e3bdecd9e3aeb892f841021dfaa + } + c := v.Args[0].AuxInt + x := v.Args[1] + if !(is32Bit(c)) { + goto endca635e3bdecd9e3aeb892f841021dfaa + } + v.Op = OpAMD64ADDQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto endca635e3bdecd9e3aeb892f841021dfaa +endca635e3bdecd9e3aeb892f841021dfaa: + ; + // match: (ADDQ x (SHLQconst [3] y)) + // cond: + // result: (LEAQ8 x y) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64SHLQconst { + goto endc02313d35a0525d1d680cd58992e820d + } + if v.Args[1].AuxInt != 3 { + goto endc02313d35a0525d1d680cd58992e820d + } + y := v.Args[1].Args[0] + v.Op = OpAMD64LEAQ8 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto endc02313d35a0525d1d680cd58992e820d +endc02313d35a0525d1d680cd58992e820d: + ; + // match: (ADDQ x (NEGQ y)) + // cond: + // result: (SUBQ x y) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64NEGQ { + goto endec8f899c6e175a0147a90750f9bfe0a2 + } + y := v.Args[1].Args[0] + v.Op = OpAMD64SUBQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto endec8f899c6e175a0147a90750f9bfe0a2 +endec8f899c6e175a0147a90750f9bfe0a2: + ; + return false +} +func rewriteValueAMD64_OpAMD64ADDQconst(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (ADDQconst [c] (LEAQ8 [d] x y)) + // cond: + // result: (LEAQ8 [addOff(c, d)] x y) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64LEAQ8 { + goto ende2cc681c9abf9913288803fb1b39e639 + } + d := v.Args[0].AuxInt + x := v.Args[0].Args[0] + y := v.Args[0].Args[1] + v.Op = OpAMD64LEAQ8 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(c, d) + v.AddArg(x) + v.AddArg(y) + return true + } + goto ende2cc681c9abf9913288803fb1b39e639 +ende2cc681c9abf9913288803fb1b39e639: + ; + // match: (ADDQconst [0] x) + // cond: + // result: x + { + if v.AuxInt != 0 { + goto end03d9f5a3e153048b0afa781401e2a849 + } + x := v.Args[0] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end03d9f5a3e153048b0afa781401e2a849 +end03d9f5a3e153048b0afa781401e2a849: + ; + // match: (ADDQconst [c] (MOVQconst [d])) + // cond: + // result: (MOVQconst [c+d]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVQconst { + goto end09dc54395b4e96e8332cf8e4e7481c52 + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + d + return true + } + goto end09dc54395b4e96e8332cf8e4e7481c52 +end09dc54395b4e96e8332cf8e4e7481c52: + ; + // match: (ADDQconst [c] (ADDQconst [d] x)) + // cond: + // result: (ADDQconst [c+d] x) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64ADDQconst { + goto endd4cb539641f0dc40bfd0cb7fbb9b0405 + } + d := v.Args[0].AuxInt + x := v.Args[0].Args[0] + v.Op = OpAMD64ADDQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + d + v.AddArg(x) + return true + } + goto endd4cb539641f0dc40bfd0cb7fbb9b0405 +endd4cb539641f0dc40bfd0cb7fbb9b0405: + ; + return false +} +func rewriteValueAMD64_OpAMD64ADDW(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (ADDW x (MOVWconst [c])) + // cond: + // result: (ADDWconst [c] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVWconst { + goto end1aabd2317de77c7dfc4876fd7e4c5011 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64ADDWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end1aabd2317de77c7dfc4876fd7e4c5011 +end1aabd2317de77c7dfc4876fd7e4c5011: + ; + // match: (ADDW (MOVWconst [c]) x) + // cond: + // result: (ADDWconst [c] x) + { + if v.Args[0].Op != OpAMD64MOVWconst { + goto ende3aede99966f388afc624f9e86676fd2 + } + c := v.Args[0].AuxInt + x := v.Args[1] + v.Op = OpAMD64ADDWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto ende3aede99966f388afc624f9e86676fd2 +ende3aede99966f388afc624f9e86676fd2: + ; + // match: (ADDW x (NEGW y)) + // cond: + // result: (SUBW x y) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64NEGW { + goto end55cf2af0d75f3ec413528eeb799e94d5 + } + y := v.Args[1].Args[0] + v.Op = OpAMD64SUBW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end55cf2af0d75f3ec413528eeb799e94d5 +end55cf2af0d75f3ec413528eeb799e94d5: + ; + return false +} +func rewriteValueAMD64_OpAMD64ADDWconst(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (ADDWconst [c] (MOVWconst [d])) + // cond: + // result: (MOVWconst [c+d]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVWconst { + goto end32541920f2f5a920dfae41d8ebbef00f + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + d + return true + } + goto end32541920f2f5a920dfae41d8ebbef00f +end32541920f2f5a920dfae41d8ebbef00f: + ; + // match: (ADDWconst [c] (ADDWconst [d] x)) + // cond: + // result: (ADDWconst [c+d] x) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64ADDWconst { + goto end73944f6ddda7e4c050f11d17484ff9a5 + } + d := v.Args[0].AuxInt + x := v.Args[0].Args[0] + v.Op = OpAMD64ADDWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + d + v.AddArg(x) + return true + } + goto end73944f6ddda7e4c050f11d17484ff9a5 +end73944f6ddda7e4c050f11d17484ff9a5: + ; + return false +} +func rewriteValueAMD64_OpAMD64ANDB(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (ANDB x (MOVLconst [c])) + // cond: + // result: (ANDBconst [c] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVLconst { + goto end01100cd255396e29bfdb130f4fbc9bbc + } + c := v.Args[1].AuxInt + v.Op = OpAMD64ANDBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end01100cd255396e29bfdb130f4fbc9bbc +end01100cd255396e29bfdb130f4fbc9bbc: + ; + // match: (ANDB (MOVLconst [c]) x) + // cond: + // result: (ANDBconst [c] x) + { + if v.Args[0].Op != OpAMD64MOVLconst { + goto end70830ce2834dc5f8d786fa6789460926 + } + c := v.Args[0].AuxInt + x := v.Args[1] + v.Op = OpAMD64ANDBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end70830ce2834dc5f8d786fa6789460926 +end70830ce2834dc5f8d786fa6789460926: + ; + // match: (ANDB x (MOVBconst [c])) + // cond: + // result: (ANDBconst [c] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVBconst { + goto endd275ec2e73768cb3d201478fc934e06c + } + c := v.Args[1].AuxInt + v.Op = OpAMD64ANDBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto endd275ec2e73768cb3d201478fc934e06c +endd275ec2e73768cb3d201478fc934e06c: + ; + // match: (ANDB (MOVBconst [c]) x) + // cond: + // result: (ANDBconst [c] x) + { + if v.Args[0].Op != OpAMD64MOVBconst { + goto end4068edac2ae0f354cf581db210288b98 + } + c := v.Args[0].AuxInt + x := v.Args[1] + v.Op = OpAMD64ANDBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end4068edac2ae0f354cf581db210288b98 +end4068edac2ae0f354cf581db210288b98: + ; + // match: (ANDB x x) + // cond: + // result: x + { + x := v.Args[0] + if v.Args[1] != x { + goto endb8ff272a1456513da708603abe37541c + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto endb8ff272a1456513da708603abe37541c +endb8ff272a1456513da708603abe37541c: + ; + return false +} +func rewriteValueAMD64_OpAMD64ANDBconst(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (ANDBconst [c] _) + // cond: int8(c)==0 + // result: (MOVBconst [0]) + { + c := v.AuxInt + if !(int8(c) == 0) { + goto end2106d410c949da14d7c00041f40eca76 + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end2106d410c949da14d7c00041f40eca76 +end2106d410c949da14d7c00041f40eca76: + ; + // match: (ANDBconst [c] x) + // cond: int8(c)==-1 + // result: x + { + c := v.AuxInt + x := v.Args[0] + if !(int8(c) == -1) { + goto enda0b78503c204c8225de1433949a71fe4 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto enda0b78503c204c8225de1433949a71fe4 +enda0b78503c204c8225de1433949a71fe4: + ; + // match: (ANDBconst [c] (MOVBconst [d])) + // cond: + // result: (MOVBconst [c&d]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVBconst { + goto end946312b1f216933da86febe293eb956f + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & d + return true + } + goto end946312b1f216933da86febe293eb956f +end946312b1f216933da86febe293eb956f: + ; + return false +} +func rewriteValueAMD64_OpAMD64ANDL(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (ANDL x (MOVLconst [c])) + // cond: + // result: (ANDLconst [c] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVLconst { + goto end0a4c49d9a26759c0fd21369dafcd7abb + } + c := v.Args[1].AuxInt + v.Op = OpAMD64ANDLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end0a4c49d9a26759c0fd21369dafcd7abb +end0a4c49d9a26759c0fd21369dafcd7abb: + ; + // match: (ANDL (MOVLconst [c]) x) + // cond: + // result: (ANDLconst [c] x) + { + if v.Args[0].Op != OpAMD64MOVLconst { + goto end0529ba323d9b6f15c41add401ef67959 + } + c := v.Args[0].AuxInt + x := v.Args[1] + v.Op = OpAMD64ANDLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end0529ba323d9b6f15c41add401ef67959 +end0529ba323d9b6f15c41add401ef67959: + ; + // match: (ANDL x x) + // cond: + // result: x + { + x := v.Args[0] + if v.Args[1] != x { + goto enddfb08a0d0c262854db3905cb323388c7 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto enddfb08a0d0c262854db3905cb323388c7 +enddfb08a0d0c262854db3905cb323388c7: + ; + return false +} +func rewriteValueAMD64_OpAMD64ANDLconst(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (ANDLconst [c] _) + // cond: int32(c)==0 + // result: (MOVLconst [0]) + { + c := v.AuxInt + if !(int32(c) == 0) { + goto end5efb241208aef28c950b7bcf8d85d5de + } + v.Op = OpAMD64MOVLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end5efb241208aef28c950b7bcf8d85d5de +end5efb241208aef28c950b7bcf8d85d5de: + ; + // match: (ANDLconst [c] x) + // cond: int32(c)==-1 + // result: x + { + c := v.AuxInt + x := v.Args[0] + if !(int32(c) == -1) { + goto end0e852ae30bb8289d6ffee0c9267e3e0c + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end0e852ae30bb8289d6ffee0c9267e3e0c +end0e852ae30bb8289d6ffee0c9267e3e0c: + ; + // match: (ANDLconst [c] (MOVLconst [d])) + // cond: + // result: (MOVLconst [c&d]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVLconst { + goto end7bfd24059369753eadd235f07e2dd7b8 + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & d + return true + } + goto end7bfd24059369753eadd235f07e2dd7b8 +end7bfd24059369753eadd235f07e2dd7b8: + ; + 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) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVQconst { + goto end048fadc69e81103480015b84b9cafff7 + } + c := v.Args[1].AuxInt + if !(is32Bit(c)) { + goto end048fadc69e81103480015b84b9cafff7 + } + v.Op = OpAMD64ANDQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end048fadc69e81103480015b84b9cafff7 +end048fadc69e81103480015b84b9cafff7: + ; + // match: (ANDQ (MOVQconst [c]) x) + // cond: is32Bit(c) + // result: (ANDQconst [c] x) + { + if v.Args[0].Op != OpAMD64MOVQconst { + goto end3035a3bf650b708705fd27dd857ab0a4 + } + c := v.Args[0].AuxInt + x := v.Args[1] + if !(is32Bit(c)) { + goto end3035a3bf650b708705fd27dd857ab0a4 + } + v.Op = OpAMD64ANDQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end3035a3bf650b708705fd27dd857ab0a4 +end3035a3bf650b708705fd27dd857ab0a4: + ; + // match: (ANDQ x x) + // cond: + // result: x + { + x := v.Args[0] + if v.Args[1] != x { + goto end06b5ec19efdd4e79f03a5e4a2c3c3427 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end06b5ec19efdd4e79f03a5e4a2c3c3427 +end06b5ec19efdd4e79f03a5e4a2c3c3427: + ; + return false +} +func rewriteValueAMD64_OpAMD64ANDQconst(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (ANDQconst [0] _) + // cond: + // result: (MOVQconst [0]) + { + if v.AuxInt != 0 { + goto end57018c1d0f54fd721521095b4832bab2 + } + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end57018c1d0f54fd721521095b4832bab2 +end57018c1d0f54fd721521095b4832bab2: + ; + // match: (ANDQconst [-1] x) + // cond: + // result: x + { + if v.AuxInt != -1 { + goto endb542c4b42ab94a7bedb32dec8f610d67 + } + x := v.Args[0] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto endb542c4b42ab94a7bedb32dec8f610d67 +endb542c4b42ab94a7bedb32dec8f610d67: + ; + // match: (ANDQconst [c] (MOVQconst [d])) + // cond: + // result: (MOVQconst [c&d]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVQconst { + goto end67ca66494705b0345a5f22c710225292 + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & d + return true + } + goto end67ca66494705b0345a5f22c710225292 +end67ca66494705b0345a5f22c710225292: + ; + return false +} +func rewriteValueAMD64_OpAMD64ANDW(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (ANDW x (MOVLconst [c])) + // cond: + // result: (ANDWconst [c] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVLconst { + goto endce6f557823ee2fdd7a8f47b6f925fc7c + } + c := v.Args[1].AuxInt + v.Op = OpAMD64ANDWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto endce6f557823ee2fdd7a8f47b6f925fc7c +endce6f557823ee2fdd7a8f47b6f925fc7c: + ; + // match: (ANDW (MOVLconst [c]) x) + // cond: + // result: (ANDWconst [c] x) + { + if v.Args[0].Op != OpAMD64MOVLconst { + goto endc46af0d9265c08b09f1f1fba24feda80 + } + c := v.Args[0].AuxInt + x := v.Args[1] + v.Op = OpAMD64ANDWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto endc46af0d9265c08b09f1f1fba24feda80 +endc46af0d9265c08b09f1f1fba24feda80: + ; + // match: (ANDW x (MOVWconst [c])) + // cond: + // result: (ANDWconst [c] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVWconst { + goto enda77a39f65a5eb3436a5842eab69a3103 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64ANDWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto enda77a39f65a5eb3436a5842eab69a3103 +enda77a39f65a5eb3436a5842eab69a3103: + ; + // match: (ANDW (MOVWconst [c]) x) + // cond: + // result: (ANDWconst [c] x) + { + if v.Args[0].Op != OpAMD64MOVWconst { + goto endea2a25eb525a5dbf6d5132d84ea4e7a5 + } + c := v.Args[0].AuxInt + x := v.Args[1] + v.Op = OpAMD64ANDWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto endea2a25eb525a5dbf6d5132d84ea4e7a5 +endea2a25eb525a5dbf6d5132d84ea4e7a5: + ; + // match: (ANDW x x) + // cond: + // result: x + { + x := v.Args[0] + if v.Args[1] != x { + goto end3a26cf52dd1b77f07cc9e005760dbb11 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end3a26cf52dd1b77f07cc9e005760dbb11 +end3a26cf52dd1b77f07cc9e005760dbb11: + ; + return false +} +func rewriteValueAMD64_OpAMD64ANDWconst(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (ANDWconst [c] _) + // cond: int16(c)==0 + // result: (MOVWconst [0]) + { + c := v.AuxInt + if !(int16(c) == 0) { + goto end336ece33b4f0fb44dfe1f24981df7b74 + } + v.Op = OpAMD64MOVWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end336ece33b4f0fb44dfe1f24981df7b74 +end336ece33b4f0fb44dfe1f24981df7b74: + ; + // match: (ANDWconst [c] x) + // cond: int16(c)==-1 + // result: x + { + c := v.AuxInt + x := v.Args[0] + if !(int16(c) == -1) { + goto endfb111c3afa8c5c4040fa6000fadee810 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto endfb111c3afa8c5c4040fa6000fadee810 +endfb111c3afa8c5c4040fa6000fadee810: + ; + // match: (ANDWconst [c] (MOVWconst [d])) + // cond: + // result: (MOVWconst [c&d]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVWconst { + goto end250eb27fcac10bf6c0d96ce66a21726e + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & d + return true + } + goto end250eb27fcac10bf6c0d96ce66a21726e +end250eb27fcac10bf6c0d96ce66a21726e: + ; + return false +} +func rewriteValueAMD64_OpAdd16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Add16 x y) + // cond: + // result: (ADDW x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ADDW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto ende604481c6de9fe4574cb2954ba2ddc67 +ende604481c6de9fe4574cb2954ba2ddc67: + ; + return false +} +func rewriteValueAMD64_OpAdd32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Add32 x y) + // cond: + // result: (ADDL x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ADDL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto endc445ea2a65385445676cd684ae9a42b5 +endc445ea2a65385445676cd684ae9a42b5: + ; + return false +} +func rewriteValueAMD64_OpAdd32F(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Add32F x y) + // cond: + // result: (ADDSS x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ADDSS + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end5d82e1c10823774894c036b7c5b8fed4 +end5d82e1c10823774894c036b7c5b8fed4: + ; + return false +} +func rewriteValueAMD64_OpAdd64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Add64 x y) + // cond: + // result: (ADDQ x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ADDQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto endd88f18b3f39e3ccc201477a616f0abc0 +endd88f18b3f39e3ccc201477a616f0abc0: + ; + return false +} +func rewriteValueAMD64_OpAdd64F(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Add64F x y) + // cond: + // result: (ADDSD x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ADDSD + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end62f2de6c70abd214e6987ee37976653a +end62f2de6c70abd214e6987ee37976653a: + ; + return false +} +func rewriteValueAMD64_OpAdd8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Add8 x y) + // cond: + // result: (ADDB x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ADDB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end6117c84a6b75c1b816b3fb095bc5f656 +end6117c84a6b75c1b816b3fb095bc5f656: + ; + return false +} +func rewriteValueAMD64_OpAddPtr(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (AddPtr x y) + // cond: + // result: (ADDQ x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ADDQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto enda1d5640788c7157996f9d4af602dec1c +enda1d5640788c7157996f9d4af602dec1c: + ; + return false +} +func rewriteValueAMD64_OpAddr(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Addr {sym} base) + // cond: + // result: (LEAQ {sym} base) + { + sym := v.Aux + base := v.Args[0] + v.Op = OpAMD64LEAQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Aux = sym + v.AddArg(base) + return true + } + goto end53cad0c3c9daa5575680e77c14e05e72 +end53cad0c3c9daa5575680e77c14e05e72: + ; + return false +} +func rewriteValueAMD64_OpAnd16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (And16 x y) + // cond: + // result: (ANDW x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end1c01f04a173d86ce1a6d1ef59e753014 +end1c01f04a173d86ce1a6d1ef59e753014: + ; + return false +} +func rewriteValueAMD64_OpAnd32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (And32 x y) + // cond: + // result: (ANDL x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end6b9eb9375b3a859028a6ba6bf6b8ec88 +end6b9eb9375b3a859028a6ba6bf6b8ec88: + ; + return false +} +func rewriteValueAMD64_OpAnd64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (And64 x y) + // cond: + // result: (ANDQ x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto enda0bde5853819d05fa2b7d3b723629552 +enda0bde5853819d05fa2b7d3b723629552: + ; + return false +} +func rewriteValueAMD64_OpAnd8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (And8 x y) + // cond: + // result: (ANDB x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end0f53bee6291f1229b43aa1b5f977b4f2 +end0f53bee6291f1229b43aa1b5f977b4f2: + ; + return false +} +func rewriteValueAMD64_OpAMD64CMPB(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (CMPB x (MOVBconst [c])) + // cond: + // result: (CMPBconst x [c]) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVBconst { + goto end52190c0b8759133aa6c540944965c4c0 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64CMPBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AuxInt = c + return true + } + goto end52190c0b8759133aa6c540944965c4c0 +end52190c0b8759133aa6c540944965c4c0: + ; + // match: (CMPB (MOVBconst [c]) x) + // cond: + // result: (InvertFlags (CMPBconst x [c])) + { + if v.Args[0].Op != OpAMD64MOVBconst { + goto end25ab646f9eb8749ea58c8fbbb4bf6bcd + } + c := v.Args[0].AuxInt + x := v.Args[1] + v.Op = OpAMD64InvertFlags + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + v0.AddArg(x) + v0.AuxInt = c + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto end25ab646f9eb8749ea58c8fbbb4bf6bcd +end25ab646f9eb8749ea58c8fbbb4bf6bcd: + ; + return false +} +func rewriteValueAMD64_OpAMD64CMPL(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (CMPL x (MOVLconst [c])) + // cond: + // result: (CMPLconst x [c]) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVLconst { + goto end49ff4559c4bdecb2aef0c905e2d9a6cf + } + c := v.Args[1].AuxInt + v.Op = OpAMD64CMPLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AuxInt = c + return true + } + goto end49ff4559c4bdecb2aef0c905e2d9a6cf +end49ff4559c4bdecb2aef0c905e2d9a6cf: + ; + // match: (CMPL (MOVLconst [c]) x) + // cond: + // result: (InvertFlags (CMPLconst x [c])) + { + if v.Args[0].Op != OpAMD64MOVLconst { + goto end7d89230086678ab4ed5cc96a3ae358d6 + } + c := v.Args[0].AuxInt + x := v.Args[1] + v.Op = OpAMD64InvertFlags + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v0.AddArg(x) + v0.AuxInt = c + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto end7d89230086678ab4ed5cc96a3ae358d6 +end7d89230086678ab4ed5cc96a3ae358d6: + ; + 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]) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVQconst { + goto end3bbb2c6caa57853a7561738ce3c0c630 + } + c := v.Args[1].AuxInt + if !(is32Bit(c)) { + goto end3bbb2c6caa57853a7561738ce3c0c630 + } + v.Op = OpAMD64CMPQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AuxInt = c + return true + } + goto end3bbb2c6caa57853a7561738ce3c0c630 +end3bbb2c6caa57853a7561738ce3c0c630: + ; + // match: (CMPQ (MOVQconst [c]) x) + // cond: is32Bit(c) + // result: (InvertFlags (CMPQconst x [c])) + { + if v.Args[0].Op != OpAMD64MOVQconst { + goto end153e951c4d9890ee40bf6f189ff6280e + } + c := v.Args[0].AuxInt + x := v.Args[1] + if !(is32Bit(c)) { + goto end153e951c4d9890ee40bf6f189ff6280e + } + v.Op = OpAMD64InvertFlags + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v0.AddArg(x) + v0.AuxInt = c + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto end153e951c4d9890ee40bf6f189ff6280e +end153e951c4d9890ee40bf6f189ff6280e: + ; + return false +} +func rewriteValueAMD64_OpAMD64CMPW(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (CMPW x (MOVWconst [c])) + // cond: + // result: (CMPWconst x [c]) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVWconst { + goto end310a9ba58ac35c97587e08c63fe8a46c + } + c := v.Args[1].AuxInt + v.Op = OpAMD64CMPWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AuxInt = c + return true + } + goto end310a9ba58ac35c97587e08c63fe8a46c +end310a9ba58ac35c97587e08c63fe8a46c: + ; + // match: (CMPW (MOVWconst [c]) x) + // cond: + // result: (InvertFlags (CMPWconst x [c])) + { + if v.Args[0].Op != OpAMD64MOVWconst { + goto end3c52d0ae6e3d186bf131b41276c21889 + } + c := v.Args[0].AuxInt + x := v.Args[1] + v.Op = OpAMD64InvertFlags + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v0.AddArg(x) + v0.AuxInt = c + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto end3c52d0ae6e3d186bf131b41276c21889 +end3c52d0ae6e3d186bf131b41276c21889: + ; + 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) + { + argwid := v.AuxInt + entry := v.Args[0] + closure := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64CALLclosure + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = argwid + v.AddArg(entry) + v.AddArg(closure) + v.AddArg(mem) + return true + } + goto endfd75d26316012d86cb71d0dd1214259b +endfd75d26316012d86cb71d0dd1214259b: + ; + return false +} +func rewriteValueAMD64_OpCom16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Com16 x) + // cond: + // result: (NOTW x) + { + x := v.Args[0] + v.Op = OpAMD64NOTW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end1b14ba8d7d7aa585ec0a211827f280ae +end1b14ba8d7d7aa585ec0a211827f280ae: + ; + return false +} +func rewriteValueAMD64_OpCom32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Com32 x) + // cond: + // result: (NOTL x) + { + x := v.Args[0] + v.Op = OpAMD64NOTL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end6eb124ba3bdb3fd6031414370852feb6 +end6eb124ba3bdb3fd6031414370852feb6: + ; + return false +} +func rewriteValueAMD64_OpCom64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Com64 x) + // cond: + // result: (NOTQ x) + { + x := v.Args[0] + v.Op = OpAMD64NOTQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto endf5f3b355a87779c347e305719dddda05 +endf5f3b355a87779c347e305719dddda05: + ; + return false +} +func rewriteValueAMD64_OpCom8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Com8 x) + // cond: + // result: (NOTB x) + { + x := v.Args[0] + v.Op = OpAMD64NOTB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end1c7c5c055d663ccf1f05fbc4883030c6 +end1c7c5c055d663ccf1f05fbc4883030c6: + ; + return false +} +func rewriteValueAMD64_OpConst16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Const16 [val]) + // cond: + // result: (MOVWconst [val]) + { + val := v.AuxInt + v.Op = OpAMD64MOVWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = val + return true + } + goto end2c6c92f297873b8ac12bd035d56d001e +end2c6c92f297873b8ac12bd035d56d001e: + ; + return false +} +func rewriteValueAMD64_OpConst32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Const32 [val]) + // cond: + // result: (MOVLconst [val]) + { + val := v.AuxInt + v.Op = OpAMD64MOVLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = val + return true + } + goto enddae5807662af67143a3ac3ad9c63bae5 +enddae5807662af67143a3ac3ad9c63bae5: + ; + return false +} +func rewriteValueAMD64_OpConst32F(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Const32F [val]) + // cond: + // result: (MOVSSconst [val]) + { + val := v.AuxInt + v.Op = OpAMD64MOVSSconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = val + return true + } + goto endfabcef2d57a8f36eaa6041de6f112b89 +endfabcef2d57a8f36eaa6041de6f112b89: + ; + return false +} +func rewriteValueAMD64_OpConst64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Const64 [val]) + // cond: + // result: (MOVQconst [val]) + { + val := v.AuxInt + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = val + return true + } + goto endc630434ae7f143ab69d5f482a9b52b5f +endc630434ae7f143ab69d5f482a9b52b5f: + ; + return false +} +func rewriteValueAMD64_OpConst64F(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Const64F [val]) + // cond: + // result: (MOVSDconst [val]) + { + val := v.AuxInt + v.Op = OpAMD64MOVSDconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = val + return true + } + goto endae6cf7189e464bbde17b98635a20f0ff +endae6cf7189e464bbde17b98635a20f0ff: + ; + return false +} +func rewriteValueAMD64_OpConst8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Const8 [val]) + // cond: + // result: (MOVBconst [val]) + { + val := v.AuxInt + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = val + return true + } + goto end200524c722ed14ca935ba47f8f30327d +end200524c722ed14ca935ba47f8f30327d: + ; + return false +} +func rewriteValueAMD64_OpConstBool(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (ConstBool [b]) + // cond: + // result: (MOVBconst [b]) + { + b := v.AuxInt + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = b + return true + } + goto end6d919011283330dcbcb3826f0adc6793 +end6d919011283330dcbcb3826f0adc6793: + ; + return false +} +func rewriteValueAMD64_OpConstNil(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (ConstNil) + // cond: + // result: (MOVQconst [0]) + { + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto endea557d921056c25b945a49649e4b9b91 +endea557d921056c25b945a49649e4b9b91: + ; + return false +} +func rewriteValueAMD64_OpConstPtr(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (ConstPtr [val]) + // cond: + // result: (MOVQconst [val]) + { + val := v.AuxInt + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = val + return true + } + goto endc395c0a53eeccf597e225a07b53047d1 +endc395c0a53eeccf597e225a07b53047d1: + ; + return false +} +func rewriteValueAMD64_OpConvert(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Convert x) + // cond: + // result: (LEAQ x) + { + t := v.Type + x := v.Args[0] + v.Op = OpAMD64LEAQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = t + v.AddArg(x) + return true + } + goto end1cac40a6074914d6ae3d4aa039a625ed +end1cac40a6074914d6ae3d4aa039a625ed: + ; + return false +} +func rewriteValueAMD64_OpCvt32Fto32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Cvt32Fto32 x) + // cond: + // result: (CVTTSS2SL x) + { + x := v.Args[0] + v.Op = OpAMD64CVTTSS2SL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto enda410209d31804e1bce7bdc235fc62342 +enda410209d31804e1bce7bdc235fc62342: + ; + return false +} +func rewriteValueAMD64_OpCvt32Fto64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Cvt32Fto64 x) + // cond: + // result: (CVTTSS2SQ x) + { + x := v.Args[0] + v.Op = OpAMD64CVTTSS2SQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto enddb02fa4f3230a14d557d6c90cdadd523 +enddb02fa4f3230a14d557d6c90cdadd523: + ; + return false +} +func rewriteValueAMD64_OpCvt32Fto64F(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Cvt32Fto64F x) + // cond: + // result: (CVTSS2SD x) + { + x := v.Args[0] + v.Op = OpAMD64CVTSS2SD + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end0bf5d6f8d182ee2b3ab7d7c2f8ff7790 +end0bf5d6f8d182ee2b3ab7d7c2f8ff7790: + ; + return false +} +func rewriteValueAMD64_OpCvt32to32F(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Cvt32to32F x) + // cond: + // result: (CVTSL2SS x) + { + x := v.Args[0] + v.Op = OpAMD64CVTSL2SS + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto ende0bdea2b21aecdb8399d6fd80ddc97d6 +ende0bdea2b21aecdb8399d6fd80ddc97d6: + ; + return false +} +func rewriteValueAMD64_OpCvt32to64F(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Cvt32to64F x) + // cond: + // result: (CVTSL2SD x) + { + x := v.Args[0] + v.Op = OpAMD64CVTSL2SD + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto ende06cbe745112bcf0e6612788ef71c958 +ende06cbe745112bcf0e6612788ef71c958: + ; + return false +} +func rewriteValueAMD64_OpCvt64Fto32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Cvt64Fto32 x) + // cond: + // result: (CVTTSD2SL x) + { + x := v.Args[0] + v.Op = OpAMD64CVTTSD2SL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto endc213dd690dfe568607dec717b2c385b7 +endc213dd690dfe568607dec717b2c385b7: + ; + return false +} +func rewriteValueAMD64_OpCvt64Fto32F(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Cvt64Fto32F x) + // cond: + // result: (CVTSD2SS x) + { + x := v.Args[0] + v.Op = OpAMD64CVTSD2SS + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto endfd70158a96824ced99712d606c607d94 +endfd70158a96824ced99712d606c607d94: + ; + return false +} +func rewriteValueAMD64_OpCvt64Fto64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Cvt64Fto64 x) + // cond: + // result: (CVTTSD2SQ x) + { + x := v.Args[0] + v.Op = OpAMD64CVTTSD2SQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end0bf3e4468047fd20714266ff05797454 +end0bf3e4468047fd20714266ff05797454: + ; + return false +} +func rewriteValueAMD64_OpCvt64to32F(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Cvt64to32F x) + // cond: + // result: (CVTSQ2SS x) + { + x := v.Args[0] + v.Op = OpAMD64CVTSQ2SS + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto endfecc08b8a8cbd2bf3be21a077c4d0d40 +endfecc08b8a8cbd2bf3be21a077c4d0d40: + ; + return false +} +func rewriteValueAMD64_OpCvt64to64F(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Cvt64to64F x) + // cond: + // result: (CVTSQ2SD x) + { + x := v.Args[0] + v.Op = OpAMD64CVTSQ2SD + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto endf74ce5df659f385f75c61187b515a5d0 +endf74ce5df659f385f75c61187b515a5d0: + ; + return false +} +func rewriteValueAMD64_OpDeferCall(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (DeferCall [argwid] mem) + // cond: + // result: (CALLdefer [argwid] mem) + { + argwid := v.AuxInt + mem := v.Args[0] + v.Op = OpAMD64CALLdefer + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = argwid + v.AddArg(mem) + return true + } + goto end1c408581037450df959dd1fb7554a022 +end1c408581037450df959dd1fb7554a022: + ; + return false +} +func rewriteValueAMD64_OpDiv16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Div16 x y) + // cond: + // result: (DIVW x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64DIVW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto endb60a86e606726640c84d3e1e5a5ce890 +endb60a86e606726640c84d3e1e5a5ce890: + ; + return false +} +func rewriteValueAMD64_OpDiv16u(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Div16u x y) + // cond: + // result: (DIVWU x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64DIVWU + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end6af9e212a865593e506bfdf7db67c9ec +end6af9e212a865593e506bfdf7db67c9ec: + ; + return false +} +func rewriteValueAMD64_OpDiv32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Div32 x y) + // cond: + // result: (DIVL x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64DIVL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto endf20ac71407e57c2904684d3cc33cf697 +endf20ac71407e57c2904684d3cc33cf697: + ; + return false +} +func rewriteValueAMD64_OpDiv32F(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Div32F x y) + // cond: + // result: (DIVSS x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64DIVSS + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto enddca0462c7b176c4138854d7d5627ab5b +enddca0462c7b176c4138854d7d5627ab5b: + ; + return false +} +func rewriteValueAMD64_OpDiv32u(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Div32u x y) + // cond: + // result: (DIVLU x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64DIVLU + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto enda22604d23eeb1298008c97b817f60bbd +enda22604d23eeb1298008c97b817f60bbd: + ; + return false +} +func rewriteValueAMD64_OpDiv64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Div64 x y) + // cond: + // result: (DIVQ x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64DIVQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end86490d9b337333dfc09a413e1e0120a9 +end86490d9b337333dfc09a413e1e0120a9: + ; + return false +} +func rewriteValueAMD64_OpDiv64F(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Div64F x y) + // cond: + // result: (DIVSD x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64DIVSD + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end12299d76db5144a60f564d34ba97eb43 +end12299d76db5144a60f564d34ba97eb43: + ; + return false +} +func rewriteValueAMD64_OpDiv64u(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Div64u x y) + // cond: + // result: (DIVQU x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64DIVQU + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto endf871d8b397e5fad6a5b500cc0c759a8d +endf871d8b397e5fad6a5b500cc0c759a8d: + ; + 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)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64DIVW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpSignExt8to16, TypeInvalid) + v0.AddArg(x) + v0.Type = config.fe.TypeInt16() + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpSignExt8to16, TypeInvalid) + v1.AddArg(y) + v1.Type = config.fe.TypeInt16() + v.AddArg(v1) + return true + } + goto endeee2bc780a73ec2ccb1a66c527816ee0 +endeee2bc780a73ec2ccb1a66c527816ee0: + ; + 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)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64DIVWU + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpZeroExt8to16, TypeInvalid) + v0.AddArg(x) + v0.Type = config.fe.TypeUInt16() + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpZeroExt8to16, TypeInvalid) + v1.AddArg(y) + v1.Type = config.fe.TypeUInt16() + v.AddArg(v1) + return true + } + goto end39da6664d6434d844303f6924cc875dd +end39da6664d6434d844303f6924cc875dd: + ; + return false +} +func rewriteValueAMD64_OpEq16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Eq16 x y) + // cond: + // result: (SETEQ (CMPW x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETEQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto endd7f668b1d23603b0949953ee8dec8107 +endd7f668b1d23603b0949953ee8dec8107: + ; + return false +} +func rewriteValueAMD64_OpEq32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Eq32 x y) + // cond: + // result: (SETEQ (CMPL x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETEQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto endf28041ae0c73fb341cc0d2f4903fb2fb +endf28041ae0c73fb341cc0d2f4903fb2fb: + ; + return false +} +func rewriteValueAMD64_OpEq32F(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Eq32F x y) + // cond: + // result: (SETEQF (UCOMISS x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETEQF + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto endb2c12933769e5faa8fc238048e113dee +endb2c12933769e5faa8fc238048e113dee: + ; + return false +} +func rewriteValueAMD64_OpEq64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Eq64 x y) + // cond: + // result: (SETEQ (CMPQ x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETEQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto ende07a380487b710b51bcd5aa6d3144b8c +ende07a380487b710b51bcd5aa6d3144b8c: + ; + return false +} +func rewriteValueAMD64_OpEq64F(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Eq64F x y) + // cond: + // result: (SETEQF (UCOMISD x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETEQF + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto end68e20c0c1b3ee62fbd17af07ac100704 +end68e20c0c1b3ee62fbd17af07ac100704: + ; + return false +} +func rewriteValueAMD64_OpEq8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Eq8 x y) + // cond: + // result: (SETEQ (CMPB x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETEQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto end359e5a51d2ab928a455f0ae5adb42ab0 +end359e5a51d2ab928a455f0ae5adb42ab0: + ; + return false +} +func rewriteValueAMD64_OpEqPtr(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (EqPtr x y) + // cond: + // result: (SETEQ (CMPQ x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETEQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto endf19bd3c0eb99d15718bef4066d62560c +endf19bd3c0eb99d15718bef4066d62560c: + ; + return false +} +func rewriteValueAMD64_OpGeq16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Geq16 x y) + // cond: + // result: (SETGE (CMPW x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETGE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto end0a3f723d5c0b877c473b0043d814867b +end0a3f723d5c0b877c473b0043d814867b: + ; + return false +} +func rewriteValueAMD64_OpGeq16U(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Geq16U x y) + // cond: + // result: (SETAE (CMPW x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETAE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto end79d754a28ee34eff95140635b26f0248 +end79d754a28ee34eff95140635b26f0248: + ; + return false +} +func rewriteValueAMD64_OpGeq32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Geq32 x y) + // cond: + // result: (SETGE (CMPL x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETGE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto endfb1f6286a1b153b2a3f5b8548a782c8c +endfb1f6286a1b153b2a3f5b8548a782c8c: + ; + return false +} +func rewriteValueAMD64_OpGeq32F(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Geq32F x y) + // cond: + // result: (SETGEF (UCOMISS x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETGEF + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto end7a8d6107a945410e64db06669a61da97 +end7a8d6107a945410e64db06669a61da97: + ; + return false +} +func rewriteValueAMD64_OpGeq32U(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Geq32U x y) + // cond: + // result: (SETAE (CMPL x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETAE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto endc5d3478a626df01ede063564f4cb80d0 +endc5d3478a626df01ede063564f4cb80d0: + ; + return false +} +func rewriteValueAMD64_OpGeq64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Geq64 x y) + // cond: + // result: (SETGE (CMPQ x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETGE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto end74bddb7905ab865de5b041e7e4789911 +end74bddb7905ab865de5b041e7e4789911: + ; + return false +} +func rewriteValueAMD64_OpGeq64F(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Geq64F x y) + // cond: + // result: (SETGEF (UCOMISD x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETGEF + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto end9fac9bd98ef58b7fbbe1a31f84bdcccf +end9fac9bd98ef58b7fbbe1a31f84bdcccf: + ; + return false +} +func rewriteValueAMD64_OpGeq64U(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Geq64U x y) + // cond: + // result: (SETAE (CMPQ x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETAE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto end95101721fc8f5be9969e50e364143e7f +end95101721fc8f5be9969e50e364143e7f: + ; + return false +} +func rewriteValueAMD64_OpGeq8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Geq8 x y) + // cond: + // result: (SETGE (CMPB x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETGE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto end983070a3db317bdb64b5a0fb104d267c +end983070a3db317bdb64b5a0fb104d267c: + ; + return false +} +func rewriteValueAMD64_OpGeq8U(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Geq8U x y) + // cond: + // result: (SETAE (CMPB x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETAE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto enda617119faaccc0f0c2d23548116cf331 +enda617119faaccc0f0c2d23548116cf331: + ; + return false +} +func rewriteValueAMD64_OpGetClosurePtr(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (GetClosurePtr) + // cond: + // result: (LoweredGetClosurePtr) + { + v.Op = OpAMD64LoweredGetClosurePtr + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + return true + } + goto end6fd0b53f0acb4d35e7d7fa78d2ca1392 +end6fd0b53f0acb4d35e7d7fa78d2ca1392: + ; + return false +} +func rewriteValueAMD64_OpGetG(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (GetG mem) + // cond: + // result: (LoweredGetG mem) + { + mem := v.Args[0] + v.Op = OpAMD64LoweredGetG + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(mem) + return true + } + goto endf543eaaf68c4bef1d4cdc8ba19683723 +endf543eaaf68c4bef1d4cdc8ba19683723: + ; + return false +} +func rewriteValueAMD64_OpGoCall(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (GoCall [argwid] mem) + // cond: + // result: (CALLgo [argwid] mem) + { + argwid := v.AuxInt + mem := v.Args[0] + v.Op = OpAMD64CALLgo + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = argwid + v.AddArg(mem) + return true + } + goto end1cef0f92c46e6aaa2c7abdf5f2794baf +end1cef0f92c46e6aaa2c7abdf5f2794baf: + ; + return false +} +func rewriteValueAMD64_OpGreater16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Greater16 x y) + // cond: + // result: (SETG (CMPW x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETG + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto end4e4a1307c61240af9a86d8fe4f834ee8 +end4e4a1307c61240af9a86d8fe4f834ee8: + ; + return false +} +func rewriteValueAMD64_OpGreater16U(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Greater16U x y) + // cond: + // result: (SETA (CMPW x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETA + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto end7c66c75f4b8ec1db593f3e60cfba9592 +end7c66c75f4b8ec1db593f3e60cfba9592: + ; + return false +} +func rewriteValueAMD64_OpGreater32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Greater32 x y) + // cond: + // result: (SETG (CMPL x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETG + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto end6fb0eae4a0e0e81b4afb085d398d873b +end6fb0eae4a0e0e81b4afb085d398d873b: + ; + return false +} +func rewriteValueAMD64_OpGreater32F(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Greater32F x y) + // cond: + // result: (SETGF (UCOMISS x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETGF + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto end94df0bd5cedad8ce8021df1b24da40c6 +end94df0bd5cedad8ce8021df1b24da40c6: + ; + return false +} +func rewriteValueAMD64_OpGreater32U(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Greater32U x y) + // cond: + // result: (SETA (CMPL x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETA + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto end18da022a28eae8bd0771e0c948aadaf8 +end18da022a28eae8bd0771e0c948aadaf8: + ; + return false +} +func rewriteValueAMD64_OpGreater64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Greater64 x y) + // cond: + // result: (SETG (CMPQ x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETG + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto endc025c908708f939780fba0da0c1148b4 +endc025c908708f939780fba0da0c1148b4: + ; + return false +} +func rewriteValueAMD64_OpGreater64F(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Greater64F x y) + // cond: + // result: (SETGF (UCOMISD x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETGF + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto end033ca5181b18376e7215c02812ef5a6b +end033ca5181b18376e7215c02812ef5a6b: + ; + return false +} +func rewriteValueAMD64_OpGreater64U(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Greater64U x y) + // cond: + // result: (SETA (CMPQ x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETA + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto endb3e25347041760a04d3fc8321c3f3d00 +endb3e25347041760a04d3fc8321c3f3d00: + ; + return false +} +func rewriteValueAMD64_OpGreater8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Greater8 x y) + // cond: + // result: (SETG (CMPB x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETG + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto enda3eeb5da2e69cb54a1515601d4b360d4 +enda3eeb5da2e69cb54a1515601d4b360d4: + ; + return false +} +func rewriteValueAMD64_OpGreater8U(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Greater8U x y) + // cond: + // result: (SETA (CMPB x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETA + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto endd2027f3b6471262f42b90c8cc0413667 +endd2027f3b6471262f42b90c8cc0413667: + ; + return false +} +func rewriteValueAMD64_OpHmul16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Hmul16 x y) + // cond: + // result: (HMULW x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64HMULW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end1b9ff394bb3b06fc109637656b6875f5 +end1b9ff394bb3b06fc109637656b6875f5: + ; + return false +} +func rewriteValueAMD64_OpHmul16u(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Hmul16u x y) + // cond: + // result: (HMULWU x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64HMULWU + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto endee9089e794a43f2ce1619a6ef61670f4 +endee9089e794a43f2ce1619a6ef61670f4: + ; + return false +} +func rewriteValueAMD64_OpHmul32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Hmul32 x y) + // cond: + // result: (HMULL x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64HMULL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end7c83c91ef2634f0b1da4f49350b437b1 +end7c83c91ef2634f0b1da4f49350b437b1: + ; + return false +} +func rewriteValueAMD64_OpHmul32u(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Hmul32u x y) + // cond: + // result: (HMULLU x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64HMULLU + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end3c4f36611dc8815aa2a63d4ec0eaa06d +end3c4f36611dc8815aa2a63d4ec0eaa06d: + ; + return false +} +func rewriteValueAMD64_OpHmul8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Hmul8 x y) + // cond: + // result: (HMULB x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64HMULB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end51b2cc9f1ed15314e68fc81024f281a7 +end51b2cc9f1ed15314e68fc81024f281a7: + ; + return false +} +func rewriteValueAMD64_OpHmul8u(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Hmul8u x y) + // cond: + // result: (HMULBU x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64HMULBU + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto ende68d7b3a3c774cedc3522af9d635c39d +ende68d7b3a3c774cedc3522af9d635c39d: + ; + return false +} +func rewriteValueAMD64_OpITab(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (ITab (Load ptr mem)) + // cond: + // result: (MOVQload ptr mem) + { + if v.Args[0].Op != OpLoad { + goto enda49fcae3630a097c78aa58189c90a97a + } + ptr := v.Args[0].Args[0] + mem := v.Args[0].Args[1] + v.Op = OpAMD64MOVQload + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto enda49fcae3630a097c78aa58189c90a97a +enda49fcae3630a097c78aa58189c90a97a: + ; + 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) + { + argwid := v.AuxInt + entry := v.Args[0] + mem := v.Args[1] + v.Op = OpAMD64CALLinter + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = argwid + v.AddArg(entry) + v.AddArg(mem) + return true + } + goto endc04351e492ed362efc6aa75121bca305 +endc04351e492ed362efc6aa75121bca305: + ; + return false +} +func rewriteValueAMD64_OpIsInBounds(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (IsInBounds idx len) + // cond: + // result: (SETB (CMPQ idx len)) + { + idx := v.Args[0] + len := v.Args[1] + v.Op = OpAMD64SETB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0.AddArg(idx) + v0.AddArg(len) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto endfff988d5f1912886d73be3bb563c37d9 +endfff988d5f1912886d73be3bb563c37d9: + ; + return false +} +func rewriteValueAMD64_OpIsNonNil(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (IsNonNil p) + // cond: + // result: (SETNE (TESTQ p p)) + { + p := v.Args[0] + v.Op = OpAMD64SETNE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64TESTQ, TypeInvalid) + v0.AddArg(p) + v0.AddArg(p) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto end0af5ec868ede9ea73fb0602d54b863e9 +end0af5ec868ede9ea73fb0602d54b863e9: + ; + return false +} +func rewriteValueAMD64_OpIsSliceInBounds(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (IsSliceInBounds idx len) + // cond: + // result: (SETBE (CMPQ idx len)) + { + idx := v.Args[0] + len := v.Args[1] + v.Op = OpAMD64SETBE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0.AddArg(idx) + v0.AddArg(len) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto end02799ad95fe7fb5ce3c2c8ab313b737c +end02799ad95fe7fb5ce3c2c8ab313b737c: + ; + return false +} +func rewriteValueAMD64_OpLeq16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Leq16 x y) + // cond: + // result: (SETLE (CMPW x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETLE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto end586c647ca6bb8ec725eea917c743d1ea +end586c647ca6bb8ec725eea917c743d1ea: + ; + return false +} +func rewriteValueAMD64_OpLeq16U(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Leq16U x y) + // cond: + // result: (SETBE (CMPW x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETBE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto end9c24a81bc6a4a92267bd6638362dfbfc +end9c24a81bc6a4a92267bd6638362dfbfc: + ; + return false +} +func rewriteValueAMD64_OpLeq32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Leq32 x y) + // cond: + // result: (SETLE (CMPL x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETLE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto end595ee99a9fc3460b2748b9129b139f88 +end595ee99a9fc3460b2748b9129b139f88: + ; + return false +} +func rewriteValueAMD64_OpLeq32F(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Leq32F x y) + // cond: + // result: (SETGEF (UCOMISS y x)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETGEF + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeInvalid) + v0.AddArg(y) + v0.AddArg(x) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto endfee4b989a80cc43328b24f7017e80a17 +endfee4b989a80cc43328b24f7017e80a17: + ; + return false +} +func rewriteValueAMD64_OpLeq32U(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Leq32U x y) + // cond: + // result: (SETBE (CMPL x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETBE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto end1a59850aad6cb17c295d0dc359013420 +end1a59850aad6cb17c295d0dc359013420: + ; + return false +} +func rewriteValueAMD64_OpLeq64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Leq64 x y) + // cond: + // result: (SETLE (CMPQ x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETLE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto end406def83fcbf29cd8fa306170b512de2 +end406def83fcbf29cd8fa306170b512de2: + ; + return false +} +func rewriteValueAMD64_OpLeq64F(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Leq64F x y) + // cond: + // result: (SETGEF (UCOMISD y x)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETGEF + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeInvalid) + v0.AddArg(y) + v0.AddArg(x) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto end6e3de6d4b5668f673e3822d5947edbd0 +end6e3de6d4b5668f673e3822d5947edbd0: + ; + return false +} +func rewriteValueAMD64_OpLeq64U(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Leq64U x y) + // cond: + // result: (SETBE (CMPQ x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETBE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto end52f23c145b80639c8d60420ad4057bc7 +end52f23c145b80639c8d60420ad4057bc7: + ; + return false +} +func rewriteValueAMD64_OpLeq8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Leq8 x y) + // cond: + // result: (SETLE (CMPB x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETLE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto end72ecba6f2a7062cb266923dfec811f79 +end72ecba6f2a7062cb266923dfec811f79: + ; + return false +} +func rewriteValueAMD64_OpLeq8U(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Leq8U x y) + // cond: + // result: (SETBE (CMPB x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETBE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto endb043b338cced4f15400d8d6e584ebea7 +endb043b338cced4f15400d8d6e584ebea7: + ; + return false +} +func rewriteValueAMD64_OpLess16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Less16 x y) + // cond: + // result: (SETL (CMPW x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto end2f6c6ba80eda8d68e77a58cba13d3f16 +end2f6c6ba80eda8d68e77a58cba13d3f16: + ; + return false +} +func rewriteValueAMD64_OpLess16U(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Less16U x y) + // cond: + // result: (SETB (CMPW x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto end9f65eefe7b83a3c436b5c16664c93703 +end9f65eefe7b83a3c436b5c16664c93703: + ; + return false +} +func rewriteValueAMD64_OpLess32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Less32 x y) + // cond: + // result: (SETL (CMPL x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto end6632ff4ee994eb5b14cdf60c99ac3798 +end6632ff4ee994eb5b14cdf60c99ac3798: + ; + return false +} +func rewriteValueAMD64_OpLess32F(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Less32F x y) + // cond: + // result: (SETGF (UCOMISS y x)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETGF + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeInvalid) + v0.AddArg(y) + v0.AddArg(x) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto end5b3b0c96a7fc2ede81bc89c9abaac9d0 +end5b3b0c96a7fc2ede81bc89c9abaac9d0: + ; + return false +} +func rewriteValueAMD64_OpLess32U(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Less32U x y) + // cond: + // result: (SETB (CMPL x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto end39e5a513c7fb0a42817a6cf9c6143b60 +end39e5a513c7fb0a42817a6cf9c6143b60: + ; + return false +} +func rewriteValueAMD64_OpLess64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Less64 x y) + // cond: + // result: (SETL (CMPQ x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto enddce827d3e922e8487b61a88c2b1510f2 +enddce827d3e922e8487b61a88c2b1510f2: + ; + return false +} +func rewriteValueAMD64_OpLess64F(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Less64F x y) + // cond: + // result: (SETGF (UCOMISD y x)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETGF + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeInvalid) + v0.AddArg(y) + v0.AddArg(x) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto endf2be3d2dcb6543d2159e7fff5ccbbb55 +endf2be3d2dcb6543d2159e7fff5ccbbb55: + ; + return false +} +func rewriteValueAMD64_OpLess64U(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Less64U x y) + // cond: + // result: (SETB (CMPQ x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto endb76d7768f175a44baf6d63d12ab6e81d +endb76d7768f175a44baf6d63d12ab6e81d: + ; + return false +} +func rewriteValueAMD64_OpLess8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Less8 x y) + // cond: + // result: (SETL (CMPB x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto end314fbffe99f3bd4b07857a80c0b914cd +end314fbffe99f3bd4b07857a80c0b914cd: + ; + return false +} +func rewriteValueAMD64_OpLess8U(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Less8U x y) + // cond: + // result: (SETB (CMPB x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto endadccc5d80fd053a33004ed0759f64d93 +endadccc5d80fd053a33004ed0759f64d93: + ; + return false +} +func rewriteValueAMD64_OpLoad(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Load ptr mem) + // cond: (is64BitInt(t) || isPtr(t)) + // result: (MOVQload ptr mem) + { + t := v.Type + ptr := v.Args[0] + mem := v.Args[1] + if !(is64BitInt(t) || isPtr(t)) { + goto end7c4c53acf57ebc5f03273652ba1d5934 + } + v.Op = OpAMD64MOVQload + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto end7c4c53acf57ebc5f03273652ba1d5934 +end7c4c53acf57ebc5f03273652ba1d5934: + ; + // match: (Load ptr mem) + // cond: is32BitInt(t) + // result: (MOVLload ptr mem) + { + t := v.Type + ptr := v.Args[0] + mem := v.Args[1] + if !(is32BitInt(t)) { + goto ende1cfcb15bfbcfd448ce303d0882a4057 + } + v.Op = OpAMD64MOVLload + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto ende1cfcb15bfbcfd448ce303d0882a4057 +ende1cfcb15bfbcfd448ce303d0882a4057: + ; + // match: (Load ptr mem) + // cond: is16BitInt(t) + // result: (MOVWload ptr mem) + { + t := v.Type + ptr := v.Args[0] + mem := v.Args[1] + if !(is16BitInt(t)) { + goto end2d0a1304501ed9f4e9e2d288505a9c7c + } + v.Op = OpAMD64MOVWload + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto end2d0a1304501ed9f4e9e2d288505a9c7c +end2d0a1304501ed9f4e9e2d288505a9c7c: + ; + // match: (Load ptr mem) + // cond: (t.IsBoolean() || is8BitInt(t)) + // result: (MOVBload ptr mem) + { + t := v.Type + ptr := v.Args[0] + mem := v.Args[1] + if !(t.IsBoolean() || is8BitInt(t)) { + goto end8f83bf72293670e75b22d6627bd13f0b + } + v.Op = OpAMD64MOVBload + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto end8f83bf72293670e75b22d6627bd13f0b +end8f83bf72293670e75b22d6627bd13f0b: + ; + // match: (Load ptr mem) + // cond: is32BitFloat(t) + // result: (MOVSSload ptr mem) + { + t := v.Type + ptr := v.Args[0] + mem := v.Args[1] + if !(is32BitFloat(t)) { + goto end63383c4895805881aabceebea3c4c533 + } + v.Op = OpAMD64MOVSSload + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto end63383c4895805881aabceebea3c4c533 +end63383c4895805881aabceebea3c4c533: + ; + // match: (Load ptr mem) + // cond: is64BitFloat(t) + // result: (MOVSDload ptr mem) + { + t := v.Type + ptr := v.Args[0] + mem := v.Args[1] + if !(is64BitFloat(t)) { + goto end99d0858c0a5bb72f0fe4decc748da812 + } + v.Op = OpAMD64MOVSDload + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto end99d0858c0a5bb72f0fe4decc748da812 +end99d0858c0a5bb72f0fe4decc748da812: + ; + return false +} +func rewriteValueAMD64_OpLrot16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Lrot16 x [c]) + // cond: + // result: (ROLWconst [c&15] x) + { + t := v.Type + x := v.Args[0] + c := v.AuxInt + v.Op = OpAMD64ROLWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = t + v.AuxInt = c & 15 + v.AddArg(x) + return true + } + goto endb23dfa24c619d0068f925899d53ee7fd +endb23dfa24c619d0068f925899d53ee7fd: + ; + return false +} +func rewriteValueAMD64_OpLrot32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Lrot32 x [c]) + // cond: + // result: (ROLLconst [c&31] x) + { + t := v.Type + x := v.Args[0] + c := v.AuxInt + v.Op = OpAMD64ROLLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = t + v.AuxInt = c & 31 + v.AddArg(x) + return true + } + goto end38b2215c011896c36845f72ecb72b1b0 +end38b2215c011896c36845f72ecb72b1b0: + ; + return false +} +func rewriteValueAMD64_OpLrot64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Lrot64 x [c]) + // cond: + // result: (ROLQconst [c&63] x) + { + t := v.Type + x := v.Args[0] + c := v.AuxInt + v.Op = OpAMD64ROLQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = t + v.AuxInt = c & 63 + v.AddArg(x) + return true + } + goto end5cb355e4f3ca387f252ef4f6a55f9f68 +end5cb355e4f3ca387f252ef4f6a55f9f68: + ; + return false +} +func rewriteValueAMD64_OpLrot8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Lrot8 x [c]) + // cond: + // result: (ROLBconst [c&7] x) + { + t := v.Type + x := v.Args[0] + c := v.AuxInt + v.Op = OpAMD64ROLBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = t + v.AuxInt = c & 7 + v.AddArg(x) + return true + } + goto end26bfb3dd5b537cf13ac9f2978d94ed71 +end26bfb3dd5b537cf13ac9f2978d94ed71: + ; + return false +} +func rewriteValueAMD64_OpLsh16x16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Lsh16x16 x y) + // cond: + // result: (ANDW (SHLW x y) (SBBLcarrymask (CMPWconst [16] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64SHLW, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1.Type = t + v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v2.AuxInt = 16 + v2.AddArg(y) + v2.Type = TypeFlags + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto end7ffc4f31c526f7fcb2283215b458f589 +end7ffc4f31c526f7fcb2283215b458f589: + ; + return false +} +func rewriteValueAMD64_OpLsh16x32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Lsh16x32 x y) + // cond: + // result: (ANDW (SHLW x y) (SBBLcarrymask (CMPLconst [16] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64SHLW, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1.Type = t + v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v2.AuxInt = 16 + v2.AddArg(y) + v2.Type = TypeFlags + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto enddcc0e751d315967423c99518c0cc065e +enddcc0e751d315967423c99518c0cc065e: + ; + return false +} +func rewriteValueAMD64_OpLsh16x64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Lsh16x64 x y) + // cond: + // result: (ANDW (SHLW x y) (SBBLcarrymask (CMPQconst [16] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64SHLW, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1.Type = t + v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v2.AuxInt = 16 + v2.AddArg(y) + v2.Type = TypeFlags + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto endf6368b59d046ca83050cd75fbe8715d2 +endf6368b59d046ca83050cd75fbe8715d2: + ; + return false +} +func rewriteValueAMD64_OpLsh16x8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Lsh16x8 x y) + // cond: + // result: (ANDW (SHLW x y) (SBBLcarrymask (CMPBconst [16] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64SHLW, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1.Type = t + v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + v2.AuxInt = 16 + v2.AddArg(y) + v2.Type = TypeFlags + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto end8730d944c8fb358001ba2d165755bdc4 +end8730d944c8fb358001ba2d165755bdc4: + ; + return false +} +func rewriteValueAMD64_OpLsh32x16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Lsh32x16 x y) + // cond: + // result: (ANDL (SHLL x y) (SBBLcarrymask (CMPWconst [32] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64SHLL, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1.Type = t + v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v2.AuxInt = 32 + v2.AddArg(y) + v2.Type = TypeFlags + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto end5a43b7e9b0780e62f622bac0a68524d2 +end5a43b7e9b0780e62f622bac0a68524d2: + ; + return false +} +func rewriteValueAMD64_OpLsh32x32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Lsh32x32 x y) + // cond: + // result: (ANDL (SHLL x y) (SBBLcarrymask (CMPLconst [32] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64SHLL, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1.Type = t + v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v2.AuxInt = 32 + v2.AddArg(y) + v2.Type = TypeFlags + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto end9ce0ab6f9095c24ea46ca8fe2d7e5507 +end9ce0ab6f9095c24ea46ca8fe2d7e5507: + ; + return false +} +func rewriteValueAMD64_OpLsh32x64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Lsh32x64 x y) + // cond: + // result: (ANDL (SHLL x y) (SBBLcarrymask (CMPQconst [32] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64SHLL, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1.Type = t + v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v2.AuxInt = 32 + v2.AddArg(y) + v2.Type = TypeFlags + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto end646b5471b709d5ea6c21f49a2815236f +end646b5471b709d5ea6c21f49a2815236f: + ; + return false +} +func rewriteValueAMD64_OpLsh32x8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Lsh32x8 x y) + // cond: + // result: (ANDL (SHLL x y) (SBBLcarrymask (CMPBconst [32] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64SHLL, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1.Type = t + v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + v2.AuxInt = 32 + v2.AddArg(y) + v2.Type = TypeFlags + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto end96a677c71370e7c9179125f92cbdfda8 +end96a677c71370e7c9179125f92cbdfda8: + ; + return false +} +func rewriteValueAMD64_OpLsh64x16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Lsh64x16 x y) + // cond: + // result: (ANDQ (SHLQ x y) (SBBQcarrymask (CMPWconst [64] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64SHLQ, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1.Type = t + v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v2.AuxInt = 64 + v2.AddArg(y) + v2.Type = TypeFlags + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto end5f88f241d68d38954222d81559cd7f9f +end5f88f241d68d38954222d81559cd7f9f: + ; + return false +} +func rewriteValueAMD64_OpLsh64x32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Lsh64x32 x y) + // cond: + // result: (ANDQ (SHLQ x y) (SBBQcarrymask (CMPLconst [64] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64SHLQ, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1.Type = t + v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v2.AuxInt = 64 + v2.AddArg(y) + v2.Type = TypeFlags + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto endae1705f03ed3d6f43cd63b53496a910a +endae1705f03ed3d6f43cd63b53496a910a: + ; + return false +} +func rewriteValueAMD64_OpLsh64x64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Lsh64x64 x y) + // cond: + // result: (ANDQ (SHLQ x y) (SBBQcarrymask (CMPQconst [64] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64SHLQ, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1.Type = t + v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v2.AuxInt = 64 + v2.AddArg(y) + v2.Type = TypeFlags + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto end1f6f5f510c5c68e4ce4a78643e6d85a1 +end1f6f5f510c5c68e4ce4a78643e6d85a1: + ; + return false +} +func rewriteValueAMD64_OpLsh64x8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Lsh64x8 x y) + // cond: + // result: (ANDQ (SHLQ x y) (SBBQcarrymask (CMPBconst [64] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64SHLQ, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1.Type = t + v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + v2.AuxInt = 64 + v2.AddArg(y) + v2.Type = TypeFlags + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto endd14f5c89e3496b0e425aa1ae366f4b53 +endd14f5c89e3496b0e425aa1ae366f4b53: + ; + return false +} +func rewriteValueAMD64_OpLsh8x16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Lsh8x16 x y) + // cond: + // result: (ANDB (SHLB x y) (SBBLcarrymask (CMPWconst [8] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64SHLB, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1.Type = t + v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v2.AuxInt = 8 + v2.AddArg(y) + v2.Type = TypeFlags + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto end0926c3d8b9a0776ba5058946f6e1a4b7 +end0926c3d8b9a0776ba5058946f6e1a4b7: + ; + return false +} +func rewriteValueAMD64_OpLsh8x32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Lsh8x32 x y) + // cond: + // result: (ANDB (SHLB x y) (SBBLcarrymask (CMPLconst [8] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64SHLB, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1.Type = t + v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v2.AuxInt = 8 + v2.AddArg(y) + v2.Type = TypeFlags + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto end5987682d77f197ef0fd95251f413535a +end5987682d77f197ef0fd95251f413535a: + ; + return false +} +func rewriteValueAMD64_OpLsh8x64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Lsh8x64 x y) + // cond: + // result: (ANDB (SHLB x y) (SBBLcarrymask (CMPQconst [8] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64SHLB, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1.Type = t + v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v2.AuxInt = 8 + v2.AddArg(y) + v2.Type = TypeFlags + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto end9ffe6731d7d6514b8c0482f1645eee18 +end9ffe6731d7d6514b8c0482f1645eee18: + ; + return false +} +func rewriteValueAMD64_OpLsh8x8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Lsh8x8 x y) + // cond: + // result: (ANDB (SHLB x y) (SBBLcarrymask (CMPBconst [8] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64SHLB, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1.Type = t + v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + v2.AuxInt = 8 + v2.AddArg(y) + v2.Type = TypeFlags + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto end2b75242a31c3713ffbfdd8f0288b1c12 +end2b75242a31c3713ffbfdd8f0288b1c12: + ; + 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 [off] {sym} ptr mem) + { + if v.Args[0].Op != OpAMD64MOVBload { + goto end19c38f3a1a37dca50637c917fa26e4f7 + } + off := v.Args[0].AuxInt + sym := v.Args[0].Aux + ptr := v.Args[0].Args[0] + mem := v.Args[0].Args[1] + v0 := v.Args[0].Block.NewValue0(v.Line, OpAMD64MOVBQSXload, TypeInvalid) + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(v0) + v0.Type = v.Type + v0.AuxInt = off + v0.Aux = sym + v0.AddArg(ptr) + v0.AddArg(mem) + return true + } + goto end19c38f3a1a37dca50637c917fa26e4f7 +end19c38f3a1a37dca50637c917fa26e4f7: + ; + 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 [off] {sym} ptr mem) + { + if v.Args[0].Op != OpAMD64MOVBload { + goto end1169bcf3d56fa24321b002eaebd5a62d + } + off := v.Args[0].AuxInt + sym := v.Args[0].Aux + ptr := v.Args[0].Args[0] + mem := v.Args[0].Args[1] + v0 := v.Args[0].Block.NewValue0(v.Line, OpAMD64MOVBQZXload, TypeInvalid) + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(v0) + v0.Type = v.Type + v0.AuxInt = off + v0.Aux = sym + v0.AddArg(ptr) + v0.AddArg(mem) + return true + } + goto end1169bcf3d56fa24321b002eaebd5a62d +end1169bcf3d56fa24321b002eaebd5a62d: + ; + return false +} +func rewriteValueAMD64_OpAMD64MOVBload(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (MOVBload [off1] {sym} (ADDQconst [off2] ptr) mem) + // cond: + // result: (MOVBload [addOff(off1, off2)] {sym} ptr mem) + { + off1 := v.AuxInt + sym := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto end7ec9147ab863c1bd59190fed81f894b6 + } + off2 := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + mem := v.Args[1] + v.Op = OpAMD64MOVBload + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = sym + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto end7ec9147ab863c1bd59190fed81f894b6 +end7ec9147ab863c1bd59190fed81f894b6: + ; + // match: (MOVBload [off1] {sym1} (LEAQ [off2] {sym2} base) mem) + // cond: canMergeSym(sym1, sym2) + // result: (MOVBload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem) + { + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ { + goto end3771a59cf66b0df99120d76f4c358fab + } + off2 := v.Args[0].AuxInt + sym2 := v.Args[0].Aux + base := v.Args[0].Args[0] + mem := v.Args[1] + if !(canMergeSym(sym1, sym2)) { + goto end3771a59cf66b0df99120d76f4c358fab + } + v.Op = OpAMD64MOVBload + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(base) + v.AddArg(mem) + return true + } + goto end3771a59cf66b0df99120d76f4c358fab +end3771a59cf66b0df99120d76f4c358fab: + ; + 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) + { + off := v.AuxInt + sym := v.Aux + ptr := v.Args[0] + if v.Args[1].Op != OpAMD64MOVBQSX { + goto end5b3f41f0770d566ff1647dea1d4a40e8 + } + x := v.Args[1].Args[0] + mem := v.Args[2] + v.Op = OpAMD64MOVBstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = off + v.Aux = sym + v.AddArg(ptr) + v.AddArg(x) + v.AddArg(mem) + return true + } + goto end5b3f41f0770d566ff1647dea1d4a40e8 +end5b3f41f0770d566ff1647dea1d4a40e8: + ; + // match: (MOVBstore [off] {sym} ptr (MOVBQZX x) mem) + // cond: + // result: (MOVBstore [off] {sym} ptr x mem) + { + off := v.AuxInt + sym := v.Aux + ptr := v.Args[0] + if v.Args[1].Op != OpAMD64MOVBQZX { + goto end3a2e55db7e03920700c4875f6a55de3b + } + x := v.Args[1].Args[0] + mem := v.Args[2] + v.Op = OpAMD64MOVBstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = off + v.Aux = sym + v.AddArg(ptr) + v.AddArg(x) + v.AddArg(mem) + return true + } + goto end3a2e55db7e03920700c4875f6a55de3b +end3a2e55db7e03920700c4875f6a55de3b: + ; + // match: (MOVBstore [off1] {sym} (ADDQconst [off2] ptr) val mem) + // cond: + // result: (MOVBstore [addOff(off1, off2)] {sym} ptr val mem) + { + off1 := v.AuxInt + sym := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto ende6347ac19d0469ee59d2e7f2e18d1070 + } + off2 := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + val := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64MOVBstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = sym + v.AddArg(ptr) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto ende6347ac19d0469ee59d2e7f2e18d1070 +ende6347ac19d0469ee59d2e7f2e18d1070: + ; + // match: (MOVBstore [off] {sym} ptr (MOVBconst [c]) mem) + // cond: validStoreConstOff(off) + // result: (MOVBstoreconst [makeStoreConst(int64(int8(c)),off)] {sym} ptr mem) + { + off := v.AuxInt + sym := v.Aux + ptr := v.Args[0] + if v.Args[1].Op != OpAMD64MOVBconst { + goto enda8ebda583a842dae6377b7f562040318 + } + c := v.Args[1].AuxInt + mem := v.Args[2] + if !(validStoreConstOff(off)) { + goto enda8ebda583a842dae6377b7f562040318 + } + v.Op = OpAMD64MOVBstoreconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = makeStoreConst(int64(int8(c)), off) + v.Aux = sym + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto enda8ebda583a842dae6377b7f562040318 +enda8ebda583a842dae6377b7f562040318: + ; + // 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) + { + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ { + goto enda7086cf7f6b8cf81972e2c3d4b12f3fc + } + 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)) { + goto enda7086cf7f6b8cf81972e2c3d4b12f3fc + } + v.Op = OpAMD64MOVBstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(base) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto enda7086cf7f6b8cf81972e2c3d4b12f3fc +enda7086cf7f6b8cf81972e2c3d4b12f3fc: + ; + return false +} +func rewriteValueAMD64_OpAMD64MOVBstoreconst(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (MOVBstoreconst [sc] {s} (ADDQconst [off] ptr) mem) + // cond: StoreConst(sc).canAdd(off) + // result: (MOVBstoreconst [StoreConst(sc).add(off)] {s} ptr mem) + { + sc := v.AuxInt + s := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto ende1cdf6d463f91ba4dd1956f8ba4cb128 + } + off := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + mem := v.Args[1] + if !(StoreConst(sc).canAdd(off)) { + goto ende1cdf6d463f91ba4dd1956f8ba4cb128 + } + v.Op = OpAMD64MOVBstoreconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = StoreConst(sc).add(off) + v.Aux = s + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto ende1cdf6d463f91ba4dd1956f8ba4cb128 +ende1cdf6d463f91ba4dd1956f8ba4cb128: + ; + // match: (MOVBstoreconst [sc] {sym1} (LEAQ [off] {sym2} ptr) mem) + // cond: canMergeSym(sym1, sym2) && StoreConst(sc).canAdd(off) + // result: (MOVBstoreconst [StoreConst(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem) + { + sc := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ { + goto end5feed29bca3ce7d5fccda89acf71c855 + } + off := v.Args[0].AuxInt + sym2 := v.Args[0].Aux + ptr := v.Args[0].Args[0] + mem := v.Args[1] + if !(canMergeSym(sym1, sym2) && StoreConst(sc).canAdd(off)) { + goto end5feed29bca3ce7d5fccda89acf71c855 + } + v.Op = OpAMD64MOVBstoreconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = StoreConst(sc).add(off) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto end5feed29bca3ce7d5fccda89acf71c855 +end5feed29bca3ce7d5fccda89acf71c855: + ; + return false +} +func rewriteValueAMD64_OpAMD64MOVLload(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (MOVLload [off1] {sym} (ADDQconst [off2] ptr) mem) + // cond: + // result: (MOVLload [addOff(off1, off2)] {sym} ptr mem) + { + off1 := v.AuxInt + sym := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto end0c8b8a40360c5c581d92723eca04d340 + } + off2 := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + mem := v.Args[1] + v.Op = OpAMD64MOVLload + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = sym + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto end0c8b8a40360c5c581d92723eca04d340 +end0c8b8a40360c5c581d92723eca04d340: + ; + // match: (MOVLload [off1] {sym1} (LEAQ [off2] {sym2} base) mem) + // cond: canMergeSym(sym1, sym2) + // result: (MOVLload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem) + { + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ { + goto enddb9e59335876d8a565c425731438a1b3 + } + off2 := v.Args[0].AuxInt + sym2 := v.Args[0].Aux + base := v.Args[0].Args[0] + mem := v.Args[1] + if !(canMergeSym(sym1, sym2)) { + goto enddb9e59335876d8a565c425731438a1b3 + } + v.Op = OpAMD64MOVLload + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(base) + v.AddArg(mem) + return true + } + goto enddb9e59335876d8a565c425731438a1b3 +enddb9e59335876d8a565c425731438a1b3: + ; + 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) + { + off := v.AuxInt + sym := v.Aux + ptr := v.Args[0] + if v.Args[1].Op != OpAMD64MOVLQSX { + goto end1fb7b2ae707c76d30927c21f85d77472 + } + x := v.Args[1].Args[0] + mem := v.Args[2] + v.Op = OpAMD64MOVLstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = off + v.Aux = sym + v.AddArg(ptr) + v.AddArg(x) + v.AddArg(mem) + return true + } + goto end1fb7b2ae707c76d30927c21f85d77472 +end1fb7b2ae707c76d30927c21f85d77472: + ; + // match: (MOVLstore [off] {sym} ptr (MOVLQZX x) mem) + // cond: + // result: (MOVLstore [off] {sym} ptr x mem) + { + off := v.AuxInt + sym := v.Aux + ptr := v.Args[0] + if v.Args[1].Op != OpAMD64MOVLQZX { + goto end199e8c23a5e7e99728a43d6a83b2c2cf + } + x := v.Args[1].Args[0] + mem := v.Args[2] + v.Op = OpAMD64MOVLstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = off + v.Aux = sym + v.AddArg(ptr) + v.AddArg(x) + v.AddArg(mem) + return true + } + goto end199e8c23a5e7e99728a43d6a83b2c2cf +end199e8c23a5e7e99728a43d6a83b2c2cf: + ; + // match: (MOVLstore [off1] {sym} (ADDQconst [off2] ptr) val mem) + // cond: + // result: (MOVLstore [addOff(off1, off2)] {sym} ptr val mem) + { + off1 := v.AuxInt + sym := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto end43bffdb8d9c1fc85a95778d4911955f1 + } + off2 := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + val := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64MOVLstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = sym + v.AddArg(ptr) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto end43bffdb8d9c1fc85a95778d4911955f1 +end43bffdb8d9c1fc85a95778d4911955f1: + ; + // match: (MOVLstore [off] {sym} ptr (MOVLconst [c]) mem) + // cond: validStoreConstOff(off) + // result: (MOVLstoreconst [makeStoreConst(int64(int32(c)),off)] {sym} ptr mem) + { + off := v.AuxInt + sym := v.Aux + ptr := v.Args[0] + if v.Args[1].Op != OpAMD64MOVLconst { + goto end14bc0c027d67d279cf3ef2038b759ce2 + } + c := v.Args[1].AuxInt + mem := v.Args[2] + if !(validStoreConstOff(off)) { + goto end14bc0c027d67d279cf3ef2038b759ce2 + } + v.Op = OpAMD64MOVLstoreconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = makeStoreConst(int64(int32(c)), off) + v.Aux = sym + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto end14bc0c027d67d279cf3ef2038b759ce2 +end14bc0c027d67d279cf3ef2038b759ce2: + ; + // 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) + { + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ { + goto endd57b1e4313fc7a3331340a9af00ba116 + } + 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)) { + goto endd57b1e4313fc7a3331340a9af00ba116 + } + v.Op = OpAMD64MOVLstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(base) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto endd57b1e4313fc7a3331340a9af00ba116 +endd57b1e4313fc7a3331340a9af00ba116: + ; + return false +} +func rewriteValueAMD64_OpAMD64MOVLstoreconst(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (MOVLstoreconst [sc] {s} (ADDQconst [off] ptr) mem) + // cond: StoreConst(sc).canAdd(off) + // result: (MOVLstoreconst [StoreConst(sc).add(off)] {s} ptr mem) + { + sc := v.AuxInt + s := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto end7665f96d0aaa57009bf98632f19bf8e7 + } + off := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + mem := v.Args[1] + if !(StoreConst(sc).canAdd(off)) { + goto end7665f96d0aaa57009bf98632f19bf8e7 + } + v.Op = OpAMD64MOVLstoreconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = StoreConst(sc).add(off) + v.Aux = s + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto end7665f96d0aaa57009bf98632f19bf8e7 +end7665f96d0aaa57009bf98632f19bf8e7: + ; + // match: (MOVLstoreconst [sc] {sym1} (LEAQ [off] {sym2} ptr) mem) + // cond: canMergeSym(sym1, sym2) && StoreConst(sc).canAdd(off) + // result: (MOVLstoreconst [StoreConst(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem) + { + sc := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ { + goto end1664c6056a9c65fcbe30eca273e8ee64 + } + off := v.Args[0].AuxInt + sym2 := v.Args[0].Aux + ptr := v.Args[0].Args[0] + mem := v.Args[1] + if !(canMergeSym(sym1, sym2) && StoreConst(sc).canAdd(off)) { + goto end1664c6056a9c65fcbe30eca273e8ee64 + } + v.Op = OpAMD64MOVLstoreconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = StoreConst(sc).add(off) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto end1664c6056a9c65fcbe30eca273e8ee64 +end1664c6056a9c65fcbe30eca273e8ee64: + ; + 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) + { + off1 := v.AuxInt + sym := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto endf1e8fcf569ddd8b3f7a2f61696971913 + } + off2 := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + mem := v.Args[1] + v.Op = OpAMD64MOVOload + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = sym + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto endf1e8fcf569ddd8b3f7a2f61696971913 +endf1e8fcf569ddd8b3f7a2f61696971913: + ; + // match: (MOVOload [off1] {sym1} (LEAQ [off2] {sym2} base) mem) + // cond: canMergeSym(sym1, sym2) + // result: (MOVOload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem) + { + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ { + goto endd36cf9b00af7a8f44fb8c60067a8efb2 + } + off2 := v.Args[0].AuxInt + sym2 := v.Args[0].Aux + base := v.Args[0].Args[0] + mem := v.Args[1] + if !(canMergeSym(sym1, sym2)) { + goto endd36cf9b00af7a8f44fb8c60067a8efb2 + } + v.Op = OpAMD64MOVOload + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(base) + v.AddArg(mem) + return true + } + goto endd36cf9b00af7a8f44fb8c60067a8efb2 +endd36cf9b00af7a8f44fb8c60067a8efb2: + ; + 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) + { + off1 := v.AuxInt + sym := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto end2be573aa1bd919e567e6156a4ee36517 + } + off2 := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + val := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64MOVOstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = sym + v.AddArg(ptr) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto end2be573aa1bd919e567e6156a4ee36517 +end2be573aa1bd919e567e6156a4ee36517: + ; + // 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) + { + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ { + goto endc28b9b3efe9eb235e1586c4555280c20 + } + 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)) { + goto endc28b9b3efe9eb235e1586c4555280c20 + } + v.Op = OpAMD64MOVOstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(base) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto endc28b9b3efe9eb235e1586c4555280c20 +endc28b9b3efe9eb235e1586c4555280c20: + ; + return false +} +func rewriteValueAMD64_OpAMD64MOVQload(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (MOVQload [off1] {sym} (ADDQconst [off2] ptr) mem) + // cond: + // result: (MOVQload [addOff(off1, off2)] {sym} ptr mem) + { + off1 := v.AuxInt + sym := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto end0b8c50dd7faefb7d046f9a27e054df77 + } + off2 := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + mem := v.Args[1] + v.Op = OpAMD64MOVQload + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = sym + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto end0b8c50dd7faefb7d046f9a27e054df77 +end0b8c50dd7faefb7d046f9a27e054df77: + ; + // match: (MOVQload [off1] {sym1} (LEAQ [off2] {sym2} base) mem) + // cond: canMergeSym(sym1, sym2) + // result: (MOVQload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem) + { + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ { + goto endd0c093adc4f05f2037005734c77d3cc4 + } + off2 := v.Args[0].AuxInt + sym2 := v.Args[0].Aux + base := v.Args[0].Args[0] + mem := v.Args[1] + if !(canMergeSym(sym1, sym2)) { + goto endd0c093adc4f05f2037005734c77d3cc4 + } + v.Op = OpAMD64MOVQload + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(base) + v.AddArg(mem) + return true + } + goto endd0c093adc4f05f2037005734c77d3cc4 +endd0c093adc4f05f2037005734c77d3cc4: + ; + // 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) + { + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ8 { + goto end74a50d810fb3945e809f608cd094a59c + } + 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)) { + goto end74a50d810fb3945e809f608cd094a59c + } + v.Op = OpAMD64MOVQloadidx8 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(ptr) + v.AddArg(idx) + v.AddArg(mem) + return true + } + goto end74a50d810fb3945e809f608cd094a59c +end74a50d810fb3945e809f608cd094a59c: + ; + return false +} +func rewriteValueAMD64_OpAMD64MOVQloadidx8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (MOVQloadidx8 [off1] {sym} (ADDQconst [off2] ptr) idx mem) + // cond: + // result: (MOVQloadidx8 [addOff(off1, off2)] {sym} ptr idx mem) + { + off1 := v.AuxInt + sym := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto endb138bf9b0b33ec824bf0aff619f8bafa + } + off2 := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + idx := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64MOVQloadidx8 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = sym + v.AddArg(ptr) + v.AddArg(idx) + v.AddArg(mem) + return true + } + goto endb138bf9b0b33ec824bf0aff619f8bafa +endb138bf9b0b33ec824bf0aff619f8bafa: + ; + 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) + { + off1 := v.AuxInt + sym := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto end0a110b5e42a4576c32fda50590092848 + } + off2 := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + val := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64MOVQstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = sym + v.AddArg(ptr) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto end0a110b5e42a4576c32fda50590092848 +end0a110b5e42a4576c32fda50590092848: + ; + // match: (MOVQstore [off] {sym} ptr (MOVQconst [c]) mem) + // cond: validStoreConst(c,off) + // result: (MOVQstoreconst [makeStoreConst(c,off)] {sym} ptr mem) + { + off := v.AuxInt + sym := v.Aux + ptr := v.Args[0] + if v.Args[1].Op != OpAMD64MOVQconst { + goto end8368f37d24b6a2f59c3d00966c4d4111 + } + c := v.Args[1].AuxInt + mem := v.Args[2] + if !(validStoreConst(c, off)) { + goto end8368f37d24b6a2f59c3d00966c4d4111 + } + v.Op = OpAMD64MOVQstoreconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = makeStoreConst(c, off) + v.Aux = sym + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto end8368f37d24b6a2f59c3d00966c4d4111 +end8368f37d24b6a2f59c3d00966c4d4111: + ; + // 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) + { + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ { + goto end9a0cfe20b3b0f587e252760907c1b5c0 + } + 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)) { + goto end9a0cfe20b3b0f587e252760907c1b5c0 + } + v.Op = OpAMD64MOVQstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(base) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto end9a0cfe20b3b0f587e252760907c1b5c0 +end9a0cfe20b3b0f587e252760907c1b5c0: + ; + // 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) + { + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ8 { + goto end442c322e6719e280b6be1c12858e49d7 + } + 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)) { + goto end442c322e6719e280b6be1c12858e49d7 + } + v.Op = OpAMD64MOVQstoreidx8 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(ptr) + v.AddArg(idx) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto end442c322e6719e280b6be1c12858e49d7 +end442c322e6719e280b6be1c12858e49d7: + ; + return false +} +func rewriteValueAMD64_OpAMD64MOVQstoreconst(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (MOVQstoreconst [sc] {s} (ADDQconst [off] ptr) mem) + // cond: StoreConst(sc).canAdd(off) + // result: (MOVQstoreconst [StoreConst(sc).add(off)] {s} ptr mem) + { + sc := v.AuxInt + s := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto end5826e30265c68ea8c4cd595ceedf9405 + } + off := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + mem := v.Args[1] + if !(StoreConst(sc).canAdd(off)) { + goto end5826e30265c68ea8c4cd595ceedf9405 + } + v.Op = OpAMD64MOVQstoreconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = StoreConst(sc).add(off) + v.Aux = s + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto end5826e30265c68ea8c4cd595ceedf9405 +end5826e30265c68ea8c4cd595ceedf9405: + ; + // match: (MOVQstoreconst [sc] {sym1} (LEAQ [off] {sym2} ptr) mem) + // cond: canMergeSym(sym1, sym2) && StoreConst(sc).canAdd(off) + // result: (MOVQstoreconst [StoreConst(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem) + { + sc := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ { + goto endb9c7f7a9dbc6b885d84f851c74b018e5 + } + off := v.Args[0].AuxInt + sym2 := v.Args[0].Aux + ptr := v.Args[0].Args[0] + mem := v.Args[1] + if !(canMergeSym(sym1, sym2) && StoreConst(sc).canAdd(off)) { + goto endb9c7f7a9dbc6b885d84f851c74b018e5 + } + v.Op = OpAMD64MOVQstoreconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = StoreConst(sc).add(off) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto endb9c7f7a9dbc6b885d84f851c74b018e5 +endb9c7f7a9dbc6b885d84f851c74b018e5: + ; + return false +} +func rewriteValueAMD64_OpAMD64MOVQstoreidx8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (MOVQstoreidx8 [off1] {sym} (ADDQconst [off2] ptr) idx val mem) + // cond: + // result: (MOVQstoreidx8 [addOff(off1, off2)] {sym} ptr idx val mem) + { + off1 := v.AuxInt + sym := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto end50671766fdab364c1edbd2072fb8e525 + } + off2 := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + idx := v.Args[1] + val := v.Args[2] + mem := v.Args[3] + v.Op = OpAMD64MOVQstoreidx8 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = sym + v.AddArg(ptr) + v.AddArg(idx) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto end50671766fdab364c1edbd2072fb8e525 +end50671766fdab364c1edbd2072fb8e525: + ; + 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) + { + off1 := v.AuxInt + sym := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto end6dad9bf78e7368bb095eb2dfba7e244a + } + off2 := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + mem := v.Args[1] + v.Op = OpAMD64MOVSDload + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = sym + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto end6dad9bf78e7368bb095eb2dfba7e244a +end6dad9bf78e7368bb095eb2dfba7e244a: + ; + // match: (MOVSDload [off1] {sym1} (LEAQ [off2] {sym2} base) mem) + // cond: canMergeSym(sym1, sym2) + // result: (MOVSDload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem) + { + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ { + goto end96fa9c439e31050aa91582bc2a9f2c20 + } + off2 := v.Args[0].AuxInt + sym2 := v.Args[0].Aux + base := v.Args[0].Args[0] + mem := v.Args[1] + if !(canMergeSym(sym1, sym2)) { + goto end96fa9c439e31050aa91582bc2a9f2c20 + } + v.Op = OpAMD64MOVSDload + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(base) + v.AddArg(mem) + return true + } + goto end96fa9c439e31050aa91582bc2a9f2c20 +end96fa9c439e31050aa91582bc2a9f2c20: + ; + // 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) + { + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ8 { + goto endbcb2ce441824d0e3a4b501018cfa7f60 + } + 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)) { + goto endbcb2ce441824d0e3a4b501018cfa7f60 + } + v.Op = OpAMD64MOVSDloadidx8 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(ptr) + v.AddArg(idx) + v.AddArg(mem) + return true + } + goto endbcb2ce441824d0e3a4b501018cfa7f60 +endbcb2ce441824d0e3a4b501018cfa7f60: + ; + return false +} +func rewriteValueAMD64_OpAMD64MOVSDloadidx8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (MOVSDloadidx8 [off1] {sym} (ADDQconst [off2] {sym} ptr) idx mem) + // cond: + // result: (MOVSDloadidx8 [addOff(off1, off2)] {sym} ptr idx mem) + { + off1 := v.AuxInt + sym := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto end84f0f457e271104a92343e3b1d2804c6 + } + off2 := v.Args[0].AuxInt + if v.Args[0].Aux != v.Aux { + goto end84f0f457e271104a92343e3b1d2804c6 + } + ptr := v.Args[0].Args[0] + idx := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64MOVSDloadidx8 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = sym + v.AddArg(ptr) + v.AddArg(idx) + v.AddArg(mem) + return true + } + goto end84f0f457e271104a92343e3b1d2804c6 +end84f0f457e271104a92343e3b1d2804c6: + ; + 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) + { + off1 := v.AuxInt + sym := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto end6c6160664143cc66e63e67b9aa43a7ef + } + off2 := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + val := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64MOVSDstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = sym + v.AddArg(ptr) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto end6c6160664143cc66e63e67b9aa43a7ef +end6c6160664143cc66e63e67b9aa43a7ef: + ; + // 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) + { + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ { + goto end415dde14f3400bec1b2756174a5d7179 + } + 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)) { + goto end415dde14f3400bec1b2756174a5d7179 + } + v.Op = OpAMD64MOVSDstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(base) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto end415dde14f3400bec1b2756174a5d7179 +end415dde14f3400bec1b2756174a5d7179: + ; + // 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) + { + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ8 { + goto end1ad6fc0c5b59610dabf7f9595a48a230 + } + 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)) { + goto end1ad6fc0c5b59610dabf7f9595a48a230 + } + v.Op = OpAMD64MOVSDstoreidx8 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(ptr) + v.AddArg(idx) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto end1ad6fc0c5b59610dabf7f9595a48a230 +end1ad6fc0c5b59610dabf7f9595a48a230: + ; + return false +} +func rewriteValueAMD64_OpAMD64MOVSDstoreidx8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (MOVSDstoreidx8 [off1] {sym} (ADDQconst [off2] {sym} ptr) idx val mem) + // cond: + // result: (MOVSDstoreidx8 [addOff(off1, off2)] {sym} ptr idx val mem) + { + off1 := v.AuxInt + sym := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto endc0e28f57697cb6038d5d09eafe26c947 + } + off2 := v.Args[0].AuxInt + if v.Args[0].Aux != v.Aux { + goto endc0e28f57697cb6038d5d09eafe26c947 + } + ptr := v.Args[0].Args[0] + idx := v.Args[1] + val := v.Args[2] + mem := v.Args[3] + v.Op = OpAMD64MOVSDstoreidx8 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = sym + v.AddArg(ptr) + v.AddArg(idx) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto endc0e28f57697cb6038d5d09eafe26c947 +endc0e28f57697cb6038d5d09eafe26c947: + ; + 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) + { + off1 := v.AuxInt + sym := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto end96d63dbb64b0adfa944684c9e939c972 + } + off2 := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + mem := v.Args[1] + v.Op = OpAMD64MOVSSload + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = sym + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto end96d63dbb64b0adfa944684c9e939c972 +end96d63dbb64b0adfa944684c9e939c972: + ; + // match: (MOVSSload [off1] {sym1} (LEAQ [off2] {sym2} base) mem) + // cond: canMergeSym(sym1, sym2) + // result: (MOVSSload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem) + { + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ { + goto end15f2583bd72ad7fc077b3952634a1c85 + } + off2 := v.Args[0].AuxInt + sym2 := v.Args[0].Aux + base := v.Args[0].Args[0] + mem := v.Args[1] + if !(canMergeSym(sym1, sym2)) { + goto end15f2583bd72ad7fc077b3952634a1c85 + } + v.Op = OpAMD64MOVSSload + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(base) + v.AddArg(mem) + return true + } + goto end15f2583bd72ad7fc077b3952634a1c85 +end15f2583bd72ad7fc077b3952634a1c85: + ; + // 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) + { + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ4 { + goto end49722f4a0adba31bb143601ce1d2aae0 + } + 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)) { + goto end49722f4a0adba31bb143601ce1d2aae0 + } + v.Op = OpAMD64MOVSSloadidx4 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(ptr) + v.AddArg(idx) + v.AddArg(mem) + return true + } + goto end49722f4a0adba31bb143601ce1d2aae0 +end49722f4a0adba31bb143601ce1d2aae0: + ; + return false +} +func rewriteValueAMD64_OpAMD64MOVSSloadidx4(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (MOVSSloadidx4 [off1] {sym} (ADDQconst [off2] {sym} ptr) idx mem) + // cond: + // result: (MOVSSloadidx4 [addOff(off1, off2)] {sym} ptr idx mem) + { + off1 := v.AuxInt + sym := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto end7eb5a1ab1e2508683d879ec25286754b + } + off2 := v.Args[0].AuxInt + if v.Args[0].Aux != v.Aux { + goto end7eb5a1ab1e2508683d879ec25286754b + } + ptr := v.Args[0].Args[0] + idx := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64MOVSSloadidx4 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = sym + v.AddArg(ptr) + v.AddArg(idx) + v.AddArg(mem) + return true + } + goto end7eb5a1ab1e2508683d879ec25286754b +end7eb5a1ab1e2508683d879ec25286754b: + ; + 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) + { + off1 := v.AuxInt + sym := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto endf711aa4081a9b2924b55387d4f70cfd6 + } + off2 := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + val := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64MOVSSstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = sym + v.AddArg(ptr) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto endf711aa4081a9b2924b55387d4f70cfd6 +endf711aa4081a9b2924b55387d4f70cfd6: + ; + // 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) + { + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ { + goto end70ebc170131920e515e3f416a6b952c5 + } + 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)) { + goto end70ebc170131920e515e3f416a6b952c5 + } + v.Op = OpAMD64MOVSSstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(base) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto end70ebc170131920e515e3f416a6b952c5 +end70ebc170131920e515e3f416a6b952c5: + ; + // 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) + { + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ4 { + goto end1622dc435e45833eda4d29d44df7cc34 + } + 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)) { + goto end1622dc435e45833eda4d29d44df7cc34 + } + v.Op = OpAMD64MOVSSstoreidx4 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(ptr) + v.AddArg(idx) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto end1622dc435e45833eda4d29d44df7cc34 +end1622dc435e45833eda4d29d44df7cc34: + ; + return false +} +func rewriteValueAMD64_OpAMD64MOVSSstoreidx4(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (MOVSSstoreidx4 [off1] {sym} (ADDQconst [off2] {sym} ptr) idx val mem) + // cond: + // result: (MOVSSstoreidx4 [addOff(off1, off2)] {sym} ptr idx val mem) + { + off1 := v.AuxInt + sym := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto end66e4853026306cd46f414c22d281254f + } + off2 := v.Args[0].AuxInt + if v.Args[0].Aux != v.Aux { + goto end66e4853026306cd46f414c22d281254f + } + ptr := v.Args[0].Args[0] + idx := v.Args[1] + val := v.Args[2] + mem := v.Args[3] + v.Op = OpAMD64MOVSSstoreidx4 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = sym + v.AddArg(ptr) + v.AddArg(idx) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto end66e4853026306cd46f414c22d281254f +end66e4853026306cd46f414c22d281254f: + ; + return false +} +func rewriteValueAMD64_OpAMD64MOVWload(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (MOVWload [off1] {sym} (ADDQconst [off2] ptr) mem) + // cond: + // result: (MOVWload [addOff(off1, off2)] {sym} ptr mem) + { + off1 := v.AuxInt + sym := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto endfcb0ce76f96e8b0c2eb19a9b827c1b73 + } + off2 := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + mem := v.Args[1] + v.Op = OpAMD64MOVWload + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = sym + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto endfcb0ce76f96e8b0c2eb19a9b827c1b73 +endfcb0ce76f96e8b0c2eb19a9b827c1b73: + ; + // match: (MOVWload [off1] {sym1} (LEAQ [off2] {sym2} base) mem) + // cond: canMergeSym(sym1, sym2) + // result: (MOVWload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem) + { + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ { + goto end7a79314cb49bf53d79c38c3077d87457 + } + off2 := v.Args[0].AuxInt + sym2 := v.Args[0].Aux + base := v.Args[0].Args[0] + mem := v.Args[1] + if !(canMergeSym(sym1, sym2)) { + goto end7a79314cb49bf53d79c38c3077d87457 + } + v.Op = OpAMD64MOVWload + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(base) + v.AddArg(mem) + return true + } + goto end7a79314cb49bf53d79c38c3077d87457 +end7a79314cb49bf53d79c38c3077d87457: + ; + 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) + { + off := v.AuxInt + sym := v.Aux + ptr := v.Args[0] + if v.Args[1].Op != OpAMD64MOVWQSX { + goto endca90c534e75c7f5cb803504d119a853f + } + x := v.Args[1].Args[0] + mem := v.Args[2] + v.Op = OpAMD64MOVWstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = off + v.Aux = sym + v.AddArg(ptr) + v.AddArg(x) + v.AddArg(mem) + return true + } + goto endca90c534e75c7f5cb803504d119a853f +endca90c534e75c7f5cb803504d119a853f: + ; + // match: (MOVWstore [off] {sym} ptr (MOVWQZX x) mem) + // cond: + // result: (MOVWstore [off] {sym} ptr x mem) + { + off := v.AuxInt + sym := v.Aux + ptr := v.Args[0] + if v.Args[1].Op != OpAMD64MOVWQZX { + goto end187fe73dfaf9cf5f4c349283b4dfd9d1 + } + x := v.Args[1].Args[0] + mem := v.Args[2] + v.Op = OpAMD64MOVWstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = off + v.Aux = sym + v.AddArg(ptr) + v.AddArg(x) + v.AddArg(mem) + return true + } + goto end187fe73dfaf9cf5f4c349283b4dfd9d1 +end187fe73dfaf9cf5f4c349283b4dfd9d1: + ; + // match: (MOVWstore [off1] {sym} (ADDQconst [off2] ptr) val mem) + // cond: + // result: (MOVWstore [addOff(off1, off2)] {sym} ptr val mem) + { + off1 := v.AuxInt + sym := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto endda15fdd59aa956ded0440188f38de1aa + } + off2 := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + val := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64MOVWstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = sym + v.AddArg(ptr) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto endda15fdd59aa956ded0440188f38de1aa +endda15fdd59aa956ded0440188f38de1aa: + ; + // match: (MOVWstore [off] {sym} ptr (MOVWconst [c]) mem) + // cond: validStoreConstOff(off) + // result: (MOVWstoreconst [makeStoreConst(int64(int16(c)),off)] {sym} ptr mem) + { + off := v.AuxInt + sym := v.Aux + ptr := v.Args[0] + if v.Args[1].Op != OpAMD64MOVWconst { + goto end226f449215b8ea54ac24fb8d52356ffa + } + c := v.Args[1].AuxInt + mem := v.Args[2] + if !(validStoreConstOff(off)) { + goto end226f449215b8ea54ac24fb8d52356ffa + } + v.Op = OpAMD64MOVWstoreconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = makeStoreConst(int64(int16(c)), off) + v.Aux = sym + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto end226f449215b8ea54ac24fb8d52356ffa +end226f449215b8ea54ac24fb8d52356ffa: + ; + // 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) + { + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ { + goto end4cc466ede8e64e415c899ccac81c0f27 + } + 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)) { + goto end4cc466ede8e64e415c899ccac81c0f27 + } + v.Op = OpAMD64MOVWstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(base) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto end4cc466ede8e64e415c899ccac81c0f27 +end4cc466ede8e64e415c899ccac81c0f27: + ; + return false +} +func rewriteValueAMD64_OpAMD64MOVWstoreconst(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (MOVWstoreconst [sc] {s} (ADDQconst [off] ptr) mem) + // cond: StoreConst(sc).canAdd(off) + // result: (MOVWstoreconst [StoreConst(sc).add(off)] {s} ptr mem) + { + sc := v.AuxInt + s := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto end2b764f9cf1bb32af25ba4e70a6705b91 + } + off := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + mem := v.Args[1] + if !(StoreConst(sc).canAdd(off)) { + goto end2b764f9cf1bb32af25ba4e70a6705b91 + } + v.Op = OpAMD64MOVWstoreconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = StoreConst(sc).add(off) + v.Aux = s + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto end2b764f9cf1bb32af25ba4e70a6705b91 +end2b764f9cf1bb32af25ba4e70a6705b91: + ; + // match: (MOVWstoreconst [sc] {sym1} (LEAQ [off] {sym2} ptr) mem) + // cond: canMergeSym(sym1, sym2) && StoreConst(sc).canAdd(off) + // result: (MOVWstoreconst [StoreConst(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem) + { + sc := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ { + goto enda15bfd8d540015b2245c65be486d2ffd + } + off := v.Args[0].AuxInt + sym2 := v.Args[0].Aux + ptr := v.Args[0].Args[0] + mem := v.Args[1] + if !(canMergeSym(sym1, sym2) && StoreConst(sc).canAdd(off)) { + goto enda15bfd8d540015b2245c65be486d2ffd + } + v.Op = OpAMD64MOVWstoreconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = StoreConst(sc).add(off) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto enda15bfd8d540015b2245c65be486d2ffd +enda15bfd8d540015b2245c65be486d2ffd: + ; + return false +} +func rewriteValueAMD64_OpAMD64MULB(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (MULB x (MOVBconst [c])) + // cond: + // result: (MULBconst [c] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVBconst { + goto end66c6419213ddeb52b1c53fb589a70e5f + } + c := v.Args[1].AuxInt + v.Op = OpAMD64MULBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end66c6419213ddeb52b1c53fb589a70e5f +end66c6419213ddeb52b1c53fb589a70e5f: + ; + // match: (MULB (MOVBconst [c]) x) + // cond: + // result: (MULBconst [c] x) + { + if v.Args[0].Op != OpAMD64MOVBconst { + goto end7e82c8dbbba265b78035ca7df394bb06 + } + c := v.Args[0].AuxInt + x := v.Args[1] + v.Op = OpAMD64MULBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end7e82c8dbbba265b78035ca7df394bb06 +end7e82c8dbbba265b78035ca7df394bb06: + ; + return false +} +func rewriteValueAMD64_OpAMD64MULBconst(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (MULBconst [c] (MOVBconst [d])) + // cond: + // result: (MOVBconst [c*d]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVBconst { + goto endf2db9f96016085f8cb4082b4af01b2aa + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c * d + return true + } + goto endf2db9f96016085f8cb4082b4af01b2aa +endf2db9f96016085f8cb4082b4af01b2aa: + ; + return false +} +func rewriteValueAMD64_OpAMD64MULL(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (MULL x (MOVLconst [c])) + // cond: + // result: (MULLconst [c] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVLconst { + goto end893477a261bcad6c2821b77c83075c6c + } + c := v.Args[1].AuxInt + v.Op = OpAMD64MULLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end893477a261bcad6c2821b77c83075c6c +end893477a261bcad6c2821b77c83075c6c: + ; + // match: (MULL (MOVLconst [c]) x) + // cond: + // result: (MULLconst [c] x) + { + if v.Args[0].Op != OpAMD64MOVLconst { + goto end8a0f957c528a54eecb0dbfc5d96e017a + } + c := v.Args[0].AuxInt + x := v.Args[1] + v.Op = OpAMD64MULLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end8a0f957c528a54eecb0dbfc5d96e017a +end8a0f957c528a54eecb0dbfc5d96e017a: + ; + return false +} +func rewriteValueAMD64_OpAMD64MULLconst(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (MULLconst [c] (MOVLconst [d])) + // cond: + // result: (MOVLconst [c*d]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVLconst { + goto endd5732835ed1276ef8b728bcfc1289f73 + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c * d + return true + } + goto endd5732835ed1276ef8b728bcfc1289f73 +endd5732835ed1276ef8b728bcfc1289f73: + ; + 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) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVQconst { + goto endb38c6e3e0ddfa25ba0ef9684ac1528c0 + } + c := v.Args[1].AuxInt + if !(is32Bit(c)) { + goto endb38c6e3e0ddfa25ba0ef9684ac1528c0 + } + v.Op = OpAMD64MULQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto endb38c6e3e0ddfa25ba0ef9684ac1528c0 +endb38c6e3e0ddfa25ba0ef9684ac1528c0: + ; + // match: (MULQ (MOVQconst [c]) x) + // cond: is32Bit(c) + // result: (MULQconst [c] x) + { + if v.Args[0].Op != OpAMD64MOVQconst { + goto end9cb4f29b0bd7141639416735dcbb3b87 + } + c := v.Args[0].AuxInt + x := v.Args[1] + if !(is32Bit(c)) { + goto end9cb4f29b0bd7141639416735dcbb3b87 + } + v.Op = OpAMD64MULQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end9cb4f29b0bd7141639416735dcbb3b87 +end9cb4f29b0bd7141639416735dcbb3b87: + ; + return false +} +func rewriteValueAMD64_OpAMD64MULQconst(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (MULQconst [-1] x) + // cond: + // result: (NEGQ x) + { + if v.AuxInt != -1 { + goto end82501cca6b5fb121a7f8b197e55f2fec + } + x := v.Args[0] + v.Op = OpAMD64NEGQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end82501cca6b5fb121a7f8b197e55f2fec +end82501cca6b5fb121a7f8b197e55f2fec: + ; + // match: (MULQconst [0] _) + // cond: + // result: (MOVQconst [0]) + { + if v.AuxInt != 0 { + goto endcb9faa068e3558ff44daaf1d47d091b5 + } + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto endcb9faa068e3558ff44daaf1d47d091b5 +endcb9faa068e3558ff44daaf1d47d091b5: + ; + // match: (MULQconst [1] x) + // cond: + // result: x + { + if v.AuxInt != 1 { + goto end0b527e71db2b288b2841a1f757aa580d + } + x := v.Args[0] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end0b527e71db2b288b2841a1f757aa580d +end0b527e71db2b288b2841a1f757aa580d: + ; + // match: (MULQconst [3] x) + // cond: + // result: (LEAQ2 x x) + { + if v.AuxInt != 3 { + goto end34a86f261671b5852bec6c57155fe0da + } + x := v.Args[0] + v.Op = OpAMD64LEAQ2 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(x) + return true + } + goto end34a86f261671b5852bec6c57155fe0da +end34a86f261671b5852bec6c57155fe0da: + ; + // match: (MULQconst [5] x) + // cond: + // result: (LEAQ4 x x) + { + if v.AuxInt != 5 { + goto end534601906c45a9171a9fec3e4b82b189 + } + x := v.Args[0] + v.Op = OpAMD64LEAQ4 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(x) + return true + } + goto end534601906c45a9171a9fec3e4b82b189 +end534601906c45a9171a9fec3e4b82b189: + ; + // match: (MULQconst [9] x) + // cond: + // result: (LEAQ8 x x) + { + if v.AuxInt != 9 { + goto end48a2280b6459821289c56073b8354997 + } + x := v.Args[0] + v.Op = OpAMD64LEAQ8 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(x) + return true + } + goto end48a2280b6459821289c56073b8354997 +end48a2280b6459821289c56073b8354997: + ; + // match: (MULQconst [c] x) + // cond: isPowerOfTwo(c) + // result: (SHLQconst [log2(c)] x) + { + c := v.AuxInt + x := v.Args[0] + if !(isPowerOfTwo(c)) { + goto end75076953dbfe022526a153eda99b39b2 + } + v.Op = OpAMD64SHLQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = log2(c) + v.AddArg(x) + return true + } + goto end75076953dbfe022526a153eda99b39b2 +end75076953dbfe022526a153eda99b39b2: + ; + // match: (MULQconst [c] (MOVQconst [d])) + // cond: + // result: (MOVQconst [c*d]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVQconst { + goto end55c38c5c405101e610d7ba7fc702ddc0 + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c * d + return true + } + goto end55c38c5c405101e610d7ba7fc702ddc0 +end55c38c5c405101e610d7ba7fc702ddc0: + ; + return false +} +func rewriteValueAMD64_OpAMD64MULW(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (MULW x (MOVWconst [c])) + // cond: + // result: (MULWconst [c] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVWconst { + goto end542112cc08217d4bdffc1a645d290ffb + } + c := v.Args[1].AuxInt + v.Op = OpAMD64MULWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end542112cc08217d4bdffc1a645d290ffb +end542112cc08217d4bdffc1a645d290ffb: + ; + // match: (MULW (MOVWconst [c]) x) + // cond: + // result: (MULWconst [c] x) + { + if v.Args[0].Op != OpAMD64MOVWconst { + goto endd97b4245ced2b3d27d8c555b06281de4 + } + c := v.Args[0].AuxInt + x := v.Args[1] + v.Op = OpAMD64MULWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto endd97b4245ced2b3d27d8c555b06281de4 +endd97b4245ced2b3d27d8c555b06281de4: + ; + return false +} +func rewriteValueAMD64_OpAMD64MULWconst(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (MULWconst [c] (MOVWconst [d])) + // cond: + // result: (MOVWconst [c*d]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVWconst { + goto end61dbc9d9e93dd6946a20a1f475b3f74b + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c * d + return true + } + goto end61dbc9d9e93dd6946a20a1f475b3f74b +end61dbc9d9e93dd6946a20a1f475b3f74b: + ; + return false +} +func rewriteValueAMD64_OpMod16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Mod16 x y) + // cond: + // result: (MODW x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64MODW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end036bac694be9fe0d6b00b86c2e625990 +end036bac694be9fe0d6b00b86c2e625990: + ; + return false +} +func rewriteValueAMD64_OpMod16u(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Mod16u x y) + // cond: + // result: (MODWU x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64MODWU + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto enda75d900097f1510ca1c6df786bef0c24 +enda75d900097f1510ca1c6df786bef0c24: + ; + return false +} +func rewriteValueAMD64_OpMod32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Mod32 x y) + // cond: + // result: (MODL x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64MODL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end12c8c0ecf3296810b8217cd4e40f7707 +end12c8c0ecf3296810b8217cd4e40f7707: + ; + return false +} +func rewriteValueAMD64_OpMod32u(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Mod32u x y) + // cond: + // result: (MODLU x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64MODLU + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end1f0892076cfd58733a08d3ab175a3c1c +end1f0892076cfd58733a08d3ab175a3c1c: + ; + return false +} +func rewriteValueAMD64_OpMod64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Mod64 x y) + // cond: + // result: (MODQ x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64MODQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto endaae75f449baf5dc108be4e0439af97f2 +endaae75f449baf5dc108be4e0439af97f2: + ; + return false +} +func rewriteValueAMD64_OpMod64u(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Mod64u x y) + // cond: + // result: (MODQU x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64MODQU + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end0d4c8b9df77e59289fb14e2496559d1d +end0d4c8b9df77e59289fb14e2496559d1d: + ; + 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)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64MODW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpSignExt8to16, TypeInvalid) + v0.AddArg(x) + v0.Type = config.fe.TypeInt16() + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpSignExt8to16, TypeInvalid) + v1.AddArg(y) + v1.Type = config.fe.TypeInt16() + v.AddArg(v1) + return true + } + goto endf959fc16e72bc6dc47ab7c9ee3778901 +endf959fc16e72bc6dc47ab7c9ee3778901: + ; + 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)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64MODWU + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpZeroExt8to16, TypeInvalid) + v0.AddArg(x) + v0.Type = config.fe.TypeUInt16() + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpZeroExt8to16, TypeInvalid) + v1.AddArg(y) + v1.Type = config.fe.TypeUInt16() + v.AddArg(v1) + return true + } + goto end9b3274d9dd7f1e91c75ce5e7b548fe97 +end9b3274d9dd7f1e91c75ce5e7b548fe97: + ; + return false +} +func rewriteValueAMD64_OpMove(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Move [0] _ _ mem) + // cond: + // result: mem + { + if v.AuxInt != 0 { + goto end0961cbfe144a616cba75190d07d65e41 + } + mem := v.Args[2] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = mem.Type + v.AddArg(mem) + return true + } + goto end0961cbfe144a616cba75190d07d65e41 +end0961cbfe144a616cba75190d07d65e41: + ; + // match: (Move [1] dst src mem) + // cond: + // result: (MOVBstore dst (MOVBload src mem) mem) + { + if v.AuxInt != 1 { + goto end72e5dd27e999493b67ea3af4ecc60d48 + } + dst := v.Args[0] + src := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64MOVBstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(dst) + v0 := b.NewValue0(v.Line, OpAMD64MOVBload, TypeInvalid) + v0.AddArg(src) + v0.AddArg(mem) + v0.Type = config.fe.TypeUInt8() + v.AddArg(v0) + v.AddArg(mem) + return true + } + goto end72e5dd27e999493b67ea3af4ecc60d48 +end72e5dd27e999493b67ea3af4ecc60d48: + ; + // match: (Move [2] dst src mem) + // cond: + // result: (MOVWstore dst (MOVWload src mem) mem) + { + if v.AuxInt != 2 { + goto end017f774e406d4578b4bcefcd8db8ec1e + } + dst := v.Args[0] + src := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64MOVWstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(dst) + v0 := b.NewValue0(v.Line, OpAMD64MOVWload, TypeInvalid) + v0.AddArg(src) + v0.AddArg(mem) + v0.Type = config.fe.TypeUInt16() + v.AddArg(v0) + v.AddArg(mem) + return true + } + goto end017f774e406d4578b4bcefcd8db8ec1e +end017f774e406d4578b4bcefcd8db8ec1e: + ; + // match: (Move [4] dst src mem) + // cond: + // result: (MOVLstore dst (MOVLload src mem) mem) + { + if v.AuxInt != 4 { + goto end938ec47a2ddf8e9b4bf71ffade6e5b3f + } + dst := v.Args[0] + src := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64MOVLstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(dst) + v0 := b.NewValue0(v.Line, OpAMD64MOVLload, TypeInvalid) + v0.AddArg(src) + v0.AddArg(mem) + v0.Type = config.fe.TypeUInt32() + v.AddArg(v0) + v.AddArg(mem) + return true + } + goto end938ec47a2ddf8e9b4bf71ffade6e5b3f +end938ec47a2ddf8e9b4bf71ffade6e5b3f: + ; + // match: (Move [8] dst src mem) + // cond: + // result: (MOVQstore dst (MOVQload src mem) mem) + { + if v.AuxInt != 8 { + goto end696b3498f5fee17f49ae0f708d3dfe4b + } + dst := v.Args[0] + src := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64MOVQstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(dst) + v0 := b.NewValue0(v.Line, OpAMD64MOVQload, TypeInvalid) + v0.AddArg(src) + v0.AddArg(mem) + v0.Type = config.fe.TypeUInt64() + v.AddArg(v0) + v.AddArg(mem) + return true + } + goto end696b3498f5fee17f49ae0f708d3dfe4b +end696b3498f5fee17f49ae0f708d3dfe4b: + ; + // match: (Move [16] dst src mem) + // cond: + // result: (MOVOstore dst (MOVOload src mem) mem) + { + if v.AuxInt != 16 { + goto end4894ace925d468c10a5b0c5b91fc4c1c + } + dst := v.Args[0] + src := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64MOVOstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(dst) + v0 := b.NewValue0(v.Line, OpAMD64MOVOload, TypeInvalid) + v0.AddArg(src) + v0.AddArg(mem) + v0.Type = TypeInt128 + v.AddArg(v0) + v.AddArg(mem) + return true + } + goto end4894ace925d468c10a5b0c5b91fc4c1c +end4894ace925d468c10a5b0c5b91fc4c1c: + ; + // match: (Move [3] dst src mem) + // cond: + // result: (MOVBstore [2] dst (MOVBload [2] src mem) (MOVWstore dst (MOVWload src mem) mem)) + { + if v.AuxInt != 3 { + goto end76ce0004999139fe4608c3c5356eb364 + } + dst := v.Args[0] + src := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64MOVBstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 2 + v.AddArg(dst) + v0 := b.NewValue0(v.Line, OpAMD64MOVBload, TypeInvalid) + v0.AuxInt = 2 + v0.AddArg(src) + v0.AddArg(mem) + v0.Type = config.fe.TypeUInt8() + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64MOVWstore, TypeInvalid) + v1.AddArg(dst) + v2 := b.NewValue0(v.Line, OpAMD64MOVWload, TypeInvalid) + v2.AddArg(src) + v2.AddArg(mem) + v2.Type = config.fe.TypeUInt16() + v1.AddArg(v2) + v1.AddArg(mem) + v1.Type = TypeMem + v.AddArg(v1) + return true + } + goto end76ce0004999139fe4608c3c5356eb364 +end76ce0004999139fe4608c3c5356eb364: + ; + // match: (Move [5] dst src mem) + // cond: + // result: (MOVBstore [4] dst (MOVBload [4] src mem) (MOVLstore dst (MOVLload src mem) mem)) + { + if v.AuxInt != 5 { + goto end21378690c0f39bdd6b46566d57da34e3 + } + dst := v.Args[0] + src := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64MOVBstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 4 + v.AddArg(dst) + v0 := b.NewValue0(v.Line, OpAMD64MOVBload, TypeInvalid) + v0.AuxInt = 4 + v0.AddArg(src) + v0.AddArg(mem) + v0.Type = config.fe.TypeUInt8() + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64MOVLstore, TypeInvalid) + v1.AddArg(dst) + v2 := b.NewValue0(v.Line, OpAMD64MOVLload, TypeInvalid) + v2.AddArg(src) + v2.AddArg(mem) + v2.Type = config.fe.TypeUInt32() + v1.AddArg(v2) + v1.AddArg(mem) + v1.Type = TypeMem + v.AddArg(v1) + return true + } + goto end21378690c0f39bdd6b46566d57da34e3 +end21378690c0f39bdd6b46566d57da34e3: + ; + // match: (Move [6] dst src mem) + // cond: + // result: (MOVWstore [4] dst (MOVWload [4] src mem) (MOVLstore dst (MOVLload src mem) mem)) + { + if v.AuxInt != 6 { + goto endcb6e509881d8638d8cae3af4f2b19a8e + } + dst := v.Args[0] + src := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64MOVWstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 4 + v.AddArg(dst) + v0 := b.NewValue0(v.Line, OpAMD64MOVWload, TypeInvalid) + v0.AuxInt = 4 + v0.AddArg(src) + v0.AddArg(mem) + v0.Type = config.fe.TypeUInt16() + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64MOVLstore, TypeInvalid) + v1.AddArg(dst) + v2 := b.NewValue0(v.Line, OpAMD64MOVLload, TypeInvalid) + v2.AddArg(src) + v2.AddArg(mem) + v2.Type = config.fe.TypeUInt32() + v1.AddArg(v2) + v1.AddArg(mem) + v1.Type = TypeMem + v.AddArg(v1) + return true + } + goto endcb6e509881d8638d8cae3af4f2b19a8e +endcb6e509881d8638d8cae3af4f2b19a8e: + ; + // match: (Move [7] dst src mem) + // cond: + // result: (MOVLstore [3] dst (MOVLload [3] src mem) (MOVLstore dst (MOVLload src mem) mem)) + { + if v.AuxInt != 7 { + goto end3429ae54bc071c0856ad366c79b7ab97 + } + dst := v.Args[0] + src := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64MOVLstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 3 + v.AddArg(dst) + v0 := b.NewValue0(v.Line, OpAMD64MOVLload, TypeInvalid) + v0.AuxInt = 3 + v0.AddArg(src) + v0.AddArg(mem) + v0.Type = config.fe.TypeUInt32() + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64MOVLstore, TypeInvalid) + v1.AddArg(dst) + v2 := b.NewValue0(v.Line, OpAMD64MOVLload, TypeInvalid) + v2.AddArg(src) + v2.AddArg(mem) + v2.Type = config.fe.TypeUInt32() + v1.AddArg(v2) + v1.AddArg(mem) + v1.Type = TypeMem + v.AddArg(v1) + return true + } + goto end3429ae54bc071c0856ad366c79b7ab97 +end3429ae54bc071c0856ad366c79b7ab97: + ; + // 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)) + { + size := v.AuxInt + dst := v.Args[0] + src := v.Args[1] + mem := v.Args[2] + if !(size > 8 && size < 16) { + goto endc90f121709d5411d389649dea89a2251 + } + v.Op = OpAMD64MOVQstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = size - 8 + v.AddArg(dst) + v0 := b.NewValue0(v.Line, OpAMD64MOVQload, TypeInvalid) + v0.AuxInt = size - 8 + v0.AddArg(src) + v0.AddArg(mem) + v0.Type = config.fe.TypeUInt64() + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64MOVQstore, TypeInvalid) + v1.AddArg(dst) + v2 := b.NewValue0(v.Line, OpAMD64MOVQload, TypeInvalid) + v2.AddArg(src) + v2.AddArg(mem) + v2.Type = config.fe.TypeUInt64() + v1.AddArg(v2) + v1.AddArg(mem) + v1.Type = TypeMem + v.AddArg(v1) + return true + } + goto endc90f121709d5411d389649dea89a2251 +endc90f121709d5411d389649dea89a2251: + ; + // match: (Move [size] dst src mem) + // cond: size > 16 && size%16 != 0 && size%16 <= 8 + // result: (Move [size-size%16] (ADDQconst dst [size%16]) (ADDQconst src [size%16]) (MOVQstore dst (MOVQload src mem) mem)) + { + size := v.AuxInt + dst := v.Args[0] + src := v.Args[1] + mem := v.Args[2] + if !(size > 16 && size%16 != 0 && size%16 <= 8) { + goto end376c57db23b866866f23677c6cde43ba + } + v.Op = OpMove + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = size - size%16 + v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) + v0.Type = dst.Type + v0.AddArg(dst) + v0.AuxInt = size % 16 + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) + v1.Type = src.Type + v1.AddArg(src) + v1.AuxInt = size % 16 + v.AddArg(v1) + v2 := b.NewValue0(v.Line, OpAMD64MOVQstore, TypeInvalid) + v2.AddArg(dst) + v3 := b.NewValue0(v.Line, OpAMD64MOVQload, TypeInvalid) + v3.AddArg(src) + v3.AddArg(mem) + v3.Type = config.fe.TypeUInt64() + v2.AddArg(v3) + v2.AddArg(mem) + v2.Type = TypeMem + v.AddArg(v2) + return true + } + goto end376c57db23b866866f23677c6cde43ba +end376c57db23b866866f23677c6cde43ba: + ; + // match: (Move [size] dst src mem) + // cond: size > 16 && size%16 != 0 && size%16 > 8 + // result: (Move [size-size%16] (ADDQconst dst [size%16]) (ADDQconst src [size%16]) (MOVOstore dst (MOVOload src mem) mem)) + { + size := v.AuxInt + dst := v.Args[0] + src := v.Args[1] + mem := v.Args[2] + if !(size > 16 && size%16 != 0 && size%16 > 8) { + goto end2f82f76766a21f8802768380cf10a497 + } + v.Op = OpMove + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = size - size%16 + v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) + v0.Type = dst.Type + v0.AddArg(dst) + v0.AuxInt = size % 16 + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) + v1.Type = src.Type + v1.AddArg(src) + v1.AuxInt = size % 16 + v.AddArg(v1) + v2 := b.NewValue0(v.Line, OpAMD64MOVOstore, TypeInvalid) + v2.AddArg(dst) + v3 := b.NewValue0(v.Line, OpAMD64MOVOload, TypeInvalid) + v3.AddArg(src) + v3.AddArg(mem) + v3.Type = TypeInt128 + v2.AddArg(v3) + v2.AddArg(mem) + v2.Type = TypeMem + v.AddArg(v2) + return true + } + goto end2f82f76766a21f8802768380cf10a497 +end2f82f76766a21f8802768380cf10a497: + ; + // match: (Move [size] dst src mem) + // cond: size >= 32 && size <= 16*64 && size%16 == 0 + // result: (DUFFCOPY [14*(64-size/16)] dst src mem) + { + size := v.AuxInt + dst := v.Args[0] + src := v.Args[1] + mem := v.Args[2] + if !(size >= 32 && size <= 16*64 && size%16 == 0) { + goto endcb66da6685f0079ee1f84d10fa561f22 + } + v.Op = OpAMD64DUFFCOPY + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 14 * (64 - size/16) + v.AddArg(dst) + v.AddArg(src) + v.AddArg(mem) + return true + } + goto endcb66da6685f0079ee1f84d10fa561f22 +endcb66da6685f0079ee1f84d10fa561f22: + ; + // match: (Move [size] dst src mem) + // cond: size > 16*64 && size%8 == 0 + // result: (REPMOVSQ dst src (MOVQconst [size/8]) mem) + { + size := v.AuxInt + dst := v.Args[0] + src := v.Args[1] + mem := v.Args[2] + if !(size > 16*64 && size%8 == 0) { + goto end7ae25ff1bbdcf34efef09613745e9d6e + } + v.Op = OpAMD64REPMOVSQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(dst) + v.AddArg(src) + v0 := b.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) + v0.AuxInt = size / 8 + v0.Type = config.fe.TypeUInt64() + v.AddArg(v0) + v.AddArg(mem) + return true + } + goto end7ae25ff1bbdcf34efef09613745e9d6e +end7ae25ff1bbdcf34efef09613745e9d6e: + ; + return false +} +func rewriteValueAMD64_OpMul16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Mul16 x y) + // cond: + // result: (MULW x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64MULW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end1addf5ea2c885aa1729b8f944859d00c +end1addf5ea2c885aa1729b8f944859d00c: + ; + return false +} +func rewriteValueAMD64_OpMul32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Mul32 x y) + // cond: + // result: (MULL x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64MULL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto ende144381f85808e5144782804768e2859 +ende144381f85808e5144782804768e2859: + ; + return false +} +func rewriteValueAMD64_OpMul32F(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Mul32F x y) + // cond: + // result: (MULSS x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64MULSS + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end32105a3bfe0237b799b69d83b3f171ca +end32105a3bfe0237b799b69d83b3f171ca: + ; + return false +} +func rewriteValueAMD64_OpMul64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Mul64 x y) + // cond: + // result: (MULQ x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64MULQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end38da21e77ac329eb643b20e7d97d5853 +end38da21e77ac329eb643b20e7d97d5853: + ; + return false +} +func rewriteValueAMD64_OpMul64F(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Mul64F x y) + // cond: + // result: (MULSD x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64MULSD + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end0ff6e1919fb0a3e549eb82b43edf1f52 +end0ff6e1919fb0a3e549eb82b43edf1f52: + ; + return false +} +func rewriteValueAMD64_OpMul8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Mul8 x y) + // cond: + // result: (MULB x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64MULB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto endd876d6bc42a2285b801f42dadbd8757c +endd876d6bc42a2285b801f42dadbd8757c: + ; + return false +} +func rewriteValueAMD64_OpMulPtr(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (MulPtr x y) + // cond: + // result: (MULQ x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64MULQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto endbbedad106c011a93243e2062afdcc75f +endbbedad106c011a93243e2062afdcc75f: + ; + return false +} +func rewriteValueAMD64_OpAMD64NEGB(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (NEGB (MOVBconst [c])) + // cond: + // result: (MOVBconst [-c]) + { + if v.Args[0].Op != OpAMD64MOVBconst { + goto end36d0300ba9eab8c9da86246ff653ca96 + } + c := v.Args[0].AuxInt + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = -c + return true + } + goto end36d0300ba9eab8c9da86246ff653ca96 +end36d0300ba9eab8c9da86246ff653ca96: + ; + return false +} +func rewriteValueAMD64_OpAMD64NEGL(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (NEGL (MOVLconst [c])) + // cond: + // result: (MOVLconst [-c]) + { + if v.Args[0].Op != OpAMD64MOVLconst { + goto end7a245ec67e56bd51911e5ba2d0aa0a16 + } + c := v.Args[0].AuxInt + v.Op = OpAMD64MOVLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = -c + return true + } + goto end7a245ec67e56bd51911e5ba2d0aa0a16 +end7a245ec67e56bd51911e5ba2d0aa0a16: + ; + return false +} +func rewriteValueAMD64_OpAMD64NEGQ(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (NEGQ (MOVQconst [c])) + // cond: + // result: (MOVQconst [-c]) + { + if v.Args[0].Op != OpAMD64MOVQconst { + goto end04ddd98bc6724ecb85c80c2a4e2bca5a + } + c := v.Args[0].AuxInt + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = -c + return true + } + goto end04ddd98bc6724ecb85c80c2a4e2bca5a +end04ddd98bc6724ecb85c80c2a4e2bca5a: + ; + return false +} +func rewriteValueAMD64_OpAMD64NEGW(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (NEGW (MOVWconst [c])) + // cond: + // result: (MOVWconst [-c]) + { + if v.Args[0].Op != OpAMD64MOVWconst { + goto end1db6636f0a51848d8a34f6561ecfe7ae + } + c := v.Args[0].AuxInt + v.Op = OpAMD64MOVWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = -c + return true + } + goto end1db6636f0a51848d8a34f6561ecfe7ae +end1db6636f0a51848d8a34f6561ecfe7ae: + ; + return false +} +func rewriteValueAMD64_OpAMD64NOTB(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (NOTB (MOVBconst [c])) + // cond: + // result: (MOVBconst [^c]) + { + if v.Args[0].Op != OpAMD64MOVBconst { + goto end9e383a9ceb29a9e2bf890ec6a67212a8 + } + c := v.Args[0].AuxInt + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = ^c + return true + } + goto end9e383a9ceb29a9e2bf890ec6a67212a8 +end9e383a9ceb29a9e2bf890ec6a67212a8: + ; + return false +} +func rewriteValueAMD64_OpAMD64NOTL(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (NOTL (MOVLconst [c])) + // cond: + // result: (MOVLconst [^c]) + { + if v.Args[0].Op != OpAMD64MOVLconst { + goto endcc73972c088d5e652a1370a96e56502d + } + c := v.Args[0].AuxInt + v.Op = OpAMD64MOVLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = ^c + return true + } + goto endcc73972c088d5e652a1370a96e56502d +endcc73972c088d5e652a1370a96e56502d: + ; + return false +} +func rewriteValueAMD64_OpAMD64NOTQ(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (NOTQ (MOVQconst [c])) + // cond: + // result: (MOVQconst [^c]) + { + if v.Args[0].Op != OpAMD64MOVQconst { + goto endb39ddb6bf7339d46f74114baad4333b6 + } + c := v.Args[0].AuxInt + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = ^c + return true + } + goto endb39ddb6bf7339d46f74114baad4333b6 +endb39ddb6bf7339d46f74114baad4333b6: + ; + return false +} +func rewriteValueAMD64_OpAMD64NOTW(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (NOTW (MOVWconst [c])) + // cond: + // result: (MOVWconst [^c]) + { + if v.Args[0].Op != OpAMD64MOVWconst { + goto end35848095ebcf894c6957ad3be5f82c43 + } + c := v.Args[0].AuxInt + v.Op = OpAMD64MOVWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = ^c + return true + } + goto end35848095ebcf894c6957ad3be5f82c43 +end35848095ebcf894c6957ad3be5f82c43: + ; + return false +} +func rewriteValueAMD64_OpNeg16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Neg16 x) + // cond: + // result: (NEGW x) + { + x := v.Args[0] + v.Op = OpAMD64NEGW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end7a8c652f4ffeb49656119af69512edb2 +end7a8c652f4ffeb49656119af69512edb2: + ; + return false +} +func rewriteValueAMD64_OpNeg32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Neg32 x) + // cond: + // result: (NEGL x) + { + x := v.Args[0] + v.Op = OpAMD64NEGL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto endce1f7e17fc193f6c076e47d5e401e126 +endce1f7e17fc193f6c076e47d5e401e126: + ; + return false +} +func rewriteValueAMD64_OpNeg32F(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Neg32F x) + // cond: + // result: (PXOR x (MOVSSconst [f2i(math.Copysign(0, -1))])) + { + x := v.Args[0] + v.Op = OpAMD64PXOR + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpAMD64MOVSSconst, TypeInvalid) + v0.Type = config.Frontend().TypeFloat32() + v0.AuxInt = f2i(math.Copysign(0, -1)) + v.AddArg(v0) + return true + } + goto end685a5fc899e195b9091afbe2a7146051 +end685a5fc899e195b9091afbe2a7146051: + ; + return false +} +func rewriteValueAMD64_OpNeg64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Neg64 x) + // cond: + // result: (NEGQ x) + { + x := v.Args[0] + v.Op = OpAMD64NEGQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto enda06c5b1718f2b96aba10bf5a5c437c6c +enda06c5b1718f2b96aba10bf5a5c437c6c: + ; + return false +} +func rewriteValueAMD64_OpNeg64F(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Neg64F x) + // cond: + // result: (PXOR x (MOVSDconst [f2i(math.Copysign(0, -1))])) + { + x := v.Args[0] + v.Op = OpAMD64PXOR + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpAMD64MOVSDconst, TypeInvalid) + v0.Type = config.Frontend().TypeFloat64() + v0.AuxInt = f2i(math.Copysign(0, -1)) + v.AddArg(v0) + return true + } + goto ende85ae82b7a51e75000eb9158d584acb2 +ende85ae82b7a51e75000eb9158d584acb2: + ; + return false +} +func rewriteValueAMD64_OpNeg8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Neg8 x) + // cond: + // result: (NEGB x) + { + x := v.Args[0] + v.Op = OpAMD64NEGB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end1e5f495a2ac6cdea47b1ae5ba62aa95d +end1e5f495a2ac6cdea47b1ae5ba62aa95d: + ; + return false +} +func rewriteValueAMD64_OpNeq16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Neq16 x y) + // cond: + // result: (SETNE (CMPW x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETNE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto end6413ee42d523a005cce9e3372ff2c8e9 +end6413ee42d523a005cce9e3372ff2c8e9: + ; + return false +} +func rewriteValueAMD64_OpNeq32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Neq32 x y) + // cond: + // result: (SETNE (CMPL x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETNE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto endb1a3ad499a09d8262952e6cbc47a23a8 +endb1a3ad499a09d8262952e6cbc47a23a8: + ; + return false +} +func rewriteValueAMD64_OpNeq32F(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Neq32F x y) + // cond: + // result: (SETNEF (UCOMISS x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETNEF + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto end2a001b2774f58aaf8c1e9efce6ae59e7 +end2a001b2774f58aaf8c1e9efce6ae59e7: + ; + return false +} +func rewriteValueAMD64_OpNeq64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Neq64 x y) + // cond: + // result: (SETNE (CMPQ x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETNE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto end092b9159bce08d2ef7896f7d3da5a595 +end092b9159bce08d2ef7896f7d3da5a595: + ; + return false +} +func rewriteValueAMD64_OpNeq64F(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Neq64F x y) + // cond: + // result: (SETNEF (UCOMISD x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETNEF + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto endb9c010023c38bd2fee7800fbefc85d98 +endb9c010023c38bd2fee7800fbefc85d98: + ; + return false +} +func rewriteValueAMD64_OpNeq8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Neq8 x y) + // cond: + // result: (SETNE (CMPB x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETNE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto end89e59f45e068c89458cc4db1692bf3bb +end89e59f45e068c89458cc4db1692bf3bb: + ; + return false +} +func rewriteValueAMD64_OpNeqPtr(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (NeqPtr x y) + // cond: + // result: (SETNE (CMPQ x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETNE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto end3b8bb3b4952011d1d40f993d8717cf16 +end3b8bb3b4952011d1d40f993d8717cf16: + ; + return false +} +func rewriteValueAMD64_OpNilCheck(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (NilCheck ptr mem) + // cond: + // result: (LoweredNilCheck ptr mem) + { + ptr := v.Args[0] + mem := v.Args[1] + v.Op = OpAMD64LoweredNilCheck + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v.AddArg(mem) + return true + } + goto end75520e60179564948a625707b84e8a8d +end75520e60179564948a625707b84e8a8d: + ; + return false +} +func rewriteValueAMD64_OpNot(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Not x) + // cond: + // result: (XORBconst [1] x) + { + x := v.Args[0] + v.Op = OpAMD64XORBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 1 + v.AddArg(x) + return true + } + goto end73973101aad60079c62fa64624e21db1 +end73973101aad60079c62fa64624e21db1: + ; + return false +} +func rewriteValueAMD64_OpAMD64ORB(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (ORB x (MOVBconst [c])) + // cond: + // result: (ORBconst [c] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVBconst { + goto end7b63870decde2515cb77ec4f8f76817c + } + c := v.Args[1].AuxInt + v.Op = OpAMD64ORBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end7b63870decde2515cb77ec4f8f76817c +end7b63870decde2515cb77ec4f8f76817c: + ; + // match: (ORB (MOVBconst [c]) x) + // cond: + // result: (ORBconst [c] x) + { + if v.Args[0].Op != OpAMD64MOVBconst { + goto end70b43d531e2097a4f6293f66256a642e + } + c := v.Args[0].AuxInt + x := v.Args[1] + v.Op = OpAMD64ORBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end70b43d531e2097a4f6293f66256a642e +end70b43d531e2097a4f6293f66256a642e: + ; + // match: (ORB x x) + // cond: + // result: x + { + x := v.Args[0] + if v.Args[1] != x { + goto enddca5ce800a9eca157f243cb2fdb1408a + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto enddca5ce800a9eca157f243cb2fdb1408a +enddca5ce800a9eca157f243cb2fdb1408a: + ; + return false +} +func rewriteValueAMD64_OpAMD64ORBconst(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (ORBconst [c] x) + // cond: int8(c)==0 + // result: x + { + c := v.AuxInt + x := v.Args[0] + if !(int8(c) == 0) { + goto end565f78e3a843dc73943b59227b39a1b3 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end565f78e3a843dc73943b59227b39a1b3 +end565f78e3a843dc73943b59227b39a1b3: + ; + // match: (ORBconst [c] _) + // cond: int8(c)==-1 + // result: (MOVBconst [-1]) + { + c := v.AuxInt + if !(int8(c) == -1) { + goto end6033c7910d8cd536b31446e179e4610d + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = -1 + return true + } + goto end6033c7910d8cd536b31446e179e4610d +end6033c7910d8cd536b31446e179e4610d: + ; + // match: (ORBconst [c] (MOVBconst [d])) + // cond: + // result: (MOVBconst [c|d]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVBconst { + goto endbe5263f022dc10a5cf53c118937d79dd + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c | d + return true + } + goto endbe5263f022dc10a5cf53c118937d79dd +endbe5263f022dc10a5cf53c118937d79dd: + ; + return false +} +func rewriteValueAMD64_OpAMD64ORL(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (ORL x (MOVLconst [c])) + // cond: + // result: (ORLconst [c] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVLconst { + goto end1b883e30d860b6fac14ae98462c4f61a + } + c := v.Args[1].AuxInt + v.Op = OpAMD64ORLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end1b883e30d860b6fac14ae98462c4f61a +end1b883e30d860b6fac14ae98462c4f61a: + ; + // match: (ORL (MOVLconst [c]) x) + // cond: + // result: (ORLconst [c] x) + { + if v.Args[0].Op != OpAMD64MOVLconst { + goto enda5bc49524a0cbd2241f792837d0a48a8 + } + c := v.Args[0].AuxInt + x := v.Args[1] + v.Op = OpAMD64ORLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto enda5bc49524a0cbd2241f792837d0a48a8 +enda5bc49524a0cbd2241f792837d0a48a8: + ; + // match: (ORL x x) + // cond: + // result: x + { + x := v.Args[0] + if v.Args[1] != x { + goto end2dd719b68f4938777ef0d820aab93659 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end2dd719b68f4938777ef0d820aab93659 +end2dd719b68f4938777ef0d820aab93659: + ; + return false +} +func rewriteValueAMD64_OpAMD64ORLconst(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (ORLconst [c] x) + // cond: int32(c)==0 + // result: x + { + c := v.AuxInt + x := v.Args[0] + if !(int32(c) == 0) { + goto end5b52623a724e8a7167c71289fb7192f1 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end5b52623a724e8a7167c71289fb7192f1 +end5b52623a724e8a7167c71289fb7192f1: + ; + // match: (ORLconst [c] _) + // cond: int32(c)==-1 + // result: (MOVLconst [-1]) + { + c := v.AuxInt + if !(int32(c) == -1) { + goto end345a8ea439ef2ef54bd84fc8a0f73e97 + } + v.Op = OpAMD64MOVLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = -1 + return true + } + goto end345a8ea439ef2ef54bd84fc8a0f73e97 +end345a8ea439ef2ef54bd84fc8a0f73e97: + ; + // match: (ORLconst [c] (MOVLconst [d])) + // cond: + // result: (MOVLconst [c|d]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVLconst { + goto ende9ca05024248f782c88084715f81d727 + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c | d + return true + } + goto ende9ca05024248f782c88084715f81d727 +ende9ca05024248f782c88084715f81d727: + ; + 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) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVQconst { + goto end601f2bb3ccda102e484ff60adeaf6d26 + } + c := v.Args[1].AuxInt + if !(is32Bit(c)) { + goto end601f2bb3ccda102e484ff60adeaf6d26 + } + v.Op = OpAMD64ORQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end601f2bb3ccda102e484ff60adeaf6d26 +end601f2bb3ccda102e484ff60adeaf6d26: + ; + // match: (ORQ (MOVQconst [c]) x) + // cond: is32Bit(c) + // result: (ORQconst [c] x) + { + if v.Args[0].Op != OpAMD64MOVQconst { + goto end010afbebcd314e288509d79a16a6d5cc + } + c := v.Args[0].AuxInt + x := v.Args[1] + if !(is32Bit(c)) { + goto end010afbebcd314e288509d79a16a6d5cc + } + v.Op = OpAMD64ORQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end010afbebcd314e288509d79a16a6d5cc +end010afbebcd314e288509d79a16a6d5cc: + ; + // match: (ORQ x x) + // cond: + // result: x + { + x := v.Args[0] + if v.Args[1] != x { + goto end47a27d30b82db576978c5a3a57b520fb + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end47a27d30b82db576978c5a3a57b520fb +end47a27d30b82db576978c5a3a57b520fb: + ; + return false +} +func rewriteValueAMD64_OpAMD64ORQconst(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (ORQconst [0] x) + // cond: + // result: x + { + if v.AuxInt != 0 { + goto end44534da6b9ce98d33fad7e20f0be1fbd + } + x := v.Args[0] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end44534da6b9ce98d33fad7e20f0be1fbd +end44534da6b9ce98d33fad7e20f0be1fbd: + ; + // match: (ORQconst [-1] _) + // cond: + // result: (MOVQconst [-1]) + { + if v.AuxInt != -1 { + goto endcde9b9d7c4527eaa5d50b252f50b43c1 + } + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = -1 + return true + } + goto endcde9b9d7c4527eaa5d50b252f50b43c1 +endcde9b9d7c4527eaa5d50b252f50b43c1: + ; + // match: (ORQconst [c] (MOVQconst [d])) + // cond: + // result: (MOVQconst [c|d]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVQconst { + goto enda2488509b71db9abcb06a5115c4ddc2c + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c | d + return true + } + goto enda2488509b71db9abcb06a5115c4ddc2c +enda2488509b71db9abcb06a5115c4ddc2c: + ; + return false +} +func rewriteValueAMD64_OpAMD64ORW(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (ORW x (MOVWconst [c])) + // cond: + // result: (ORWconst [c] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVWconst { + goto end9f98df10892dbf170b49aace86ee0d7f + } + c := v.Args[1].AuxInt + v.Op = OpAMD64ORWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end9f98df10892dbf170b49aace86ee0d7f +end9f98df10892dbf170b49aace86ee0d7f: + ; + // match: (ORW (MOVWconst [c]) x) + // cond: + // result: (ORWconst [c] x) + { + if v.Args[0].Op != OpAMD64MOVWconst { + goto end96405942c9ceb5fcb0ddb85a8709d015 + } + c := v.Args[0].AuxInt + x := v.Args[1] + v.Op = OpAMD64ORWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end96405942c9ceb5fcb0ddb85a8709d015 +end96405942c9ceb5fcb0ddb85a8709d015: + ; + // match: (ORW x x) + // cond: + // result: x + { + x := v.Args[0] + if v.Args[1] != x { + goto endc6a23b64e541dc9cfc6a90fd7028e8c1 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto endc6a23b64e541dc9cfc6a90fd7028e8c1 +endc6a23b64e541dc9cfc6a90fd7028e8c1: + ; + return false +} +func rewriteValueAMD64_OpAMD64ORWconst(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (ORWconst [c] x) + // cond: int16(c)==0 + // result: x + { + c := v.AuxInt + x := v.Args[0] + if !(int16(c) == 0) { + goto endbbbdec9091c8b4c58e587eac8a43402d + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto endbbbdec9091c8b4c58e587eac8a43402d +endbbbdec9091c8b4c58e587eac8a43402d: + ; + // match: (ORWconst [c] _) + // cond: int16(c)==-1 + // result: (MOVWconst [-1]) + { + c := v.AuxInt + if !(int16(c) == -1) { + goto ended87a5775f5e04b2d2a117a63d82dd9b + } + v.Op = OpAMD64MOVWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = -1 + return true + } + goto ended87a5775f5e04b2d2a117a63d82dd9b +ended87a5775f5e04b2d2a117a63d82dd9b: + ; + // match: (ORWconst [c] (MOVWconst [d])) + // cond: + // result: (MOVWconst [c|d]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVWconst { + goto endba9221a8462b5c62e8d7c686f64c2778 + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c | d + return true + } + goto endba9221a8462b5c62e8d7c686f64c2778 +endba9221a8462b5c62e8d7c686f64c2778: + ; + return false +} +func rewriteValueAMD64_OpOffPtr(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (OffPtr [off] ptr) + // cond: + // result: (ADDQconst [off] ptr) + { + off := v.AuxInt + ptr := v.Args[0] + v.Op = OpAMD64ADDQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = off + v.AddArg(ptr) + return true + } + goto end0429f947ee7ac49ff45a243e461a5290 +end0429f947ee7ac49ff45a243e461a5290: + ; + return false +} +func rewriteValueAMD64_OpOr16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Or16 x y) + // cond: + // result: (ORW x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ORW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end8fedf2c79d5607b7056b0ff015199cbd +end8fedf2c79d5607b7056b0ff015199cbd: + ; + return false +} +func rewriteValueAMD64_OpOr32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Or32 x y) + // cond: + // result: (ORL x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ORL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto endea45bed9ca97d2995b68b53e6012d384 +endea45bed9ca97d2995b68b53e6012d384: + ; + return false +} +func rewriteValueAMD64_OpOr64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Or64 x y) + // cond: + // result: (ORQ x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ORQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end3a446becaf2461f4f1a41faeef313f41 +end3a446becaf2461f4f1a41faeef313f41: + ; + return false +} +func rewriteValueAMD64_OpOr8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Or8 x y) + // cond: + // result: (ORB x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ORB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end6f8a8c559a167d1f0a5901d09a1fb248 +end6f8a8c559a167d1f0a5901d09a1fb248: + ; + return false +} +func rewriteValueAMD64_OpRsh16Ux16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh16Ux16 x y) + // cond: + // result: (ANDW (SHRW x y) (SBBLcarrymask (CMPWconst [16] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64SHRW, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1.Type = t + v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v2.AuxInt = 16 + v2.AddArg(y) + v2.Type = TypeFlags + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto end4d5e000764dcea396f2d86472c2af6eb +end4d5e000764dcea396f2d86472c2af6eb: + ; + return false +} +func rewriteValueAMD64_OpRsh16Ux32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh16Ux32 x y) + // cond: + // result: (ANDW (SHRW x y) (SBBLcarrymask (CMPLconst [16] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64SHRW, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1.Type = t + v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v2.AuxInt = 16 + v2.AddArg(y) + v2.Type = TypeFlags + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto end9ef4fe2ea4565865cd4b3aa9c7596c00 +end9ef4fe2ea4565865cd4b3aa9c7596c00: + ; + return false +} +func rewriteValueAMD64_OpRsh16Ux64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh16Ux64 x y) + // cond: + // result: (ANDW (SHRW x y) (SBBLcarrymask (CMPQconst [16] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64SHRW, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1.Type = t + v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v2.AuxInt = 16 + v2.AddArg(y) + v2.Type = TypeFlags + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto end48bc94b9a68aad454eaabc42b2e1d646 +end48bc94b9a68aad454eaabc42b2e1d646: + ; + return false +} +func rewriteValueAMD64_OpRsh16Ux8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh16Ux8 x y) + // cond: + // result: (ANDW (SHRW x y) (SBBLcarrymask (CMPBconst [16] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64SHRW, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1.Type = t + v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + v2.AuxInt = 16 + v2.AddArg(y) + v2.Type = TypeFlags + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto ende98f618fa53b1f1d5d3f79781d5cb2cc +ende98f618fa53b1f1d5d3f79781d5cb2cc: + ; + return false +} +func rewriteValueAMD64_OpRsh16x16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh16x16 x y) + // cond: + // result: (SARW x (ORW y (NOTL (SBBLcarrymask (CMPWconst [16] y))))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SARW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = t + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpAMD64ORW, TypeInvalid) + v0.Type = y.Type + v0.AddArg(y) + v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) + v1.Type = y.Type + v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v2.Type = y.Type + v3 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v3.AuxInt = 16 + v3.AddArg(y) + v3.Type = TypeFlags + v2.AddArg(v3) + v1.AddArg(v2) + v0.AddArg(v1) + v.AddArg(v0) + return true + } + goto end1de548dcf8d7c7222c7a739809597526 +end1de548dcf8d7c7222c7a739809597526: + ; + return false +} +func rewriteValueAMD64_OpRsh16x32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh16x32 x y) + // cond: + // result: (SARW x (ORL y (NOTL (SBBLcarrymask (CMPLconst [16] y))))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SARW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = t + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpAMD64ORL, TypeInvalid) + v0.Type = y.Type + v0.AddArg(y) + v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) + v1.Type = y.Type + v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v2.Type = y.Type + v3 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v3.AuxInt = 16 + v3.AddArg(y) + v3.Type = TypeFlags + v2.AddArg(v3) + v1.AddArg(v2) + v0.AddArg(v1) + v.AddArg(v0) + return true + } + goto end74419e1036ea7e0c3a09d05b1eabad22 +end74419e1036ea7e0c3a09d05b1eabad22: + ; + return false +} +func rewriteValueAMD64_OpRsh16x64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh16x64 x y) + // cond: + // result: (SARW x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst [16] y))))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SARW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = t + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpAMD64ORQ, TypeInvalid) + v0.Type = y.Type + v0.AddArg(y) + v1 := b.NewValue0(v.Line, OpAMD64NOTQ, TypeInvalid) + v1.Type = y.Type + v2 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v2.Type = y.Type + v3 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v3.AuxInt = 16 + v3.AddArg(y) + v3.Type = TypeFlags + v2.AddArg(v3) + v1.AddArg(v2) + v0.AddArg(v1) + v.AddArg(v0) + return true + } + goto ende35d1c2918196fae04fca22e80936bab +ende35d1c2918196fae04fca22e80936bab: + ; + return false +} +func rewriteValueAMD64_OpRsh16x8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh16x8 x y) + // cond: + // result: (SARW x (ORB y (NOTL (SBBLcarrymask (CMPBconst [16] y))))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SARW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = t + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpAMD64ORB, TypeInvalid) + v0.Type = y.Type + v0.AddArg(y) + v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) + v1.Type = y.Type + v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v2.Type = y.Type + v3 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + v3.AuxInt = 16 + v3.AddArg(y) + v3.Type = TypeFlags + v2.AddArg(v3) + v1.AddArg(v2) + v0.AddArg(v1) + v.AddArg(v0) + return true + } + goto endaa6a45afc4c6552c1a90a13160578fba +endaa6a45afc4c6552c1a90a13160578fba: + ; + return false +} +func rewriteValueAMD64_OpRsh32Ux16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh32Ux16 x y) + // cond: + // result: (ANDL (SHRL x y) (SBBLcarrymask (CMPWconst [32] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64SHRL, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1.Type = t + v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v2.AuxInt = 32 + v2.AddArg(y) + v2.Type = TypeFlags + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto end74495683df77023ed619b4ecee98d94a +end74495683df77023ed619b4ecee98d94a: + ; + return false +} +func rewriteValueAMD64_OpRsh32Ux32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh32Ux32 x y) + // cond: + // result: (ANDL (SHRL x y) (SBBLcarrymask (CMPLconst [32] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64SHRL, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1.Type = t + v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v2.AuxInt = 32 + v2.AddArg(y) + v2.Type = TypeFlags + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto enda7d6c92ab2d7467102db447d6b431b28 +enda7d6c92ab2d7467102db447d6b431b28: + ; + return false +} +func rewriteValueAMD64_OpRsh32Ux64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh32Ux64 x y) + // cond: + // result: (ANDL (SHRL x y) (SBBLcarrymask (CMPQconst [32] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64SHRL, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1.Type = t + v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v2.AuxInt = 32 + v2.AddArg(y) + v2.Type = TypeFlags + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto end7c0829166a6219a15de2c0aa688a9bb3 +end7c0829166a6219a15de2c0aa688a9bb3: + ; + return false +} +func rewriteValueAMD64_OpRsh32Ux8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh32Ux8 x y) + // cond: + // result: (ANDL (SHRL x y) (SBBLcarrymask (CMPBconst [32] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64SHRL, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1.Type = t + v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + v2.AuxInt = 32 + v2.AddArg(y) + v2.Type = TypeFlags + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto end221315aa8a09c9d8d2f243bf445446ea +end221315aa8a09c9d8d2f243bf445446ea: + ; + return false +} +func rewriteValueAMD64_OpRsh32x16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh32x16 x y) + // cond: + // result: (SARL x (ORW y (NOTL (SBBLcarrymask (CMPWconst [32] y))))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SARL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = t + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpAMD64ORW, TypeInvalid) + v0.Type = y.Type + v0.AddArg(y) + v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) + v1.Type = y.Type + v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v2.Type = y.Type + v3 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v3.AuxInt = 32 + v3.AddArg(y) + v3.Type = TypeFlags + v2.AddArg(v3) + v1.AddArg(v2) + v0.AddArg(v1) + v.AddArg(v0) + return true + } + goto end521b60d91648f07fe1be359f1cdbde29 +end521b60d91648f07fe1be359f1cdbde29: + ; + return false +} +func rewriteValueAMD64_OpRsh32x32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh32x32 x y) + // cond: + // result: (SARL x (ORL y (NOTL (SBBLcarrymask (CMPLconst [32] y))))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SARL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = t + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpAMD64ORL, TypeInvalid) + v0.Type = y.Type + v0.AddArg(y) + v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) + v1.Type = y.Type + v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v2.Type = y.Type + v3 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v3.AuxInt = 32 + v3.AddArg(y) + v3.Type = TypeFlags + v2.AddArg(v3) + v1.AddArg(v2) + v0.AddArg(v1) + v.AddArg(v0) + return true + } + goto end0fc03188975afbca2139e28c38b7cd17 +end0fc03188975afbca2139e28c38b7cd17: + ; + return false +} +func rewriteValueAMD64_OpRsh32x64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh32x64 x y) + // cond: + // result: (SARL x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst [32] y))))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SARL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = t + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpAMD64ORQ, TypeInvalid) + v0.Type = y.Type + v0.AddArg(y) + v1 := b.NewValue0(v.Line, OpAMD64NOTQ, TypeInvalid) + v1.Type = y.Type + v2 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v2.Type = y.Type + v3 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v3.AuxInt = 32 + v3.AddArg(y) + v3.Type = TypeFlags + v2.AddArg(v3) + v1.AddArg(v2) + v0.AddArg(v1) + v.AddArg(v0) + return true + } + goto endf36790cc7ba330d448b403a450a7c1d4 +endf36790cc7ba330d448b403a450a7c1d4: + ; + return false +} +func rewriteValueAMD64_OpRsh32x8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh32x8 x y) + // cond: + // result: (SARL x (ORB y (NOTL (SBBLcarrymask (CMPBconst [32] y))))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SARL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = t + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpAMD64ORB, TypeInvalid) + v0.Type = y.Type + v0.AddArg(y) + v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) + v1.Type = y.Type + v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v2.Type = y.Type + v3 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + v3.AuxInt = 32 + v3.AddArg(y) + v3.Type = TypeFlags + v2.AddArg(v3) + v1.AddArg(v2) + v0.AddArg(v1) + v.AddArg(v0) + return true + } + goto end1242709228488be2f2505ead8eabb871 +end1242709228488be2f2505ead8eabb871: + ; + return false +} +func rewriteValueAMD64_OpRsh64Ux16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh64Ux16 x y) + // cond: + // result: (ANDQ (SHRQ x y) (SBBQcarrymask (CMPWconst [64] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64SHRQ, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1.Type = t + v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v2.AuxInt = 64 + v2.AddArg(y) + v2.Type = TypeFlags + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto end0bc6c36a57ebaf0b90fc418f976fe210 +end0bc6c36a57ebaf0b90fc418f976fe210: + ; + return false +} +func rewriteValueAMD64_OpRsh64Ux32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh64Ux32 x y) + // cond: + // result: (ANDQ (SHRQ x y) (SBBQcarrymask (CMPLconst [64] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64SHRQ, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1.Type = t + v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v2.AuxInt = 64 + v2.AddArg(y) + v2.Type = TypeFlags + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto ende3f52062f53bc3b5aa0461a644e38a1b +ende3f52062f53bc3b5aa0461a644e38a1b: + ; + return false +} +func rewriteValueAMD64_OpRsh64Ux64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh64Ux64 x y) + // cond: + // result: (ANDQ (SHRQ x y) (SBBQcarrymask (CMPQconst [64] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64SHRQ, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1.Type = t + v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v2.AuxInt = 64 + v2.AddArg(y) + v2.Type = TypeFlags + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto endaec410d0544f817303c79bad739c50fd +endaec410d0544f817303c79bad739c50fd: + ; + return false +} +func rewriteValueAMD64_OpRsh64Ux8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh64Ux8 x y) + // cond: + // result: (ANDQ (SHRQ x y) (SBBQcarrymask (CMPBconst [64] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64SHRQ, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v1.Type = t + v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + v2.AuxInt = 64 + v2.AddArg(y) + v2.Type = TypeFlags + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto end0318851ecb02e4ad8a2669034adf7862 +end0318851ecb02e4ad8a2669034adf7862: + ; + return false +} +func rewriteValueAMD64_OpRsh64x16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh64x16 x y) + // cond: + // result: (SARQ x (ORW y (NOTL (SBBLcarrymask (CMPWconst [64] y))))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SARQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = t + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpAMD64ORW, TypeInvalid) + v0.Type = y.Type + v0.AddArg(y) + v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) + v1.Type = y.Type + v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v2.Type = y.Type + v3 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v3.AuxInt = 64 + v3.AddArg(y) + v3.Type = TypeFlags + v2.AddArg(v3) + v1.AddArg(v2) + v0.AddArg(v1) + v.AddArg(v0) + return true + } + goto endcf8bbca9a7a848fbebaaaa8b699cd086 +endcf8bbca9a7a848fbebaaaa8b699cd086: + ; + return false +} +func rewriteValueAMD64_OpRsh64x32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh64x32 x y) + // cond: + // result: (SARQ x (ORL y (NOTL (SBBLcarrymask (CMPLconst [64] y))))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SARQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = t + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpAMD64ORL, TypeInvalid) + v0.Type = y.Type + v0.AddArg(y) + v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) + v1.Type = y.Type + v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v2.Type = y.Type + v3 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v3.AuxInt = 64 + v3.AddArg(y) + v3.Type = TypeFlags + v2.AddArg(v3) + v1.AddArg(v2) + v0.AddArg(v1) + v.AddArg(v0) + return true + } + goto end7604d45b06ee69bf2feddf88b2f33cb6 +end7604d45b06ee69bf2feddf88b2f33cb6: + ; + return false +} +func rewriteValueAMD64_OpRsh64x64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh64x64 x y) + // cond: + // result: (SARQ x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst [64] y))))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SARQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = t + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpAMD64ORQ, TypeInvalid) + v0.Type = y.Type + v0.AddArg(y) + v1 := b.NewValue0(v.Line, OpAMD64NOTQ, TypeInvalid) + v1.Type = y.Type + v2 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v2.Type = y.Type + v3 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v3.AuxInt = 64 + v3.AddArg(y) + v3.Type = TypeFlags + v2.AddArg(v3) + v1.AddArg(v2) + v0.AddArg(v1) + v.AddArg(v0) + return true + } + goto end12a3b44af604b515ad5530502336486f +end12a3b44af604b515ad5530502336486f: + ; + return false +} +func rewriteValueAMD64_OpRsh64x8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh64x8 x y) + // cond: + // result: (SARQ x (ORB y (NOTL (SBBLcarrymask (CMPBconst [64] y))))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SARQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = t + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpAMD64ORB, TypeInvalid) + v0.Type = y.Type + v0.AddArg(y) + v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) + v1.Type = y.Type + v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v2.Type = y.Type + v3 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + v3.AuxInt = 64 + v3.AddArg(y) + v3.Type = TypeFlags + v2.AddArg(v3) + v1.AddArg(v2) + v0.AddArg(v1) + v.AddArg(v0) + return true + } + goto end4e2a83809914aad301a2f74d3c38fbbb +end4e2a83809914aad301a2f74d3c38fbbb: + ; + return false +} +func rewriteValueAMD64_OpRsh8Ux16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh8Ux16 x y) + // cond: + // result: (ANDB (SHRB x y) (SBBLcarrymask (CMPWconst [8] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64SHRB, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1.Type = t + v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v2.AuxInt = 8 + v2.AddArg(y) + v2.Type = TypeFlags + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto end724175a51b6efac60c6bb9d83d81215a +end724175a51b6efac60c6bb9d83d81215a: + ; + return false +} +func rewriteValueAMD64_OpRsh8Ux32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh8Ux32 x y) + // cond: + // result: (ANDB (SHRB x y) (SBBLcarrymask (CMPLconst [8] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64SHRB, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1.Type = t + v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v2.AuxInt = 8 + v2.AddArg(y) + v2.Type = TypeFlags + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto end9d973431bed6682c1d557a535cf440ed +end9d973431bed6682c1d557a535cf440ed: + ; + return false +} +func rewriteValueAMD64_OpRsh8Ux64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh8Ux64 x y) + // cond: + // result: (ANDB (SHRB x y) (SBBLcarrymask (CMPQconst [8] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64SHRB, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1.Type = t + v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v2.AuxInt = 8 + v2.AddArg(y) + v2.Type = TypeFlags + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto end9586937cdeb7946c337d46cd30cb9a11 +end9586937cdeb7946c337d46cd30cb9a11: + ; + return false +} +func rewriteValueAMD64_OpRsh8Ux8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh8Ux8 x y) + // cond: + // result: (ANDB (SHRB x y) (SBBLcarrymask (CMPBconst [8] y))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64ANDB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64SHRB, TypeInvalid) + v0.Type = t + v0.AddArg(x) + v0.AddArg(y) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v1.Type = t + v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + v2.AuxInt = 8 + v2.AddArg(y) + v2.Type = TypeFlags + v1.AddArg(v2) + v.AddArg(v1) + return true + } + goto endc5a55ef63d86e6b8d4d366a947bf563d +endc5a55ef63d86e6b8d4d366a947bf563d: + ; + return false +} +func rewriteValueAMD64_OpRsh8x16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh8x16 x y) + // cond: + // result: (SARB x (ORW y (NOTL (SBBLcarrymask (CMPWconst [8] y))))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SARB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = t + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpAMD64ORW, TypeInvalid) + v0.Type = y.Type + v0.AddArg(y) + v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) + v1.Type = y.Type + v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v2.Type = y.Type + v3 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v3.AuxInt = 8 + v3.AddArg(y) + v3.Type = TypeFlags + v2.AddArg(v3) + v1.AddArg(v2) + v0.AddArg(v1) + v.AddArg(v0) + return true + } + goto endfa967d6583c1bb9644514c2013b919f8 +endfa967d6583c1bb9644514c2013b919f8: + ; + return false +} +func rewriteValueAMD64_OpRsh8x32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh8x32 x y) + // cond: + // result: (SARB x (ORL y (NOTL (SBBLcarrymask (CMPLconst [8] y))))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SARB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = t + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpAMD64ORL, TypeInvalid) + v0.Type = y.Type + v0.AddArg(y) + v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) + v1.Type = y.Type + v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v2.Type = y.Type + v3 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v3.AuxInt = 8 + v3.AddArg(y) + v3.Type = TypeFlags + v2.AddArg(v3) + v1.AddArg(v2) + v0.AddArg(v1) + v.AddArg(v0) + return true + } + goto ende5a630810624a1bd3677618c2cbc8619 +ende5a630810624a1bd3677618c2cbc8619: + ; + return false +} +func rewriteValueAMD64_OpRsh8x64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh8x64 x y) + // cond: + // result: (SARB x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst [8] y))))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SARB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = t + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpAMD64ORQ, TypeInvalid) + v0.Type = y.Type + v0.AddArg(y) + v1 := b.NewValue0(v.Line, OpAMD64NOTQ, TypeInvalid) + v1.Type = y.Type + v2 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) + v2.Type = y.Type + v3 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v3.AuxInt = 8 + v3.AddArg(y) + v3.Type = TypeFlags + v2.AddArg(v3) + v1.AddArg(v2) + v0.AddArg(v1) + v.AddArg(v0) + return true + } + goto end23c55e49d8bc44afc680b2a4eade5af6 +end23c55e49d8bc44afc680b2a4eade5af6: + ; + return false +} +func rewriteValueAMD64_OpRsh8x8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh8x8 x y) + // cond: + // result: (SARB x (ORB y (NOTL (SBBLcarrymask (CMPBconst [8] y))))) + { + t := v.Type + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SARB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = t + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpAMD64ORB, TypeInvalid) + v0.Type = y.Type + v0.AddArg(y) + v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) + v1.Type = y.Type + v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) + v2.Type = y.Type + v3 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + v3.AuxInt = 8 + v3.AddArg(y) + v3.Type = TypeFlags + v2.AddArg(v3) + v1.AddArg(v2) + v0.AddArg(v1) + v.AddArg(v0) + return true + } + goto enddab0c33c56e2e9434b880e1718621979 +enddab0c33c56e2e9434b880e1718621979: + ; + return false +} +func rewriteValueAMD64_OpAMD64SARB(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (SARB x (MOVBconst [c])) + // cond: + // result: (SARBconst [c&31] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVBconst { + goto end3bf3d17717aa6c04462e56d1c87902ce + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SARBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 31 + v.AddArg(x) + return true + } + goto end3bf3d17717aa6c04462e56d1c87902ce +end3bf3d17717aa6c04462e56d1c87902ce: + ; + 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)]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVQconst { + goto end06e0e38775f0650ed672427d19cd8fff + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = d >> uint64(c) + return true + } + goto end06e0e38775f0650ed672427d19cd8fff +end06e0e38775f0650ed672427d19cd8fff: + ; + return false +} +func rewriteValueAMD64_OpAMD64SARL(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (SARL x (MOVLconst [c])) + // cond: + // result: (SARLconst [c&31] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVLconst { + goto ende586a72c1b232ee0b63e37c71eeb8470 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SARLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 31 + v.AddArg(x) + return true + } + goto ende586a72c1b232ee0b63e37c71eeb8470 +ende586a72c1b232ee0b63e37c71eeb8470: + ; + 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)]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVQconst { + goto end8f34dc94323303e75b7bcc8e731cf1db + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = d >> uint64(c) + return true + } + goto end8f34dc94323303e75b7bcc8e731cf1db +end8f34dc94323303e75b7bcc8e731cf1db: + ; + 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) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVQconst { + goto end25e720ab203be2745dded5550e6d8a7c + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SARQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 63 + v.AddArg(x) + return true + } + goto end25e720ab203be2745dded5550e6d8a7c +end25e720ab203be2745dded5550e6d8a7c: + ; + 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)]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVQconst { + goto endd949ba69a1ff71ba62c49b39c68f269e + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = d >> uint64(c) + return true + } + goto endd949ba69a1ff71ba62c49b39c68f269e +endd949ba69a1ff71ba62c49b39c68f269e: + ; + return false +} +func rewriteValueAMD64_OpAMD64SARW(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (SARW x (MOVWconst [c])) + // cond: + // result: (SARWconst [c&31] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVWconst { + goto endc46e3f211f94238f9a0aec3c498af490 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SARWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 31 + v.AddArg(x) + return true + } + goto endc46e3f211f94238f9a0aec3c498af490 +endc46e3f211f94238f9a0aec3c498af490: + ; + 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)]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVQconst { + goto endca23e80dba22ab574f843c7a4cef24ab + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = d >> uint64(c) + return true + } + goto endca23e80dba22ab574f843c7a4cef24ab +endca23e80dba22ab574f843c7a4cef24ab: + ; + return false +} +func rewriteValueAMD64_OpAMD64SBBLcarrymask(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (SBBLcarrymask (CMPQconst [c] (MOVQconst [d]))) + // cond: inBounds64(d, c) + // result: (MOVLconst [-1]) + { + if v.Args[0].Op != OpAMD64CMPQconst { + goto end490c8a7039bab41e90e564fbb8500233 + } + c := v.Args[0].AuxInt + if v.Args[0].Args[0].Op != OpAMD64MOVQconst { + goto end490c8a7039bab41e90e564fbb8500233 + } + d := v.Args[0].Args[0].AuxInt + if !(inBounds64(d, c)) { + goto end490c8a7039bab41e90e564fbb8500233 + } + v.Op = OpAMD64MOVLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = -1 + return true + } + goto end490c8a7039bab41e90e564fbb8500233 +end490c8a7039bab41e90e564fbb8500233: + ; + // match: (SBBLcarrymask (CMPQconst [c] (MOVQconst [d]))) + // cond: !inBounds64(d, c) + // result: (MOVLconst [0]) + { + if v.Args[0].Op != OpAMD64CMPQconst { + goto end95e703eabe71d831b7a3d2f9fabe7de9 + } + c := v.Args[0].AuxInt + if v.Args[0].Args[0].Op != OpAMD64MOVQconst { + goto end95e703eabe71d831b7a3d2f9fabe7de9 + } + d := v.Args[0].Args[0].AuxInt + if !(!inBounds64(d, c)) { + goto end95e703eabe71d831b7a3d2f9fabe7de9 + } + v.Op = OpAMD64MOVLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end95e703eabe71d831b7a3d2f9fabe7de9 +end95e703eabe71d831b7a3d2f9fabe7de9: + ; + // match: (SBBLcarrymask (CMPLconst [c] (MOVLconst [d]))) + // cond: inBounds32(d, c) + // result: (MOVLconst [-1]) + { + if v.Args[0].Op != OpAMD64CMPLconst { + goto end00c0a561340b0172c9a21f63648b86e2 + } + c := v.Args[0].AuxInt + if v.Args[0].Args[0].Op != OpAMD64MOVLconst { + goto end00c0a561340b0172c9a21f63648b86e2 + } + d := v.Args[0].Args[0].AuxInt + if !(inBounds32(d, c)) { + goto end00c0a561340b0172c9a21f63648b86e2 + } + v.Op = OpAMD64MOVLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = -1 + return true + } + goto end00c0a561340b0172c9a21f63648b86e2 +end00c0a561340b0172c9a21f63648b86e2: + ; + // match: (SBBLcarrymask (CMPLconst [c] (MOVLconst [d]))) + // cond: !inBounds32(d, c) + // result: (MOVLconst [0]) + { + if v.Args[0].Op != OpAMD64CMPLconst { + goto enda73c8bf14f7b45dd97c6a006e317b0b8 + } + c := v.Args[0].AuxInt + if v.Args[0].Args[0].Op != OpAMD64MOVLconst { + goto enda73c8bf14f7b45dd97c6a006e317b0b8 + } + d := v.Args[0].Args[0].AuxInt + if !(!inBounds32(d, c)) { + goto enda73c8bf14f7b45dd97c6a006e317b0b8 + } + v.Op = OpAMD64MOVLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto enda73c8bf14f7b45dd97c6a006e317b0b8 +enda73c8bf14f7b45dd97c6a006e317b0b8: + ; + // match: (SBBLcarrymask (CMPWconst [c] (MOVWconst [d]))) + // cond: inBounds16(d, c) + // result: (MOVLconst [-1]) + { + if v.Args[0].Op != OpAMD64CMPWconst { + goto endb94dc44cd77f66ed3bf3742874b666fc + } + c := v.Args[0].AuxInt + if v.Args[0].Args[0].Op != OpAMD64MOVWconst { + goto endb94dc44cd77f66ed3bf3742874b666fc + } + d := v.Args[0].Args[0].AuxInt + if !(inBounds16(d, c)) { + goto endb94dc44cd77f66ed3bf3742874b666fc + } + v.Op = OpAMD64MOVLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = -1 + return true + } + goto endb94dc44cd77f66ed3bf3742874b666fc +endb94dc44cd77f66ed3bf3742874b666fc: + ; + // match: (SBBLcarrymask (CMPWconst [c] (MOVWconst [d]))) + // cond: !inBounds16(d, c) + // result: (MOVLconst [0]) + { + if v.Args[0].Op != OpAMD64CMPWconst { + goto end7a02def6194822f7ab937d78088504d2 + } + c := v.Args[0].AuxInt + if v.Args[0].Args[0].Op != OpAMD64MOVWconst { + goto end7a02def6194822f7ab937d78088504d2 + } + d := v.Args[0].Args[0].AuxInt + if !(!inBounds16(d, c)) { + goto end7a02def6194822f7ab937d78088504d2 + } + v.Op = OpAMD64MOVLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end7a02def6194822f7ab937d78088504d2 +end7a02def6194822f7ab937d78088504d2: + ; + // match: (SBBLcarrymask (CMPBconst [c] (MOVBconst [d]))) + // cond: inBounds8(d, c) + // result: (MOVLconst [-1]) + { + if v.Args[0].Op != OpAMD64CMPBconst { + goto end79c8e4a20761df731521e6cd956c4245 + } + c := v.Args[0].AuxInt + if v.Args[0].Args[0].Op != OpAMD64MOVBconst { + goto end79c8e4a20761df731521e6cd956c4245 + } + d := v.Args[0].Args[0].AuxInt + if !(inBounds8(d, c)) { + goto end79c8e4a20761df731521e6cd956c4245 + } + v.Op = OpAMD64MOVLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = -1 + return true + } + goto end79c8e4a20761df731521e6cd956c4245 +end79c8e4a20761df731521e6cd956c4245: + ; + // match: (SBBLcarrymask (CMPBconst [c] (MOVBconst [d]))) + // cond: !inBounds8(d, c) + // result: (MOVLconst [0]) + { + if v.Args[0].Op != OpAMD64CMPBconst { + goto end95b5b21dd7756ae41575759a1eff2bea + } + c := v.Args[0].AuxInt + if v.Args[0].Args[0].Op != OpAMD64MOVBconst { + goto end95b5b21dd7756ae41575759a1eff2bea + } + d := v.Args[0].Args[0].AuxInt + if !(!inBounds8(d, c)) { + goto end95b5b21dd7756ae41575759a1eff2bea + } + v.Op = OpAMD64MOVLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end95b5b21dd7756ae41575759a1eff2bea +end95b5b21dd7756ae41575759a1eff2bea: + ; + return false +} +func rewriteValueAMD64_OpAMD64SBBQcarrymask(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (SBBQcarrymask (CMPQconst [c] (MOVQconst [d]))) + // cond: inBounds64(d, c) + // result: (MOVQconst [-1]) + { + if v.Args[0].Op != OpAMD64CMPQconst { + goto end0c26df98feb38f149eca12f33c15de1b + } + c := v.Args[0].AuxInt + if v.Args[0].Args[0].Op != OpAMD64MOVQconst { + goto end0c26df98feb38f149eca12f33c15de1b + } + d := v.Args[0].Args[0].AuxInt + if !(inBounds64(d, c)) { + goto end0c26df98feb38f149eca12f33c15de1b + } + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = -1 + return true + } + goto end0c26df98feb38f149eca12f33c15de1b +end0c26df98feb38f149eca12f33c15de1b: + ; + // match: (SBBQcarrymask (CMPQconst [c] (MOVQconst [d]))) + // cond: !inBounds64(d, c) + // result: (MOVQconst [0]) + { + if v.Args[0].Op != OpAMD64CMPQconst { + goto end8965aa1e1153e5ecd123bbb31a618570 + } + c := v.Args[0].AuxInt + if v.Args[0].Args[0].Op != OpAMD64MOVQconst { + goto end8965aa1e1153e5ecd123bbb31a618570 + } + d := v.Args[0].Args[0].AuxInt + if !(!inBounds64(d, c)) { + goto end8965aa1e1153e5ecd123bbb31a618570 + } + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end8965aa1e1153e5ecd123bbb31a618570 +end8965aa1e1153e5ecd123bbb31a618570: + ; + // match: (SBBQcarrymask (CMPLconst [c] (MOVLconst [d]))) + // cond: inBounds32(d, c) + // result: (MOVQconst [-1]) + { + if v.Args[0].Op != OpAMD64CMPLconst { + goto end8772ede6098981a61af0f478841d7d54 + } + c := v.Args[0].AuxInt + if v.Args[0].Args[0].Op != OpAMD64MOVLconst { + goto end8772ede6098981a61af0f478841d7d54 + } + d := v.Args[0].Args[0].AuxInt + if !(inBounds32(d, c)) { + goto end8772ede6098981a61af0f478841d7d54 + } + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = -1 + return true + } + goto end8772ede6098981a61af0f478841d7d54 +end8772ede6098981a61af0f478841d7d54: + ; + // match: (SBBQcarrymask (CMPLconst [c] (MOVLconst [d]))) + // cond: !inBounds32(d, c) + // result: (MOVQconst [0]) + { + if v.Args[0].Op != OpAMD64CMPLconst { + goto end2d535e90075ee777fc616e6b9847a384 + } + c := v.Args[0].AuxInt + if v.Args[0].Args[0].Op != OpAMD64MOVLconst { + goto end2d535e90075ee777fc616e6b9847a384 + } + d := v.Args[0].Args[0].AuxInt + if !(!inBounds32(d, c)) { + goto end2d535e90075ee777fc616e6b9847a384 + } + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end2d535e90075ee777fc616e6b9847a384 +end2d535e90075ee777fc616e6b9847a384: + ; + // match: (SBBQcarrymask (CMPWconst [c] (MOVWconst [d]))) + // cond: inBounds16(d, c) + // result: (MOVQconst [-1]) + { + if v.Args[0].Op != OpAMD64CMPWconst { + goto end3103c51e14b4fc894b4170f16f37eebc + } + c := v.Args[0].AuxInt + if v.Args[0].Args[0].Op != OpAMD64MOVWconst { + goto end3103c51e14b4fc894b4170f16f37eebc + } + d := v.Args[0].Args[0].AuxInt + if !(inBounds16(d, c)) { + goto end3103c51e14b4fc894b4170f16f37eebc + } + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = -1 + return true + } + goto end3103c51e14b4fc894b4170f16f37eebc +end3103c51e14b4fc894b4170f16f37eebc: + ; + // match: (SBBQcarrymask (CMPWconst [c] (MOVWconst [d]))) + // cond: !inBounds16(d, c) + // result: (MOVQconst [0]) + { + if v.Args[0].Op != OpAMD64CMPWconst { + goto enddae2191a59cfef5efb04ebab9354745c + } + c := v.Args[0].AuxInt + if v.Args[0].Args[0].Op != OpAMD64MOVWconst { + goto enddae2191a59cfef5efb04ebab9354745c + } + d := v.Args[0].Args[0].AuxInt + if !(!inBounds16(d, c)) { + goto enddae2191a59cfef5efb04ebab9354745c + } + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto enddae2191a59cfef5efb04ebab9354745c +enddae2191a59cfef5efb04ebab9354745c: + ; + // match: (SBBQcarrymask (CMPBconst [c] (MOVBconst [d]))) + // cond: inBounds8(d, c) + // result: (MOVQconst [-1]) + { + if v.Args[0].Op != OpAMD64CMPBconst { + goto end72e088325ca005b0251b1ee82da3c5d9 + } + c := v.Args[0].AuxInt + if v.Args[0].Args[0].Op != OpAMD64MOVBconst { + goto end72e088325ca005b0251b1ee82da3c5d9 + } + d := v.Args[0].Args[0].AuxInt + if !(inBounds8(d, c)) { + goto end72e088325ca005b0251b1ee82da3c5d9 + } + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = -1 + return true + } + goto end72e088325ca005b0251b1ee82da3c5d9 +end72e088325ca005b0251b1ee82da3c5d9: + ; + // match: (SBBQcarrymask (CMPBconst [c] (MOVBconst [d]))) + // cond: !inBounds8(d, c) + // result: (MOVQconst [0]) + { + if v.Args[0].Op != OpAMD64CMPBconst { + goto endcb388100f5b933aa94095096d2bb425e + } + c := v.Args[0].AuxInt + if v.Args[0].Args[0].Op != OpAMD64MOVBconst { + goto endcb388100f5b933aa94095096d2bb425e + } + d := v.Args[0].Args[0].AuxInt + if !(!inBounds8(d, c)) { + goto endcb388100f5b933aa94095096d2bb425e + } + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto endcb388100f5b933aa94095096d2bb425e +endcb388100f5b933aa94095096d2bb425e: + ; + return false +} +func rewriteValueAMD64_OpAMD64SETA(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (SETA (InvertFlags x)) + // cond: + // result: (SETB x) + { + if v.Args[0].Op != OpAMD64InvertFlags { + goto enda4ac36e94fc279d762b5a6c7c6cc665d + } + x := v.Args[0].Args[0] + v.Op = OpAMD64SETB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto enda4ac36e94fc279d762b5a6c7c6cc665d +enda4ac36e94fc279d762b5a6c7c6cc665d: + ; + return false +} +func rewriteValueAMD64_OpAMD64SETAE(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (SETAE (InvertFlags x)) + // cond: + // result: (SETBE x) + { + if v.Args[0].Op != OpAMD64InvertFlags { + goto end0468f5be6caf682fdea6b91d6648991e + } + x := v.Args[0].Args[0] + v.Op = OpAMD64SETBE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end0468f5be6caf682fdea6b91d6648991e +end0468f5be6caf682fdea6b91d6648991e: + ; + return false +} +func rewriteValueAMD64_OpAMD64SETB(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (SETB (InvertFlags x)) + // cond: + // result: (SETA x) + { + if v.Args[0].Op != OpAMD64InvertFlags { + goto endc9eba7aa1e54a228570d2f5cc96f3565 + } + x := v.Args[0].Args[0] + v.Op = OpAMD64SETA + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto endc9eba7aa1e54a228570d2f5cc96f3565 +endc9eba7aa1e54a228570d2f5cc96f3565: + ; + return false +} +func rewriteValueAMD64_OpAMD64SETBE(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (SETBE (InvertFlags x)) + // cond: + // result: (SETAE x) + { + if v.Args[0].Op != OpAMD64InvertFlags { + goto end9d9031643469798b14b8cad1f5a7a1ba + } + x := v.Args[0].Args[0] + v.Op = OpAMD64SETAE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end9d9031643469798b14b8cad1f5a7a1ba +end9d9031643469798b14b8cad1f5a7a1ba: + ; + return false +} +func rewriteValueAMD64_OpAMD64SETEQ(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (SETEQ (InvertFlags x)) + // cond: + // result: (SETEQ x) + { + if v.Args[0].Op != OpAMD64InvertFlags { + goto end5d2039c9368d8c0cfba23b5a85b459e1 + } + x := v.Args[0].Args[0] + v.Op = OpAMD64SETEQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end5d2039c9368d8c0cfba23b5a85b459e1 +end5d2039c9368d8c0cfba23b5a85b459e1: + ; + return false +} +func rewriteValueAMD64_OpAMD64SETG(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (SETG (InvertFlags x)) + // cond: + // result: (SETL x) + { + if v.Args[0].Op != OpAMD64InvertFlags { + goto endf7586738694c9cd0b74ae28bbadb649f + } + x := v.Args[0].Args[0] + v.Op = OpAMD64SETL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto endf7586738694c9cd0b74ae28bbadb649f +endf7586738694c9cd0b74ae28bbadb649f: + ; + return false +} +func rewriteValueAMD64_OpAMD64SETGE(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (SETGE (InvertFlags x)) + // cond: + // result: (SETLE x) + { + if v.Args[0].Op != OpAMD64InvertFlags { + goto end82c11eff6f842159f564f2dad3d2eedc + } + x := v.Args[0].Args[0] + v.Op = OpAMD64SETLE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end82c11eff6f842159f564f2dad3d2eedc +end82c11eff6f842159f564f2dad3d2eedc: + ; + return false +} +func rewriteValueAMD64_OpAMD64SETL(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (SETL (InvertFlags x)) + // cond: + // result: (SETG x) + { + if v.Args[0].Op != OpAMD64InvertFlags { + goto ende33160cd86b9d4d3b77e02fb4658d5d3 + } + x := v.Args[0].Args[0] + v.Op = OpAMD64SETG + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto ende33160cd86b9d4d3b77e02fb4658d5d3 +ende33160cd86b9d4d3b77e02fb4658d5d3: + ; + return false +} +func rewriteValueAMD64_OpAMD64SETLE(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (SETLE (InvertFlags x)) + // cond: + // result: (SETGE x) + { + if v.Args[0].Op != OpAMD64InvertFlags { + goto end9307d96753efbeb888d1c98a6aba7a29 + } + x := v.Args[0].Args[0] + v.Op = OpAMD64SETGE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end9307d96753efbeb888d1c98a6aba7a29 +end9307d96753efbeb888d1c98a6aba7a29: + ; + return false +} +func rewriteValueAMD64_OpAMD64SETNE(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (SETNE (InvertFlags x)) + // cond: + // result: (SETNE x) + { + if v.Args[0].Op != OpAMD64InvertFlags { + goto endbc71811b789475308014550f638026eb + } + x := v.Args[0].Args[0] + v.Op = OpAMD64SETNE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto endbc71811b789475308014550f638026eb +endbc71811b789475308014550f638026eb: + ; + return false +} +func rewriteValueAMD64_OpAMD64SHLB(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (SHLB x (MOVBconst [c])) + // cond: + // result: (SHLBconst [c&31] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVBconst { + goto end2d0d0111d831d8a575b5627284a6337a + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SHLBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 31 + v.AddArg(x) + return true + } + goto end2d0d0111d831d8a575b5627284a6337a +end2d0d0111d831d8a575b5627284a6337a: + ; + return false +} +func rewriteValueAMD64_OpAMD64SHLL(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (SHLL x (MOVLconst [c])) + // cond: + // result: (SHLLconst [c&31] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVLconst { + goto end633f9ddcfbb63374c895a5f78da75d25 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SHLLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 31 + v.AddArg(x) + return true + } + goto end633f9ddcfbb63374c895a5f78da75d25 +end633f9ddcfbb63374c895a5f78da75d25: + ; + 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) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVQconst { + goto end4d7e3a945cacdd6b6c8c0de6f465d4ae + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SHLQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 63 + v.AddArg(x) + return true + } + goto end4d7e3a945cacdd6b6c8c0de6f465d4ae +end4d7e3a945cacdd6b6c8c0de6f465d4ae: + ; + return false +} +func rewriteValueAMD64_OpAMD64SHLW(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (SHLW x (MOVWconst [c])) + // cond: + // result: (SHLWconst [c&31] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVWconst { + goto endba96a52aa58d28b3357828051e0e695c + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SHLWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 31 + v.AddArg(x) + return true + } + goto endba96a52aa58d28b3357828051e0e695c +endba96a52aa58d28b3357828051e0e695c: + ; + return false +} +func rewriteValueAMD64_OpAMD64SHRB(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (SHRB x (MOVBconst [c])) + // cond: + // result: (SHRBconst [c&31] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVBconst { + goto enddb1cd5aaa826d43fa4f6d1b2b8795e58 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SHRBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 31 + v.AddArg(x) + return true + } + goto enddb1cd5aaa826d43fa4f6d1b2b8795e58 +enddb1cd5aaa826d43fa4f6d1b2b8795e58: + ; + return false +} +func rewriteValueAMD64_OpAMD64SHRL(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (SHRL x (MOVLconst [c])) + // cond: + // result: (SHRLconst [c&31] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVLconst { + goto end344b8b9202e1925e8d0561f1c21412fc + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SHRLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 31 + v.AddArg(x) + return true + } + goto end344b8b9202e1925e8d0561f1c21412fc +end344b8b9202e1925e8d0561f1c21412fc: + ; + 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) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVQconst { + goto end699d35e2d5cfa08b8a3b1c8a183ddcf3 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SHRQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 63 + v.AddArg(x) + return true + } + goto end699d35e2d5cfa08b8a3b1c8a183ddcf3 +end699d35e2d5cfa08b8a3b1c8a183ddcf3: + ; + return false +} +func rewriteValueAMD64_OpAMD64SHRW(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (SHRW x (MOVWconst [c])) + // cond: + // result: (SHRWconst [c&31] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVWconst { + goto endd75ff1f9b3e9ec9c942a39b6179da1b3 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SHRWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 31 + v.AddArg(x) + return true + } + goto endd75ff1f9b3e9ec9c942a39b6179da1b3 +endd75ff1f9b3e9ec9c942a39b6179da1b3: + ; + return false +} +func rewriteValueAMD64_OpAMD64SUBB(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (SUBB x (MOVBconst [c])) + // cond: + // result: (SUBBconst x [c]) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVBconst { + goto end9ca5d2a70e2df1a5a3ed6786bce1f7b2 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SUBBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AuxInt = c + return true + } + goto end9ca5d2a70e2df1a5a3ed6786bce1f7b2 +end9ca5d2a70e2df1a5a3ed6786bce1f7b2: + ; + // match: (SUBB (MOVBconst [c]) x) + // cond: + // result: (NEGB (SUBBconst x [c])) + { + if v.Args[0].Op != OpAMD64MOVBconst { + goto endc288755d69b04d24a6aac32a73956411 + } + c := v.Args[0].AuxInt + x := v.Args[1] + v.Op = OpAMD64NEGB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64SUBBconst, TypeInvalid) + v0.Type = v.Type + v0.AddArg(x) + v0.AuxInt = c + v.AddArg(v0) + return true + } + goto endc288755d69b04d24a6aac32a73956411 +endc288755d69b04d24a6aac32a73956411: + ; + // match: (SUBB x x) + // cond: + // result: (MOVBconst [0]) + { + x := v.Args[0] + if v.Args[1] != x { + goto ende8904403d937d95b0d6133d3ec92bb45 + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto ende8904403d937d95b0d6133d3ec92bb45 +ende8904403d937d95b0d6133d3ec92bb45: + ; + return false +} +func rewriteValueAMD64_OpAMD64SUBBconst(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (SUBBconst [c] (MOVBconst [d])) + // cond: + // result: (MOVBconst [d-c]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVBconst { + goto enddc5383558e2f3eae507afcb94eada964 + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = d - c + return true + } + goto enddc5383558e2f3eae507afcb94eada964 +enddc5383558e2f3eae507afcb94eada964: + ; + // match: (SUBBconst [c] (SUBBconst [d] x)) + // cond: + // result: (ADDBconst [-c-d] x) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64SUBBconst { + goto end035c57413a46eb347ecb3736d1510915 + } + d := v.Args[0].AuxInt + x := v.Args[0].Args[0] + v.Op = OpAMD64ADDBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = -c - d + v.AddArg(x) + return true + } + goto end035c57413a46eb347ecb3736d1510915 +end035c57413a46eb347ecb3736d1510915: + ; + return false +} +func rewriteValueAMD64_OpAMD64SUBL(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (SUBL x (MOVLconst [c])) + // cond: + // result: (SUBLconst x [c]) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVLconst { + goto end178c1d6c86f9c16f6497586c2f7d8625 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SUBLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AuxInt = c + return true + } + goto end178c1d6c86f9c16f6497586c2f7d8625 +end178c1d6c86f9c16f6497586c2f7d8625: + ; + // match: (SUBL (MOVLconst [c]) x) + // cond: + // result: (NEGL (SUBLconst x [c])) + { + if v.Args[0].Op != OpAMD64MOVLconst { + goto endb0efe6e15ec20486b849534a00483ae2 + } + c := v.Args[0].AuxInt + x := v.Args[1] + v.Op = OpAMD64NEGL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64SUBLconst, TypeInvalid) + v0.Type = v.Type + v0.AddArg(x) + v0.AuxInt = c + v.AddArg(v0) + return true + } + goto endb0efe6e15ec20486b849534a00483ae2 +endb0efe6e15ec20486b849534a00483ae2: + ; + // match: (SUBL x x) + // cond: + // result: (MOVLconst [0]) + { + x := v.Args[0] + if v.Args[1] != x { + goto end332f1f641f875c69bea7289191e69133 + } + v.Op = OpAMD64MOVLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end332f1f641f875c69bea7289191e69133 +end332f1f641f875c69bea7289191e69133: + ; + return false +} +func rewriteValueAMD64_OpAMD64SUBLconst(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (SUBLconst [c] (MOVLconst [d])) + // cond: + // result: (MOVLconst [d-c]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVLconst { + goto end6c5c6d58d4bdd0a5c2f7bf10b343b41e + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = d - c + return true + } + goto end6c5c6d58d4bdd0a5c2f7bf10b343b41e +end6c5c6d58d4bdd0a5c2f7bf10b343b41e: + ; + // match: (SUBLconst [c] (SUBLconst [d] x)) + // cond: + // result: (ADDLconst [-c-d] x) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64SUBLconst { + goto end0c9ffb11e8a56ced1b14dbf6bf9a6737 + } + d := v.Args[0].AuxInt + x := v.Args[0].Args[0] + v.Op = OpAMD64ADDLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = -c - d + v.AddArg(x) + return true + } + goto end0c9ffb11e8a56ced1b14dbf6bf9a6737 +end0c9ffb11e8a56ced1b14dbf6bf9a6737: + ; + 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]) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVQconst { + goto end9bbb7b20824a498752c605942fad89c2 + } + c := v.Args[1].AuxInt + if !(is32Bit(c)) { + goto end9bbb7b20824a498752c605942fad89c2 + } + v.Op = OpAMD64SUBQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AuxInt = c + return true + } + goto end9bbb7b20824a498752c605942fad89c2 +end9bbb7b20824a498752c605942fad89c2: + ; + // match: (SUBQ (MOVQconst [c]) x) + // cond: is32Bit(c) + // result: (NEGQ (SUBQconst x [c])) + { + if v.Args[0].Op != OpAMD64MOVQconst { + goto end8beb96de3efee9206d1bd4b7d777d2cb + } + c := v.Args[0].AuxInt + x := v.Args[1] + if !(is32Bit(c)) { + goto end8beb96de3efee9206d1bd4b7d777d2cb + } + v.Op = OpAMD64NEGQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64SUBQconst, TypeInvalid) + v0.Type = v.Type + v0.AddArg(x) + v0.AuxInt = c + v.AddArg(v0) + return true + } + goto end8beb96de3efee9206d1bd4b7d777d2cb +end8beb96de3efee9206d1bd4b7d777d2cb: + ; + // match: (SUBQ x x) + // cond: + // result: (MOVQconst [0]) + { + x := v.Args[0] + if v.Args[1] != x { + goto endd87d1d839d2dc54d9c90fa4f73383480 + } + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto endd87d1d839d2dc54d9c90fa4f73383480 +endd87d1d839d2dc54d9c90fa4f73383480: + ; + return false +} +func rewriteValueAMD64_OpAMD64SUBQconst(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (SUBQconst [c] (MOVQconst [d])) + // cond: + // result: (MOVQconst [d-c]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVQconst { + goto endb0daebe6831cf381377c3e4248070f25 + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = d - c + return true + } + goto endb0daebe6831cf381377c3e4248070f25 +endb0daebe6831cf381377c3e4248070f25: + ; + // match: (SUBQconst [c] (SUBQconst [d] x)) + // cond: + // result: (ADDQconst [-c-d] x) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64SUBQconst { + goto end2d40ddb5ae9e90679456254c61858d9d + } + d := v.Args[0].AuxInt + x := v.Args[0].Args[0] + v.Op = OpAMD64ADDQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = -c - d + v.AddArg(x) + return true + } + goto end2d40ddb5ae9e90679456254c61858d9d +end2d40ddb5ae9e90679456254c61858d9d: + ; + return false +} +func rewriteValueAMD64_OpAMD64SUBW(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (SUBW x (MOVWconst [c])) + // cond: + // result: (SUBWconst x [c]) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVWconst { + goto end135aa9100b2f61d58b37cede37b63731 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SUBWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AuxInt = c + return true + } + goto end135aa9100b2f61d58b37cede37b63731 +end135aa9100b2f61d58b37cede37b63731: + ; + // match: (SUBW (MOVWconst [c]) x) + // cond: + // result: (NEGW (SUBWconst x [c])) + { + if v.Args[0].Op != OpAMD64MOVWconst { + goto end44d23f7e65a4b1c42d0e6463f8e493b6 + } + c := v.Args[0].AuxInt + x := v.Args[1] + v.Op = OpAMD64NEGW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64SUBWconst, TypeInvalid) + v0.Type = v.Type + v0.AddArg(x) + v0.AuxInt = c + v.AddArg(v0) + return true + } + goto end44d23f7e65a4b1c42d0e6463f8e493b6 +end44d23f7e65a4b1c42d0e6463f8e493b6: + ; + // match: (SUBW x x) + // cond: + // result: (MOVWconst [0]) + { + x := v.Args[0] + if v.Args[1] != x { + goto endb970e7c318d04a1afe1dfe08a7ca0d9c + } + v.Op = OpAMD64MOVWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto endb970e7c318d04a1afe1dfe08a7ca0d9c +endb970e7c318d04a1afe1dfe08a7ca0d9c: + ; + return false +} +func rewriteValueAMD64_OpAMD64SUBWconst(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (SUBWconst [c] (MOVWconst [d])) + // cond: + // result: (MOVWconst [d-c]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVWconst { + goto endae629a229c399eaed7dbb95b1b0e6f8a + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = d - c + return true + } + goto endae629a229c399eaed7dbb95b1b0e6f8a +endae629a229c399eaed7dbb95b1b0e6f8a: + ; + // match: (SUBWconst [c] (SUBWconst [d] x)) + // cond: + // result: (ADDWconst [-c-d] x) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64SUBWconst { + goto enda59f08d12aa08717b0443b7bb1b71374 + } + d := v.Args[0].AuxInt + x := v.Args[0].Args[0] + v.Op = OpAMD64ADDWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = -c - d + v.AddArg(x) + return true + } + goto enda59f08d12aa08717b0443b7bb1b71374 +enda59f08d12aa08717b0443b7bb1b71374: + ; + return false +} +func rewriteValueAMD64_OpSignExt16to32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (SignExt16to32 x) + // cond: + // result: (MOVWQSX x) + { + x := v.Args[0] + v.Op = OpAMD64MOVWQSX + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end21e4271c2b48a5aa3561ccfa8fa67cd9 +end21e4271c2b48a5aa3561ccfa8fa67cd9: + ; + return false +} +func rewriteValueAMD64_OpSignExt16to64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (SignExt16to64 x) + // cond: + // result: (MOVWQSX x) + { + x := v.Args[0] + v.Op = OpAMD64MOVWQSX + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto endc6d242ee3a3e195ef0f9e8dae47ada75 +endc6d242ee3a3e195ef0f9e8dae47ada75: + ; + return false +} +func rewriteValueAMD64_OpSignExt32to64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (SignExt32to64 x) + // cond: + // result: (MOVLQSX x) + { + x := v.Args[0] + v.Op = OpAMD64MOVLQSX + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto endb9f1a8b2d01eee44964a71a01bca165c +endb9f1a8b2d01eee44964a71a01bca165c: + ; + return false +} +func rewriteValueAMD64_OpSignExt8to16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (SignExt8to16 x) + // cond: + // result: (MOVBQSX x) + { + x := v.Args[0] + v.Op = OpAMD64MOVBQSX + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end372869f08e147404b80634e5f83fd506 +end372869f08e147404b80634e5f83fd506: + ; + return false +} +func rewriteValueAMD64_OpSignExt8to32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (SignExt8to32 x) + // cond: + // result: (MOVBQSX x) + { + x := v.Args[0] + v.Op = OpAMD64MOVBQSX + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end913e3575e5b4cf7f60585c108db40464 +end913e3575e5b4cf7f60585c108db40464: + ; + return false +} +func rewriteValueAMD64_OpSignExt8to64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (SignExt8to64 x) + // cond: + // result: (MOVBQSX x) + { + x := v.Args[0] + v.Op = OpAMD64MOVBQSX + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto endcef6d6001d3f25cf5dacee11a46e5c8c +endcef6d6001d3f25cf5dacee11a46e5c8c: + ; + return false +} +func rewriteValueAMD64_OpSqrt(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Sqrt x) + // cond: + // result: (SQRTSD x) + { + x := v.Args[0] + v.Op = OpAMD64SQRTSD + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end72f79ca9ec139e15856aaa03338cf543 +end72f79ca9ec139e15856aaa03338cf543: + ; + 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) + { + argwid := v.AuxInt + target := v.Aux + mem := v.Args[0] + v.Op = OpAMD64CALLstatic + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = argwid + v.Aux = target + v.AddArg(mem) + return true + } + goto end32c5cbec813d1c2ae94fc9b1090e4b2a +end32c5cbec813d1c2ae94fc9b1090e4b2a: + ; + 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) + { + if v.AuxInt != 8 { + goto endaeec4f61bc8e67dbf3fa2f79fe4c2b9e + } + ptr := v.Args[0] + val := v.Args[1] + mem := v.Args[2] + if !(is64BitFloat(val.Type)) { + goto endaeec4f61bc8e67dbf3fa2f79fe4c2b9e + } + v.Op = OpAMD64MOVSDstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto endaeec4f61bc8e67dbf3fa2f79fe4c2b9e +endaeec4f61bc8e67dbf3fa2f79fe4c2b9e: + ; + // match: (Store [4] ptr val mem) + // cond: is32BitFloat(val.Type) + // result: (MOVSSstore ptr val mem) + { + if v.AuxInt != 4 { + goto endf638ca0a75871b5062da15324d0e0384 + } + ptr := v.Args[0] + val := v.Args[1] + mem := v.Args[2] + if !(is32BitFloat(val.Type)) { + goto endf638ca0a75871b5062da15324d0e0384 + } + v.Op = OpAMD64MOVSSstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto endf638ca0a75871b5062da15324d0e0384 +endf638ca0a75871b5062da15324d0e0384: + ; + // match: (Store [8] ptr val mem) + // cond: + // result: (MOVQstore ptr val mem) + { + if v.AuxInt != 8 { + goto endd1eb7c3ea0c806e7a53ff3be86186eb7 + } + ptr := v.Args[0] + val := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64MOVQstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto endd1eb7c3ea0c806e7a53ff3be86186eb7 +endd1eb7c3ea0c806e7a53ff3be86186eb7: + ; + // match: (Store [4] ptr val mem) + // cond: + // result: (MOVLstore ptr val mem) + { + if v.AuxInt != 4 { + goto end44e3b22360da76ecd59be9a8c2dd1347 + } + ptr := v.Args[0] + val := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64MOVLstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto end44e3b22360da76ecd59be9a8c2dd1347 +end44e3b22360da76ecd59be9a8c2dd1347: + ; + // match: (Store [2] ptr val mem) + // cond: + // result: (MOVWstore ptr val mem) + { + if v.AuxInt != 2 { + goto endd0342b7fd3d0713f3e26922660047c71 + } + ptr := v.Args[0] + val := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64MOVWstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto endd0342b7fd3d0713f3e26922660047c71 +endd0342b7fd3d0713f3e26922660047c71: + ; + // match: (Store [1] ptr val mem) + // cond: + // result: (MOVBstore ptr val mem) + { + if v.AuxInt != 1 { + goto end8e76e20031197ca875889d2b4d0eb1d1 + } + ptr := v.Args[0] + val := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64MOVBstore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto end8e76e20031197ca875889d2b4d0eb1d1 +end8e76e20031197ca875889d2b4d0eb1d1: + ; + return false +} +func rewriteValueAMD64_OpSub16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Sub16 x y) + // cond: + // result: (SUBW x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SUBW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end54adc5de883c0460ca71c6ee464d4244 +end54adc5de883c0460ca71c6ee464d4244: + ; + return false +} +func rewriteValueAMD64_OpSub32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Sub32 x y) + // cond: + // result: (SUBL x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SUBL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto enddc3a2a488bda8c5856f93343e5ffe5f8 +enddc3a2a488bda8c5856f93343e5ffe5f8: + ; + return false +} +func rewriteValueAMD64_OpSub32F(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Sub32F x y) + // cond: + // result: (SUBSS x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SUBSS + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end20193c1804b0e707702a884fb8abd60d +end20193c1804b0e707702a884fb8abd60d: + ; + return false +} +func rewriteValueAMD64_OpSub64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Sub64 x y) + // cond: + // result: (SUBQ x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SUBQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto endd88d5646309fd9174584888ecc8aca2c +endd88d5646309fd9174584888ecc8aca2c: + ; + return false +} +func rewriteValueAMD64_OpSub64F(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Sub64F x y) + // cond: + // result: (SUBSD x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SUBSD + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end5d5af7b8a3326bf9151f00a0013b73d7 +end5d5af7b8a3326bf9151f00a0013b73d7: + ; + return false +} +func rewriteValueAMD64_OpSub8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Sub8 x y) + // cond: + // result: (SUBB x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SUBB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end7d33bf9bdfa505f96b930563eca7955f +end7d33bf9bdfa505f96b930563eca7955f: + ; + return false +} +func rewriteValueAMD64_OpSubPtr(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (SubPtr x y) + // cond: + // result: (SUBQ x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SUBQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end748f63f755afe0b97a8f3cf7e4d9cbfe +end748f63f755afe0b97a8f3cf7e4d9cbfe: + ; + return false +} +func rewriteValueAMD64_OpTrunc16to8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Trunc16to8 x) + // cond: + // result: x + { + x := v.Args[0] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end8e2f5e0a6e3a06423c077747de6c2bdd +end8e2f5e0a6e3a06423c077747de6c2bdd: + ; + return false +} +func rewriteValueAMD64_OpTrunc32to16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Trunc32to16 x) + // cond: + // result: x + { + x := v.Args[0] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end5bed0e3a3c1c6374d86beb5a4397708c +end5bed0e3a3c1c6374d86beb5a4397708c: + ; + return false +} +func rewriteValueAMD64_OpTrunc32to8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Trunc32to8 x) + // cond: + // result: x + { + x := v.Args[0] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto endef0b8032ce91979ce6cd0004260c04ee +endef0b8032ce91979ce6cd0004260c04ee: + ; + return false +} +func rewriteValueAMD64_OpTrunc64to16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Trunc64to16 x) + // cond: + // result: x + { + x := v.Args[0] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto endd32fd6e0ce970c212835e6f71c3dcbfd +endd32fd6e0ce970c212835e6f71c3dcbfd: + ; + return false +} +func rewriteValueAMD64_OpTrunc64to32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Trunc64to32 x) + // cond: + // result: x + { + x := v.Args[0] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end1212c4e84153210aff7fd630fb3e1883 +end1212c4e84153210aff7fd630fb3e1883: + ; + return false +} +func rewriteValueAMD64_OpTrunc64to8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Trunc64to8 x) + // cond: + // result: x + { + x := v.Args[0] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end734f017d4b2810ca2288f7037365824c +end734f017d4b2810ca2288f7037365824c: + ; + return false +} +func rewriteValueAMD64_OpAMD64XORB(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (XORB x (MOVBconst [c])) + // cond: + // result: (XORBconst [c] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVBconst { + goto enda9ed9fdd115ffdffa8127c007c34d7b7 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64XORBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto enda9ed9fdd115ffdffa8127c007c34d7b7 +enda9ed9fdd115ffdffa8127c007c34d7b7: + ; + // match: (XORB (MOVBconst [c]) x) + // cond: + // result: (XORBconst [c] x) + { + if v.Args[0].Op != OpAMD64MOVBconst { + goto endb02a07d9dc7b802c59f013116e952f3f + } + c := v.Args[0].AuxInt + x := v.Args[1] + v.Op = OpAMD64XORBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto endb02a07d9dc7b802c59f013116e952f3f +endb02a07d9dc7b802c59f013116e952f3f: + ; + // match: (XORB x x) + // cond: + // result: (MOVBconst [0]) + { + x := v.Args[0] + if v.Args[1] != x { + goto end2afddc39503d04d572a3a07878f6c9c9 + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end2afddc39503d04d572a3a07878f6c9c9 +end2afddc39503d04d572a3a07878f6c9c9: + ; + return false +} +func rewriteValueAMD64_OpAMD64XORBconst(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (XORBconst [c] (MOVBconst [d])) + // cond: + // result: (MOVBconst [c^d]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVBconst { + goto end6d8d1b612af9d253605c8bc69b822903 + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c ^ d + return true + } + goto end6d8d1b612af9d253605c8bc69b822903 +end6d8d1b612af9d253605c8bc69b822903: + ; + return false +} +func rewriteValueAMD64_OpAMD64XORL(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (XORL x (MOVLconst [c])) + // cond: + // result: (XORLconst [c] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVLconst { + goto enda9459d509d3416da67d13a22dd074a9c + } + c := v.Args[1].AuxInt + v.Op = OpAMD64XORLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto enda9459d509d3416da67d13a22dd074a9c +enda9459d509d3416da67d13a22dd074a9c: + ; + // match: (XORL (MOVLconst [c]) x) + // cond: + // result: (XORLconst [c] x) + { + if v.Args[0].Op != OpAMD64MOVLconst { + goto end9c1a0af00eeadd8aa325e55f1f3fb89c + } + c := v.Args[0].AuxInt + x := v.Args[1] + v.Op = OpAMD64XORLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end9c1a0af00eeadd8aa325e55f1f3fb89c +end9c1a0af00eeadd8aa325e55f1f3fb89c: + ; + // match: (XORL x x) + // cond: + // result: (MOVLconst [0]) + { + x := v.Args[0] + if v.Args[1] != x { + goto end7bcf9cfeb69a0d7647389124eb53ce2a + } + v.Op = OpAMD64MOVLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end7bcf9cfeb69a0d7647389124eb53ce2a +end7bcf9cfeb69a0d7647389124eb53ce2a: + ; + return false +} +func rewriteValueAMD64_OpAMD64XORLconst(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (XORLconst [c] (MOVLconst [d])) + // cond: + // result: (MOVLconst [c^d]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVLconst { + goto end71238075b10b68a226903cc453c4715c + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c ^ d + return true + } + goto end71238075b10b68a226903cc453c4715c +end71238075b10b68a226903cc453c4715c: + ; + 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) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVQconst { + goto end452341f950062e0483f16438fb9ec500 + } + c := v.Args[1].AuxInt + if !(is32Bit(c)) { + goto end452341f950062e0483f16438fb9ec500 + } + v.Op = OpAMD64XORQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end452341f950062e0483f16438fb9ec500 +end452341f950062e0483f16438fb9ec500: + ; + // match: (XORQ (MOVQconst [c]) x) + // cond: is32Bit(c) + // result: (XORQconst [c] x) + { + if v.Args[0].Op != OpAMD64MOVQconst { + goto endd221a7e3daaaaa29ee385ad36e061b57 + } + c := v.Args[0].AuxInt + x := v.Args[1] + if !(is32Bit(c)) { + goto endd221a7e3daaaaa29ee385ad36e061b57 + } + v.Op = OpAMD64XORQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto endd221a7e3daaaaa29ee385ad36e061b57 +endd221a7e3daaaaa29ee385ad36e061b57: + ; + // match: (XORQ x x) + // cond: + // result: (MOVQconst [0]) + { + x := v.Args[0] + if v.Args[1] != x { + goto end10575a5d711cf14e6d4dffbb0e8dfaeb + } + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end10575a5d711cf14e6d4dffbb0e8dfaeb +end10575a5d711cf14e6d4dffbb0e8dfaeb: + ; + return false +} +func rewriteValueAMD64_OpAMD64XORQconst(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (XORQconst [c] (MOVQconst [d])) + // cond: + // result: (MOVQconst [c^d]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVQconst { + goto end3f404d4f07362319fbad2e1ba0827a9f + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c ^ d + return true + } + goto end3f404d4f07362319fbad2e1ba0827a9f +end3f404d4f07362319fbad2e1ba0827a9f: + ; + return false +} +func rewriteValueAMD64_OpAMD64XORW(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (XORW x (MOVWconst [c])) + // cond: + // result: (XORWconst [c] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVWconst { + goto end2ca109efd66c221a5691a4da95ec6c67 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64XORWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end2ca109efd66c221a5691a4da95ec6c67 +end2ca109efd66c221a5691a4da95ec6c67: + ; + // match: (XORW (MOVWconst [c]) x) + // cond: + // result: (XORWconst [c] x) + { + if v.Args[0].Op != OpAMD64MOVWconst { + goto end51ee62a06d4301e5a4aed7a6639b1d53 + } + c := v.Args[0].AuxInt + x := v.Args[1] + v.Op = OpAMD64XORWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto end51ee62a06d4301e5a4aed7a6639b1d53 +end51ee62a06d4301e5a4aed7a6639b1d53: + ; + // match: (XORW x x) + // cond: + // result: (MOVWconst [0]) + { + x := v.Args[0] + if v.Args[1] != x { + goto end07f332e857be0c2707797ed480a2faf4 + } + v.Op = OpAMD64MOVWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end07f332e857be0c2707797ed480a2faf4 +end07f332e857be0c2707797ed480a2faf4: + ; + return false +} +func rewriteValueAMD64_OpAMD64XORWconst(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (XORWconst [c] (MOVWconst [d])) + // cond: + // result: (MOVWconst [c^d]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVWconst { + goto ende24881ccdfa8486c4593fd9aa5df1ed6 + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c ^ d + return true + } + goto ende24881ccdfa8486c4593fd9aa5df1ed6 +ende24881ccdfa8486c4593fd9aa5df1ed6: + ; + return false +} +func rewriteValueAMD64_OpXor16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Xor16 x y) + // cond: + // result: (XORW x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64XORW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end20efdd5dfd5130abf818de5546a991a0 +end20efdd5dfd5130abf818de5546a991a0: + ; + return false +} +func rewriteValueAMD64_OpXor32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Xor32 x y) + // cond: + // result: (XORL x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64XORL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end9da6bce98b437e2609488346116a75d8 +end9da6bce98b437e2609488346116a75d8: + ; + return false +} +func rewriteValueAMD64_OpXor64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Xor64 x y) + // cond: + // result: (XORQ x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64XORQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto endc88cd189c2a6f07ecff324ed94809f8f +endc88cd189c2a6f07ecff324ed94809f8f: + ; + return false +} +func rewriteValueAMD64_OpXor8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Xor8 x y) + // cond: + // result: (XORB x y) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64XORB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end50f4434ef96916d3e65ad3cc236d1723 +end50f4434ef96916d3e65ad3cc236d1723: + ; + return false +} +func rewriteValueAMD64_OpZero(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Zero [0] _ mem) + // cond: + // result: mem + { + if v.AuxInt != 0 { + goto endc9a38a60f0322f93682daa824611272c + } + mem := v.Args[1] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = mem.Type + v.AddArg(mem) + return true + } + goto endc9a38a60f0322f93682daa824611272c +endc9a38a60f0322f93682daa824611272c: + ; + // match: (Zero [1] destptr mem) + // cond: + // result: (MOVBstoreconst [0] destptr mem) + { + if v.AuxInt != 1 { + goto ende0161981658beee468c9e2368fe31eb8 + } + destptr := v.Args[0] + mem := v.Args[1] + v.Op = OpAMD64MOVBstoreconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + v.AddArg(destptr) + v.AddArg(mem) + return true + } + goto ende0161981658beee468c9e2368fe31eb8 +ende0161981658beee468c9e2368fe31eb8: + ; + // match: (Zero [2] destptr mem) + // cond: + // result: (MOVWstoreconst [0] destptr mem) + { + if v.AuxInt != 2 { + goto end4e4aaf641bf2818bb71f1397e4685bdd + } + destptr := v.Args[0] + mem := v.Args[1] + v.Op = OpAMD64MOVWstoreconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + v.AddArg(destptr) + v.AddArg(mem) + return true + } + goto end4e4aaf641bf2818bb71f1397e4685bdd +end4e4aaf641bf2818bb71f1397e4685bdd: + ; + // match: (Zero [4] destptr mem) + // cond: + // result: (MOVLstoreconst [0] destptr mem) + { + if v.AuxInt != 4 { + goto end7612f59dd66ebfc632ea5bc85f5437b5 + } + destptr := v.Args[0] + mem := v.Args[1] + v.Op = OpAMD64MOVLstoreconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + v.AddArg(destptr) + v.AddArg(mem) + return true + } + goto end7612f59dd66ebfc632ea5bc85f5437b5 +end7612f59dd66ebfc632ea5bc85f5437b5: + ; + // match: (Zero [8] destptr mem) + // cond: + // result: (MOVQstoreconst [0] destptr mem) + { + if v.AuxInt != 8 { + goto end07aaaebfa15a48c52cd79b68e28d266f + } + destptr := v.Args[0] + mem := v.Args[1] + v.Op = OpAMD64MOVQstoreconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + v.AddArg(destptr) + v.AddArg(mem) + return true + } + goto end07aaaebfa15a48c52cd79b68e28d266f +end07aaaebfa15a48c52cd79b68e28d266f: + ; + // match: (Zero [3] destptr mem) + // cond: + // result: (MOVBstoreconst [makeStoreConst(0,2)] destptr (MOVWstoreconst [0] destptr mem)) + { + if v.AuxInt != 3 { + goto end03b2ae08f901891919e454f05273fb4e + } + destptr := v.Args[0] + mem := v.Args[1] + v.Op = OpAMD64MOVBstoreconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = makeStoreConst(0, 2) + v.AddArg(destptr) + v0 := b.NewValue0(v.Line, OpAMD64MOVWstoreconst, TypeInvalid) + v0.AuxInt = 0 + v0.AddArg(destptr) + v0.AddArg(mem) + v0.Type = TypeMem + v.AddArg(v0) + return true + } + goto end03b2ae08f901891919e454f05273fb4e +end03b2ae08f901891919e454f05273fb4e: + ; + // match: (Zero [5] destptr mem) + // cond: + // result: (MOVBstoreconst [makeStoreConst(0,4)] destptr (MOVLstoreconst [0] destptr mem)) + { + if v.AuxInt != 5 { + goto endc473059deb6291d483262b08312eab48 + } + destptr := v.Args[0] + mem := v.Args[1] + v.Op = OpAMD64MOVBstoreconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = makeStoreConst(0, 4) + v.AddArg(destptr) + v0 := b.NewValue0(v.Line, OpAMD64MOVLstoreconst, TypeInvalid) + v0.AuxInt = 0 + v0.AddArg(destptr) + v0.AddArg(mem) + v0.Type = TypeMem + v.AddArg(v0) + return true + } + goto endc473059deb6291d483262b08312eab48 +endc473059deb6291d483262b08312eab48: + ; + // match: (Zero [6] destptr mem) + // cond: + // result: (MOVWstoreconst [makeStoreConst(0,4)] destptr (MOVLstoreconst [0] destptr mem)) + { + if v.AuxInt != 6 { + goto end41b38839f25e3749384d53b5945bd56b + } + destptr := v.Args[0] + mem := v.Args[1] + v.Op = OpAMD64MOVWstoreconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = makeStoreConst(0, 4) + v.AddArg(destptr) + v0 := b.NewValue0(v.Line, OpAMD64MOVLstoreconst, TypeInvalid) + v0.AuxInt = 0 + v0.AddArg(destptr) + v0.AddArg(mem) + v0.Type = TypeMem + v.AddArg(v0) + return true + } + goto end41b38839f25e3749384d53b5945bd56b +end41b38839f25e3749384d53b5945bd56b: + ; + // match: (Zero [7] destptr mem) + // cond: + // result: (MOVLstoreconst [makeStoreConst(0,3)] destptr (MOVLstoreconst [0] destptr mem)) + { + if v.AuxInt != 7 { + goto end06e677d4c1ac43e08783eb8117a589b6 + } + destptr := v.Args[0] + mem := v.Args[1] + v.Op = OpAMD64MOVLstoreconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = makeStoreConst(0, 3) + v.AddArg(destptr) + v0 := b.NewValue0(v.Line, OpAMD64MOVLstoreconst, TypeInvalid) + v0.AuxInt = 0 + v0.AddArg(destptr) + v0.AddArg(mem) + v0.Type = TypeMem + v.AddArg(v0) + return true + } + goto end06e677d4c1ac43e08783eb8117a589b6 +end06e677d4c1ac43e08783eb8117a589b6: + ; + // match: (Zero [size] destptr mem) + // cond: size%8 != 0 && size > 8 + // result: (Zero [size-size%8] (ADDQconst destptr [size%8]) (MOVQstoreconst [0] destptr mem)) + { + size := v.AuxInt + destptr := v.Args[0] + mem := v.Args[1] + if !(size%8 != 0 && size > 8) { + goto endc8760f86b83b1372fce0042ab5200fc1 + } + v.Op = OpZero + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = size - size%8 + v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) + v0.AddArg(destptr) + v0.AuxInt = size % 8 + v0.Type = config.fe.TypeUInt64() + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeInvalid) + v1.AuxInt = 0 + v1.AddArg(destptr) + v1.AddArg(mem) + v1.Type = TypeMem + v.AddArg(v1) + return true + } + goto endc8760f86b83b1372fce0042ab5200fc1 +endc8760f86b83b1372fce0042ab5200fc1: + ; + // match: (Zero [16] destptr mem) + // cond: + // result: (MOVQstoreconst [makeStoreConst(0,8)] destptr (MOVQstoreconst [0] destptr mem)) + { + if v.AuxInt != 16 { + goto endce0bdb028011236be9f04fb53462204d + } + destptr := v.Args[0] + mem := v.Args[1] + v.Op = OpAMD64MOVQstoreconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = makeStoreConst(0, 8) + v.AddArg(destptr) + v0 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeInvalid) + v0.AuxInt = 0 + v0.AddArg(destptr) + v0.AddArg(mem) + v0.Type = TypeMem + v.AddArg(v0) + return true + } + goto endce0bdb028011236be9f04fb53462204d +endce0bdb028011236be9f04fb53462204d: + ; + // match: (Zero [24] destptr mem) + // cond: + // result: (MOVQstoreconst [makeStoreConst(0,16)] destptr (MOVQstoreconst [makeStoreConst(0,8)] destptr (MOVQstoreconst [0] destptr mem))) + { + if v.AuxInt != 24 { + goto end859fe3911b36516ea096299b2a85350e + } + destptr := v.Args[0] + mem := v.Args[1] + v.Op = OpAMD64MOVQstoreconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = makeStoreConst(0, 16) + v.AddArg(destptr) + v0 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeInvalid) + v0.AuxInt = makeStoreConst(0, 8) + v0.AddArg(destptr) + v1 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeInvalid) + v1.AuxInt = 0 + v1.AddArg(destptr) + v1.AddArg(mem) + v1.Type = TypeMem + v0.AddArg(v1) + v0.Type = TypeMem + v.AddArg(v0) + return true + } + goto end859fe3911b36516ea096299b2a85350e +end859fe3911b36516ea096299b2a85350e: + ; + // match: (Zero [32] destptr mem) + // cond: + // result: (MOVQstoreconst [makeStoreConst(0,24)] destptr (MOVQstoreconst [makeStoreConst(0,16)] destptr (MOVQstoreconst [makeStoreConst(0,8)] destptr (MOVQstoreconst [0] destptr mem)))) + { + if v.AuxInt != 32 { + goto end2c246614f6a9a07f1a683691b3f5780f + } + destptr := v.Args[0] + mem := v.Args[1] + v.Op = OpAMD64MOVQstoreconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = makeStoreConst(0, 24) + v.AddArg(destptr) + v0 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeInvalid) + v0.AuxInt = makeStoreConst(0, 16) + v0.AddArg(destptr) + v1 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeInvalid) + v1.AuxInt = makeStoreConst(0, 8) + v1.AddArg(destptr) + v2 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeInvalid) + v2.AuxInt = 0 + v2.AddArg(destptr) + v2.AddArg(mem) + v2.Type = TypeMem + v1.AddArg(v2) + v1.Type = TypeMem + v0.AddArg(v1) + v0.Type = TypeMem + v.AddArg(v0) + return true + } + goto end2c246614f6a9a07f1a683691b3f5780f +end2c246614f6a9a07f1a683691b3f5780f: + ; + // 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)) + { + size := v.AuxInt + destptr := v.Args[0] + mem := v.Args[1] + if !(size <= 1024 && size%8 == 0 && size%16 != 0) { + goto end240266449c3e493db1c3b38a78682ff0 + } + v.Op = OpZero + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = size - 8 + v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) + v0.AuxInt = 8 + v0.AddArg(destptr) + v0.Type = config.fe.TypeUInt64() + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64MOVQstore, TypeInvalid) + v1.AddArg(destptr) + v2 := b.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) + v2.AuxInt = 0 + v2.Type = config.fe.TypeUInt64() + v1.AddArg(v2) + v1.AddArg(mem) + v1.Type = TypeMem + v.AddArg(v1) + return true + } + goto end240266449c3e493db1c3b38a78682ff0 +end240266449c3e493db1c3b38a78682ff0: + ; + // match: (Zero [size] destptr mem) + // cond: size <= 1024 && size%16 == 0 + // result: (DUFFZERO [duffStart(size)] (ADDQconst [duffAdj(size)] destptr) (MOVOconst [0]) mem) + { + size := v.AuxInt + destptr := v.Args[0] + mem := v.Args[1] + if !(size <= 1024 && size%16 == 0) { + goto endf508bb887eee9119069b22c23dbca138 + } + v.Op = OpAMD64DUFFZERO + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = duffStart(size) + v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) + v0.AuxInt = duffAdj(size) + v0.AddArg(destptr) + v0.Type = config.fe.TypeUInt64() + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64MOVOconst, TypeInvalid) + v1.AuxInt = 0 + v1.Type = TypeInt128 + v.AddArg(v1) + v.AddArg(mem) + return true + } + goto endf508bb887eee9119069b22c23dbca138 +endf508bb887eee9119069b22c23dbca138: + ; + // match: (Zero [size] destptr mem) + // cond: size > 1024 && size%8 == 0 + // result: (REPSTOSQ destptr (MOVQconst [size/8]) (MOVQconst [0]) mem) + { + size := v.AuxInt + destptr := v.Args[0] + mem := v.Args[1] + if !(size > 1024 && size%8 == 0) { + goto endb9d55d4ba0e70ed918e3ac757727441b + } + v.Op = OpAMD64REPSTOSQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(destptr) + v0 := b.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) + v0.AuxInt = size / 8 + v0.Type = config.fe.TypeUInt64() + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) + v1.AuxInt = 0 + v1.Type = config.fe.TypeUInt64() + v.AddArg(v1) + v.AddArg(mem) + return true + } + goto endb9d55d4ba0e70ed918e3ac757727441b +endb9d55d4ba0e70ed918e3ac757727441b: + ; + return false +} +func rewriteValueAMD64_OpZeroExt16to32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (ZeroExt16to32 x) + // cond: + // result: (MOVWQZX x) + { + x := v.Args[0] + v.Op = OpAMD64MOVWQZX + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto endbfff79412a2cc96095069c66812844b4 +endbfff79412a2cc96095069c66812844b4: + ; + return false +} +func rewriteValueAMD64_OpZeroExt16to64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (ZeroExt16to64 x) + // cond: + // result: (MOVWQZX x) + { + x := v.Args[0] + v.Op = OpAMD64MOVWQZX + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end7a40262c5c856101058d2bd518ed0910 +end7a40262c5c856101058d2bd518ed0910: + ; + return false +} +func rewriteValueAMD64_OpZeroExt32to64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (ZeroExt32to64 x) + // cond: + // result: (MOVLQZX x) + { + x := v.Args[0] + v.Op = OpAMD64MOVLQZX + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto enddf83bdc8cc6c5673a9ef7aca7affe45a +enddf83bdc8cc6c5673a9ef7aca7affe45a: + ; + return false +} +func rewriteValueAMD64_OpZeroExt8to16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (ZeroExt8to16 x) + // cond: + // result: (MOVBQZX x) + { + x := v.Args[0] + v.Op = OpAMD64MOVBQZX + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto endd03d53d2a585727e4107ae1a3cc55479 +endd03d53d2a585727e4107ae1a3cc55479: + ; + return false +} +func rewriteValueAMD64_OpZeroExt8to32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (ZeroExt8to32 x) + // cond: + // result: (MOVBQZX x) + { + x := v.Args[0] + v.Op = OpAMD64MOVBQZX + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto endcbd33e965b3dab14fced5ae93d8949de +endcbd33e965b3dab14fced5ae93d8949de: + ; + return false +} +func rewriteValueAMD64_OpZeroExt8to64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (ZeroExt8to64 x) + // cond: + // result: (MOVBQZX x) + { + x := v.Args[0] + v.Op = OpAMD64MOVBQZX + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true } + goto end63ae7cc15db9d15189b2f1342604b2cb +end63ae7cc15db9d15189b2f1342604b2cb: + ; return false } func rewriteBlockAMD64(b *Block) bool { diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index 3bd017b74a..e30f17df9c 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -6,1716 +6,2058 @@ import "math" var _ = math.MinInt8 // in case not otherwise used func rewriteValuegeneric(v *Value, config *Config) bool { - b := v.Block switch v.Op { case OpAdd64: - // match: (Add64 (Const64 [c]) (Const64 [d])) - // cond: - // result: (Const64 [c+d]) - { - if v.Args[0].Op != OpConst64 { - goto end8c46df6f85a11cb1d594076b0e467908 - } - c := v.Args[0].AuxInt - if v.Args[1].Op != OpConst64 { - goto end8c46df6f85a11cb1d594076b0e467908 - } - d := v.Args[1].AuxInt - v.Op = OpConst64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c + d - return true - } - goto end8c46df6f85a11cb1d594076b0e467908 - end8c46df6f85a11cb1d594076b0e467908: - ; + return rewriteValuegeneric_OpAdd64(v, config) case OpAddPtr: - // match: (AddPtr (ConstPtr [c]) (ConstPtr [d])) - // cond: - // result: (ConstPtr [c+d]) - { - if v.Args[0].Op != OpConstPtr { - goto end145c1aec793b2befff34bc8983b48a38 - } - c := v.Args[0].AuxInt - if v.Args[1].Op != OpConstPtr { - goto end145c1aec793b2befff34bc8983b48a38 - } - d := v.Args[1].AuxInt - v.Op = OpConstPtr - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c + d - return true - } - goto end145c1aec793b2befff34bc8983b48a38 - end145c1aec793b2befff34bc8983b48a38: - ; + return rewriteValuegeneric_OpAddPtr(v, config) case OpAnd16: - // match: (And16 x x) - // cond: - // result: x - { - x := v.Args[0] - if v.Args[1] != x { - goto end69ed6ee2a4fb0491b56c17f3c1926b10 - } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = x.Type - v.AddArg(x) - return true - } - goto end69ed6ee2a4fb0491b56c17f3c1926b10 - end69ed6ee2a4fb0491b56c17f3c1926b10: - ; + return rewriteValuegeneric_OpAnd16(v, config) case OpAnd32: - // match: (And32 x x) - // cond: - // result: x - { - x := v.Args[0] - if v.Args[1] != x { - goto endbbe8c3c5b2ca8f013aa178d856f3a99c - } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = x.Type - v.AddArg(x) - return true - } - goto endbbe8c3c5b2ca8f013aa178d856f3a99c - endbbe8c3c5b2ca8f013aa178d856f3a99c: - ; + return rewriteValuegeneric_OpAnd32(v, config) case OpAnd64: - // match: (And64 x x) - // cond: - // result: x - { - x := v.Args[0] - if v.Args[1] != x { - goto endc9736bf24d2e5cd8d662e1bcf3164640 - } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = x.Type - v.AddArg(x) - return true - } - goto endc9736bf24d2e5cd8d662e1bcf3164640 - endc9736bf24d2e5cd8d662e1bcf3164640: - ; + return rewriteValuegeneric_OpAnd64(v, config) case OpAnd8: - // match: (And8 x x) - // cond: - // result: x - { - x := v.Args[0] - if v.Args[1] != x { - goto endeaf127389bd0d4b0e0e297830f8f463b - } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = x.Type - v.AddArg(x) - return true - } - goto endeaf127389bd0d4b0e0e297830f8f463b - endeaf127389bd0d4b0e0e297830f8f463b: - ; + return rewriteValuegeneric_OpAnd8(v, config) case OpArrayIndex: - // match: (ArrayIndex (Load ptr mem) idx) - // cond: b == v.Args[0].Block - // result: (Load (PtrIndex ptr idx) mem) - { - if v.Args[0].Op != OpLoad { - goto end68b373270d9d605c420497edefaa71df - } - ptr := v.Args[0].Args[0] - mem := v.Args[0].Args[1] - idx := v.Args[1] - if !(b == v.Args[0].Block) { - goto end68b373270d9d605c420497edefaa71df - } - v.Op = OpLoad - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpPtrIndex, TypeInvalid) - v0.Type = v.Type.PtrTo() - v0.AddArg(ptr) - v0.AddArg(idx) - v.AddArg(v0) - v.AddArg(mem) - return true - } - goto end68b373270d9d605c420497edefaa71df - end68b373270d9d605c420497edefaa71df: - ; + return rewriteValuegeneric_OpArrayIndex(v, config) case OpCom16: - // match: (Com16 (Com16 x)) - // cond: - // result: x - { - if v.Args[0].Op != OpCom16 { - goto end1ea17710dd4dd7ba4e710e0e4c7b5a56 - } - x := v.Args[0].Args[0] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = x.Type - v.AddArg(x) - return true - } - goto end1ea17710dd4dd7ba4e710e0e4c7b5a56 - end1ea17710dd4dd7ba4e710e0e4c7b5a56: - ; + return rewriteValuegeneric_OpCom16(v, config) case OpCom32: - // match: (Com32 (Com32 x)) - // cond: - // result: x - { - if v.Args[0].Op != OpCom32 { - goto end9a04ed536496e292c27bef4414128cbf - } - x := v.Args[0].Args[0] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = x.Type - v.AddArg(x) - return true - } - goto end9a04ed536496e292c27bef4414128cbf - end9a04ed536496e292c27bef4414128cbf: - ; + return rewriteValuegeneric_OpCom32(v, config) case OpCom64: - // match: (Com64 (Com64 x)) - // cond: - // result: x - { - if v.Args[0].Op != OpCom64 { - goto ended44e29d5968f0f7b86972b7bf417ab3 - } - x := v.Args[0].Args[0] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = x.Type - v.AddArg(x) - return true - } - goto ended44e29d5968f0f7b86972b7bf417ab3 - ended44e29d5968f0f7b86972b7bf417ab3: - ; + return rewriteValuegeneric_OpCom64(v, config) case OpCom8: - // match: (Com8 (Com8 x)) - // cond: - // result: x - { - if v.Args[0].Op != OpCom8 { - goto end4d92ff3ba567d9afd38fc9ca113602ad - } - x := v.Args[0].Args[0] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = x.Type - v.AddArg(x) - return true - } - goto end4d92ff3ba567d9afd38fc9ca113602ad - end4d92ff3ba567d9afd38fc9ca113602ad: - ; + return rewriteValuegeneric_OpCom8(v, config) case OpComplexImag: - // match: (ComplexImag (ComplexMake _ imag )) - // cond: - // result: imag - { - if v.Args[0].Op != OpComplexMake { - goto endec3009fd8727d03002021997936e091f - } - imag := v.Args[0].Args[1] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = imag.Type - v.AddArg(imag) - return true - } - goto endec3009fd8727d03002021997936e091f - endec3009fd8727d03002021997936e091f: - ; + return rewriteValuegeneric_OpComplexImag(v, config) case OpComplexReal: - // match: (ComplexReal (ComplexMake real _ )) - // cond: - // result: real - { - if v.Args[0].Op != OpComplexMake { - goto end8db3e16bd59af1adaa4b734c8adcc71d - } - real := v.Args[0].Args[0] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = real.Type - v.AddArg(real) - return true - } - goto end8db3e16bd59af1adaa4b734c8adcc71d - end8db3e16bd59af1adaa4b734c8adcc71d: - ; + return rewriteValuegeneric_OpComplexReal(v, config) case OpConstInterface: - // match: (ConstInterface) - // cond: - // result: (IMake (ConstNil ) (ConstNil )) - { - v.Op = OpIMake - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpConstNil, TypeInvalid) - v0.Type = config.fe.TypeBytePtr() - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpConstNil, TypeInvalid) - v1.Type = config.fe.TypeBytePtr() - v.AddArg(v1) - return true - } - goto end0367bd8f20a320cc41568f2b28657f6b - end0367bd8f20a320cc41568f2b28657f6b: - ; + return rewriteValuegeneric_OpConstInterface(v, config) case OpConstSlice: - // match: (ConstSlice) - // cond: - // result: (SliceMake (ConstNil ) (ConstPtr [0]) (ConstPtr [0])) - { - v.Op = OpSliceMake - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpConstNil, TypeInvalid) - v0.Type = config.fe.TypeBytePtr() - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpConstPtr, TypeInvalid) - v1.AuxInt = 0 - v1.Type = config.fe.TypeUintptr() - v.AddArg(v1) - v2 := b.NewValue0(v.Line, OpConstPtr, TypeInvalid) - v2.AuxInt = 0 - v2.Type = config.fe.TypeUintptr() - v.AddArg(v2) - return true - } - goto endc587abac76a5fd9b1284ba891a178e63 - endc587abac76a5fd9b1284ba891a178e63: - ; + return rewriteValuegeneric_OpConstSlice(v, config) case OpConstString: - // match: (ConstString {s}) - // cond: - // result: (StringMake (Addr {config.fe.StringData(s.(string))} (SB)) (ConstPtr [int64(len(s.(string)))])) - { - s := v.Aux - v.Op = OpStringMake - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpAddr, TypeInvalid) - v0.Type = config.fe.TypeBytePtr() - v0.Aux = config.fe.StringData(s.(string)) - v1 := b.NewValue0(v.Line, OpSB, TypeInvalid) - v1.Type = config.fe.TypeUintptr() - v0.AddArg(v1) - v.AddArg(v0) - v2 := b.NewValue0(v.Line, OpConstPtr, TypeInvalid) - v2.AuxInt = int64(len(s.(string))) - v2.Type = config.fe.TypeUintptr() - v.AddArg(v2) - return true - } - goto end2eb756398dd4c6b6d126012a26284c89 - end2eb756398dd4c6b6d126012a26284c89: - ; + return rewriteValuegeneric_OpConstString(v, config) case OpConvert: - // match: (Convert (Add64 (Convert ptr) off)) - // cond: - // result: (Add64 ptr off) - { - if v.Args[0].Op != OpAdd64 { - goto end913a7ecf456c00ffbee36c2dbbf0e1af - } - if v.Args[0].Args[0].Op != OpConvert { - goto end913a7ecf456c00ffbee36c2dbbf0e1af - } - ptr := v.Args[0].Args[0].Args[0] - off := v.Args[0].Args[1] - v.Op = OpAdd64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(ptr) - v.AddArg(off) - return true - } - goto end913a7ecf456c00ffbee36c2dbbf0e1af - end913a7ecf456c00ffbee36c2dbbf0e1af: - ; + return rewriteValuegeneric_OpConvert(v, config) case OpEq16: - // match: (Eq16 x x) - // cond: - // result: (ConstBool [1]) - { - x := v.Args[0] - if v.Args[1] != x { - goto end0c0fe5fdfba3821add3448fd3f1fc6b7 - } - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 1 - return true - } - goto end0c0fe5fdfba3821add3448fd3f1fc6b7 - end0c0fe5fdfba3821add3448fd3f1fc6b7: - ; + return rewriteValuegeneric_OpEq16(v, config) case OpEq32: - // match: (Eq32 x x) - // cond: - // result: (ConstBool [1]) - { - x := v.Args[0] - if v.Args[1] != x { - goto end6da547ec4ee93d787434f3bda873e4a0 - } - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 1 - return true - } - goto end6da547ec4ee93d787434f3bda873e4a0 - end6da547ec4ee93d787434f3bda873e4a0: - ; + return rewriteValuegeneric_OpEq32(v, config) case OpEq64: - // match: (Eq64 x x) - // cond: - // result: (ConstBool [1]) - { - x := v.Args[0] - if v.Args[1] != x { - goto endb1d471cc503ba8bb05440f01dbf33d81 - } - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 1 - return true - } - goto endb1d471cc503ba8bb05440f01dbf33d81 - endb1d471cc503ba8bb05440f01dbf33d81: - ; + return rewriteValuegeneric_OpEq64(v, config) case OpEq8: - // match: (Eq8 x x) - // cond: - // result: (ConstBool [1]) - { - x := v.Args[0] - if v.Args[1] != x { - goto enda66da0d3e7e51624ee46527727c48a9a - } - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 1 - return true - } - goto enda66da0d3e7e51624ee46527727c48a9a - enda66da0d3e7e51624ee46527727c48a9a: - ; + return rewriteValuegeneric_OpEq8(v, config) case OpEqInter: - // match: (EqInter x y) - // cond: - // result: (EqPtr (ITab x) (ITab y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpEqPtr - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpITab, TypeInvalid) - v0.AddArg(x) - v0.Type = config.fe.TypeUintptr() - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpITab, TypeInvalid) - v1.AddArg(y) - v1.Type = config.fe.TypeUintptr() - v.AddArg(v1) - return true - } - goto end1cc40483caab33ece971ab7e6c8fdfca - end1cc40483caab33ece971ab7e6c8fdfca: - ; + return rewriteValuegeneric_OpEqInter(v, config) case OpEqPtr: - // match: (EqPtr p (ConstNil)) - // cond: - // result: (Not (IsNonNil p)) - { - p := v.Args[0] - if v.Args[1].Op != OpConstNil { - goto ende701cdb6a2c1fff4d4b283b7f8f6178b - } - v.Op = OpNot - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpIsNonNil, TypeInvalid) - v0.AddArg(p) - v0.Type = config.fe.TypeBool() - v.AddArg(v0) - return true - } - goto ende701cdb6a2c1fff4d4b283b7f8f6178b - ende701cdb6a2c1fff4d4b283b7f8f6178b: - ; - // match: (EqPtr (ConstNil) p) - // cond: - // result: (Not (IsNonNil p)) - { - if v.Args[0].Op != OpConstNil { - goto end7cdc0d5c38fbffe6287c8928803b038e - } - p := v.Args[1] - v.Op = OpNot - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpIsNonNil, TypeInvalid) - v0.AddArg(p) - v0.Type = config.fe.TypeBool() - v.AddArg(v0) - return true - } - goto end7cdc0d5c38fbffe6287c8928803b038e - end7cdc0d5c38fbffe6287c8928803b038e: - ; + return rewriteValuegeneric_OpEqPtr(v, config) case OpEqSlice: - // match: (EqSlice x y) - // cond: - // result: (EqPtr (SlicePtr x) (SlicePtr y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpEqPtr - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpSlicePtr, TypeInvalid) - v0.AddArg(x) - v0.Type = config.fe.TypeUintptr() - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpSlicePtr, TypeInvalid) - v1.AddArg(y) - v1.Type = config.fe.TypeUintptr() - v.AddArg(v1) - return true - } - goto end9cd53ca57ee90aa09c54f8071c8e8769 - end9cd53ca57ee90aa09c54f8071c8e8769: - ; + return rewriteValuegeneric_OpEqSlice(v, config) case OpIData: - // match: (IData (IMake _ data)) - // cond: - // result: data - { - if v.Args[0].Op != OpIMake { - goto endbfa1bb944cdc07933effb16a35152e12 - } - data := v.Args[0].Args[1] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = data.Type - v.AddArg(data) - return true - } - goto endbfa1bb944cdc07933effb16a35152e12 - endbfa1bb944cdc07933effb16a35152e12: - ; + return rewriteValuegeneric_OpIData(v, config) case OpITab: - // match: (ITab (IMake itab _)) - // cond: - // result: itab - { - if v.Args[0].Op != OpIMake { - goto endfcbb9414a776ff9c8512da3e0f4d8fbd - } - itab := v.Args[0].Args[0] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = itab.Type - v.AddArg(itab) - return true - } - goto endfcbb9414a776ff9c8512da3e0f4d8fbd - endfcbb9414a776ff9c8512da3e0f4d8fbd: - ; + return rewriteValuegeneric_OpITab(v, config) case OpIsInBounds: - // match: (IsInBounds (Const32 [c]) (Const32 [d])) - // cond: - // result: (ConstBool [b2i(inBounds32(c,d))]) - { - if v.Args[0].Op != OpConst32 { - goto endf0a2ecfe84b293de6ff0919e45d19d9d - } - c := v.Args[0].AuxInt - if v.Args[1].Op != OpConst32 { - goto endf0a2ecfe84b293de6ff0919e45d19d9d - } - d := v.Args[1].AuxInt - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = b2i(inBounds32(c, d)) - return true - } - goto endf0a2ecfe84b293de6ff0919e45d19d9d - endf0a2ecfe84b293de6ff0919e45d19d9d: - ; - // match: (IsInBounds (Const64 [c]) (Const64 [d])) - // cond: - // result: (ConstBool [b2i(inBounds64(c,d))]) - { - if v.Args[0].Op != OpConst64 { - goto end4b406f402c135f50f71effcc904ecb2b - } - c := v.Args[0].AuxInt - if v.Args[1].Op != OpConst64 { - goto end4b406f402c135f50f71effcc904ecb2b - } - d := v.Args[1].AuxInt - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = b2i(inBounds64(c, d)) - return true - } - goto end4b406f402c135f50f71effcc904ecb2b - end4b406f402c135f50f71effcc904ecb2b: - ; - // match: (IsInBounds (ConstPtr [c]) (ConstPtr [d])) - // cond: config.PtrSize == 4 - // result: (ConstBool [b2i(inBounds32(c,d))]) - { - if v.Args[0].Op != OpConstPtr { - goto end4323278ec7a053034fcf7033697d7b3b - } - c := v.Args[0].AuxInt - if v.Args[1].Op != OpConstPtr { - goto end4323278ec7a053034fcf7033697d7b3b - } - d := v.Args[1].AuxInt - if !(config.PtrSize == 4) { - goto end4323278ec7a053034fcf7033697d7b3b - } - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = b2i(inBounds32(c, d)) - return true - } - goto end4323278ec7a053034fcf7033697d7b3b - end4323278ec7a053034fcf7033697d7b3b: - ; - // match: (IsInBounds (ConstPtr [c]) (ConstPtr [d])) - // cond: config.PtrSize == 8 - // result: (ConstBool [b2i(inBounds64(c,d))]) - { - if v.Args[0].Op != OpConstPtr { - goto endb550b8814df20b5eeda4f43cc94e902b - } - c := v.Args[0].AuxInt - if v.Args[1].Op != OpConstPtr { - goto endb550b8814df20b5eeda4f43cc94e902b - } - d := v.Args[1].AuxInt - if !(config.PtrSize == 8) { - goto endb550b8814df20b5eeda4f43cc94e902b - } - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = b2i(inBounds64(c, d)) - return true - } - goto endb550b8814df20b5eeda4f43cc94e902b - endb550b8814df20b5eeda4f43cc94e902b: - ; + return rewriteValuegeneric_OpIsInBounds(v, config) case OpLoad: - // match: (Load ptr mem) - // cond: t.IsComplex() && t.Size() == 8 - // result: (ComplexMake (Load ptr mem) (Load (OffPtr [4] ptr) mem) ) - { - t := v.Type - ptr := v.Args[0] - mem := v.Args[1] - if !(t.IsComplex() && t.Size() == 8) { - goto end665854b31b828893d90b36bb462ff381 - } - v.Op = OpComplexMake - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpLoad, TypeInvalid) - v0.Type = config.fe.TypeFloat32() - v0.AddArg(ptr) - v0.AddArg(mem) - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpLoad, TypeInvalid) - v1.Type = config.fe.TypeFloat32() - v2 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v2.Type = config.fe.TypeFloat32().PtrTo() - v2.AuxInt = 4 - v2.AddArg(ptr) - v1.AddArg(v2) - v1.AddArg(mem) - v.AddArg(v1) - return true - } - goto end665854b31b828893d90b36bb462ff381 - end665854b31b828893d90b36bb462ff381: - ; - // match: (Load ptr mem) - // cond: t.IsComplex() && t.Size() == 16 - // result: (ComplexMake (Load ptr mem) (Load (OffPtr [8] ptr) mem) ) - { - t := v.Type - ptr := v.Args[0] - mem := v.Args[1] - if !(t.IsComplex() && t.Size() == 16) { - goto end1b106f89e0e3e26c613b957a7c98d8ad - } - v.Op = OpComplexMake - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpLoad, TypeInvalid) - v0.Type = config.fe.TypeFloat64() - v0.AddArg(ptr) - v0.AddArg(mem) - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpLoad, TypeInvalid) - v1.Type = config.fe.TypeFloat64() - v2 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v2.Type = config.fe.TypeFloat64().PtrTo() - v2.AuxInt = 8 - v2.AddArg(ptr) - v1.AddArg(v2) - v1.AddArg(mem) - v.AddArg(v1) - return true - } - goto end1b106f89e0e3e26c613b957a7c98d8ad - end1b106f89e0e3e26c613b957a7c98d8ad: - ; - // match: (Load ptr mem) - // cond: t.IsString() - // result: (StringMake (Load ptr mem) (Load (OffPtr [config.PtrSize] ptr) mem)) - { - t := v.Type - ptr := v.Args[0] - mem := v.Args[1] - if !(t.IsString()) { - goto end7c75255555bf9dd796298d9f6eaf9cf2 - } - v.Op = OpStringMake - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpLoad, TypeInvalid) - v0.Type = config.fe.TypeBytePtr() - v0.AddArg(ptr) - v0.AddArg(mem) - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpLoad, TypeInvalid) - v1.Type = config.fe.TypeUintptr() - v2 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v2.Type = config.fe.TypeUintptr().PtrTo() - v2.AuxInt = config.PtrSize - v2.AddArg(ptr) - v1.AddArg(v2) - v1.AddArg(mem) - v.AddArg(v1) - return true - } - goto end7c75255555bf9dd796298d9f6eaf9cf2 - end7c75255555bf9dd796298d9f6eaf9cf2: - ; - // match: (Load ptr mem) - // cond: t.IsSlice() - // result: (SliceMake (Load ptr mem) (Load (OffPtr [config.PtrSize] ptr) mem) (Load (OffPtr [2*config.PtrSize] ptr) mem)) - { - t := v.Type - ptr := v.Args[0] - mem := v.Args[1] - if !(t.IsSlice()) { - goto end12c46556d962198680eb3238859e3016 - } - v.Op = OpSliceMake - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpLoad, TypeInvalid) - v0.Type = config.fe.TypeBytePtr() - v0.AddArg(ptr) - v0.AddArg(mem) - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpLoad, TypeInvalid) - v1.Type = config.fe.TypeUintptr() - v2 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v2.Type = config.fe.TypeUintptr().PtrTo() - v2.AuxInt = config.PtrSize - v2.AddArg(ptr) - v1.AddArg(v2) - v1.AddArg(mem) - v.AddArg(v1) - v3 := b.NewValue0(v.Line, OpLoad, TypeInvalid) - v3.Type = config.fe.TypeUintptr() - v4 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v4.Type = config.fe.TypeUintptr().PtrTo() - v4.AuxInt = 2 * config.PtrSize - v4.AddArg(ptr) - v3.AddArg(v4) - v3.AddArg(mem) - v.AddArg(v3) - return true - } - goto end12c46556d962198680eb3238859e3016 - end12c46556d962198680eb3238859e3016: - ; - // match: (Load ptr mem) - // cond: t.IsInterface() - // result: (IMake (Load ptr mem) (Load (OffPtr [config.PtrSize] ptr) mem)) - { - t := v.Type - ptr := v.Args[0] - mem := v.Args[1] - if !(t.IsInterface()) { - goto end12671c83ebe3ccbc8e53383765ee7675 - } - v.Op = OpIMake - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpLoad, TypeInvalid) - v0.Type = config.fe.TypeBytePtr() - v0.AddArg(ptr) - v0.AddArg(mem) - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpLoad, TypeInvalid) - v1.Type = config.fe.TypeBytePtr() - v2 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v2.Type = config.fe.TypeBytePtr().PtrTo() - v2.AuxInt = config.PtrSize - v2.AddArg(ptr) - v1.AddArg(v2) - v1.AddArg(mem) - v.AddArg(v1) - return true - } - goto end12671c83ebe3ccbc8e53383765ee7675 - end12671c83ebe3ccbc8e53383765ee7675: - ; + return rewriteValuegeneric_OpLoad(v, config) case OpMul64: - // match: (Mul64 (Const64 [c]) (Const64 [d])) - // cond: - // result: (Const64 [c*d]) - { - if v.Args[0].Op != OpConst64 { - goto end7aea1048b5d1230974b97f17238380ae - } - c := v.Args[0].AuxInt - if v.Args[1].Op != OpConst64 { - goto end7aea1048b5d1230974b97f17238380ae - } - d := v.Args[1].AuxInt - v.Op = OpConst64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c * d - return true - } - goto end7aea1048b5d1230974b97f17238380ae - end7aea1048b5d1230974b97f17238380ae: - ; + return rewriteValuegeneric_OpMul64(v, config) case OpMulPtr: - // match: (MulPtr (ConstPtr [c]) (ConstPtr [d])) - // cond: - // result: (ConstPtr [c*d]) - { - if v.Args[0].Op != OpConstPtr { - goto end808c190f346658bb1ad032bf37a1059f - } - c := v.Args[0].AuxInt - if v.Args[1].Op != OpConstPtr { - goto end808c190f346658bb1ad032bf37a1059f - } - d := v.Args[1].AuxInt - v.Op = OpConstPtr - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = c * d - return true - } - goto end808c190f346658bb1ad032bf37a1059f - end808c190f346658bb1ad032bf37a1059f: - ; + return rewriteValuegeneric_OpMulPtr(v, config) case OpNeq16: - // match: (Neq16 x x) - // cond: - // result: (ConstBool [0]) - { - x := v.Args[0] - if v.Args[1] != x { - goto ende76a50b524aeb16c7aeccf5f5cc60c06 - } - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 0 - return true - } - goto ende76a50b524aeb16c7aeccf5f5cc60c06 - ende76a50b524aeb16c7aeccf5f5cc60c06: - ; + return rewriteValuegeneric_OpNeq16(v, config) case OpNeq32: - // match: (Neq32 x x) - // cond: - // result: (ConstBool [0]) - { - x := v.Args[0] - if v.Args[1] != x { - goto end3713a608cffd29b40ff7c3b3f2585cbb - } - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 0 - return true - } - goto end3713a608cffd29b40ff7c3b3f2585cbb - end3713a608cffd29b40ff7c3b3f2585cbb: - ; + return rewriteValuegeneric_OpNeq32(v, config) case OpNeq64: - // match: (Neq64 x x) - // cond: - // result: (ConstBool [0]) - { - x := v.Args[0] - if v.Args[1] != x { - goto end3601ad382705ea12b79d2008c1e5725c - } - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 0 - return true - } - goto end3601ad382705ea12b79d2008c1e5725c - end3601ad382705ea12b79d2008c1e5725c: - ; + return rewriteValuegeneric_OpNeq64(v, config) case OpNeq8: - // match: (Neq8 x x) - // cond: - // result: (ConstBool [0]) - { - x := v.Args[0] - if v.Args[1] != x { - goto end09a0deaf3c42627d0d2d3efa96e30745 - } - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 0 - return true - } - goto end09a0deaf3c42627d0d2d3efa96e30745 - end09a0deaf3c42627d0d2d3efa96e30745: - ; + return rewriteValuegeneric_OpNeq8(v, config) case OpNeqInter: - // match: (NeqInter x y) - // cond: - // result: (NeqPtr (ITab x) (ITab y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpNeqPtr - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpITab, TypeInvalid) - v0.AddArg(x) - v0.Type = config.fe.TypeUintptr() - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpITab, TypeInvalid) - v1.AddArg(y) - v1.Type = config.fe.TypeUintptr() - v.AddArg(v1) - return true - } - goto end17b2333bf57e9fe81a671be02f9c4c14 - end17b2333bf57e9fe81a671be02f9c4c14: - ; + return rewriteValuegeneric_OpNeqInter(v, config) case OpNeqPtr: - // match: (NeqPtr p (ConstNil)) - // cond: - // result: (IsNonNil p) - { - p := v.Args[0] - if v.Args[1].Op != OpConstNil { - goto endba798520b4d41172b110347158c44791 - } - v.Op = OpIsNonNil - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(p) - return true - } - goto endba798520b4d41172b110347158c44791 - endba798520b4d41172b110347158c44791: - ; - // match: (NeqPtr (ConstNil) p) - // cond: - // result: (IsNonNil p) - { - if v.Args[0].Op != OpConstNil { - goto enddd95e9c3606d9fd48034f1a703561e45 - } - p := v.Args[1] - v.Op = OpIsNonNil - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(p) - return true - } - goto enddd95e9c3606d9fd48034f1a703561e45 - enddd95e9c3606d9fd48034f1a703561e45: - ; + return rewriteValuegeneric_OpNeqPtr(v, config) case OpNeqSlice: - // match: (NeqSlice x y) - // cond: - // result: (NeqPtr (SlicePtr x) (SlicePtr y)) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpNeqPtr - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v0 := b.NewValue0(v.Line, OpSlicePtr, TypeInvalid) - v0.AddArg(x) - v0.Type = config.fe.TypeUintptr() - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpSlicePtr, TypeInvalid) - v1.AddArg(y) - v1.Type = config.fe.TypeUintptr() - v.AddArg(v1) - return true - } - goto endc6bc83c506e491236ca66ea1081231a2 - endc6bc83c506e491236ca66ea1081231a2: - ; + return rewriteValuegeneric_OpNeqSlice(v, config) case OpOr16: - // match: (Or16 x x) - // cond: - // result: x - { - x := v.Args[0] - if v.Args[1] != x { - goto end47a2f25fd31a76807aced3e2b126acdc - } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = x.Type - v.AddArg(x) - return true - } - goto end47a2f25fd31a76807aced3e2b126acdc - end47a2f25fd31a76807aced3e2b126acdc: - ; + return rewriteValuegeneric_OpOr16(v, config) case OpOr32: - // match: (Or32 x x) - // cond: - // result: x - { - x := v.Args[0] - if v.Args[1] != x { - goto end231e283e568e90bd9a3e6a4fa328c8a4 - } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = x.Type - v.AddArg(x) - return true - } - goto end231e283e568e90bd9a3e6a4fa328c8a4 - end231e283e568e90bd9a3e6a4fa328c8a4: - ; + return rewriteValuegeneric_OpOr32(v, config) case OpOr64: - // match: (Or64 x x) - // cond: - // result: x - { - x := v.Args[0] - if v.Args[1] != x { - goto end6b0efc212016dc97d0e3939db04c81d9 - } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = x.Type - v.AddArg(x) - return true - } - goto end6b0efc212016dc97d0e3939db04c81d9 - end6b0efc212016dc97d0e3939db04c81d9: - ; + return rewriteValuegeneric_OpOr64(v, config) case OpOr8: - // match: (Or8 x x) - // cond: - // result: x - { - x := v.Args[0] - if v.Args[1] != x { - goto end05295dbfafd6869af79b4daee9fda000 - } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = x.Type - v.AddArg(x) - return true - } - goto end05295dbfafd6869af79b4daee9fda000 - end05295dbfafd6869af79b4daee9fda000: - ; + return rewriteValuegeneric_OpOr8(v, config) case OpPtrIndex: - // match: (PtrIndex ptr idx) - // cond: - // result: (AddPtr ptr (MulPtr idx (ConstPtr [t.Elem().Size()]))) - { - t := v.Type - ptr := v.Args[0] - idx := v.Args[1] - v.Op = OpAddPtr - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(ptr) - v0 := b.NewValue0(v.Line, OpMulPtr, TypeInvalid) - v0.AddArg(idx) - v1 := b.NewValue0(v.Line, OpConstPtr, TypeInvalid) - v1.AuxInt = t.Elem().Size() - v1.Type = config.fe.TypeUintptr() - v0.AddArg(v1) - v0.Type = config.fe.TypeUintptr() - v.AddArg(v0) - return true - } - goto end502555083d57a877982955070cda7530 - end502555083d57a877982955070cda7530: - ; + return rewriteValuegeneric_OpPtrIndex(v, config) case OpSliceCap: - // match: (SliceCap (SliceMake _ _ cap)) - // cond: - // result: cap - { - if v.Args[0].Op != OpSliceMake { - goto end1bd11616743632b33b410964667fb3c6 - } - cap := v.Args[0].Args[2] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = cap.Type - v.AddArg(cap) - return true - } - goto end1bd11616743632b33b410964667fb3c6 - end1bd11616743632b33b410964667fb3c6: - ; + return rewriteValuegeneric_OpSliceCap(v, config) case OpSliceLen: - // match: (SliceLen (SliceMake _ len _)) - // cond: - // result: len - { - if v.Args[0].Op != OpSliceMake { - goto endebb2090199d13e4c2ae52fb3e778f7fd - } - len := v.Args[0].Args[1] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = len.Type - v.AddArg(len) - return true - } - goto endebb2090199d13e4c2ae52fb3e778f7fd - endebb2090199d13e4c2ae52fb3e778f7fd: - ; + return rewriteValuegeneric_OpSliceLen(v, config) case OpSlicePtr: - // match: (SlicePtr (SliceMake ptr _ _ )) - // cond: - // result: ptr - { - if v.Args[0].Op != OpSliceMake { - goto end526acc0a705137a5d25577499206720b - } - ptr := v.Args[0].Args[0] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = ptr.Type - v.AddArg(ptr) - return true - } - goto end526acc0a705137a5d25577499206720b - end526acc0a705137a5d25577499206720b: - ; + return rewriteValuegeneric_OpSlicePtr(v, config) case OpStore: - // match: (Store [8] dst (ComplexMake real imag) mem) - // cond: - // result: (Store [4] (OffPtr [4] dst) imag (Store [4] dst real mem)) - { - if v.AuxInt != 8 { - goto endced898cb0a165662afe48ea44ad3318a - } - dst := v.Args[0] - if v.Args[1].Op != OpComplexMake { - goto endced898cb0a165662afe48ea44ad3318a - } - real := v.Args[1].Args[0] - imag := v.Args[1].Args[1] - mem := v.Args[2] - v.Op = OpStore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 4 - v0 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v0.Type = config.fe.TypeFloat32().PtrTo() - v0.AuxInt = 4 - v0.AddArg(dst) - v.AddArg(v0) - v.AddArg(imag) - v1 := b.NewValue0(v.Line, OpStore, TypeInvalid) - v1.AuxInt = 4 - v1.AddArg(dst) - v1.AddArg(real) - v1.AddArg(mem) - v1.Type = TypeMem - v.AddArg(v1) - return true - } - goto endced898cb0a165662afe48ea44ad3318a - endced898cb0a165662afe48ea44ad3318a: - ; - // match: (Store [16] dst (ComplexMake real imag) mem) - // cond: - // result: (Store [8] (OffPtr [8] dst) imag (Store [8] dst real mem)) - { - if v.AuxInt != 16 { - goto end3851a482d7bd37a93c4d81581e85b3ab - } - dst := v.Args[0] - if v.Args[1].Op != OpComplexMake { - goto end3851a482d7bd37a93c4d81581e85b3ab - } - real := v.Args[1].Args[0] - imag := v.Args[1].Args[1] - mem := v.Args[2] - v.Op = OpStore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 8 - v0 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v0.Type = config.fe.TypeFloat64().PtrTo() - v0.AuxInt = 8 - v0.AddArg(dst) - v.AddArg(v0) - v.AddArg(imag) - v1 := b.NewValue0(v.Line, OpStore, TypeInvalid) - v1.AuxInt = 8 - v1.AddArg(dst) - v1.AddArg(real) - v1.AddArg(mem) - v1.Type = TypeMem - v.AddArg(v1) - return true - } - goto end3851a482d7bd37a93c4d81581e85b3ab - end3851a482d7bd37a93c4d81581e85b3ab: - ; - // match: (Store [2*config.PtrSize] dst (StringMake ptr len) mem) - // cond: - // result: (Store [config.PtrSize] (OffPtr [config.PtrSize] dst) len (Store [config.PtrSize] dst ptr mem)) - { - if v.AuxInt != 2*config.PtrSize { - goto end12abe4021d24e76ed56d64b18730bffb - } - dst := v.Args[0] - if v.Args[1].Op != OpStringMake { - goto end12abe4021d24e76ed56d64b18730bffb - } - ptr := v.Args[1].Args[0] - len := v.Args[1].Args[1] - mem := v.Args[2] - v.Op = OpStore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = config.PtrSize - v0 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v0.Type = config.fe.TypeUintptr().PtrTo() - v0.AuxInt = config.PtrSize - v0.AddArg(dst) - v.AddArg(v0) - v.AddArg(len) - v1 := b.NewValue0(v.Line, OpStore, TypeInvalid) - v1.AuxInt = config.PtrSize - v1.AddArg(dst) - v1.AddArg(ptr) - v1.AddArg(mem) - v1.Type = TypeMem - v.AddArg(v1) - return true - } - goto end12abe4021d24e76ed56d64b18730bffb - end12abe4021d24e76ed56d64b18730bffb: - ; - // match: (Store [3*config.PtrSize] dst (SliceMake ptr len cap) mem) - // cond: - // result: (Store [config.PtrSize] (OffPtr [2*config.PtrSize] dst) cap (Store [config.PtrSize] (OffPtr [config.PtrSize] dst) len (Store [config.PtrSize] dst ptr mem))) - { - if v.AuxInt != 3*config.PtrSize { - goto end7498d25e17db5398cf073a8590e35cc2 - } - dst := v.Args[0] - if v.Args[1].Op != OpSliceMake { - goto end7498d25e17db5398cf073a8590e35cc2 - } - ptr := v.Args[1].Args[0] - len := v.Args[1].Args[1] - cap := v.Args[1].Args[2] - mem := v.Args[2] - v.Op = OpStore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = config.PtrSize - v0 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v0.Type = config.fe.TypeUintptr().PtrTo() - v0.AuxInt = 2 * config.PtrSize - v0.AddArg(dst) - v.AddArg(v0) - v.AddArg(cap) - v1 := b.NewValue0(v.Line, OpStore, TypeInvalid) - v1.AuxInt = config.PtrSize - v2 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v2.Type = config.fe.TypeUintptr().PtrTo() - v2.AuxInt = config.PtrSize - v2.AddArg(dst) - v1.AddArg(v2) - v1.AddArg(len) - v3 := b.NewValue0(v.Line, OpStore, TypeInvalid) - v3.AuxInt = config.PtrSize - v3.AddArg(dst) - v3.AddArg(ptr) - v3.AddArg(mem) - v3.Type = TypeMem - v1.AddArg(v3) - v1.Type = TypeMem - v.AddArg(v1) - return true - } - goto end7498d25e17db5398cf073a8590e35cc2 - end7498d25e17db5398cf073a8590e35cc2: - ; - // match: (Store [2*config.PtrSize] dst (IMake itab data) mem) - // cond: - // result: (Store [config.PtrSize] (OffPtr [config.PtrSize] dst) data (Store [config.PtrSize] dst itab mem)) - { - if v.AuxInt != 2*config.PtrSize { - goto endaa801a871178ae3256b3f6f5d9f13514 - } - dst := v.Args[0] - if v.Args[1].Op != OpIMake { - goto endaa801a871178ae3256b3f6f5d9f13514 - } - itab := v.Args[1].Args[0] - data := v.Args[1].Args[1] - mem := v.Args[2] - v.Op = OpStore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = config.PtrSize - v0 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v0.Type = config.fe.TypeBytePtr().PtrTo() - v0.AuxInt = config.PtrSize - v0.AddArg(dst) - v.AddArg(v0) - v.AddArg(data) - v1 := b.NewValue0(v.Line, OpStore, TypeInvalid) - v1.AuxInt = config.PtrSize - v1.AddArg(dst) - v1.AddArg(itab) - v1.AddArg(mem) - v1.Type = TypeMem - v.AddArg(v1) - return true - } - goto endaa801a871178ae3256b3f6f5d9f13514 - endaa801a871178ae3256b3f6f5d9f13514: - ; - // match: (Store [size] dst (Load src mem) mem) - // cond: !config.fe.CanSSA(t) - // result: (Move [size] dst src mem) - { - size := v.AuxInt - dst := v.Args[0] - if v.Args[1].Op != OpLoad { - goto end45295326269ba18413dceb7b608a0b9d - } - t := v.Args[1].Type - src := v.Args[1].Args[0] - mem := v.Args[1].Args[1] - if v.Args[2] != mem { - goto end45295326269ba18413dceb7b608a0b9d - } - if !(!config.fe.CanSSA(t)) { - goto end45295326269ba18413dceb7b608a0b9d - } - v.Op = OpMove - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = size - v.AddArg(dst) - v.AddArg(src) - v.AddArg(mem) - return true - } - goto end45295326269ba18413dceb7b608a0b9d - end45295326269ba18413dceb7b608a0b9d: - ; - // match: (Store [size] dst (Load src mem) (VarDef {x} mem)) - // cond: !config.fe.CanSSA(t) - // result: (Move [size] dst src (VarDef {x} mem)) - { - size := v.AuxInt - dst := v.Args[0] - if v.Args[1].Op != OpLoad { - goto end7f3cc0baffb82ba3ee879599b189a512 - } - t := v.Args[1].Type - src := v.Args[1].Args[0] - mem := v.Args[1].Args[1] - if v.Args[2].Op != OpVarDef { - goto end7f3cc0baffb82ba3ee879599b189a512 - } - x := v.Args[2].Aux - if v.Args[2].Args[0] != mem { - goto end7f3cc0baffb82ba3ee879599b189a512 - } - if !(!config.fe.CanSSA(t)) { - goto end7f3cc0baffb82ba3ee879599b189a512 - } - v.Op = OpMove - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = size - v.AddArg(dst) - v.AddArg(src) - v0 := b.NewValue0(v.Line, OpVarDef, TypeInvalid) - v0.Aux = x - v0.AddArg(mem) - v0.Type = TypeMem - v.AddArg(v0) - return true - } - goto end7f3cc0baffb82ba3ee879599b189a512 - end7f3cc0baffb82ba3ee879599b189a512: - ; + return rewriteValuegeneric_OpStore(v, config) case OpStringLen: - // match: (StringLen (StringMake _ len)) - // cond: - // result: len - { - if v.Args[0].Op != OpStringMake { - goto end0d922460b7e5ca88324034f4bd6c027c - } - len := v.Args[0].Args[1] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = len.Type - v.AddArg(len) - return true - } - goto end0d922460b7e5ca88324034f4bd6c027c - end0d922460b7e5ca88324034f4bd6c027c: - ; + return rewriteValuegeneric_OpStringLen(v, config) case OpStringPtr: - // match: (StringPtr (StringMake ptr _)) - // cond: - // result: ptr - { - if v.Args[0].Op != OpStringMake { - goto end061edc5d85c73ad909089af2556d9380 - } - ptr := v.Args[0].Args[0] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.Type = ptr.Type - v.AddArg(ptr) - return true - } - goto end061edc5d85c73ad909089af2556d9380 - end061edc5d85c73ad909089af2556d9380: - ; + return rewriteValuegeneric_OpStringPtr(v, config) case OpStructSelect: - // match: (StructSelect [idx] (Load ptr mem)) - // cond: - // result: @v.Args[0].Block (Load (OffPtr [idx] ptr) mem) - { - idx := v.AuxInt - if v.Args[0].Op != OpLoad { - goto end27abc5bf0299ce1bd5457af6ce8e3fba - } - ptr := v.Args[0].Args[0] - mem := v.Args[0].Args[1] - v0 := v.Args[0].Block.NewValue0(v.Line, OpLoad, TypeInvalid) - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(v0) - v0.Type = v.Type - v1 := v.Args[0].Block.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v1.Type = v.Type.PtrTo() - v1.AuxInt = idx - v1.AddArg(ptr) - v0.AddArg(v1) - v0.AddArg(mem) - return true - } - goto end27abc5bf0299ce1bd5457af6ce8e3fba - end27abc5bf0299ce1bd5457af6ce8e3fba: - ; + return rewriteValuegeneric_OpStructSelect(v, config) case OpSub16: - // match: (Sub16 x x) - // cond: - // result: (Const16 [0]) - { - x := v.Args[0] - if v.Args[1] != x { - goto end83da541391be564f2a08464e674a49e7 - } - v.Op = OpConst16 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 0 - return true - } - goto end83da541391be564f2a08464e674a49e7 - end83da541391be564f2a08464e674a49e7: - ; + return rewriteValuegeneric_OpSub16(v, config) case OpSub32: - // match: (Sub32 x x) - // cond: - // result: (Const32 [0]) - { - x := v.Args[0] - if v.Args[1] != x { - goto enda747581e798f199e07f4ad69747cd069 - } - v.Op = OpConst32 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 0 - return true - } - goto enda747581e798f199e07f4ad69747cd069 - enda747581e798f199e07f4ad69747cd069: - ; + return rewriteValuegeneric_OpSub32(v, config) case OpSub64: - // match: (Sub64 x x) - // cond: - // result: (Const64 [0]) - { - x := v.Args[0] - if v.Args[1] != x { - goto end0387dc2b7bbe57d4aa54eab5d959da4b - } - v.Op = OpConst64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 0 - return true - } - goto end0387dc2b7bbe57d4aa54eab5d959da4b - end0387dc2b7bbe57d4aa54eab5d959da4b: - ; + return rewriteValuegeneric_OpSub64(v, config) case OpSub8: - // match: (Sub8 x x) - // cond: - // result: (Const8 [0]) - { - x := v.Args[0] - if v.Args[1] != x { - goto end4e2ee15ef17611919a1a6b5f80bbfe18 - } - v.Op = OpConst8 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 0 - return true - } - goto end4e2ee15ef17611919a1a6b5f80bbfe18 - end4e2ee15ef17611919a1a6b5f80bbfe18: - ; + return rewriteValuegeneric_OpSub8(v, config) case OpXor16: - // match: (Xor16 x x) - // cond: - // result: (Const16 [0]) - { - x := v.Args[0] - if v.Args[1] != x { - goto end5733ceb1903b8140248d8e2cac02fefe - } - v.Op = OpConst16 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 0 - return true - } - goto end5733ceb1903b8140248d8e2cac02fefe - end5733ceb1903b8140248d8e2cac02fefe: - ; + return rewriteValuegeneric_OpXor16(v, config) case OpXor32: - // match: (Xor32 x x) - // cond: - // result: (Const32 [0]) - { - x := v.Args[0] - if v.Args[1] != x { - goto end268ca02df6515d648e0bfb4e90981d25 - } - v.Op = OpConst32 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 0 - return true - } - goto end268ca02df6515d648e0bfb4e90981d25 - end268ca02df6515d648e0bfb4e90981d25: - ; + return rewriteValuegeneric_OpXor32(v, config) case OpXor64: - // match: (Xor64 x x) - // cond: - // result: (Const64 [0]) - { - x := v.Args[0] - if v.Args[1] != x { - goto endaf44e7f9fc58af30df69070953fb45ce - } - v.Op = OpConst64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 0 - return true - } - goto endaf44e7f9fc58af30df69070953fb45ce - endaf44e7f9fc58af30df69070953fb45ce: - ; + return rewriteValuegeneric_OpXor64(v, config) case OpXor8: - // match: (Xor8 x x) - // cond: - // result: (Const8 [0]) - { - x := v.Args[0] - if v.Args[1] != x { - goto end949b3a60b7d181688e6f79f93c782fc8 - } - v.Op = OpConst8 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = 0 - return true - } - goto end949b3a60b7d181688e6f79f93c782fc8 - end949b3a60b7d181688e6f79f93c782fc8: + return rewriteValuegeneric_OpXor8(v, config) + } + 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]) + { + if v.Args[0].Op != OpConst64 { + goto end8c46df6f85a11cb1d594076b0e467908 + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst64 { + goto end8c46df6f85a11cb1d594076b0e467908 + } + d := v.Args[1].AuxInt + v.Op = OpConst64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + d + return true + } + goto end8c46df6f85a11cb1d594076b0e467908 +end8c46df6f85a11cb1d594076b0e467908: + ; + return false +} +func rewriteValuegeneric_OpAddPtr(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (AddPtr (ConstPtr [c]) (ConstPtr [d])) + // cond: + // result: (ConstPtr [c+d]) + { + if v.Args[0].Op != OpConstPtr { + goto end145c1aec793b2befff34bc8983b48a38 + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConstPtr { + goto end145c1aec793b2befff34bc8983b48a38 + } + d := v.Args[1].AuxInt + v.Op = OpConstPtr + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + d + return true + } + goto end145c1aec793b2befff34bc8983b48a38 +end145c1aec793b2befff34bc8983b48a38: + ; + return false +} +func rewriteValuegeneric_OpAnd16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (And16 x x) + // cond: + // result: x + { + x := v.Args[0] + if v.Args[1] != x { + goto end69ed6ee2a4fb0491b56c17f3c1926b10 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end69ed6ee2a4fb0491b56c17f3c1926b10 +end69ed6ee2a4fb0491b56c17f3c1926b10: + ; + return false +} +func rewriteValuegeneric_OpAnd32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (And32 x x) + // cond: + // result: x + { + x := v.Args[0] + if v.Args[1] != x { + goto endbbe8c3c5b2ca8f013aa178d856f3a99c + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto endbbe8c3c5b2ca8f013aa178d856f3a99c +endbbe8c3c5b2ca8f013aa178d856f3a99c: + ; + return false +} +func rewriteValuegeneric_OpAnd64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (And64 x x) + // cond: + // result: x + { + x := v.Args[0] + if v.Args[1] != x { + goto endc9736bf24d2e5cd8d662e1bcf3164640 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto endc9736bf24d2e5cd8d662e1bcf3164640 +endc9736bf24d2e5cd8d662e1bcf3164640: + ; + return false +} +func rewriteValuegeneric_OpAnd8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (And8 x x) + // cond: + // result: x + { + x := v.Args[0] + if v.Args[1] != x { + goto endeaf127389bd0d4b0e0e297830f8f463b + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto endeaf127389bd0d4b0e0e297830f8f463b +endeaf127389bd0d4b0e0e297830f8f463b: + ; + 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 ptr idx) mem) + { + if v.Args[0].Op != OpLoad { + goto end68b373270d9d605c420497edefaa71df + } + ptr := v.Args[0].Args[0] + mem := v.Args[0].Args[1] + idx := v.Args[1] + if !(b == v.Args[0].Block) { + goto end68b373270d9d605c420497edefaa71df + } + v.Op = OpLoad + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpPtrIndex, TypeInvalid) + v0.Type = v.Type.PtrTo() + v0.AddArg(ptr) + v0.AddArg(idx) + v.AddArg(v0) + v.AddArg(mem) + return true + } + goto end68b373270d9d605c420497edefaa71df +end68b373270d9d605c420497edefaa71df: + ; + return false +} +func rewriteValuegeneric_OpCom16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Com16 (Com16 x)) + // cond: + // result: x + { + if v.Args[0].Op != OpCom16 { + goto end1ea17710dd4dd7ba4e710e0e4c7b5a56 + } + x := v.Args[0].Args[0] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end1ea17710dd4dd7ba4e710e0e4c7b5a56 +end1ea17710dd4dd7ba4e710e0e4c7b5a56: + ; + return false +} +func rewriteValuegeneric_OpCom32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Com32 (Com32 x)) + // cond: + // result: x + { + if v.Args[0].Op != OpCom32 { + goto end9a04ed536496e292c27bef4414128cbf + } + x := v.Args[0].Args[0] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end9a04ed536496e292c27bef4414128cbf +end9a04ed536496e292c27bef4414128cbf: + ; + return false +} +func rewriteValuegeneric_OpCom64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Com64 (Com64 x)) + // cond: + // result: x + { + if v.Args[0].Op != OpCom64 { + goto ended44e29d5968f0f7b86972b7bf417ab3 + } + x := v.Args[0].Args[0] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto ended44e29d5968f0f7b86972b7bf417ab3 +ended44e29d5968f0f7b86972b7bf417ab3: + ; + return false +} +func rewriteValuegeneric_OpCom8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Com8 (Com8 x)) + // cond: + // result: x + { + if v.Args[0].Op != OpCom8 { + goto end4d92ff3ba567d9afd38fc9ca113602ad + } + x := v.Args[0].Args[0] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end4d92ff3ba567d9afd38fc9ca113602ad +end4d92ff3ba567d9afd38fc9ca113602ad: + ; + return false +} +func rewriteValuegeneric_OpComplexImag(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (ComplexImag (ComplexMake _ imag )) + // cond: + // result: imag + { + if v.Args[0].Op != OpComplexMake { + goto endec3009fd8727d03002021997936e091f + } + imag := v.Args[0].Args[1] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = imag.Type + v.AddArg(imag) + return true + } + goto endec3009fd8727d03002021997936e091f +endec3009fd8727d03002021997936e091f: + ; + return false +} +func rewriteValuegeneric_OpComplexReal(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (ComplexReal (ComplexMake real _ )) + // cond: + // result: real + { + if v.Args[0].Op != OpComplexMake { + goto end8db3e16bd59af1adaa4b734c8adcc71d + } + real := v.Args[0].Args[0] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = real.Type + v.AddArg(real) + return true + } + goto end8db3e16bd59af1adaa4b734c8adcc71d +end8db3e16bd59af1adaa4b734c8adcc71d: + ; + return false +} +func rewriteValuegeneric_OpConstInterface(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (ConstInterface) + // cond: + // result: (IMake (ConstNil ) (ConstNil )) + { + v.Op = OpIMake + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpConstNil, TypeInvalid) + v0.Type = config.fe.TypeBytePtr() + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpConstNil, TypeInvalid) + v1.Type = config.fe.TypeBytePtr() + v.AddArg(v1) + return true + } + goto end0367bd8f20a320cc41568f2b28657f6b +end0367bd8f20a320cc41568f2b28657f6b: + ; + return false +} +func rewriteValuegeneric_OpConstSlice(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (ConstSlice) + // cond: + // result: (SliceMake (ConstNil ) (ConstPtr [0]) (ConstPtr [0])) + { + v.Op = OpSliceMake + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpConstNil, TypeInvalid) + v0.Type = config.fe.TypeBytePtr() + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpConstPtr, TypeInvalid) + v1.AuxInt = 0 + v1.Type = config.fe.TypeUintptr() + v.AddArg(v1) + v2 := b.NewValue0(v.Line, OpConstPtr, TypeInvalid) + v2.AuxInt = 0 + v2.Type = config.fe.TypeUintptr() + v.AddArg(v2) + return true + } + goto endc587abac76a5fd9b1284ba891a178e63 +endc587abac76a5fd9b1284ba891a178e63: + ; + return false +} +func rewriteValuegeneric_OpConstString(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (ConstString {s}) + // cond: + // result: (StringMake (Addr {config.fe.StringData(s.(string))} (SB)) (ConstPtr [int64(len(s.(string)))])) + { + s := v.Aux + v.Op = OpStringMake + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAddr, TypeInvalid) + v0.Type = config.fe.TypeBytePtr() + v0.Aux = config.fe.StringData(s.(string)) + v1 := b.NewValue0(v.Line, OpSB, TypeInvalid) + v1.Type = config.fe.TypeUintptr() + v0.AddArg(v1) + v.AddArg(v0) + v2 := b.NewValue0(v.Line, OpConstPtr, TypeInvalid) + v2.AuxInt = int64(len(s.(string))) + v2.Type = config.fe.TypeUintptr() + v.AddArg(v2) + return true + } + goto end2eb756398dd4c6b6d126012a26284c89 +end2eb756398dd4c6b6d126012a26284c89: + ; + return false +} +func rewriteValuegeneric_OpConvert(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Convert (Add64 (Convert ptr) off)) + // cond: + // result: (Add64 ptr off) + { + if v.Args[0].Op != OpAdd64 { + goto end913a7ecf456c00ffbee36c2dbbf0e1af + } + if v.Args[0].Args[0].Op != OpConvert { + goto end913a7ecf456c00ffbee36c2dbbf0e1af + } + ptr := v.Args[0].Args[0].Args[0] + off := v.Args[0].Args[1] + v.Op = OpAdd64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v.AddArg(off) + return true + } + goto end913a7ecf456c00ffbee36c2dbbf0e1af +end913a7ecf456c00ffbee36c2dbbf0e1af: + ; + return false +} +func rewriteValuegeneric_OpEq16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Eq16 x x) + // cond: + // result: (ConstBool [1]) + { + x := v.Args[0] + if v.Args[1] != x { + goto end0c0fe5fdfba3821add3448fd3f1fc6b7 + } + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 1 + return true + } + goto end0c0fe5fdfba3821add3448fd3f1fc6b7 +end0c0fe5fdfba3821add3448fd3f1fc6b7: + ; + return false +} +func rewriteValuegeneric_OpEq32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Eq32 x x) + // cond: + // result: (ConstBool [1]) + { + x := v.Args[0] + if v.Args[1] != x { + goto end6da547ec4ee93d787434f3bda873e4a0 + } + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 1 + return true + } + goto end6da547ec4ee93d787434f3bda873e4a0 +end6da547ec4ee93d787434f3bda873e4a0: + ; + return false +} +func rewriteValuegeneric_OpEq64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Eq64 x x) + // cond: + // result: (ConstBool [1]) + { + x := v.Args[0] + if v.Args[1] != x { + goto endb1d471cc503ba8bb05440f01dbf33d81 + } + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 1 + return true + } + goto endb1d471cc503ba8bb05440f01dbf33d81 +endb1d471cc503ba8bb05440f01dbf33d81: + ; + return false +} +func rewriteValuegeneric_OpEq8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Eq8 x x) + // cond: + // result: (ConstBool [1]) + { + x := v.Args[0] + if v.Args[1] != x { + goto enda66da0d3e7e51624ee46527727c48a9a + } + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 1 + return true + } + goto enda66da0d3e7e51624ee46527727c48a9a +enda66da0d3e7e51624ee46527727c48a9a: + ; + 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)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpEqPtr + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpITab, TypeInvalid) + v0.AddArg(x) + v0.Type = config.fe.TypeUintptr() + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpITab, TypeInvalid) + v1.AddArg(y) + v1.Type = config.fe.TypeUintptr() + v.AddArg(v1) + return true + } + goto end1cc40483caab33ece971ab7e6c8fdfca +end1cc40483caab33ece971ab7e6c8fdfca: + ; + return false +} +func rewriteValuegeneric_OpEqPtr(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (EqPtr p (ConstNil)) + // cond: + // result: (Not (IsNonNil p)) + { + p := v.Args[0] + if v.Args[1].Op != OpConstNil { + goto ende701cdb6a2c1fff4d4b283b7f8f6178b + } + v.Op = OpNot + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpIsNonNil, TypeInvalid) + v0.AddArg(p) + v0.Type = config.fe.TypeBool() + v.AddArg(v0) + return true + } + goto ende701cdb6a2c1fff4d4b283b7f8f6178b +ende701cdb6a2c1fff4d4b283b7f8f6178b: + ; + // match: (EqPtr (ConstNil) p) + // cond: + // result: (Not (IsNonNil p)) + { + if v.Args[0].Op != OpConstNil { + goto end7cdc0d5c38fbffe6287c8928803b038e + } + p := v.Args[1] + v.Op = OpNot + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpIsNonNil, TypeInvalid) + v0.AddArg(p) + v0.Type = config.fe.TypeBool() + v.AddArg(v0) + return true + } + goto end7cdc0d5c38fbffe6287c8928803b038e +end7cdc0d5c38fbffe6287c8928803b038e: + ; + 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)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpEqPtr + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpSlicePtr, TypeInvalid) + v0.AddArg(x) + v0.Type = config.fe.TypeUintptr() + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpSlicePtr, TypeInvalid) + v1.AddArg(y) + v1.Type = config.fe.TypeUintptr() + v.AddArg(v1) + return true + } + goto end9cd53ca57ee90aa09c54f8071c8e8769 +end9cd53ca57ee90aa09c54f8071c8e8769: + ; + return false +} +func rewriteValuegeneric_OpIData(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (IData (IMake _ data)) + // cond: + // result: data + { + if v.Args[0].Op != OpIMake { + goto endbfa1bb944cdc07933effb16a35152e12 + } + data := v.Args[0].Args[1] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = data.Type + v.AddArg(data) + return true + } + goto endbfa1bb944cdc07933effb16a35152e12 +endbfa1bb944cdc07933effb16a35152e12: + ; + return false +} +func rewriteValuegeneric_OpITab(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (ITab (IMake itab _)) + // cond: + // result: itab + { + if v.Args[0].Op != OpIMake { + goto endfcbb9414a776ff9c8512da3e0f4d8fbd + } + itab := v.Args[0].Args[0] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = itab.Type + v.AddArg(itab) + return true + } + goto endfcbb9414a776ff9c8512da3e0f4d8fbd +endfcbb9414a776ff9c8512da3e0f4d8fbd: + ; + 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))]) + { + if v.Args[0].Op != OpConst32 { + goto endf0a2ecfe84b293de6ff0919e45d19d9d + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst32 { + goto endf0a2ecfe84b293de6ff0919e45d19d9d + } + d := v.Args[1].AuxInt + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = b2i(inBounds32(c, d)) + return true + } + goto endf0a2ecfe84b293de6ff0919e45d19d9d +endf0a2ecfe84b293de6ff0919e45d19d9d: + ; + // match: (IsInBounds (Const64 [c]) (Const64 [d])) + // cond: + // result: (ConstBool [b2i(inBounds64(c,d))]) + { + if v.Args[0].Op != OpConst64 { + goto end4b406f402c135f50f71effcc904ecb2b + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst64 { + goto end4b406f402c135f50f71effcc904ecb2b + } + d := v.Args[1].AuxInt + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = b2i(inBounds64(c, d)) + return true + } + goto end4b406f402c135f50f71effcc904ecb2b +end4b406f402c135f50f71effcc904ecb2b: + ; + // match: (IsInBounds (ConstPtr [c]) (ConstPtr [d])) + // cond: config.PtrSize == 4 + // result: (ConstBool [b2i(inBounds32(c,d))]) + { + if v.Args[0].Op != OpConstPtr { + goto end4323278ec7a053034fcf7033697d7b3b + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConstPtr { + goto end4323278ec7a053034fcf7033697d7b3b + } + d := v.Args[1].AuxInt + if !(config.PtrSize == 4) { + goto end4323278ec7a053034fcf7033697d7b3b + } + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = b2i(inBounds32(c, d)) + return true + } + goto end4323278ec7a053034fcf7033697d7b3b +end4323278ec7a053034fcf7033697d7b3b: + ; + // match: (IsInBounds (ConstPtr [c]) (ConstPtr [d])) + // cond: config.PtrSize == 8 + // result: (ConstBool [b2i(inBounds64(c,d))]) + { + if v.Args[0].Op != OpConstPtr { + goto endb550b8814df20b5eeda4f43cc94e902b + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConstPtr { + goto endb550b8814df20b5eeda4f43cc94e902b + } + d := v.Args[1].AuxInt + if !(config.PtrSize == 8) { + goto endb550b8814df20b5eeda4f43cc94e902b + } + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = b2i(inBounds64(c, d)) + return true + } + goto endb550b8814df20b5eeda4f43cc94e902b +endb550b8814df20b5eeda4f43cc94e902b: + ; + return false +} +func rewriteValuegeneric_OpLoad(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Load ptr mem) + // cond: t.IsComplex() && t.Size() == 8 + // result: (ComplexMake (Load ptr mem) (Load (OffPtr [4] ptr) mem) ) + { + t := v.Type + ptr := v.Args[0] + mem := v.Args[1] + if !(t.IsComplex() && t.Size() == 8) { + goto end665854b31b828893d90b36bb462ff381 + } + v.Op = OpComplexMake + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpLoad, TypeInvalid) + v0.Type = config.fe.TypeFloat32() + v0.AddArg(ptr) + v0.AddArg(mem) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpLoad, TypeInvalid) + v1.Type = config.fe.TypeFloat32() + v2 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) + v2.Type = config.fe.TypeFloat32().PtrTo() + v2.AuxInt = 4 + v2.AddArg(ptr) + v1.AddArg(v2) + v1.AddArg(mem) + v.AddArg(v1) + return true + } + goto end665854b31b828893d90b36bb462ff381 +end665854b31b828893d90b36bb462ff381: + ; + // match: (Load ptr mem) + // cond: t.IsComplex() && t.Size() == 16 + // result: (ComplexMake (Load ptr mem) (Load (OffPtr [8] ptr) mem) ) + { + t := v.Type + ptr := v.Args[0] + mem := v.Args[1] + if !(t.IsComplex() && t.Size() == 16) { + goto end1b106f89e0e3e26c613b957a7c98d8ad + } + v.Op = OpComplexMake + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpLoad, TypeInvalid) + v0.Type = config.fe.TypeFloat64() + v0.AddArg(ptr) + v0.AddArg(mem) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpLoad, TypeInvalid) + v1.Type = config.fe.TypeFloat64() + v2 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) + v2.Type = config.fe.TypeFloat64().PtrTo() + v2.AuxInt = 8 + v2.AddArg(ptr) + v1.AddArg(v2) + v1.AddArg(mem) + v.AddArg(v1) + return true + } + goto end1b106f89e0e3e26c613b957a7c98d8ad +end1b106f89e0e3e26c613b957a7c98d8ad: + ; + // match: (Load ptr mem) + // cond: t.IsString() + // result: (StringMake (Load ptr mem) (Load (OffPtr [config.PtrSize] ptr) mem)) + { + t := v.Type + ptr := v.Args[0] + mem := v.Args[1] + if !(t.IsString()) { + goto end7c75255555bf9dd796298d9f6eaf9cf2 + } + v.Op = OpStringMake + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpLoad, TypeInvalid) + v0.Type = config.fe.TypeBytePtr() + v0.AddArg(ptr) + v0.AddArg(mem) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpLoad, TypeInvalid) + v1.Type = config.fe.TypeUintptr() + v2 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) + v2.Type = config.fe.TypeUintptr().PtrTo() + v2.AuxInt = config.PtrSize + v2.AddArg(ptr) + v1.AddArg(v2) + v1.AddArg(mem) + v.AddArg(v1) + return true + } + goto end7c75255555bf9dd796298d9f6eaf9cf2 +end7c75255555bf9dd796298d9f6eaf9cf2: + ; + // match: (Load ptr mem) + // cond: t.IsSlice() + // result: (SliceMake (Load ptr mem) (Load (OffPtr [config.PtrSize] ptr) mem) (Load (OffPtr [2*config.PtrSize] ptr) mem)) + { + t := v.Type + ptr := v.Args[0] + mem := v.Args[1] + if !(t.IsSlice()) { + goto end12c46556d962198680eb3238859e3016 + } + v.Op = OpSliceMake + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpLoad, TypeInvalid) + v0.Type = config.fe.TypeBytePtr() + v0.AddArg(ptr) + v0.AddArg(mem) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpLoad, TypeInvalid) + v1.Type = config.fe.TypeUintptr() + v2 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) + v2.Type = config.fe.TypeUintptr().PtrTo() + v2.AuxInt = config.PtrSize + v2.AddArg(ptr) + v1.AddArg(v2) + v1.AddArg(mem) + v.AddArg(v1) + v3 := b.NewValue0(v.Line, OpLoad, TypeInvalid) + v3.Type = config.fe.TypeUintptr() + v4 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) + v4.Type = config.fe.TypeUintptr().PtrTo() + v4.AuxInt = 2 * config.PtrSize + v4.AddArg(ptr) + v3.AddArg(v4) + v3.AddArg(mem) + v.AddArg(v3) + return true + } + goto end12c46556d962198680eb3238859e3016 +end12c46556d962198680eb3238859e3016: + ; + // match: (Load ptr mem) + // cond: t.IsInterface() + // result: (IMake (Load ptr mem) (Load (OffPtr [config.PtrSize] ptr) mem)) + { + t := v.Type + ptr := v.Args[0] + mem := v.Args[1] + if !(t.IsInterface()) { + goto end12671c83ebe3ccbc8e53383765ee7675 + } + v.Op = OpIMake + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpLoad, TypeInvalid) + v0.Type = config.fe.TypeBytePtr() + v0.AddArg(ptr) + v0.AddArg(mem) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpLoad, TypeInvalid) + v1.Type = config.fe.TypeBytePtr() + v2 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) + v2.Type = config.fe.TypeBytePtr().PtrTo() + v2.AuxInt = config.PtrSize + v2.AddArg(ptr) + v1.AddArg(v2) + v1.AddArg(mem) + v.AddArg(v1) + return true + } + goto end12671c83ebe3ccbc8e53383765ee7675 +end12671c83ebe3ccbc8e53383765ee7675: + ; + 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]) + { + if v.Args[0].Op != OpConst64 { + goto end7aea1048b5d1230974b97f17238380ae + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst64 { + goto end7aea1048b5d1230974b97f17238380ae + } + d := v.Args[1].AuxInt + v.Op = OpConst64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c * d + return true + } + goto end7aea1048b5d1230974b97f17238380ae +end7aea1048b5d1230974b97f17238380ae: + ; + return false +} +func rewriteValuegeneric_OpMulPtr(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (MulPtr (ConstPtr [c]) (ConstPtr [d])) + // cond: + // result: (ConstPtr [c*d]) + { + if v.Args[0].Op != OpConstPtr { + goto end808c190f346658bb1ad032bf37a1059f + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConstPtr { + goto end808c190f346658bb1ad032bf37a1059f + } + d := v.Args[1].AuxInt + v.Op = OpConstPtr + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c * d + return true + } + goto end808c190f346658bb1ad032bf37a1059f +end808c190f346658bb1ad032bf37a1059f: + ; + return false +} +func rewriteValuegeneric_OpNeq16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Neq16 x x) + // cond: + // result: (ConstBool [0]) + { + x := v.Args[0] + if v.Args[1] != x { + goto ende76a50b524aeb16c7aeccf5f5cc60c06 + } + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto ende76a50b524aeb16c7aeccf5f5cc60c06 +ende76a50b524aeb16c7aeccf5f5cc60c06: + ; + return false +} +func rewriteValuegeneric_OpNeq32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Neq32 x x) + // cond: + // result: (ConstBool [0]) + { + x := v.Args[0] + if v.Args[1] != x { + goto end3713a608cffd29b40ff7c3b3f2585cbb + } + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end3713a608cffd29b40ff7c3b3f2585cbb +end3713a608cffd29b40ff7c3b3f2585cbb: + ; + return false +} +func rewriteValuegeneric_OpNeq64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Neq64 x x) + // cond: + // result: (ConstBool [0]) + { + x := v.Args[0] + if v.Args[1] != x { + goto end3601ad382705ea12b79d2008c1e5725c + } + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end3601ad382705ea12b79d2008c1e5725c +end3601ad382705ea12b79d2008c1e5725c: + ; + return false +} +func rewriteValuegeneric_OpNeq8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Neq8 x x) + // cond: + // result: (ConstBool [0]) + { + x := v.Args[0] + if v.Args[1] != x { + goto end09a0deaf3c42627d0d2d3efa96e30745 + } + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end09a0deaf3c42627d0d2d3efa96e30745 +end09a0deaf3c42627d0d2d3efa96e30745: + ; + 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)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpNeqPtr + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpITab, TypeInvalid) + v0.AddArg(x) + v0.Type = config.fe.TypeUintptr() + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpITab, TypeInvalid) + v1.AddArg(y) + v1.Type = config.fe.TypeUintptr() + v.AddArg(v1) + return true + } + goto end17b2333bf57e9fe81a671be02f9c4c14 +end17b2333bf57e9fe81a671be02f9c4c14: + ; + return false +} +func rewriteValuegeneric_OpNeqPtr(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (NeqPtr p (ConstNil)) + // cond: + // result: (IsNonNil p) + { + p := v.Args[0] + if v.Args[1].Op != OpConstNil { + goto endba798520b4d41172b110347158c44791 + } + v.Op = OpIsNonNil + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(p) + return true + } + goto endba798520b4d41172b110347158c44791 +endba798520b4d41172b110347158c44791: + ; + // match: (NeqPtr (ConstNil) p) + // cond: + // result: (IsNonNil p) + { + if v.Args[0].Op != OpConstNil { + goto enddd95e9c3606d9fd48034f1a703561e45 + } + p := v.Args[1] + v.Op = OpIsNonNil + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(p) + return true + } + goto enddd95e9c3606d9fd48034f1a703561e45 +enddd95e9c3606d9fd48034f1a703561e45: + ; + 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)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpNeqPtr + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpSlicePtr, TypeInvalid) + v0.AddArg(x) + v0.Type = config.fe.TypeUintptr() + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpSlicePtr, TypeInvalid) + v1.AddArg(y) + v1.Type = config.fe.TypeUintptr() + v.AddArg(v1) + return true + } + goto endc6bc83c506e491236ca66ea1081231a2 +endc6bc83c506e491236ca66ea1081231a2: + ; + return false +} +func rewriteValuegeneric_OpOr16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Or16 x x) + // cond: + // result: x + { + x := v.Args[0] + if v.Args[1] != x { + goto end47a2f25fd31a76807aced3e2b126acdc + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end47a2f25fd31a76807aced3e2b126acdc +end47a2f25fd31a76807aced3e2b126acdc: + ; + return false +} +func rewriteValuegeneric_OpOr32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Or32 x x) + // cond: + // result: x + { + x := v.Args[0] + if v.Args[1] != x { + goto end231e283e568e90bd9a3e6a4fa328c8a4 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end231e283e568e90bd9a3e6a4fa328c8a4 +end231e283e568e90bd9a3e6a4fa328c8a4: + ; + return false +} +func rewriteValuegeneric_OpOr64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Or64 x x) + // cond: + // result: x + { + x := v.Args[0] + if v.Args[1] != x { + goto end6b0efc212016dc97d0e3939db04c81d9 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end6b0efc212016dc97d0e3939db04c81d9 +end6b0efc212016dc97d0e3939db04c81d9: + ; + return false +} +func rewriteValuegeneric_OpOr8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Or8 x x) + // cond: + // result: x + { + x := v.Args[0] + if v.Args[1] != x { + goto end05295dbfafd6869af79b4daee9fda000 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end05295dbfafd6869af79b4daee9fda000 +end05295dbfafd6869af79b4daee9fda000: + ; + return false +} +func rewriteValuegeneric_OpPtrIndex(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (PtrIndex ptr idx) + // cond: + // result: (AddPtr ptr (MulPtr idx (ConstPtr [t.Elem().Size()]))) + { + t := v.Type + ptr := v.Args[0] + idx := v.Args[1] + v.Op = OpAddPtr + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v0 := b.NewValue0(v.Line, OpMulPtr, TypeInvalid) + v0.AddArg(idx) + v1 := b.NewValue0(v.Line, OpConstPtr, TypeInvalid) + v1.AuxInt = t.Elem().Size() + v1.Type = config.fe.TypeUintptr() + v0.AddArg(v1) + v0.Type = config.fe.TypeUintptr() + v.AddArg(v0) + return true + } + goto end502555083d57a877982955070cda7530 +end502555083d57a877982955070cda7530: + ; + return false +} +func rewriteValuegeneric_OpSliceCap(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (SliceCap (SliceMake _ _ cap)) + // cond: + // result: cap + { + if v.Args[0].Op != OpSliceMake { + goto end1bd11616743632b33b410964667fb3c6 + } + cap := v.Args[0].Args[2] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = cap.Type + v.AddArg(cap) + return true + } + goto end1bd11616743632b33b410964667fb3c6 +end1bd11616743632b33b410964667fb3c6: + ; + return false +} +func rewriteValuegeneric_OpSliceLen(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (SliceLen (SliceMake _ len _)) + // cond: + // result: len + { + if v.Args[0].Op != OpSliceMake { + goto endebb2090199d13e4c2ae52fb3e778f7fd + } + len := v.Args[0].Args[1] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = len.Type + v.AddArg(len) + return true + } + goto endebb2090199d13e4c2ae52fb3e778f7fd +endebb2090199d13e4c2ae52fb3e778f7fd: + ; + return false +} +func rewriteValuegeneric_OpSlicePtr(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (SlicePtr (SliceMake ptr _ _ )) + // cond: + // result: ptr + { + if v.Args[0].Op != OpSliceMake { + goto end526acc0a705137a5d25577499206720b + } + ptr := v.Args[0].Args[0] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = ptr.Type + v.AddArg(ptr) + return true + } + goto end526acc0a705137a5d25577499206720b +end526acc0a705137a5d25577499206720b: + ; + return false +} +func rewriteValuegeneric_OpStore(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Store [8] dst (ComplexMake real imag) mem) + // cond: + // result: (Store [4] (OffPtr [4] dst) imag (Store [4] dst real mem)) + { + if v.AuxInt != 8 { + goto endced898cb0a165662afe48ea44ad3318a + } + dst := v.Args[0] + if v.Args[1].Op != OpComplexMake { + goto endced898cb0a165662afe48ea44ad3318a + } + real := v.Args[1].Args[0] + imag := v.Args[1].Args[1] + mem := v.Args[2] + v.Op = OpStore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 4 + v0 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) + v0.Type = config.fe.TypeFloat32().PtrTo() + v0.AuxInt = 4 + v0.AddArg(dst) + v.AddArg(v0) + v.AddArg(imag) + v1 := b.NewValue0(v.Line, OpStore, TypeInvalid) + v1.AuxInt = 4 + v1.AddArg(dst) + v1.AddArg(real) + v1.AddArg(mem) + v1.Type = TypeMem + v.AddArg(v1) + return true + } + goto endced898cb0a165662afe48ea44ad3318a +endced898cb0a165662afe48ea44ad3318a: + ; + // match: (Store [16] dst (ComplexMake real imag) mem) + // cond: + // result: (Store [8] (OffPtr [8] dst) imag (Store [8] dst real mem)) + { + if v.AuxInt != 16 { + goto end3851a482d7bd37a93c4d81581e85b3ab + } + dst := v.Args[0] + if v.Args[1].Op != OpComplexMake { + goto end3851a482d7bd37a93c4d81581e85b3ab + } + real := v.Args[1].Args[0] + imag := v.Args[1].Args[1] + mem := v.Args[2] + v.Op = OpStore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 8 + v0 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) + v0.Type = config.fe.TypeFloat64().PtrTo() + v0.AuxInt = 8 + v0.AddArg(dst) + v.AddArg(v0) + v.AddArg(imag) + v1 := b.NewValue0(v.Line, OpStore, TypeInvalid) + v1.AuxInt = 8 + v1.AddArg(dst) + v1.AddArg(real) + v1.AddArg(mem) + v1.Type = TypeMem + v.AddArg(v1) + return true + } + goto end3851a482d7bd37a93c4d81581e85b3ab +end3851a482d7bd37a93c4d81581e85b3ab: + ; + // match: (Store [2*config.PtrSize] dst (StringMake ptr len) mem) + // cond: + // result: (Store [config.PtrSize] (OffPtr [config.PtrSize] dst) len (Store [config.PtrSize] dst ptr mem)) + { + if v.AuxInt != 2*config.PtrSize { + goto end12abe4021d24e76ed56d64b18730bffb + } + dst := v.Args[0] + if v.Args[1].Op != OpStringMake { + goto end12abe4021d24e76ed56d64b18730bffb + } + ptr := v.Args[1].Args[0] + len := v.Args[1].Args[1] + mem := v.Args[2] + v.Op = OpStore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = config.PtrSize + v0 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) + v0.Type = config.fe.TypeUintptr().PtrTo() + v0.AuxInt = config.PtrSize + v0.AddArg(dst) + v.AddArg(v0) + v.AddArg(len) + v1 := b.NewValue0(v.Line, OpStore, TypeInvalid) + v1.AuxInt = config.PtrSize + v1.AddArg(dst) + v1.AddArg(ptr) + v1.AddArg(mem) + v1.Type = TypeMem + v.AddArg(v1) + return true + } + goto end12abe4021d24e76ed56d64b18730bffb +end12abe4021d24e76ed56d64b18730bffb: + ; + // match: (Store [3*config.PtrSize] dst (SliceMake ptr len cap) mem) + // cond: + // result: (Store [config.PtrSize] (OffPtr [2*config.PtrSize] dst) cap (Store [config.PtrSize] (OffPtr [config.PtrSize] dst) len (Store [config.PtrSize] dst ptr mem))) + { + if v.AuxInt != 3*config.PtrSize { + goto end7498d25e17db5398cf073a8590e35cc2 + } + dst := v.Args[0] + if v.Args[1].Op != OpSliceMake { + goto end7498d25e17db5398cf073a8590e35cc2 + } + ptr := v.Args[1].Args[0] + len := v.Args[1].Args[1] + cap := v.Args[1].Args[2] + mem := v.Args[2] + v.Op = OpStore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = config.PtrSize + v0 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) + v0.Type = config.fe.TypeUintptr().PtrTo() + v0.AuxInt = 2 * config.PtrSize + v0.AddArg(dst) + v.AddArg(v0) + v.AddArg(cap) + v1 := b.NewValue0(v.Line, OpStore, TypeInvalid) + v1.AuxInt = config.PtrSize + v2 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) + v2.Type = config.fe.TypeUintptr().PtrTo() + v2.AuxInt = config.PtrSize + v2.AddArg(dst) + v1.AddArg(v2) + v1.AddArg(len) + v3 := b.NewValue0(v.Line, OpStore, TypeInvalid) + v3.AuxInt = config.PtrSize + v3.AddArg(dst) + v3.AddArg(ptr) + v3.AddArg(mem) + v3.Type = TypeMem + v1.AddArg(v3) + v1.Type = TypeMem + v.AddArg(v1) + return true + } + goto end7498d25e17db5398cf073a8590e35cc2 +end7498d25e17db5398cf073a8590e35cc2: + ; + // match: (Store [2*config.PtrSize] dst (IMake itab data) mem) + // cond: + // result: (Store [config.PtrSize] (OffPtr [config.PtrSize] dst) data (Store [config.PtrSize] dst itab mem)) + { + if v.AuxInt != 2*config.PtrSize { + goto endaa801a871178ae3256b3f6f5d9f13514 + } + dst := v.Args[0] + if v.Args[1].Op != OpIMake { + goto endaa801a871178ae3256b3f6f5d9f13514 + } + itab := v.Args[1].Args[0] + data := v.Args[1].Args[1] + mem := v.Args[2] + v.Op = OpStore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = config.PtrSize + v0 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) + v0.Type = config.fe.TypeBytePtr().PtrTo() + v0.AuxInt = config.PtrSize + v0.AddArg(dst) + v.AddArg(v0) + v.AddArg(data) + v1 := b.NewValue0(v.Line, OpStore, TypeInvalid) + v1.AuxInt = config.PtrSize + v1.AddArg(dst) + v1.AddArg(itab) + v1.AddArg(mem) + v1.Type = TypeMem + v.AddArg(v1) + return true + } + goto endaa801a871178ae3256b3f6f5d9f13514 +endaa801a871178ae3256b3f6f5d9f13514: + ; + // match: (Store [size] dst (Load src mem) mem) + // cond: !config.fe.CanSSA(t) + // result: (Move [size] dst src mem) + { + size := v.AuxInt + dst := v.Args[0] + if v.Args[1].Op != OpLoad { + goto end45295326269ba18413dceb7b608a0b9d + } + t := v.Args[1].Type + src := v.Args[1].Args[0] + mem := v.Args[1].Args[1] + if v.Args[2] != mem { + goto end45295326269ba18413dceb7b608a0b9d + } + if !(!config.fe.CanSSA(t)) { + goto end45295326269ba18413dceb7b608a0b9d + } + v.Op = OpMove + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = size + v.AddArg(dst) + v.AddArg(src) + v.AddArg(mem) + return true + } + goto end45295326269ba18413dceb7b608a0b9d +end45295326269ba18413dceb7b608a0b9d: + ; + // match: (Store [size] dst (Load src mem) (VarDef {x} mem)) + // cond: !config.fe.CanSSA(t) + // result: (Move [size] dst src (VarDef {x} mem)) + { + size := v.AuxInt + dst := v.Args[0] + if v.Args[1].Op != OpLoad { + goto end7f3cc0baffb82ba3ee879599b189a512 + } + t := v.Args[1].Type + src := v.Args[1].Args[0] + mem := v.Args[1].Args[1] + if v.Args[2].Op != OpVarDef { + goto end7f3cc0baffb82ba3ee879599b189a512 + } + x := v.Args[2].Aux + if v.Args[2].Args[0] != mem { + goto end7f3cc0baffb82ba3ee879599b189a512 + } + if !(!config.fe.CanSSA(t)) { + goto end7f3cc0baffb82ba3ee879599b189a512 + } + v.Op = OpMove + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = size + v.AddArg(dst) + v.AddArg(src) + v0 := b.NewValue0(v.Line, OpVarDef, TypeInvalid) + v0.Aux = x + v0.AddArg(mem) + v0.Type = TypeMem + v.AddArg(v0) + return true + } + goto end7f3cc0baffb82ba3ee879599b189a512 +end7f3cc0baffb82ba3ee879599b189a512: + ; + return false +} +func rewriteValuegeneric_OpStringLen(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (StringLen (StringMake _ len)) + // cond: + // result: len + { + if v.Args[0].Op != OpStringMake { + goto end0d922460b7e5ca88324034f4bd6c027c + } + len := v.Args[0].Args[1] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = len.Type + v.AddArg(len) + return true + } + goto end0d922460b7e5ca88324034f4bd6c027c +end0d922460b7e5ca88324034f4bd6c027c: + ; + return false +} +func rewriteValuegeneric_OpStringPtr(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (StringPtr (StringMake ptr _)) + // cond: + // result: ptr + { + if v.Args[0].Op != OpStringMake { + goto end061edc5d85c73ad909089af2556d9380 + } + ptr := v.Args[0].Args[0] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = ptr.Type + v.AddArg(ptr) + return true + } + goto end061edc5d85c73ad909089af2556d9380 +end061edc5d85c73ad909089af2556d9380: + ; + return false +} +func rewriteValuegeneric_OpStructSelect(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (StructSelect [idx] (Load ptr mem)) + // cond: + // result: @v.Args[0].Block (Load (OffPtr [idx] ptr) mem) + { + idx := v.AuxInt + if v.Args[0].Op != OpLoad { + goto end27abc5bf0299ce1bd5457af6ce8e3fba + } + ptr := v.Args[0].Args[0] + mem := v.Args[0].Args[1] + v0 := v.Args[0].Block.NewValue0(v.Line, OpLoad, TypeInvalid) + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(v0) + v0.Type = v.Type + v1 := v.Args[0].Block.NewValue0(v.Line, OpOffPtr, TypeInvalid) + v1.Type = v.Type.PtrTo() + v1.AuxInt = idx + v1.AddArg(ptr) + v0.AddArg(v1) + v0.AddArg(mem) + return true + } + goto end27abc5bf0299ce1bd5457af6ce8e3fba +end27abc5bf0299ce1bd5457af6ce8e3fba: + ; + return false +} +func rewriteValuegeneric_OpSub16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Sub16 x x) + // cond: + // result: (Const16 [0]) + { + x := v.Args[0] + if v.Args[1] != x { + goto end83da541391be564f2a08464e674a49e7 + } + v.Op = OpConst16 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end83da541391be564f2a08464e674a49e7 +end83da541391be564f2a08464e674a49e7: + ; + return false +} +func rewriteValuegeneric_OpSub32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Sub32 x x) + // cond: + // result: (Const32 [0]) + { + x := v.Args[0] + if v.Args[1] != x { + goto enda747581e798f199e07f4ad69747cd069 + } + v.Op = OpConst32 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto enda747581e798f199e07f4ad69747cd069 +enda747581e798f199e07f4ad69747cd069: + ; + return false +} +func rewriteValuegeneric_OpSub64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Sub64 x x) + // cond: + // result: (Const64 [0]) + { + x := v.Args[0] + if v.Args[1] != x { + goto end0387dc2b7bbe57d4aa54eab5d959da4b + } + v.Op = OpConst64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end0387dc2b7bbe57d4aa54eab5d959da4b +end0387dc2b7bbe57d4aa54eab5d959da4b: + ; + return false +} +func rewriteValuegeneric_OpSub8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Sub8 x x) + // cond: + // result: (Const8 [0]) + { + x := v.Args[0] + if v.Args[1] != x { + goto end4e2ee15ef17611919a1a6b5f80bbfe18 + } + v.Op = OpConst8 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end4e2ee15ef17611919a1a6b5f80bbfe18 +end4e2ee15ef17611919a1a6b5f80bbfe18: + ; + return false +} +func rewriteValuegeneric_OpXor16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Xor16 x x) + // cond: + // result: (Const16 [0]) + { + x := v.Args[0] + if v.Args[1] != x { + goto end5733ceb1903b8140248d8e2cac02fefe + } + v.Op = OpConst16 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end5733ceb1903b8140248d8e2cac02fefe +end5733ceb1903b8140248d8e2cac02fefe: + ; + return false +} +func rewriteValuegeneric_OpXor32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Xor32 x x) + // cond: + // result: (Const32 [0]) + { + x := v.Args[0] + if v.Args[1] != x { + goto end268ca02df6515d648e0bfb4e90981d25 + } + v.Op = OpConst32 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end268ca02df6515d648e0bfb4e90981d25 +end268ca02df6515d648e0bfb4e90981d25: + ; + return false +} +func rewriteValuegeneric_OpXor64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Xor64 x x) + // cond: + // result: (Const64 [0]) + { + x := v.Args[0] + if v.Args[1] != x { + goto endaf44e7f9fc58af30df69070953fb45ce + } + v.Op = OpConst64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto endaf44e7f9fc58af30df69070953fb45ce +endaf44e7f9fc58af30df69070953fb45ce: + ; + return false +} +func rewriteValuegeneric_OpXor8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Xor8 x x) + // cond: + // result: (Const8 [0]) + { + x := v.Args[0] + if v.Args[1] != x { + goto end949b3a60b7d181688e6f79f93c782fc8 + } + v.Op = OpConst8 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true } + goto end949b3a60b7d181688e6f79f93c782fc8 +end949b3a60b7d181688e6f79f93c782fc8: + ; return false } func rewriteBlockgeneric(b *Block) bool { -- cgit v1.3 From 74180dd7dad42b800f2408340ad17cb62c6c11fb Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Tue, 27 Oct 2015 21:35:48 -0500 Subject: [dev.ssa] cmd/compile/internal/ssa: reuse Aux values for PEXTERN This improves cse and works correctly now that divide by zero is checked explicitly. Change-Id: If54fbe403ed5230b897afc5def644ba9f0056dfd Reviewed-on: https://go-review.googlesource.com/16454 Run-TryBot: Todd Neal Reviewed-by: Keith Randall TryBot-Result: Gobot Gobot --- src/cmd/compile/internal/gc/ssa.go | 2 +- .../compile/internal/gc/testdata/loadstore_ssa.go | 28 ++++++++++++++++++++++ 2 files changed, 29 insertions(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 4b4dc09f11..b96661d15e 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -2265,7 +2265,7 @@ func (s *state) addr(n *Node, bounded bool) *ssa.Value { switch n.Class { case PEXTERN: // global variable - aux := &ssa.ExternSymbol{n.Type, n.Sym} + 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 { diff --git a/src/cmd/compile/internal/gc/testdata/loadstore_ssa.go b/src/cmd/compile/internal/gc/testdata/loadstore_ssa.go index e986f53bc6..e0b0b4dfab 100644 --- a/src/cmd/compile/internal/gc/testdata/loadstore_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/loadstore_ssa.go @@ -77,11 +77,39 @@ func testExtStore() { } } +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") -- cgit v1.3 From d04f38e3ee7b7948c4fd18a0a26ad351d2b88670 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Thu, 29 Oct 2015 13:41:02 -0700 Subject: [dev.ssa] cmd/compile: flag recomputing: find original values correctly We "spill" flag values by recomputing them from their original inputs. The "find original inputs" part of the algorithm was a hack. It was broken by rematerialization. This change does the real job of keeping track of original values for each spill/restore/flagrecompute/rematerialization we issue. Change-Id: I95088326a4ee4958c98148b063e518c80e863e4c Reviewed-on: https://go-review.googlesource.com/16500 Run-TryBot: Keith Randall Reviewed-by: Josh Bleecher Snyder TryBot-Result: Gobot Gobot --- src/cmd/compile/internal/ssa/regalloc.go | 32 ++++++++++++++++++++++++++++---- 1 file changed, 28 insertions(+), 4 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index 8181f8d39b..89deb14a4a 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -241,6 +241,10 @@ type regAllocState struct { // 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 @@ -298,6 +302,18 @@ func (s *regAllocState) getHome(v *Value) register { return register(s.home[v.ID].(*Register).Num) } +// 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) { @@ -421,11 +437,8 @@ func (s *regAllocState) allocValToReg(v *Value, mask regMask, nospill bool) *Val args := make([]*Value, 0, len(v.Args)) regspec := opcodeTable[v.Op].reg for _, i := range regspec.inputs { - a := v.Args[i.idx] // Extract the original arguments to v - for a.Op == OpLoadReg || a.Op == OpStoreReg || a.Op == OpCopy { - a = a.Args[0] - } + a := s.orig[v.Args[i.idx].ID] if a.Type.IsFlags() { s.f.Fatalf("cannot load flags value with flags arg: %v has unwrapped arg %v", v.LongString(), a.LongString()) } @@ -457,6 +470,7 @@ func (s *regAllocState) allocValToReg(v *Value, mask regMask, nospill bool) *Val 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 @@ -475,6 +489,12 @@ func (s *regAllocState) init(f *Func) { for i := range s.values { s.values[i].uses = s.values[i].usestorage[:0] } + s.orig = make([]*Value, f.NumValues()) + for _, b := range f.Blocks { + for _, v := range b.Values { + s.orig[v.ID] = v + } + } s.live = f.live() // Compute block order. This array allows us to distinguish forward edges @@ -709,6 +729,7 @@ func (s *regAllocState) regalloc(f *Func) { 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 } @@ -793,6 +814,7 @@ func (s *regAllocState) regalloc(f *Func) { // then at the end of regalloc delete the ones we never use. if !v.Type.IsFlags() { 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 } @@ -883,6 +905,7 @@ func (s *regAllocState) regalloc(f *Func) { // value so that we don't clobber it prematurely. c := s.allocValToReg(v, s.compatRegs(v), false) d := p.NewValue1(v.Line, OpStoreReg, v.Type, c) + s.setOrig(d, v) s.values[v.ID].spill2 = d } @@ -895,6 +918,7 @@ func (s *regAllocState) regalloc(f *Func) { w := v.Args[i] c := s.allocValToReg(w, s.compatRegs(w), false) v.Args[i] = p.NewValue1(v.Line, OpStoreReg, v.Type, c) + s.setOrig(v.Args[i], w) } // Figure out what value goes in each register. for r := register(0); r < numRegs; r++ { -- cgit v1.3 From cdc36252fe38cef9afa1fa1efa61897fae8a21a2 Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Tue, 27 Oct 2015 17:46:53 -0500 Subject: [dev.ssa] cmd/compile/internal/ssa: rewrite rules for const comparisons Shaves ~8k off the go binary on darwin x64. Change-Id: I73396af44ae28cd4cfc675290d6858f304d45b76 Reviewed-on: https://go-review.googlesource.com/16456 Run-TryBot: Todd Neal Reviewed-by: Keith Randall TryBot-Result: Gobot Gobot --- src/cmd/compile/internal/ssa/gen/generic.rules | 51 + src/cmd/compile/internal/ssa/rewritegeneric.go | 1384 +++++++++++++++++++++--- 2 files changed, 1295 insertions(+), 140 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index 507ac487ca..55fd83eab2 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -37,6 +37,57 @@ (Neq16 x x) -> (ConstBool [0]) (Neq8 x x) -> (ConstBool [0]) +// 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 diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index e30f17df9c..e068dcfb1e 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -55,12 +55,76 @@ func rewriteValuegeneric(v *Value, config *Config) bool { 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 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 OpMul64: @@ -582,6 +646,28 @@ func rewriteValuegeneric_OpEq16(v *Value, config *Config) bool { } goto end0c0fe5fdfba3821add3448fd3f1fc6b7 end0c0fe5fdfba3821add3448fd3f1fc6b7: + ; + // match: (Eq16 (Const16 [c]) (Const16 [d])) + // cond: + // result: (ConstBool [b2i(int16(c) == int16(d))]) + { + if v.Args[0].Op != OpConst16 { + goto end4532e1d01c10d8906fe1da14f9dfaa88 + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst16 { + goto end4532e1d01c10d8906fe1da14f9dfaa88 + } + d := v.Args[1].AuxInt + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = b2i(int16(c) == int16(d)) + return true + } + goto end4532e1d01c10d8906fe1da14f9dfaa88 +end4532e1d01c10d8906fe1da14f9dfaa88: ; return false } @@ -605,302 +691,1232 @@ func rewriteValuegeneric_OpEq32(v *Value, config *Config) bool { } goto end6da547ec4ee93d787434f3bda873e4a0 end6da547ec4ee93d787434f3bda873e4a0: + ; + // match: (Eq32 (Const32 [c]) (Const32 [d])) + // cond: + // result: (ConstBool [b2i(int32(c) == int32(d))]) + { + if v.Args[0].Op != OpConst32 { + goto end00a2464e02c9ca00e8d0077acacbb5ad + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst32 { + goto end00a2464e02c9ca00e8d0077acacbb5ad + } + d := v.Args[1].AuxInt + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = b2i(int32(c) == int32(d)) + return true + } + goto end00a2464e02c9ca00e8d0077acacbb5ad +end00a2464e02c9ca00e8d0077acacbb5ad: + ; + return false +} +func rewriteValuegeneric_OpEq64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Eq64 x x) + // cond: + // result: (ConstBool [1]) + { + x := v.Args[0] + if v.Args[1] != x { + goto endb1d471cc503ba8bb05440f01dbf33d81 + } + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 1 + return true + } + goto endb1d471cc503ba8bb05440f01dbf33d81 +endb1d471cc503ba8bb05440f01dbf33d81: + ; + // match: (Eq64 (Const64 [c]) (Const64 [d])) + // cond: + // result: (ConstBool [b2i(int64(c) == int64(d))]) + { + if v.Args[0].Op != OpConst64 { + goto end405568a707dbbc86432e91f4ce7d97d7 + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst64 { + goto end405568a707dbbc86432e91f4ce7d97d7 + } + d := v.Args[1].AuxInt + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = b2i(int64(c) == int64(d)) + return true + } + goto end405568a707dbbc86432e91f4ce7d97d7 +end405568a707dbbc86432e91f4ce7d97d7: + ; + return false +} +func rewriteValuegeneric_OpEq8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Eq8 x x) + // cond: + // result: (ConstBool [1]) + { + x := v.Args[0] + if v.Args[1] != x { + goto enda66da0d3e7e51624ee46527727c48a9a + } + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 1 + return true + } + goto enda66da0d3e7e51624ee46527727c48a9a +enda66da0d3e7e51624ee46527727c48a9a: + ; + // match: (Eq8 (Const8 [c]) (Const8 [d])) + // cond: + // result: (ConstBool [b2i(int8(c) == int8(d))]) + { + if v.Args[0].Op != OpConst8 { + goto endd49f3700ba2d1e500d3ab4fa34fd090d + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst8 { + goto endd49f3700ba2d1e500d3ab4fa34fd090d + } + d := v.Args[1].AuxInt + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = b2i(int8(c) == int8(d)) + return true + } + goto endd49f3700ba2d1e500d3ab4fa34fd090d +endd49f3700ba2d1e500d3ab4fa34fd090d: + ; + 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)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpEqPtr + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpITab, TypeInvalid) + v0.AddArg(x) + v0.Type = config.fe.TypeUintptr() + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpITab, TypeInvalid) + v1.AddArg(y) + v1.Type = config.fe.TypeUintptr() + v.AddArg(v1) + return true + } + goto end1cc40483caab33ece971ab7e6c8fdfca +end1cc40483caab33ece971ab7e6c8fdfca: + ; + return false +} +func rewriteValuegeneric_OpEqPtr(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (EqPtr p (ConstNil)) + // cond: + // result: (Not (IsNonNil p)) + { + p := v.Args[0] + if v.Args[1].Op != OpConstNil { + goto ende701cdb6a2c1fff4d4b283b7f8f6178b + } + v.Op = OpNot + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpIsNonNil, TypeInvalid) + v0.AddArg(p) + v0.Type = config.fe.TypeBool() + v.AddArg(v0) + return true + } + goto ende701cdb6a2c1fff4d4b283b7f8f6178b +ende701cdb6a2c1fff4d4b283b7f8f6178b: + ; + // match: (EqPtr (ConstNil) p) + // cond: + // result: (Not (IsNonNil p)) + { + if v.Args[0].Op != OpConstNil { + goto end7cdc0d5c38fbffe6287c8928803b038e + } + p := v.Args[1] + v.Op = OpNot + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpIsNonNil, TypeInvalid) + v0.AddArg(p) + v0.Type = config.fe.TypeBool() + v.AddArg(v0) + return true + } + goto end7cdc0d5c38fbffe6287c8928803b038e +end7cdc0d5c38fbffe6287c8928803b038e: + ; + 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)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpEqPtr + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpSlicePtr, TypeInvalid) + v0.AddArg(x) + v0.Type = config.fe.TypeUintptr() + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpSlicePtr, TypeInvalid) + v1.AddArg(y) + v1.Type = config.fe.TypeUintptr() + v.AddArg(v1) + return true + } + goto end9cd53ca57ee90aa09c54f8071c8e8769 +end9cd53ca57ee90aa09c54f8071c8e8769: + ; + 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))]) + { + if v.Args[0].Op != OpConst16 { + goto endbac100e9f1065e7d2ff863951f686f4b + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst16 { + goto endbac100e9f1065e7d2ff863951f686f4b + } + d := v.Args[1].AuxInt + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = b2i(int16(c) >= int16(d)) + return true + } + goto endbac100e9f1065e7d2ff863951f686f4b +endbac100e9f1065e7d2ff863951f686f4b: + ; + 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))]) + { + if v.Args[0].Op != OpConst16 { + goto end11c6acbc5827fc9508424b0ffcf98b34 + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst16 { + goto end11c6acbc5827fc9508424b0ffcf98b34 + } + d := v.Args[1].AuxInt + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = b2i(uint16(c) >= uint16(d)) + return true + } + goto end11c6acbc5827fc9508424b0ffcf98b34 +end11c6acbc5827fc9508424b0ffcf98b34: + ; + 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))]) + { + if v.Args[0].Op != OpConst32 { + goto end89ced97524ac75045911ca7cf6d44b28 + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst32 { + goto end89ced97524ac75045911ca7cf6d44b28 + } + d := v.Args[1].AuxInt + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = b2i(int32(c) >= int32(d)) + return true + } + goto end89ced97524ac75045911ca7cf6d44b28 +end89ced97524ac75045911ca7cf6d44b28: + ; + 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))]) + { + if v.Args[0].Op != OpConst32 { + goto end92fbe85c7bbbf0db287932822bdde991 + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst32 { + goto end92fbe85c7bbbf0db287932822bdde991 + } + d := v.Args[1].AuxInt + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = b2i(uint32(c) >= uint32(d)) + return true + } + goto end92fbe85c7bbbf0db287932822bdde991 +end92fbe85c7bbbf0db287932822bdde991: + ; + 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))]) + { + if v.Args[0].Op != OpConst64 { + goto end08a5a4bff12a346befe05ad561b080ac + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst64 { + goto end08a5a4bff12a346befe05ad561b080ac + } + d := v.Args[1].AuxInt + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = b2i(int64(c) >= int64(d)) + return true + } + goto end08a5a4bff12a346befe05ad561b080ac +end08a5a4bff12a346befe05ad561b080ac: + ; + 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))]) + { + if v.Args[0].Op != OpConst64 { + goto endd72c497b6cc2b01d43a39ec12d5010b3 + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst64 { + goto endd72c497b6cc2b01d43a39ec12d5010b3 + } + d := v.Args[1].AuxInt + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = b2i(uint64(c) >= uint64(d)) + return true + } + goto endd72c497b6cc2b01d43a39ec12d5010b3 +endd72c497b6cc2b01d43a39ec12d5010b3: + ; + 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))]) + { + if v.Args[0].Op != OpConst8 { + goto endea141068e84038c63cbdd87a8cb227d7 + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst8 { + goto endea141068e84038c63cbdd87a8cb227d7 + } + d := v.Args[1].AuxInt + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = b2i(int8(c) >= int8(d)) + return true + } + goto endea141068e84038c63cbdd87a8cb227d7 +endea141068e84038c63cbdd87a8cb227d7: + ; + 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))]) + { + if v.Args[0].Op != OpConst8 { + goto end47c128ccdc54151a243c5856b0c52ef1 + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst8 { + goto end47c128ccdc54151a243c5856b0c52ef1 + } + d := v.Args[1].AuxInt + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = b2i(uint8(c) >= uint8(d)) + return true + } + goto end47c128ccdc54151a243c5856b0c52ef1 +end47c128ccdc54151a243c5856b0c52ef1: + ; + 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))]) + { + if v.Args[0].Op != OpConst16 { + goto end390bae49463ace4d703dd24e18920f66 + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst16 { + goto end390bae49463ace4d703dd24e18920f66 + } + d := v.Args[1].AuxInt + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = b2i(int16(c) > int16(d)) + return true + } + goto end390bae49463ace4d703dd24e18920f66 +end390bae49463ace4d703dd24e18920f66: + ; + 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))]) + { + if v.Args[0].Op != OpConst16 { + goto end89ba3caf5c156fa6d908ac04c058187b + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst16 { + goto end89ba3caf5c156fa6d908ac04c058187b + } + d := v.Args[1].AuxInt + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = b2i(uint16(c) > uint16(d)) + return true + } + goto end89ba3caf5c156fa6d908ac04c058187b +end89ba3caf5c156fa6d908ac04c058187b: + ; + 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))]) + { + if v.Args[0].Op != OpConst32 { + goto end86482a9dc6439e8470da5352dd74d68d + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst32 { + goto end86482a9dc6439e8470da5352dd74d68d + } + d := v.Args[1].AuxInt + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = b2i(int32(c) > int32(d)) + return true + } + goto end86482a9dc6439e8470da5352dd74d68d +end86482a9dc6439e8470da5352dd74d68d: + ; + 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))]) + { + if v.Args[0].Op != OpConst32 { + goto end1bf3f05c1e3599a969b8be1f5f6949e4 + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst32 { + goto end1bf3f05c1e3599a969b8be1f5f6949e4 + } + d := v.Args[1].AuxInt + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = b2i(uint32(c) > uint32(d)) + return true + } + goto end1bf3f05c1e3599a969b8be1f5f6949e4 +end1bf3f05c1e3599a969b8be1f5f6949e4: + ; + 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))]) + { + if v.Args[0].Op != OpConst64 { + goto end96a82e893fda4882f23b6bab5f7fbff7 + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst64 { + goto end96a82e893fda4882f23b6bab5f7fbff7 + } + d := v.Args[1].AuxInt + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = b2i(int64(c) > int64(d)) + return true + } + goto end96a82e893fda4882f23b6bab5f7fbff7 +end96a82e893fda4882f23b6bab5f7fbff7: + ; + 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))]) + { + if v.Args[0].Op != OpConst64 { + goto end2d8f5ad85fbffeb92af985a888f6fa69 + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst64 { + goto end2d8f5ad85fbffeb92af985a888f6fa69 + } + d := v.Args[1].AuxInt + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = b2i(uint64(c) > uint64(d)) + return true + } + goto end2d8f5ad85fbffeb92af985a888f6fa69 +end2d8f5ad85fbffeb92af985a888f6fa69: + ; + 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))]) + { + if v.Args[0].Op != OpConst8 { + goto ende221967c7516b7749109cf8343fe9c83 + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst8 { + goto ende221967c7516b7749109cf8343fe9c83 + } + d := v.Args[1].AuxInt + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = b2i(int8(c) > int8(d)) + return true + } + goto ende221967c7516b7749109cf8343fe9c83 +ende221967c7516b7749109cf8343fe9c83: + ; + 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))]) + { + if v.Args[0].Op != OpConst8 { + goto enda9398c8188156dd46689fa2939147525 + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst8 { + goto enda9398c8188156dd46689fa2939147525 + } + d := v.Args[1].AuxInt + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = b2i(uint8(c) > uint8(d)) + return true + } + goto enda9398c8188156dd46689fa2939147525 +enda9398c8188156dd46689fa2939147525: + ; + return false +} +func rewriteValuegeneric_OpIData(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (IData (IMake _ data)) + // cond: + // result: data + { + if v.Args[0].Op != OpIMake { + goto endbfa1bb944cdc07933effb16a35152e12 + } + data := v.Args[0].Args[1] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = data.Type + v.AddArg(data) + return true + } + goto endbfa1bb944cdc07933effb16a35152e12 +endbfa1bb944cdc07933effb16a35152e12: + ; + return false +} +func rewriteValuegeneric_OpITab(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (ITab (IMake itab _)) + // cond: + // result: itab + { + if v.Args[0].Op != OpIMake { + goto endfcbb9414a776ff9c8512da3e0f4d8fbd + } + itab := v.Args[0].Args[0] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = itab.Type + v.AddArg(itab) + return true + } + goto endfcbb9414a776ff9c8512da3e0f4d8fbd +endfcbb9414a776ff9c8512da3e0f4d8fbd: + ; + 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))]) + { + if v.Args[0].Op != OpConst32 { + goto endf0a2ecfe84b293de6ff0919e45d19d9d + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst32 { + goto endf0a2ecfe84b293de6ff0919e45d19d9d + } + d := v.Args[1].AuxInt + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = b2i(inBounds32(c, d)) + return true + } + goto endf0a2ecfe84b293de6ff0919e45d19d9d +endf0a2ecfe84b293de6ff0919e45d19d9d: + ; + // match: (IsInBounds (Const64 [c]) (Const64 [d])) + // cond: + // result: (ConstBool [b2i(inBounds64(c,d))]) + { + if v.Args[0].Op != OpConst64 { + goto end4b406f402c135f50f71effcc904ecb2b + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst64 { + goto end4b406f402c135f50f71effcc904ecb2b + } + d := v.Args[1].AuxInt + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = b2i(inBounds64(c, d)) + return true + } + goto end4b406f402c135f50f71effcc904ecb2b +end4b406f402c135f50f71effcc904ecb2b: + ; + // match: (IsInBounds (ConstPtr [c]) (ConstPtr [d])) + // cond: config.PtrSize == 4 + // result: (ConstBool [b2i(inBounds32(c,d))]) + { + if v.Args[0].Op != OpConstPtr { + goto end4323278ec7a053034fcf7033697d7b3b + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConstPtr { + goto end4323278ec7a053034fcf7033697d7b3b + } + d := v.Args[1].AuxInt + if !(config.PtrSize == 4) { + goto end4323278ec7a053034fcf7033697d7b3b + } + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = b2i(inBounds32(c, d)) + return true + } + goto end4323278ec7a053034fcf7033697d7b3b +end4323278ec7a053034fcf7033697d7b3b: + ; + // match: (IsInBounds (ConstPtr [c]) (ConstPtr [d])) + // cond: config.PtrSize == 8 + // result: (ConstBool [b2i(inBounds64(c,d))]) + { + if v.Args[0].Op != OpConstPtr { + goto endb550b8814df20b5eeda4f43cc94e902b + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConstPtr { + goto endb550b8814df20b5eeda4f43cc94e902b + } + d := v.Args[1].AuxInt + if !(config.PtrSize == 8) { + goto endb550b8814df20b5eeda4f43cc94e902b + } + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = b2i(inBounds64(c, d)) + return true + } + goto endb550b8814df20b5eeda4f43cc94e902b +endb550b8814df20b5eeda4f43cc94e902b: + ; + 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))]) + { + if v.Args[0].Op != OpConst16 { + goto end76b1c51f9b7cd7ee2f75b9f7057569de + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst16 { + goto end76b1c51f9b7cd7ee2f75b9f7057569de + } + d := v.Args[1].AuxInt + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = b2i(int16(c) <= int16(d)) + return true + } + goto end76b1c51f9b7cd7ee2f75b9f7057569de +end76b1c51f9b7cd7ee2f75b9f7057569de: + ; + 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))]) + { + if v.Args[0].Op != OpConst16 { + goto endf010fdf7f2c438ec18c33f493dd062aa + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst16 { + goto endf010fdf7f2c438ec18c33f493dd062aa + } + d := v.Args[1].AuxInt + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = b2i(uint16(c) <= uint16(d)) + return true + } + goto endf010fdf7f2c438ec18c33f493dd062aa +endf010fdf7f2c438ec18c33f493dd062aa: + ; + 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))]) + { + if v.Args[0].Op != OpConst32 { + goto end6c7d61cfd188680bea8a5e23f08ca1de + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst32 { + goto end6c7d61cfd188680bea8a5e23f08ca1de + } + d := v.Args[1].AuxInt + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = b2i(int32(c) <= int32(d)) + return true + } + goto end6c7d61cfd188680bea8a5e23f08ca1de +end6c7d61cfd188680bea8a5e23f08ca1de: + ; + 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))]) + { + if v.Args[0].Op != OpConst32 { + goto end4363555333511ee9b649b36f1a0ba34e + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst32 { + goto end4363555333511ee9b649b36f1a0ba34e + } + d := v.Args[1].AuxInt + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = b2i(uint32(c) <= uint32(d)) + return true + } + goto end4363555333511ee9b649b36f1a0ba34e +end4363555333511ee9b649b36f1a0ba34e: ; return false } -func rewriteValuegeneric_OpEq64(v *Value, config *Config) bool { +func rewriteValuegeneric_OpLeq64(v *Value, config *Config) bool { b := v.Block _ = b - // match: (Eq64 x x) + // match: (Leq64 (Const64 [c]) (Const64 [d])) // cond: - // result: (ConstBool [1]) + // result: (ConstBool [b2i(int64(c) <= int64(d))]) { - x := v.Args[0] - if v.Args[1] != x { - goto endb1d471cc503ba8bb05440f01dbf33d81 + if v.Args[0].Op != OpConst64 { + goto enddc865cd7ac2093abc7617bedbf371c22 + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst64 { + goto enddc865cd7ac2093abc7617bedbf371c22 } + d := v.Args[1].AuxInt v.Op = OpConstBool v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = 1 + v.AuxInt = b2i(int64(c) <= int64(d)) return true } - goto endb1d471cc503ba8bb05440f01dbf33d81 -endb1d471cc503ba8bb05440f01dbf33d81: + goto enddc865cd7ac2093abc7617bedbf371c22 +enddc865cd7ac2093abc7617bedbf371c22: ; return false } -func rewriteValuegeneric_OpEq8(v *Value, config *Config) bool { +func rewriteValuegeneric_OpLeq64U(v *Value, config *Config) bool { b := v.Block _ = b - // match: (Eq8 x x) + // match: (Leq64U (Const64 [c]) (Const64 [d])) // cond: - // result: (ConstBool [1]) + // result: (ConstBool [b2i(uint64(c) <= uint64(d))]) { - x := v.Args[0] - if v.Args[1] != x { - goto enda66da0d3e7e51624ee46527727c48a9a + if v.Args[0].Op != OpConst64 { + goto end412eadb168738ba92f3f0705d4495305 + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst64 { + goto end412eadb168738ba92f3f0705d4495305 } + d := v.Args[1].AuxInt v.Op = OpConstBool v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = 1 + v.AuxInt = b2i(uint64(c) <= uint64(d)) return true } - goto enda66da0d3e7e51624ee46527727c48a9a -enda66da0d3e7e51624ee46527727c48a9a: + goto end412eadb168738ba92f3f0705d4495305 +end412eadb168738ba92f3f0705d4495305: ; return false } -func rewriteValuegeneric_OpEqInter(v *Value, config *Config) bool { +func rewriteValuegeneric_OpLeq8(v *Value, config *Config) bool { b := v.Block _ = b - // match: (EqInter x y) + // match: (Leq8 (Const8 [c]) (Const8 [d])) // cond: - // result: (EqPtr (ITab x) (ITab y)) + // result: (ConstBool [b2i(int8(c) <= int8(d))]) { - x := v.Args[0] - y := v.Args[1] - v.Op = OpEqPtr + if v.Args[0].Op != OpConst8 { + goto endb5a459da8e18c40abc0c7a20e71d0187 + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst8 { + goto endb5a459da8e18c40abc0c7a20e71d0187 + } + d := v.Args[1].AuxInt + v.Op = OpConstBool v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpITab, TypeInvalid) - v0.AddArg(x) - v0.Type = config.fe.TypeUintptr() - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpITab, TypeInvalid) - v1.AddArg(y) - v1.Type = config.fe.TypeUintptr() - v.AddArg(v1) + v.AuxInt = b2i(int8(c) <= int8(d)) return true } - goto end1cc40483caab33ece971ab7e6c8fdfca -end1cc40483caab33ece971ab7e6c8fdfca: + goto endb5a459da8e18c40abc0c7a20e71d0187 +endb5a459da8e18c40abc0c7a20e71d0187: ; return false } -func rewriteValuegeneric_OpEqPtr(v *Value, config *Config) bool { +func rewriteValuegeneric_OpLeq8U(v *Value, config *Config) bool { b := v.Block _ = b - // match: (EqPtr p (ConstNil)) + // match: (Leq8U (Const8 [c]) (Const8 [d])) // cond: - // result: (Not (IsNonNil p)) + // result: (ConstBool [b2i(uint8(c) <= uint8(d))]) { - p := v.Args[0] - if v.Args[1].Op != OpConstNil { - goto ende701cdb6a2c1fff4d4b283b7f8f6178b + if v.Args[0].Op != OpConst8 { + goto endd6622d55fcdf3fa7b08e7511cd3b7d85 } - v.Op = OpNot + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst8 { + goto endd6622d55fcdf3fa7b08e7511cd3b7d85 + } + d := v.Args[1].AuxInt + v.Op = OpConstBool v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpIsNonNil, TypeInvalid) - v0.AddArg(p) - v0.Type = config.fe.TypeBool() - v.AddArg(v0) + v.AuxInt = b2i(uint8(c) <= uint8(d)) return true } - goto ende701cdb6a2c1fff4d4b283b7f8f6178b -ende701cdb6a2c1fff4d4b283b7f8f6178b: + goto endd6622d55fcdf3fa7b08e7511cd3b7d85 +endd6622d55fcdf3fa7b08e7511cd3b7d85: ; - // match: (EqPtr (ConstNil) p) + return false +} +func rewriteValuegeneric_OpLess16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Less16 (Const16 [c]) (Const16 [d])) // cond: - // result: (Not (IsNonNil p)) + // result: (ConstBool [b2i(int16(c) < int16(d))]) { - if v.Args[0].Op != OpConstNil { - goto end7cdc0d5c38fbffe6287c8928803b038e + if v.Args[0].Op != OpConst16 { + goto end0dc915d089f05e79589ebb5c498cc360 } - p := v.Args[1] - v.Op = OpNot + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst16 { + goto end0dc915d089f05e79589ebb5c498cc360 + } + d := v.Args[1].AuxInt + v.Op = OpConstBool v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpIsNonNil, TypeInvalid) - v0.AddArg(p) - v0.Type = config.fe.TypeBool() - v.AddArg(v0) + v.AuxInt = b2i(int16(c) < int16(d)) return true } - goto end7cdc0d5c38fbffe6287c8928803b038e -end7cdc0d5c38fbffe6287c8928803b038e: + goto end0dc915d089f05e79589ebb5c498cc360 +end0dc915d089f05e79589ebb5c498cc360: ; return false } -func rewriteValuegeneric_OpEqSlice(v *Value, config *Config) bool { +func rewriteValuegeneric_OpLess16U(v *Value, config *Config) bool { b := v.Block _ = b - // match: (EqSlice x y) + // match: (Less16U (Const16 [c]) (Const16 [d])) // cond: - // result: (EqPtr (SlicePtr x) (SlicePtr y)) + // result: (ConstBool [b2i(uint16(c) < uint16(d))]) { - x := v.Args[0] - y := v.Args[1] - v.Op = OpEqPtr + if v.Args[0].Op != OpConst16 { + goto endd2bb8249443788690946fc184631a00a + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst16 { + goto endd2bb8249443788690946fc184631a00a + } + d := v.Args[1].AuxInt + v.Op = OpConstBool v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpSlicePtr, TypeInvalid) - v0.AddArg(x) - v0.Type = config.fe.TypeUintptr() - v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpSlicePtr, TypeInvalid) - v1.AddArg(y) - v1.Type = config.fe.TypeUintptr() - v.AddArg(v1) + v.AuxInt = b2i(uint16(c) < uint16(d)) return true } - goto end9cd53ca57ee90aa09c54f8071c8e8769 -end9cd53ca57ee90aa09c54f8071c8e8769: + goto endd2bb8249443788690946fc184631a00a +endd2bb8249443788690946fc184631a00a: ; return false } -func rewriteValuegeneric_OpIData(v *Value, config *Config) bool { +func rewriteValuegeneric_OpLess32(v *Value, config *Config) bool { b := v.Block _ = b - // match: (IData (IMake _ data)) + // match: (Less32 (Const32 [c]) (Const32 [d])) // cond: - // result: data + // result: (ConstBool [b2i(int32(c) < int32(d))]) { - if v.Args[0].Op != OpIMake { - goto endbfa1bb944cdc07933effb16a35152e12 + if v.Args[0].Op != OpConst32 { + goto endc86f65e499688809d414f03539bec5bf } - data := v.Args[0].Args[1] - v.Op = OpCopy + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst32 { + goto endc86f65e499688809d414f03539bec5bf + } + d := v.Args[1].AuxInt + v.Op = OpConstBool v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Type = data.Type - v.AddArg(data) + v.AuxInt = b2i(int32(c) < int32(d)) return true } - goto endbfa1bb944cdc07933effb16a35152e12 -endbfa1bb944cdc07933effb16a35152e12: + goto endc86f65e499688809d414f03539bec5bf +endc86f65e499688809d414f03539bec5bf: ; return false } -func rewriteValuegeneric_OpITab(v *Value, config *Config) bool { +func rewriteValuegeneric_OpLess32U(v *Value, config *Config) bool { b := v.Block _ = b - // match: (ITab (IMake itab _)) + // match: (Less32U (Const32 [c]) (Const32 [d])) // cond: - // result: itab + // result: (ConstBool [b2i(uint32(c) < uint32(d))]) { - if v.Args[0].Op != OpIMake { - goto endfcbb9414a776ff9c8512da3e0f4d8fbd + if v.Args[0].Op != OpConst32 { + goto end2cc68b5247b1afb90a9d3923b28ff247 } - itab := v.Args[0].Args[0] - v.Op = OpCopy + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst32 { + goto end2cc68b5247b1afb90a9d3923b28ff247 + } + d := v.Args[1].AuxInt + v.Op = OpConstBool v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Type = itab.Type - v.AddArg(itab) + v.AuxInt = b2i(uint32(c) < uint32(d)) return true } - goto endfcbb9414a776ff9c8512da3e0f4d8fbd -endfcbb9414a776ff9c8512da3e0f4d8fbd: + goto end2cc68b5247b1afb90a9d3923b28ff247 +end2cc68b5247b1afb90a9d3923b28ff247: ; return false } -func rewriteValuegeneric_OpIsInBounds(v *Value, config *Config) bool { +func rewriteValuegeneric_OpLess64(v *Value, config *Config) bool { b := v.Block _ = b - // match: (IsInBounds (Const32 [c]) (Const32 [d])) + // match: (Less64 (Const64 [c]) (Const64 [d])) // cond: - // result: (ConstBool [b2i(inBounds32(c,d))]) + // result: (ConstBool [b2i(int64(c) < int64(d))]) { - if v.Args[0].Op != OpConst32 { - goto endf0a2ecfe84b293de6ff0919e45d19d9d + if v.Args[0].Op != OpConst64 { + goto end505de73cd15125dbb59b05d8975d3128 } c := v.Args[0].AuxInt - if v.Args[1].Op != OpConst32 { - goto endf0a2ecfe84b293de6ff0919e45d19d9d + if v.Args[1].Op != OpConst64 { + goto end505de73cd15125dbb59b05d8975d3128 } d := v.Args[1].AuxInt v.Op = OpConstBool v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = b2i(inBounds32(c, d)) + v.AuxInt = b2i(int64(c) < int64(d)) return true } - goto endf0a2ecfe84b293de6ff0919e45d19d9d -endf0a2ecfe84b293de6ff0919e45d19d9d: + goto end505de73cd15125dbb59b05d8975d3128 +end505de73cd15125dbb59b05d8975d3128: ; - // match: (IsInBounds (Const64 [c]) (Const64 [d])) + return false +} +func rewriteValuegeneric_OpLess64U(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Less64U (Const64 [c]) (Const64 [d])) // cond: - // result: (ConstBool [b2i(inBounds64(c,d))]) + // result: (ConstBool [b2i(uint64(c) < uint64(d))]) { if v.Args[0].Op != OpConst64 { - goto end4b406f402c135f50f71effcc904ecb2b + goto endeb249ef36416cd1abf4f807026c059cd } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst64 { - goto end4b406f402c135f50f71effcc904ecb2b + goto endeb249ef36416cd1abf4f807026c059cd } d := v.Args[1].AuxInt v.Op = OpConstBool v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = b2i(inBounds64(c, d)) + v.AuxInt = b2i(uint64(c) < uint64(d)) return true } - goto end4b406f402c135f50f71effcc904ecb2b -end4b406f402c135f50f71effcc904ecb2b: + goto endeb249ef36416cd1abf4f807026c059cd +endeb249ef36416cd1abf4f807026c059cd: ; - // match: (IsInBounds (ConstPtr [c]) (ConstPtr [d])) - // cond: config.PtrSize == 4 - // result: (ConstBool [b2i(inBounds32(c,d))]) + 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))]) { - if v.Args[0].Op != OpConstPtr { - goto end4323278ec7a053034fcf7033697d7b3b + if v.Args[0].Op != OpConst8 { + goto endef134de03bc8537ac1f38d5eccff7673 } c := v.Args[0].AuxInt - if v.Args[1].Op != OpConstPtr { - goto end4323278ec7a053034fcf7033697d7b3b + if v.Args[1].Op != OpConst8 { + goto endef134de03bc8537ac1f38d5eccff7673 } d := v.Args[1].AuxInt - if !(config.PtrSize == 4) { - goto end4323278ec7a053034fcf7033697d7b3b - } v.Op = OpConstBool v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = b2i(inBounds32(c, d)) + v.AuxInt = b2i(int8(c) < int8(d)) return true } - goto end4323278ec7a053034fcf7033697d7b3b -end4323278ec7a053034fcf7033697d7b3b: + goto endef134de03bc8537ac1f38d5eccff7673 +endef134de03bc8537ac1f38d5eccff7673: ; - // match: (IsInBounds (ConstPtr [c]) (ConstPtr [d])) - // cond: config.PtrSize == 8 - // result: (ConstBool [b2i(inBounds64(c,d))]) + 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))]) { - if v.Args[0].Op != OpConstPtr { - goto endb550b8814df20b5eeda4f43cc94e902b + if v.Args[0].Op != OpConst8 { + goto end263ecdc279924bff8771dd1ac3f42222 } c := v.Args[0].AuxInt - if v.Args[1].Op != OpConstPtr { - goto endb550b8814df20b5eeda4f43cc94e902b + if v.Args[1].Op != OpConst8 { + goto end263ecdc279924bff8771dd1ac3f42222 } d := v.Args[1].AuxInt - if !(config.PtrSize == 8) { - goto endb550b8814df20b5eeda4f43cc94e902b - } v.Op = OpConstBool v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = b2i(inBounds64(c, d)) + v.AuxInt = b2i(uint8(c) < uint8(d)) return true } - goto endb550b8814df20b5eeda4f43cc94e902b -endb550b8814df20b5eeda4f43cc94e902b: + goto end263ecdc279924bff8771dd1ac3f42222 +end263ecdc279924bff8771dd1ac3f42222: ; return false } @@ -1157,6 +2173,28 @@ func rewriteValuegeneric_OpNeq16(v *Value, config *Config) bool { } goto ende76a50b524aeb16c7aeccf5f5cc60c06 ende76a50b524aeb16c7aeccf5f5cc60c06: + ; + // match: (Neq16 (Const16 [c]) (Const16 [d])) + // cond: + // result: (ConstBool [b2i(int16(c) != int16(d))]) + { + if v.Args[0].Op != OpConst16 { + goto end6302c9b645bb191982d28c2f846904d6 + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst16 { + goto end6302c9b645bb191982d28c2f846904d6 + } + d := v.Args[1].AuxInt + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = b2i(int16(c) != int16(d)) + return true + } + goto end6302c9b645bb191982d28c2f846904d6 +end6302c9b645bb191982d28c2f846904d6: ; return false } @@ -1180,6 +2218,28 @@ func rewriteValuegeneric_OpNeq32(v *Value, config *Config) bool { } goto end3713a608cffd29b40ff7c3b3f2585cbb end3713a608cffd29b40ff7c3b3f2585cbb: + ; + // match: (Neq32 (Const32 [c]) (Const32 [d])) + // cond: + // result: (ConstBool [b2i(int32(c) != int32(d))]) + { + if v.Args[0].Op != OpConst32 { + goto endf9f3d0814854d2d0879d331e9bdfcae2 + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst32 { + goto endf9f3d0814854d2d0879d331e9bdfcae2 + } + d := v.Args[1].AuxInt + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = b2i(int32(c) != int32(d)) + return true + } + goto endf9f3d0814854d2d0879d331e9bdfcae2 +endf9f3d0814854d2d0879d331e9bdfcae2: ; return false } @@ -1203,6 +2263,28 @@ func rewriteValuegeneric_OpNeq64(v *Value, config *Config) bool { } goto end3601ad382705ea12b79d2008c1e5725c end3601ad382705ea12b79d2008c1e5725c: + ; + // match: (Neq64 (Const64 [c]) (Const64 [d])) + // cond: + // result: (ConstBool [b2i(int64(c) != int64(d))]) + { + if v.Args[0].Op != OpConst64 { + goto endf07433ecd3c150b1b75e943aa44a7203 + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst64 { + goto endf07433ecd3c150b1b75e943aa44a7203 + } + d := v.Args[1].AuxInt + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = b2i(int64(c) != int64(d)) + return true + } + goto endf07433ecd3c150b1b75e943aa44a7203 +endf07433ecd3c150b1b75e943aa44a7203: ; return false } @@ -1226,6 +2308,28 @@ func rewriteValuegeneric_OpNeq8(v *Value, config *Config) bool { } goto end09a0deaf3c42627d0d2d3efa96e30745 end09a0deaf3c42627d0d2d3efa96e30745: + ; + // match: (Neq8 (Const8 [c]) (Const8 [d])) + // cond: + // result: (ConstBool [b2i(int8(c) != int8(d))]) + { + if v.Args[0].Op != OpConst8 { + goto end72ebdaf2de9b3aa57cf0cb8e068b5f9c + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst8 { + goto end72ebdaf2de9b3aa57cf0cb8e068b5f9c + } + d := v.Args[1].AuxInt + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = b2i(int8(c) != int8(d)) + return true + } + goto end72ebdaf2de9b3aa57cf0cb8e068b5f9c +end72ebdaf2de9b3aa57cf0cb8e068b5f9c: ; return false } -- cgit v1.3 From 729abfa35ca19a3ec9bd11a8c25eecac5eba6cc9 Mon Sep 17 00:00:00 2001 From: David Chase Date: Mon, 26 Oct 2015 17:34:06 -0400 Subject: [dev.ssa] cmd/compile: default compile+test with SSA Some tests disabled, some bifurcated into _ssa and not, with appropriate logging added to compiler. "tests/live.go" in particular needs attention. SSA-specific testing removed, since it's all SSA now. Added "-run_skips" option to tests/run.go to simplify checking whether a test still fails (or how it fails) on a skipped platform. The compiler now compiles with SSA by default. If you don't want SSA, specify GOSSAHASH=n (or N) as an environment variable. Function names ending in "_ssa" are always SSA-compiled. GOSSAFUNC=fname retains its "SSA for fname, log to ssa.html" GOSSAPKG=pkg only has an effect when GOSSAHASH=n GOSSAHASH=10101 etc retains its name-hash-matching behavior for purposes of debugging. See #13068 Change-Id: I8217bfeb34173533eaeb391b5f6935483c7d6b43 Reviewed-on: https://go-review.googlesource.com/16299 Reviewed-by: Keith Randall Run-TryBot: David Chase --- src/cmd/compile/internal/gc/ssa.go | 48 +++++-- src/cmd/compile/internal/ssa/config.go | 14 +- src/cmd/compile/internal/ssa/export_test.go | 8 +- src/cmd/compile/internal/ssa/nilcheck.go | 7 + src/cmd/dist/test.go | 34 ----- test/live.go | 1 + test/live2.go | 1 + test/nilcheck.go | 99 +++++++------- test/nilcheck_ssa.go | 187 +++++++++++++++++++++++++++ test/nilptr3.go | 2 +- test/nilptr3_ssa.go | 194 ++++++++++++++++++++++++++++ test/run.go | 7 + test/sliceopt.go | 1 + 13 files changed, 500 insertions(+), 103 deletions(-) create mode 100644 test/nilcheck_ssa.go create mode 100644 test/nilptr3_ssa.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index b96661d15e..521e6d7ffa 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -34,10 +34,10 @@ func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { // 1. IF GOSSAFUNC == current function name THEN // compile this function with SSA and log output to ssa.html - // 2. IF GOSSAHASH == "y" or "Y" THEN + // 2. IF GOSSAHASH == "" THEN // compile this function (and everything else) with SSA - // 3. IF GOSSAHASH == "" THEN + // 3. IF GOSSAHASH == "n" or "N" // IF GOSSAPKG == current package name THEN // compile this function (and everything in this package) with SSA // ELSE @@ -49,9 +49,10 @@ func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { // ELSE // compile this function with the old back end. - // Plan is for 3 to be remove, and the 2) dependence on GOSSAHASH changes - // from "y"/"Y" to empty -- then SSA is default, and is disabled by setting - // GOSSAHASH to a value that is neither 0 nor 1 (e.g., "N" or "X") + // 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. if usessa { fmt.Println("generating SSA for", name) @@ -183,10 +184,11 @@ func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { // Main call to ssa package to compile function ssa.Compile(s.f) - if usessa || gossahash == "y" || gossahash == "Y" { + // gossahash = "y" is historical/symmetric-with-"n" -- i.e., not really needed. + if usessa || gossahash == "" || gossahash == "y" || gossahash == "Y" { return s.f, true } - if gossahash == "" { + if gossahash == "n" || gossahash == "N" { if localpkg.Name != os.Getenv("GOSSAPKG") { return s.f, false } @@ -298,9 +300,11 @@ func (s *state) label(sym *Sym) *ssaLabel { return lab } -func (s *state) Logf(msg string, args ...interface{}) { s.config.Logf(msg, args...) } -func (s *state) Fatalf(msg string, args ...interface{}) { s.config.Fatalf(msg, args...) } -func (s *state) Unimplementedf(msg string, args ...interface{}) { s.config.Unimplementedf(msg, args...) } +func (s *state) Logf(msg string, args ...interface{}) { s.config.Logf(msg, args...) } +func (s *state) Fatalf(msg string, args ...interface{}) { s.config.Fatalf(msg, args...) } +func (s *state) Unimplementedf(msg string, args ...interface{}) { s.config.Unimplementedf(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 @@ -1997,7 +2001,7 @@ func (s *state) expr(n *Node) *ssa.Value { if haspointers(et) { // TODO: just one write barrier call for all of these writes? // TODO: maybe just one writeBarrierEnabled check? - s.insertWB(et, addr) + s.insertWB(et, addr, n.Lineno) } } @@ -2044,7 +2048,7 @@ func (s *state) assign(left *Node, right *ssa.Value, wb bool) { } s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, t.Size(), addr, right, s.mem()) if wb { - s.insertWB(left.Type, addr) + s.insertWB(left.Type, addr, left.Lineno) } } @@ -2566,7 +2570,7 @@ func (s *state) rtcall(fn *Node, returns bool, results []*Type, args ...*ssa.Val // been stored at location p. Tell the runtime about this write. // Note: there must be no GC suspension points between the write and // the call that this function inserts. -func (s *state) insertWB(t *Type, p *ssa.Value) { +func (s *state) insertWB(t *Type, p *ssa.Value, line int32) { // if writeBarrierEnabled { // typedmemmove_nostore(&t, p) // } @@ -2586,6 +2590,10 @@ func (s *state) insertWB(t *Type, p *ssa.Value) { taddr := s.newValue1A(ssa.OpAddr, Types[TUINTPTR], &ssa.ExternSymbol{Types[TUINTPTR], typenamesym(t)}, s.sb) s.rtcall(typedmemmove_nostore, true, nil, taddr, p) + if Debug_wb > 0 { + Warnl(int(line), "write barrier") + } + b.AddEdgeTo(s.curBlock) } @@ -2985,6 +2993,10 @@ func (s *state) dottype(n *Node, commaok bool) (res, resok *ssa.Value) { 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) @@ -4523,6 +4535,16 @@ func (e *ssaExport) Unimplementedf(msg string, args ...interface{}) { 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/ssa/config.go b/src/cmd/compile/internal/ssa/config.go index cfba10bc24..014c960267 100644 --- a/src/cmd/compile/internal/ssa/config.go +++ b/src/cmd/compile/internal/ssa/config.go @@ -49,6 +49,12 @@ type Logger interface { // Unimplemented reports that the function cannot be compiled. // It will be removed once SSA work is complete. Unimplementedf(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 { @@ -100,9 +106,11 @@ func (c *Config) NewFunc() *Func { return &Func{Config: c, NamedValues: map[GCNode][]*Value{}} } -func (c *Config) Logf(msg string, args ...interface{}) { c.fe.Logf(msg, args...) } -func (c *Config) Fatalf(msg string, args ...interface{}) { c.fe.Fatalf(msg, args...) } -func (c *Config) Unimplementedf(msg string, args ...interface{}) { c.fe.Unimplementedf(msg, args...) } +func (c *Config) Logf(msg string, args ...interface{}) { c.fe.Logf(msg, args...) } +func (c *Config) Fatalf(msg string, args ...interface{}) { c.fe.Fatalf(msg, args...) } +func (c *Config) Unimplementedf(msg string, args ...interface{}) { c.fe.Unimplementedf(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() } // TODO(khr): do we really need a separate Config, or can we just // store all its fields inside a Func? diff --git a/src/cmd/compile/internal/ssa/export_test.go b/src/cmd/compile/internal/ssa/export_test.go index d0ba7b1c09..c37db75803 100644 --- a/src/cmd/compile/internal/ssa/export_test.go +++ b/src/cmd/compile/internal/ssa/export_test.go @@ -32,9 +32,11 @@ func (DummyFrontend) Auto(t Type) GCNode { return nil } -func (d DummyFrontend) Logf(msg string, args ...interface{}) { d.t.Logf(msg, args...) } -func (d DummyFrontend) Fatalf(msg string, args ...interface{}) { d.t.Fatalf(msg, args...) } -func (d DummyFrontend) Unimplementedf(msg string, args ...interface{}) { d.t.Fatalf(msg, args...) } +func (d DummyFrontend) Logf(msg string, args ...interface{}) { d.t.Logf(msg, args...) } +func (d DummyFrontend) Fatalf(msg string, args ...interface{}) { d.t.Fatalf(msg, args...) } +func (d DummyFrontend) Unimplementedf(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 } diff --git a/src/cmd/compile/internal/ssa/nilcheck.go b/src/cmd/compile/internal/ssa/nilcheck.go index 5b012a8551..f8caa7b042 100644 --- a/src/cmd/compile/internal/ssa/nilcheck.go +++ b/src/cmd/compile/internal/ssa/nilcheck.go @@ -88,6 +88,13 @@ func nilcheckelim(f *Func) { // 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 diff --git a/src/cmd/dist/test.go b/src/cmd/dist/test.go index be6cdb5c0b..0afe4c6060 100644 --- a/src/cmd/dist/test.go +++ b/src/cmd/dist/test.go @@ -13,7 +13,6 @@ import ( "log" "os" "os/exec" - "path" "path/filepath" "regexp" "strconv" @@ -276,31 +275,6 @@ func (t *tester) registerStdTest(pkg string) { }) } -// TODO: Remove when SSA codegen is used by default. -func (t *tester) registerSSATest(pkg string) { - t.tests = append(t.tests, distTest{ - name: "go_test_ssa:" + pkg, - heading: "Testing packages with SSA codegen.", - fn: func() error { - args := []string{ - "test", - "-short", - t.timeout(180 * 3), // SSA generates slower code right now - "-gcflags=" + os.Getenv("GO_GCFLAGS"), - } - if t.race { - args = append(args, "-race") - } - args = append(args, pkg) - cmd := exec.Command("go", args...) - cmd.Env = mergeEnvLists([]string{"GOSSAPKG=" + path.Base(pkg)}, os.Environ()) - cmd.Stdout = os.Stdout - cmd.Stderr = os.Stderr - return cmd.Run() - }, - }) -} - func (t *tester) registerRaceBenchTest(pkg string) { testName := "go_test_bench:" + pkg if t.runRx == nil || t.runRx.MatchString(testName) { @@ -344,9 +318,6 @@ func (t *tester) registerTests() { if strings.HasPrefix(name, "go_test_bench:") { t.registerRaceBenchTest(strings.TrimPrefix(name, "go_test_bench:")) } - if t.goarch == "amd64" && strings.HasPrefix(name, "go_test_ssa:") { - t.registerSSATest(strings.TrimPrefix(name, "go_test_ssa:")) - } } } else { // Use a format string to only list packages and commands that have tests. @@ -363,11 +334,6 @@ func (t *tester) registerTests() { for _, pkg := range pkgs { t.registerStdTest(pkg) } - if t.goarch == "amd64" { - for _, pkg := range pkgs { - t.registerSSATest(pkg) - } - } if t.race { for _, pkg := range pkgs { t.registerRaceBenchTest(pkg) diff --git a/test/live.go b/test/live.go index ae982f4957..c54f091d1b 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 7474756157..430f9feb7e 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 99c3c5fdb6..173fcb33a6 100644 --- a/test/nilcheck.go +++ b/test/nilcheck.go @@ -1,3 +1,4 @@ +// +build !amd64 // errorcheck -0 -N -d=nil // Copyright 2013 The Go Authors. All rights reserved. @@ -17,7 +18,7 @@ type Struct struct { type BigStruct struct { X int Y float64 - A [1<<20]int + A [1 << 20]int Z string } @@ -29,86 +30,86 @@ type Empty1 struct { } 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 +139,7 @@ func f3b() { _ = &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 +147,33 @@ func f4(x *[10]int) { // 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/nilcheck_ssa.go b/test/nilcheck_ssa.go new file mode 100644 index 0000000000..a20cfd8ae6 --- /dev/null +++ b/test/nilcheck_ssa.go @@ -0,0 +1,187 @@ +// +build amd64 +// errorcheck -0 -N -d=nil + +// 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 inserted. +// Optimization is disabled, so redundant checks are not removed. + +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 "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" +} + +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 "nil check" + _ = *arrayp // ERROR "nil check" + _ = *array0p // ERROR "nil check" + _ = *array0p // ERROR "removed nil check" + _ = *intp // ERROR "removed nil check" + _ = *arrayp // ERROR "removed nil check" + _ = *structp // ERROR "nil check" + _ = *emptyp // ERROR "nil check" + _ = *arrayp // ERROR "removed nil check" + _ = *bigarrayp // ERROR "nil check" + _ = *bigstructp // ERROR "nil check" + _ = *empty1p // ERROR "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 "nil check" + + for { + if x[9999] != 0 { // ERROR "removed nil check" + break + } + } + + x = fx10k() + _ = x[9999] // ERROR "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 "nil check" + } else { + _ = x[9999] // ERROR "nil check" + } + _ = x[9999] // ERROR "nil check" + + fx10k() + // SSA nilcheck removal works across calls. + _ = x[9999] // ERROR "removed nil check" +} + +func f3a() { + x := fx10k() + y := fx10k() + z := fx10k() + _ = &x[9] // ERROR "nil check" + y = z + _ = &x[9] // ERROR "removed nil check" + x = y + _ = &x[9] // ERROR "nil check" +} + +func f3b() { + x := fx10k() + y := fx10k() + _ = &x[9] // ERROR "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 "nil check" + + for { + if x[9] != 0 { // ERROR "removed nil check" + break + } + } + + x = fx10() + _ = x[9] // ERROR "nil check" + 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 "nil check" + } else { + _ = &x[9] // ERROR "nil check" + } + _ = x[9] // ERROR "nil check" + + fx10() + _ = x[9] // ERROR "removed nil check" + + x = fx10() + y := fx10() + _ = &x[9] // ERROR "nil check" + y = x + _ = &x[9] // ERROR "removed nil check" + x = y + _ = &x[9] // ERROR "removed nil check" +} + +func f5(m map[string]struct{}) bool { + // Existence-only map lookups should not generate a nil check + _, ok := m[""] + return ok +} diff --git a/test/nilptr3.go b/test/nilptr3.go index 607c6fb984..33045207b2 100644 --- a/test/nilptr3.go +++ b/test/nilptr3.go @@ -1,7 +1,7 @@ // errorcheck -0 -d=nil // Fails on ppc64x because of incomplete optimization. // See issues 9058. -// +build !ppc64,!ppc64le +// +build !ppc64,!ppc64le,!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 0000000000..9824ce1cc0 --- /dev/null +++ b/test/nilptr3_ssa.go @@ -0,0 +1,194 @@ +// 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 "generated nil check" // bug would like to remove before indirect + + 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" +} diff --git a/test/run.go b/test/run.go index 57b386de99..425db6ed4e 100644 --- a/test/run.go +++ b/test/run.go @@ -37,6 +37,7 @@ var ( 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)") 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") @@ -328,6 +329,9 @@ type context struct { // 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, "//") { @@ -470,6 +474,9 @@ func (t *test) run() { args = args[1:] } case "skip": + if *runSkips { + break + } t.action = "skip" return default: diff --git a/test/sliceopt.go b/test/sliceopt.go index c9d089f7d2..90ec75086e 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. -- cgit v1.3 From 991873116e316f334f41343bb9bbd97720b0ee29 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Mon, 2 Nov 2015 16:56:53 -0800 Subject: [dev.ssa] cmd/compile: better ANDAND and OROR in IF and FOR For the statement if a && b { target } the old code allocated a new variable v and did: v = a if a { v = b } if v { goto target } The new code does: if a { if b { goto target } } The new arrangement tends to generate much more efficient code. In particular, there is no temporary variable and there is only one join point instead of two. The old code is still used for ANDAND and OROR which are not direct descendents of IF or FOR statements. Change-Id: I082f246d27c823c6f32d1287300e4b0911607507 Reviewed-on: https://go-review.googlesource.com/16584 Run-TryBot: Keith Randall Reviewed-by: David Chase --- src/cmd/compile/internal/gc/ssa.go | 69 ++++++++++++++++++++++++++------------ 1 file changed, 47 insertions(+), 22 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 521e6d7ffa..6210c7a691 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -645,23 +645,14 @@ func (s *state) stmt(n *Node) { s.assign(n.Left, r, n.Op == OASWB) case OIF: - cond := s.expr(n.Left) - b := s.endBlock() - b.Kind = ssa.BlockIf - b.Control = cond - b.Likely = ssa.BranchPrediction(n.Likely) // gc and ssa both use -1/0/+1 for likeliness - bThen := s.f.NewBlock(ssa.BlockPlain) bEnd := s.f.NewBlock(ssa.BlockPlain) var bElse *ssa.Block - - if n.Rlist == nil { - b.AddEdgeTo(bThen) - b.AddEdgeTo(bEnd) - } else { + if n.Rlist != nil { bElse = s.f.NewBlock(ssa.BlockPlain) - b.AddEdgeTo(bThen) - b.AddEdgeTo(bElse) + s.condBranch(n.Left, bThen, bElse, n.Likely) + } else { + s.condBranch(n.Left, bThen, bEnd, n.Likely) } s.startBlock(bThen) @@ -760,18 +751,13 @@ func (s *state) stmt(n *Node) { // generate code to test condition s.startBlock(bCond) - var cond *ssa.Value if n.Left != nil { - cond = s.expr(n.Left) + s.condBranch(n.Left, bBody, bEnd, 1) } else { - cond = s.constBool(true) + b := s.endBlock() + b.Kind = ssa.BlockPlain + b.AddEdgeTo(bBody) } - b = s.endBlock() - b.Kind = ssa.BlockIf - b.Control = cond - b.Likely = ssa.BranchLikely - b.AddEdgeTo(bBody) - b.AddEdgeTo(bEnd) // set up for continue/break in body prevContinue := s.continueTo @@ -2016,6 +2002,45 @@ func (s *state) expr(n *Node) *ssa.Value { } } +// 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. + } + 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) +} + func (s *state) assign(left *Node, right *ssa.Value, wb bool) { if left.Op == ONAME && isblank(left) { return -- cgit v1.3 From 582baae22a108e0b5f09da52c20f5ced83fe6084 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Mon, 2 Nov 2015 21:28:13 -0800 Subject: [dev.ssa] cmd/compile: Do pointer arithmetic with int, not uintptr Be more consistent about this. There's no reason to do the pointer arithmetic on a different type, as sizeof(int) >= sizeof(ptr) on all of our platforms. It simplifies our rewrite rules also, except for a few that need duplication. Add some more constant folding to get constant indexing and slicing to fold down to nothing. Change-Id: I3e56cdb14b3dc1a6a0514f0333e883f92c19e3c7 Reviewed-on: https://go-review.googlesource.com/16586 Run-TryBot: Keith Randall Reviewed-by: David Chase --- src/cmd/compile/internal/gc/ssa.go | 50 ++- src/cmd/compile/internal/ssa/func.go | 4 - src/cmd/compile/internal/ssa/gen/AMD64.rules | 2 - src/cmd/compile/internal/ssa/gen/generic.rules | 42 ++- src/cmd/compile/internal/ssa/gen/genericOps.go | 12 +- src/cmd/compile/internal/ssa/nilcheck_test.go | 14 +- src/cmd/compile/internal/ssa/opGen.go | 10 - src/cmd/compile/internal/ssa/rewrite.go | 10 +- src/cmd/compile/internal/ssa/rewriteAMD64.go | 46 --- src/cmd/compile/internal/ssa/rewritegeneric.go | 457 ++++++++++++++++++++----- 10 files changed, 448 insertions(+), 199 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 6210c7a691..5a8e43dedb 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -471,12 +471,6 @@ func (s *state) constFloat32(t ssa.Type, c float64) *ssa.Value { func (s *state) constFloat64(t ssa.Type, c float64) *ssa.Value { return s.f.ConstFloat64(s.peekLine(), t, c) } -func (s *state) constIntPtr(t ssa.Type, c int64) *ssa.Value { - if s.config.PtrSize == 4 && int64(int32(c)) != c { - s.Fatalf("pointer constant too big %d", c) - } - return s.f.ConstIntPtr(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) @@ -1781,7 +1775,7 @@ func (s *state) expr(n *Node) *ssa.Value { case ODOTPTR: p := s.expr(n.Left) s.nilCheck(p) - p = s.newValue2(ssa.OpAddPtr, p.Type, p, s.constIntPtr(Types[TUINTPTR], n.Xoffset)) + 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: @@ -1978,7 +1972,7 @@ func (s *state) expr(n *Node) *ssa.Value { c = s.variable(&capVar, Types[TINT]) // generates phi for cap p2 := s.newValue2(ssa.OpPtrIndex, pt, p, l) for i, arg := range args { - addr := s.newValue2(ssa.OpPtrIndex, pt, p2, s.constInt(Types[TUINTPTR], int64(i))) + addr := s.newValue2(ssa.OpPtrIndex, pt, p2, s.constInt(Types[TINT], int64(i))) if store[i] { s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, et.Size(), addr, arg, s.mem()) } else { @@ -2370,17 +2364,17 @@ func (s *state) addr(n *Node, bounded bool) *ssa.Value { return p case ODOT: p := s.addr(n.Left, bounded) - return s.newValue2(ssa.OpAddPtr, t, p, s.constIntPtr(Types[TUINTPTR], n.Xoffset)) + 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.constIntPtr(Types[TUINTPTR], n.Xoffset)) + 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.constIntPtr(Types[TUINTPTR], n.Xoffset)) + s.constInt(Types[TINT], n.Xoffset)) case OPARAM: p := n.Left if p.Op != ONAME || !(p.Class == PPARAM|PHEAP || p.Class == PPARAMOUT|PHEAP) { @@ -2682,14 +2676,17 @@ func (s *state) slice(t *Type, v, i, j, k *ssa.Value) (p, l, c *ssa.Value) { // 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 = (SubPtr j i) - // rcap = (SubPtr k i) + // rlen = (Sub64 j i) + // rcap = (Sub64 k i) // p = ptr // if rcap != 0 { - // p = (AddPtr ptr (MulPtr low (ConstPtr size))) + // p = (AddPtr ptr (Mul64 low (Const64 size))) // } // result = (SliceMake p size) - rlen := s.newValue2(ssa.OpSubPtr, Types[TINT], j, i) + 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(): @@ -2700,18 +2697,13 @@ func (s *state) slice(t *Type, v, i, j, k *ssa.Value) (p, l, c *ssa.Value) { case j == k: rcap = rlen default: - rcap = s.newValue2(ssa.OpSubPtr, Types[TINT], k, i) + rcap = s.newValue2(subOp, Types[TINT], k, i) } s.vars[&ptrVar] = ptr // Generate code to test the resulting slice length. - var cmp *ssa.Value - if s.config.IntSize == 8 { - cmp = s.newValue2(ssa.OpNeq64, Types[TBOOL], rcap, s.constInt(Types[TINT], 0)) - } else { - cmp = s.newValue2(ssa.OpNeq32, Types[TBOOL], rcap, s.constInt(Types[TINT], 0)) - } + cmp := s.newValue2(neqOp, Types[TBOOL], rcap, s.constInt(Types[TINT], 0)) b := s.endBlock() b.Kind = ssa.BlockIf @@ -2726,7 +2718,7 @@ func (s *state) slice(t *Type, v, i, j, k *ssa.Value) (p, l, c *ssa.Value) { if elemtype.Width == 1 { inc = i } else { - inc = s.newValue2(ssa.OpMulPtr, Types[TUINTPTR], i, s.constInt(Types[TINT], elemtype.Width)) + 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() @@ -4338,13 +4330,13 @@ func addAux2(a *obj.Addr, v *ssa.Value, offset int64) { } } -// extendIndex extends v to a full pointer width. +// 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.PtrSize { + if size == s.config.IntSize { return v } - if size > s.config.PtrSize { + 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") @@ -4354,7 +4346,7 @@ func (s *state) extendIndex(v *ssa.Value) *ssa.Value { // Extend value to the required size var op ssa.Op if v.Type.IsSigned() { - switch 10*size + s.config.PtrSize { + switch 10*size + s.config.IntSize { case 14: op = ssa.OpSignExt8to32 case 18: @@ -4369,7 +4361,7 @@ func (s *state) extendIndex(v *ssa.Value) *ssa.Value { s.Fatalf("bad signed index extension %s", v.Type) } } else { - switch 10*size + s.config.PtrSize { + switch 10*size + s.config.IntSize { case 14: op = ssa.OpZeroExt8to32 case 18: @@ -4384,7 +4376,7 @@ func (s *state) extendIndex(v *ssa.Value) *ssa.Value { s.Fatalf("bad unsigned index extension %s", v.Type) } } - return s.newValue1(op, Types[TUINTPTR], v) + return s.newValue1(op, Types[TINT], v) } // ssaRegToReg maps ssa register numbers to obj register numbers. diff --git a/src/cmd/compile/internal/ssa/func.go b/src/cmd/compile/internal/ssa/func.go index 772fffce33..ce11b184f6 100644 --- a/src/cmd/compile/internal/ssa/func.go +++ b/src/cmd/compile/internal/ssa/func.go @@ -297,10 +297,6 @@ func (f *Func) ConstInt64(line int32, t Type, c int64) *Value { // TODO: cache? return f.Entry.NewValue0I(line, OpConst64, t, c) } -func (f *Func) ConstIntPtr(line int32, t Type, c int64) *Value { - // TODO: cache? - return f.Entry.NewValue0I(line, OpConstPtr, t, c) -} func (f *Func) ConstFloat32(line int32, t Type, c float64) *Value { // TODO: cache? return f.Entry.NewValue0I(line, OpConst32F, t, int64(math.Float64bits(c))) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index bcd5ba9a8a..79669cbb0d 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -27,7 +27,6 @@ (Sub64F x y) -> (SUBSD x y) (Mul64 x y) -> (MULQ x y) -(MulPtr x y) -> (MULQ x y) (Mul32 x y) -> (MULL x y) (Mul16 x y) -> (MULW x y) (Mul8 x y) -> (MULB x y) @@ -348,7 +347,6 @@ (Const64 [val]) -> (MOVQconst [val]) (Const32F [val]) -> (MOVSSconst [val]) (Const64F [val]) -> (MOVSDconst [val]) -(ConstPtr [val]) -> (MOVQconst [val]) (ConstNil) -> (MOVQconst [0]) (ConstBool [b]) -> (MOVBconst [b]) diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index 55fd83eab2..bb347aea8b 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -20,14 +20,25 @@ // For now, the generated successors must be a permutation of the matched successors. // constant folding +(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]) -(AddPtr (ConstPtr [c]) (ConstPtr [d])) -> (ConstPtr [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]) -(MulPtr (ConstPtr [c]) (ConstPtr [d])) -> (ConstPtr [c*d]) + (IsInBounds (Const32 [c]) (Const32 [d])) -> (ConstBool [b2i(inBounds32(c,d))]) (IsInBounds (Const64 [c]) (Const64 [d])) -> (ConstBool [b2i(inBounds64(c,d))]) -(IsInBounds (ConstPtr [c]) (ConstPtr [d])) && config.PtrSize == 4 -> (ConstBool [b2i(inBounds32(c,d))]) -(IsInBounds (ConstPtr [c]) (ConstPtr [d])) && config.PtrSize == 8 -> (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]) @@ -127,7 +138,8 @@ // indexing operations // Note: bounds check has already been done (ArrayIndex (Load ptr mem) idx) && b == v.Args[0].Block -> (Load (PtrIndex ptr idx) mem) -(PtrIndex ptr idx) -> (AddPtr ptr (MulPtr idx (ConstPtr [t.Elem().Size()]))) +(PtrIndex ptr idx) && config.PtrSize == 4 -> (AddPtr ptr (Mul32 idx (Const32 [t.Elem().Size()]))) +(PtrIndex ptr idx) && config.PtrSize == 8 -> (AddPtr ptr (Mul64 idx (Const64 [t.Elem().Size()]))) (StructSelect [idx] (Load ptr mem)) -> @v.Args[0].Block (Load (OffPtr [idx] ptr) mem) // complex ops @@ -163,11 +175,16 @@ // string ops (StringPtr (StringMake ptr _)) -> ptr (StringLen (StringMake _ len)) -> len -(ConstString {s}) -> +(ConstString {s}) && config.PtrSize == 4 -> + (StringMake + (Addr {config.fe.StringData(s.(string))} + (SB)) + (Const32 [int64(len(s.(string)))])) +(ConstString {s}) && config.PtrSize == 8 -> (StringMake (Addr {config.fe.StringData(s.(string))} (SB)) - (ConstPtr [int64(len(s.(string)))])) + (Const64 [int64(len(s.(string)))])) (Load ptr mem) && t.IsString() -> (StringMake (Load ptr mem) @@ -184,11 +201,16 @@ (SlicePtr (SliceMake ptr _ _ )) -> ptr (SliceLen (SliceMake _ len _)) -> len (SliceCap (SliceMake _ _ cap)) -> cap -(ConstSlice) -> +(ConstSlice) && config.PtrSize == 4 -> + (SliceMake + (ConstNil ) + (Const32 [0]) + (Const32 [0])) +(ConstSlice) && config.PtrSize == 8 -> (SliceMake (ConstNil ) - (ConstPtr [0]) - (ConstPtr [0])) + (Const64 [0]) + (Const64 [0])) (Load ptr mem) && t.IsSlice() -> (SliceMake diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 62df826cf4..162ee0dab4 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -12,7 +12,7 @@ var genericOps = []opData{ {name: "Add16"}, {name: "Add32"}, {name: "Add64"}, - {name: "AddPtr"}, + {name: "AddPtr"}, // For address calculations. arg0 is a pointer and arg1 is an int. {name: "Add32F"}, {name: "Add64F"}, // TODO: Add64C, Add128C @@ -29,7 +29,6 @@ var genericOps = []opData{ {name: "Mul16"}, {name: "Mul32"}, {name: "Mul64"}, - {name: "MulPtr", typ: "Uintptr"}, // MulPtr is used for address calculations {name: "Mul32F"}, {name: "Mul64F"}, @@ -256,9 +255,8 @@ var genericOps = []opData{ {name: "Const64"}, {name: "Const32F"}, {name: "Const64F"}, - {name: "ConstPtr", typ: "Uintptr"}, // pointer-sized integer constant - {name: "ConstInterface"}, // nil interface - {name: "ConstSlice"}, // nil slice + {name: "ConstInterface"}, // nil interface + {name: "ConstSlice"}, // nil slice // TODO: Const32F, ... // Constant-like things @@ -338,7 +336,7 @@ var genericOps = []opData{ // Slices {name: "SliceMake"}, // arg0=ptr, arg1=len, arg2=cap - {name: "SlicePtr", typ: "Uintptr"}, // ptr(arg0) + {name: "SlicePtr", typ: "BytePtr"}, // ptr(arg0) {name: "SliceLen"}, // len(arg0) {name: "SliceCap"}, // cap(arg0) @@ -354,7 +352,7 @@ var genericOps = []opData{ // Interfaces {name: "IMake"}, // arg0=itab, arg1=data - {name: "ITab", typ: "Uintptr"}, // arg0=interface, returns itable field + {name: "ITab", typ: "BytePtr"}, // arg0=interface, returns itable field {name: "IData"}, // arg0=interface, returns data field // Spill&restore ops for the register allocator. These are diff --git a/src/cmd/compile/internal/ssa/nilcheck_test.go b/src/cmd/compile/internal/ssa/nilcheck_test.go index c0a3d8af69..8f32f32b1d 100644 --- a/src/cmd/compile/internal/ssa/nilcheck_test.go +++ b/src/cmd/compile/internal/ssa/nilcheck_test.go @@ -71,7 +71,7 @@ func TestNilcheckSimple(t *testing.T) { Valu("sb", OpSB, TypeInvalid, 0, nil), Goto("checkPtr")), Bloc("checkPtr", - Valu("ptr1", OpConstPtr, ptrType, 0, nil, "sb"), + Valu("ptr1", OpLoad, ptrType, 0, nil, "sb", "mem"), Valu("bool1", OpIsNonNil, TypeBool, 0, nil, "ptr1"), If("bool1", "secondCheck", "exit")), Bloc("secondCheck", @@ -108,7 +108,7 @@ func TestNilcheckDomOrder(t *testing.T) { Valu("sb", OpSB, TypeInvalid, 0, nil), Goto("checkPtr")), Bloc("checkPtr", - Valu("ptr1", OpConstPtr, ptrType, 0, nil, "sb"), + Valu("ptr1", OpLoad, ptrType, 0, nil, "sb", "mem"), Valu("bool1", OpIsNonNil, TypeBool, 0, nil, "ptr1"), If("bool1", "secondCheck", "exit")), Bloc("exit", @@ -255,11 +255,11 @@ func TestNilcheckKeepRemove(t *testing.T) { Valu("sb", OpSB, TypeInvalid, 0, nil), Goto("checkPtr")), Bloc("checkPtr", - Valu("ptr1", OpConstPtr, ptrType, 0, nil, "sb"), + Valu("ptr1", OpLoad, ptrType, 0, nil, "sb", "mem"), Valu("bool1", OpIsNonNil, TypeBool, 0, nil, "ptr1"), If("bool1", "differentCheck", "exit")), Bloc("differentCheck", - Valu("ptr2", OpConstPtr, ptrType, 0, nil, "sb"), + Valu("ptr2", OpLoad, ptrType, 0, nil, "sb", "mem"), Valu("bool2", OpIsNonNil, TypeBool, 0, nil, "ptr2"), If("bool2", "secondCheck", "exit")), Bloc("secondCheck", @@ -303,7 +303,7 @@ func TestNilcheckInFalseBranch(t *testing.T) { Valu("sb", OpSB, TypeInvalid, 0, nil), Goto("checkPtr")), Bloc("checkPtr", - Valu("ptr1", OpConstPtr, ptrType, 0, nil, "sb"), + Valu("ptr1", OpLoad, ptrType, 0, nil, "sb", "mem"), Valu("bool1", OpIsNonNil, TypeBool, 0, nil, "ptr1"), If("bool1", "extra", "secondCheck")), Bloc("secondCheck", @@ -354,7 +354,7 @@ func TestNilcheckUser(t *testing.T) { Valu("sb", OpSB, TypeInvalid, 0, nil), Goto("checkPtr")), Bloc("checkPtr", - Valu("ptr1", OpConstPtr, ptrType, 0, nil, "sb"), + Valu("ptr1", OpLoad, ptrType, 0, nil, "sb", "mem"), Valu("nilptr", OpConstNil, ptrType, 0, nil, "sb"), Valu("bool1", OpNeqPtr, TypeBool, 0, nil, "ptr1", "nilptr"), If("bool1", "secondCheck", "exit")), @@ -393,7 +393,7 @@ func TestNilcheckBug(t *testing.T) { Valu("sb", OpSB, TypeInvalid, 0, nil), Goto("checkPtr")), Bloc("checkPtr", - Valu("ptr1", OpConstPtr, ptrType, 0, nil, "sb"), + Valu("ptr1", OpLoad, ptrType, 0, nil, "sb", "mem"), Valu("nilptr", OpConstNil, ptrType, 0, nil, "sb"), Valu("bool1", OpNeqPtr, TypeBool, 0, nil, "ptr1", "nilptr"), If("bool1", "secondCheck", "couldBeNil")), diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 6db7a43106..400f59e174 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -301,7 +301,6 @@ const ( OpMul16 OpMul32 OpMul64 - OpMulPtr OpMul32F OpMul64F OpDiv32F @@ -474,7 +473,6 @@ const ( OpConst64 OpConst32F OpConst64F - OpConstPtr OpConstInterface OpConstSlice OpArg @@ -3293,10 +3291,6 @@ var opcodeTable = [...]opInfo{ name: "Mul64", generic: true, }, - { - name: "MulPtr", - generic: true, - }, { name: "Mul32F", generic: true, @@ -3985,10 +3979,6 @@ var opcodeTable = [...]opInfo{ name: "Const64F", generic: true, }, - { - name: "ConstPtr", - generic: true, - }, { name: "ConstInterface", generic: true, diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go index c1e446fce1..f7da347263 100644 --- a/src/cmd/compile/internal/ssa/rewrite.go +++ b/src/cmd/compile/internal/ssa/rewrite.go @@ -141,10 +141,12 @@ 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 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 } // log2 returns logarithm in base of n. // expects n to be a power of 2. diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index da152b0e12..e0a6caa5f1 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -97,8 +97,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { return rewriteValueAMD64_OpConstBool(v, config) case OpConstNil: return rewriteValueAMD64_OpConstNil(v, config) - case OpConstPtr: - return rewriteValueAMD64_OpConstPtr(v, config) case OpConvert: return rewriteValueAMD64_OpConvert(v, config) case OpCvt32Fto32: @@ -405,8 +403,6 @@ func rewriteValueAMD64(v *Value, config *Config) bool { return rewriteValueAMD64_OpMul64F(v, config) case OpMul8: return rewriteValueAMD64_OpMul8(v, config) - case OpMulPtr: - return rewriteValueAMD64_OpMulPtr(v, config) case OpAMD64NEGB: return rewriteValueAMD64_OpAMD64NEGB(v, config) case OpAMD64NEGL: @@ -2526,26 +2522,6 @@ endea557d921056c25b945a49649e4b9b91: ; return false } -func rewriteValueAMD64_OpConstPtr(v *Value, config *Config) bool { - b := v.Block - _ = b - // match: (ConstPtr [val]) - // cond: - // result: (MOVQconst [val]) - { - val := v.AuxInt - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = val - return true - } - goto endc395c0a53eeccf597e225a07b53047d1 -endc395c0a53eeccf597e225a07b53047d1: - ; - return false -} func rewriteValueAMD64_OpConvert(v *Value, config *Config) bool { b := v.Block _ = b @@ -8325,28 +8301,6 @@ endd876d6bc42a2285b801f42dadbd8757c: ; return false } -func rewriteValueAMD64_OpMulPtr(v *Value, config *Config) bool { - b := v.Block - _ = b - // match: (MulPtr x y) - // cond: - // result: (MULQ x y) - { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64MULQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AddArg(x) - v.AddArg(y) - return true - } - goto endbbedad106c011a93243e2062afdcc75f -endbbedad106c011a93243e2062afdcc75f: - ; - return false -} func rewriteValueAMD64_OpAMD64NEGB(v *Value, config *Config) bool { b := v.Block _ = b diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index e068dcfb1e..2448b43547 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -7,10 +7,14 @@ 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 OpAddPtr: - return rewriteValuegeneric_OpAddPtr(v, config) + case OpAdd8: + return rewriteValuegeneric_OpAdd8(v, config) case OpAnd16: return rewriteValuegeneric_OpAnd16(v, config) case OpAnd32: @@ -93,6 +97,8 @@ func rewriteValuegeneric(v *Value, config *Config) bool { 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: @@ -127,10 +133,14 @@ func rewriteValuegeneric(v *Value, config *Config) bool { return rewriteValuegeneric_OpLess8U(v, config) case OpLoad: return rewriteValuegeneric_OpLoad(v, config) + case OpMul16: + return rewriteValuegeneric_OpMul16(v, config) + case OpMul32: + return rewriteValuegeneric_OpMul32(v, config) case OpMul64: return rewriteValuegeneric_OpMul64(v, config) - case OpMulPtr: - return rewriteValuegeneric_OpMulPtr(v, config) + case OpMul8: + return rewriteValuegeneric_OpMul8(v, config) case OpNeq16: return rewriteValuegeneric_OpNeq16(v, config) case OpNeq32: @@ -188,6 +198,60 @@ func rewriteValuegeneric(v *Value, config *Config) bool { } 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]) + { + if v.Args[0].Op != OpConst16 { + goto end359c546ef662b7990116329cb30d6892 + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst16 { + goto end359c546ef662b7990116329cb30d6892 + } + d := v.Args[1].AuxInt + v.Op = OpConst16 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + d + return true + } + goto end359c546ef662b7990116329cb30d6892 +end359c546ef662b7990116329cb30d6892: + ; + 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]) + { + if v.Args[0].Op != OpConst32 { + goto enda3edaa9a512bd1d7a95f002c890bfb88 + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst32 { + goto enda3edaa9a512bd1d7a95f002c890bfb88 + } + d := v.Args[1].AuxInt + v.Op = OpConst32 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + d + return true + } + goto enda3edaa9a512bd1d7a95f002c890bfb88 +enda3edaa9a512bd1d7a95f002c890bfb88: + ; + return false +} func rewriteValuegeneric_OpAdd64(v *Value, config *Config) bool { b := v.Block _ = b @@ -215,30 +279,30 @@ end8c46df6f85a11cb1d594076b0e467908: ; return false } -func rewriteValuegeneric_OpAddPtr(v *Value, config *Config) bool { +func rewriteValuegeneric_OpAdd8(v *Value, config *Config) bool { b := v.Block _ = b - // match: (AddPtr (ConstPtr [c]) (ConstPtr [d])) + // match: (Add8 (Const8 [c]) (Const8 [d])) // cond: - // result: (ConstPtr [c+d]) + // result: (Const8 [c+d]) { - if v.Args[0].Op != OpConstPtr { - goto end145c1aec793b2befff34bc8983b48a38 + if v.Args[0].Op != OpConst8 { + goto end60c66721511a442aade8e4da2fb326bd } c := v.Args[0].AuxInt - if v.Args[1].Op != OpConstPtr { - goto end145c1aec793b2befff34bc8983b48a38 + if v.Args[1].Op != OpConst8 { + goto end60c66721511a442aade8e4da2fb326bd } d := v.Args[1].AuxInt - v.Op = OpConstPtr + v.Op = OpConst8 v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AuxInt = c + d return true } - goto end145c1aec793b2befff34bc8983b48a38 -end145c1aec793b2befff34bc8983b48a38: + goto end60c66721511a442aade8e4da2fb326bd +end60c66721511a442aade8e4da2fb326bd: ; return false } @@ -543,9 +607,12 @@ func rewriteValuegeneric_OpConstSlice(v *Value, config *Config) bool { b := v.Block _ = b // match: (ConstSlice) - // cond: - // result: (SliceMake (ConstNil ) (ConstPtr [0]) (ConstPtr [0])) + // cond: config.PtrSize == 4 + // result: (SliceMake (ConstNil ) (Const32 [0]) (Const32 [0])) { + if !(config.PtrSize == 4) { + goto end9ba6baf9c7247b1f5ba4099c0c3910ce + } v.Op = OpSliceMake v.AuxInt = 0 v.Aux = nil @@ -553,18 +620,45 @@ func rewriteValuegeneric_OpConstSlice(v *Value, config *Config) bool { v0 := b.NewValue0(v.Line, OpConstNil, TypeInvalid) v0.Type = config.fe.TypeBytePtr() v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpConstPtr, TypeInvalid) + v1 := b.NewValue0(v.Line, OpConst32, TypeInvalid) + v1.Type = config.fe.TypeInt() v1.AuxInt = 0 - v1.Type = config.fe.TypeUintptr() v.AddArg(v1) - v2 := b.NewValue0(v.Line, OpConstPtr, TypeInvalid) + v2 := b.NewValue0(v.Line, OpConst32, TypeInvalid) + v2.Type = config.fe.TypeInt() v2.AuxInt = 0 - v2.Type = config.fe.TypeUintptr() v.AddArg(v2) return true } - goto endc587abac76a5fd9b1284ba891a178e63 -endc587abac76a5fd9b1284ba891a178e63: + goto end9ba6baf9c7247b1f5ba4099c0c3910ce +end9ba6baf9c7247b1f5ba4099c0c3910ce: + ; + // match: (ConstSlice) + // cond: config.PtrSize == 8 + // result: (SliceMake (ConstNil ) (Const64 [0]) (Const64 [0])) + { + if !(config.PtrSize == 8) { + goto endabee2aa6bd3e3261628f677221ad2640 + } + v.Op = OpSliceMake + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpConstNil, TypeInvalid) + v0.Type = config.fe.TypeBytePtr() + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpConst64, TypeInvalid) + v1.Type = config.fe.TypeInt() + v1.AuxInt = 0 + v.AddArg(v1) + v2 := b.NewValue0(v.Line, OpConst64, TypeInvalid) + v2.Type = config.fe.TypeInt() + v2.AuxInt = 0 + v.AddArg(v2) + return true + } + goto endabee2aa6bd3e3261628f677221ad2640 +endabee2aa6bd3e3261628f677221ad2640: ; return false } @@ -572,10 +666,41 @@ func rewriteValuegeneric_OpConstString(v *Value, config *Config) bool { b := v.Block _ = b // match: (ConstString {s}) - // cond: - // result: (StringMake (Addr {config.fe.StringData(s.(string))} (SB)) (ConstPtr [int64(len(s.(string)))])) + // cond: config.PtrSize == 4 + // result: (StringMake (Addr {config.fe.StringData(s.(string))} (SB)) (Const32 [int64(len(s.(string)))])) + { + s := v.Aux + if !(config.PtrSize == 4) { + goto endaa2b20a40588873f370c5a12f084505a + } + v.Op = OpStringMake + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAddr, TypeInvalid) + v0.Type = config.fe.TypeBytePtr() + v0.Aux = config.fe.StringData(s.(string)) + v1 := b.NewValue0(v.Line, OpSB, TypeInvalid) + v1.Type = config.fe.TypeUintptr() + v0.AddArg(v1) + v.AddArg(v0) + v2 := b.NewValue0(v.Line, OpConst32, TypeInvalid) + v2.Type = config.fe.TypeInt() + v2.AuxInt = int64(len(s.(string))) + v.AddArg(v2) + return true + } + goto endaa2b20a40588873f370c5a12f084505a +endaa2b20a40588873f370c5a12f084505a: + ; + // match: (ConstString {s}) + // cond: config.PtrSize == 8 + // result: (StringMake (Addr {config.fe.StringData(s.(string))} (SB)) (Const64 [int64(len(s.(string)))])) { s := v.Aux + if !(config.PtrSize == 8) { + goto endab37d89f3959d3cf1e71b57a3c61b8eb + } v.Op = OpStringMake v.AuxInt = 0 v.Aux = nil @@ -587,14 +712,14 @@ func rewriteValuegeneric_OpConstString(v *Value, config *Config) bool { v1.Type = config.fe.TypeUintptr() v0.AddArg(v1) v.AddArg(v0) - v2 := b.NewValue0(v.Line, OpConstPtr, TypeInvalid) + v2 := b.NewValue0(v.Line, OpConst64, TypeInvalid) + v2.Type = config.fe.TypeInt() v2.AuxInt = int64(len(s.(string))) - v2.Type = config.fe.TypeUintptr() v.AddArg(v2) return true } - goto end2eb756398dd4c6b6d126012a26284c89 -end2eb756398dd4c6b6d126012a26284c89: + goto endab37d89f3959d3cf1e71b57a3c61b8eb +endab37d89f3959d3cf1e71b57a3c61b8eb: ; return false } @@ -821,11 +946,11 @@ func rewriteValuegeneric_OpEqInter(v *Value, config *Config) bool { v.resetArgs() v0 := b.NewValue0(v.Line, OpITab, TypeInvalid) v0.AddArg(x) - v0.Type = config.fe.TypeUintptr() + v0.Type = config.fe.TypeBytePtr() v.AddArg(v0) v1 := b.NewValue0(v.Line, OpITab, TypeInvalid) v1.AddArg(y) - v1.Type = config.fe.TypeUintptr() + v1.Type = config.fe.TypeBytePtr() v.AddArg(v1) return true } @@ -896,11 +1021,11 @@ func rewriteValuegeneric_OpEqSlice(v *Value, config *Config) bool { v.resetArgs() v0 := b.NewValue0(v.Line, OpSlicePtr, TypeInvalid) v0.AddArg(x) - v0.Type = config.fe.TypeUintptr() + v0.Type = config.fe.TypeBytePtr() v.AddArg(v0) v1 := b.NewValue0(v.Line, OpSlicePtr, TypeInvalid) v1.AddArg(y) - v1.Type = config.fe.TypeUintptr() + v1.Type = config.fe.TypeBytePtr() v.AddArg(v1) return true } @@ -1436,55 +1561,54 @@ endf0a2ecfe84b293de6ff0919e45d19d9d: goto end4b406f402c135f50f71effcc904ecb2b end4b406f402c135f50f71effcc904ecb2b: ; - // match: (IsInBounds (ConstPtr [c]) (ConstPtr [d])) - // cond: config.PtrSize == 4 - // result: (ConstBool [b2i(inBounds32(c,d))]) + 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))]) { - if v.Args[0].Op != OpConstPtr { - goto end4323278ec7a053034fcf7033697d7b3b + if v.Args[0].Op != OpConst32 { + goto end5e84a230c28cac987437cfed8f432cc3 } c := v.Args[0].AuxInt - if v.Args[1].Op != OpConstPtr { - goto end4323278ec7a053034fcf7033697d7b3b + if v.Args[1].Op != OpConst32 { + goto end5e84a230c28cac987437cfed8f432cc3 } d := v.Args[1].AuxInt - if !(config.PtrSize == 4) { - goto end4323278ec7a053034fcf7033697d7b3b - } v.Op = OpConstBool v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = b2i(inBounds32(c, d)) + v.AuxInt = b2i(sliceInBounds32(c, d)) return true } - goto end4323278ec7a053034fcf7033697d7b3b -end4323278ec7a053034fcf7033697d7b3b: + goto end5e84a230c28cac987437cfed8f432cc3 +end5e84a230c28cac987437cfed8f432cc3: ; - // match: (IsInBounds (ConstPtr [c]) (ConstPtr [d])) - // cond: config.PtrSize == 8 - // result: (ConstBool [b2i(inBounds64(c,d))]) + // match: (IsSliceInBounds (Const64 [c]) (Const64 [d])) + // cond: + // result: (ConstBool [b2i(sliceInBounds64(c,d))]) { - if v.Args[0].Op != OpConstPtr { - goto endb550b8814df20b5eeda4f43cc94e902b + if v.Args[0].Op != OpConst64 { + goto end3880a6fe20ad4152e98f76d84da233a7 } c := v.Args[0].AuxInt - if v.Args[1].Op != OpConstPtr { - goto endb550b8814df20b5eeda4f43cc94e902b + if v.Args[1].Op != OpConst64 { + goto end3880a6fe20ad4152e98f76d84da233a7 } d := v.Args[1].AuxInt - if !(config.PtrSize == 8) { - goto endb550b8814df20b5eeda4f43cc94e902b - } v.Op = OpConstBool v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = b2i(inBounds64(c, d)) + v.AuxInt = b2i(sliceInBounds64(c, d)) return true } - goto endb550b8814df20b5eeda4f43cc94e902b -endb550b8814df20b5eeda4f43cc94e902b: + goto end3880a6fe20ad4152e98f76d84da233a7 +end3880a6fe20ad4152e98f76d84da233a7: ; return false } @@ -2099,6 +2223,60 @@ end12671c83ebe3ccbc8e53383765ee7675: ; 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]) + { + if v.Args[0].Op != OpConst16 { + goto ende8dd468add3015aea24531cf3c89ccb7 + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst16 { + goto ende8dd468add3015aea24531cf3c89ccb7 + } + d := v.Args[1].AuxInt + v.Op = OpConst16 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c * d + return true + } + goto ende8dd468add3015aea24531cf3c89ccb7 +ende8dd468add3015aea24531cf3c89ccb7: + ; + 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]) + { + if v.Args[0].Op != OpConst32 { + goto end60b4523099fa7b55e2e872e05bd497a7 + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst32 { + goto end60b4523099fa7b55e2e872e05bd497a7 + } + d := v.Args[1].AuxInt + v.Op = OpConst32 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c * d + return true + } + goto end60b4523099fa7b55e2e872e05bd497a7 +end60b4523099fa7b55e2e872e05bd497a7: + ; + return false +} func rewriteValuegeneric_OpMul64(v *Value, config *Config) bool { b := v.Block _ = b @@ -2126,30 +2304,30 @@ end7aea1048b5d1230974b97f17238380ae: ; return false } -func rewriteValuegeneric_OpMulPtr(v *Value, config *Config) bool { +func rewriteValuegeneric_OpMul8(v *Value, config *Config) bool { b := v.Block _ = b - // match: (MulPtr (ConstPtr [c]) (ConstPtr [d])) + // match: (Mul8 (Const8 [c]) (Const8 [d])) // cond: - // result: (ConstPtr [c*d]) + // result: (Const8 [c*d]) { - if v.Args[0].Op != OpConstPtr { - goto end808c190f346658bb1ad032bf37a1059f + if v.Args[0].Op != OpConst8 { + goto end2f1952fd654c4a62ff00511041728809 } c := v.Args[0].AuxInt - if v.Args[1].Op != OpConstPtr { - goto end808c190f346658bb1ad032bf37a1059f + if v.Args[1].Op != OpConst8 { + goto end2f1952fd654c4a62ff00511041728809 } d := v.Args[1].AuxInt - v.Op = OpConstPtr + v.Op = OpConst8 v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AuxInt = c * d return true } - goto end808c190f346658bb1ad032bf37a1059f -end808c190f346658bb1ad032bf37a1059f: + goto end2f1952fd654c4a62ff00511041728809 +end2f1952fd654c4a62ff00511041728809: ; return false } @@ -2348,11 +2526,11 @@ func rewriteValuegeneric_OpNeqInter(v *Value, config *Config) bool { v.resetArgs() v0 := b.NewValue0(v.Line, OpITab, TypeInvalid) v0.AddArg(x) - v0.Type = config.fe.TypeUintptr() + v0.Type = config.fe.TypeBytePtr() v.AddArg(v0) v1 := b.NewValue0(v.Line, OpITab, TypeInvalid) v1.AddArg(y) - v1.Type = config.fe.TypeUintptr() + v1.Type = config.fe.TypeBytePtr() v.AddArg(v1) return true } @@ -2417,11 +2595,11 @@ func rewriteValuegeneric_OpNeqSlice(v *Value, config *Config) bool { v.resetArgs() v0 := b.NewValue0(v.Line, OpSlicePtr, TypeInvalid) v0.AddArg(x) - v0.Type = config.fe.TypeUintptr() + v0.Type = config.fe.TypeBytePtr() v.AddArg(v0) v1 := b.NewValue0(v.Line, OpSlicePtr, TypeInvalid) v1.AddArg(y) - v1.Type = config.fe.TypeUintptr() + v1.Type = config.fe.TypeBytePtr() v.AddArg(v1) return true } @@ -2530,29 +2708,60 @@ func rewriteValuegeneric_OpPtrIndex(v *Value, config *Config) bool { b := v.Block _ = b // match: (PtrIndex ptr idx) - // cond: - // result: (AddPtr ptr (MulPtr idx (ConstPtr [t.Elem().Size()]))) + // cond: config.PtrSize == 4 + // result: (AddPtr ptr (Mul32 idx (Const32 [t.Elem().Size()]))) { t := v.Type ptr := v.Args[0] idx := v.Args[1] + if !(config.PtrSize == 4) { + goto endd902622aaa1e7545b5a2a0c08b47d287 + } v.Op = OpAddPtr v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AddArg(ptr) - v0 := b.NewValue0(v.Line, OpMulPtr, TypeInvalid) + v0 := b.NewValue0(v.Line, OpMul32, TypeInvalid) + v0.Type = config.fe.TypeInt() v0.AddArg(idx) - v1 := b.NewValue0(v.Line, OpConstPtr, TypeInvalid) + v1 := b.NewValue0(v.Line, OpConst32, TypeInvalid) + v1.Type = config.fe.TypeInt() + v1.AuxInt = t.Elem().Size() + v0.AddArg(v1) + v.AddArg(v0) + return true + } + goto endd902622aaa1e7545b5a2a0c08b47d287 +endd902622aaa1e7545b5a2a0c08b47d287: + ; + // match: (PtrIndex ptr idx) + // cond: config.PtrSize == 8 + // result: (AddPtr ptr (Mul64 idx (Const64 [t.Elem().Size()]))) + { + t := v.Type + ptr := v.Args[0] + idx := v.Args[1] + if !(config.PtrSize == 8) { + goto end47a5f1d1b158914fa383de024bbe3b08 + } + v.Op = OpAddPtr + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(ptr) + v0 := b.NewValue0(v.Line, OpMul64, TypeInvalid) + v0.Type = config.fe.TypeInt() + v0.AddArg(idx) + v1 := b.NewValue0(v.Line, OpConst64, TypeInvalid) + v1.Type = config.fe.TypeInt() v1.AuxInt = t.Elem().Size() - v1.Type = config.fe.TypeUintptr() v0.AddArg(v1) - v0.Type = config.fe.TypeUintptr() v.AddArg(v0) return true } - goto end502555083d57a877982955070cda7530 -end502555083d57a877982955070cda7530: + goto end47a5f1d1b158914fa383de024bbe3b08 +end47a5f1d1b158914fa383de024bbe3b08: ; return false } @@ -2983,6 +3192,28 @@ end27abc5bf0299ce1bd5457af6ce8e3fba: func rewriteValuegeneric_OpSub16(v *Value, config *Config) bool { b := v.Block _ = b + // match: (Sub16 (Const16 [c]) (Const16 [d])) + // cond: + // result: (Const16 [c-d]) + { + if v.Args[0].Op != OpConst16 { + goto end5c6fab95c9dbeff5973119096bfd4e78 + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst16 { + goto end5c6fab95c9dbeff5973119096bfd4e78 + } + d := v.Args[1].AuxInt + v.Op = OpConst16 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c - d + return true + } + goto end5c6fab95c9dbeff5973119096bfd4e78 +end5c6fab95c9dbeff5973119096bfd4e78: + ; // match: (Sub16 x x) // cond: // result: (Const16 [0]) @@ -3006,6 +3237,28 @@ end83da541391be564f2a08464e674a49e7: func rewriteValuegeneric_OpSub32(v *Value, config *Config) bool { b := v.Block _ = b + // match: (Sub32 (Const32 [c]) (Const32 [d])) + // cond: + // result: (Const32 [c-d]) + { + if v.Args[0].Op != OpConst32 { + goto end7623799db780e1bcc42c6ea0df9c49d3 + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst32 { + goto end7623799db780e1bcc42c6ea0df9c49d3 + } + d := v.Args[1].AuxInt + v.Op = OpConst32 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c - d + return true + } + goto end7623799db780e1bcc42c6ea0df9c49d3 +end7623799db780e1bcc42c6ea0df9c49d3: + ; // match: (Sub32 x x) // cond: // result: (Const32 [0]) @@ -3029,6 +3282,28 @@ enda747581e798f199e07f4ad69747cd069: func rewriteValuegeneric_OpSub64(v *Value, config *Config) bool { b := v.Block _ = b + // match: (Sub64 (Const64 [c]) (Const64 [d])) + // cond: + // result: (Const64 [c-d]) + { + if v.Args[0].Op != OpConst64 { + goto end5a84a285ff0ff48b8ad3c64b15e3459f + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst64 { + goto end5a84a285ff0ff48b8ad3c64b15e3459f + } + d := v.Args[1].AuxInt + v.Op = OpConst64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c - d + return true + } + goto end5a84a285ff0ff48b8ad3c64b15e3459f +end5a84a285ff0ff48b8ad3c64b15e3459f: + ; // match: (Sub64 x x) // cond: // result: (Const64 [0]) @@ -3052,6 +3327,28 @@ end0387dc2b7bbe57d4aa54eab5d959da4b: func rewriteValuegeneric_OpSub8(v *Value, config *Config) bool { b := v.Block _ = b + // match: (Sub8 (Const8 [c]) (Const8 [d])) + // cond: + // result: (Const8 [c-d]) + { + if v.Args[0].Op != OpConst8 { + goto endc00ea11c7535529e211710574f5cff24 + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst8 { + goto endc00ea11c7535529e211710574f5cff24 + } + d := v.Args[1].AuxInt + v.Op = OpConst8 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c - d + return true + } + goto endc00ea11c7535529e211710574f5cff24 +endc00ea11c7535529e211710574f5cff24: + ; // match: (Sub8 x x) // cond: // result: (Const8 [0]) -- cgit v1.3 From 02f4d0a130ba95d7a03418c3ef308d7d21b34af3 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Mon, 2 Nov 2015 08:10:26 -0800 Subject: [dev.ssa] cmd/compile: start arguments as spilled Declare a function's arguments as having already been spilled so their use just requires a restore. Allow spill locations to be portions of larger objects the stack. Required to load portions of compound input arguments. Rename the memory input to InputMem. Use Arg for the pre-spilled argument values. Change-Id: I8fe2a03ffbba1022d98bfae2052b376b96d32dda Reviewed-on: https://go-review.googlesource.com/16536 Run-TryBot: Keith Randall TryBot-Result: Gobot Gobot Reviewed-by: David Chase --- src/cmd/compile/internal/gc/pgen.go | 3 + src/cmd/compile/internal/gc/ssa.go | 54 +++++-- src/cmd/compile/internal/ssa/compile.go | 2 +- src/cmd/compile/internal/ssa/config.go | 2 +- src/cmd/compile/internal/ssa/deadcode.go | 34 ++-- src/cmd/compile/internal/ssa/deadcode_test.go | 8 +- src/cmd/compile/internal/ssa/deadstore_test.go | 6 +- src/cmd/compile/internal/ssa/decompose.go | 69 ++++++++- src/cmd/compile/internal/ssa/dom_test.go | 26 ++-- src/cmd/compile/internal/ssa/func.go | 7 +- src/cmd/compile/internal/ssa/func_test.go | 32 ++-- src/cmd/compile/internal/ssa/gen/generic.rules | 45 ++++-- src/cmd/compile/internal/ssa/gen/genericOps.go | 3 +- src/cmd/compile/internal/ssa/html.go | 4 + src/cmd/compile/internal/ssa/location.go | 14 +- src/cmd/compile/internal/ssa/lower.go | 2 +- src/cmd/compile/internal/ssa/nilcheck_test.go | 20 +-- src/cmd/compile/internal/ssa/opGen.go | 5 + src/cmd/compile/internal/ssa/print.go | 8 + src/cmd/compile/internal/ssa/regalloc.go | 10 ++ src/cmd/compile/internal/ssa/regalloc_test.go | 2 +- src/cmd/compile/internal/ssa/rewritegeneric.go | 206 +++++++++++++++++++++---- src/cmd/compile/internal/ssa/schedule_test.go | 2 +- src/cmd/compile/internal/ssa/shift_test.go | 2 +- src/cmd/compile/internal/ssa/stackalloc.go | 34 ++-- src/cmd/compile/internal/ssa/tighten.go | 4 +- src/runtime/runtime-gdb_test.go | 7 - 27 files changed, 470 insertions(+), 141 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/pgen.go index 87e99df2e6..c8f2059543 100644 --- a/src/cmd/compile/internal/gc/pgen.go +++ b/src/cmd/compile/internal/gc/pgen.go @@ -484,6 +484,9 @@ func compile(fn *Node) { if ssafn != nil && usessa { genssa(ssafn, ptxt, gcargs, gclocals) + if Curfn.Func.Endlineno != 0 { + lineno = Curfn.Func.Endlineno + } return } Genlist(Curfn.Func.Enter) diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 5a8e43dedb..2c935b7247 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -97,7 +97,7 @@ func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { // Allocate starting values s.labels = map[string]*ssaLabel{} s.labeledNodes = map[*Node]*ssaLabel{} - s.startmem = s.entryNewValue0(ssa.OpArg, ssa.TypeMem) + 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]) @@ -3168,6 +3168,12 @@ func (s *state) lookupVarIncoming(b *ssa.Block, t ssa.Type, name *Node) *ssa.Val if name == &memVar { return s.startmem } + if canSSA(name) { + v := s.entryNewValue0A(ssa.OpArg, t, name) + // v starts with AuxInt == 0. + s.addNamedValue(name, v) + return v + } // variable is live at the entry block. Load it. addr := s.decladdrs[name] if addr == nil { @@ -3239,18 +3245,21 @@ func (s *state) addNamedValue(n *Node, v *ssa.Value) { // Don't track autotmp_ variables. return } - if n.Class == PPARAM || n.Class == PPARAMOUT { - // TODO: Remove this + 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) } - values, ok := s.f.NamedValues[n] + 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, n) + s.f.Names = append(s.f.Names, loc) } - s.f.NamedValues[n] = append(values, v) + s.f.NamedValues[loc] = append(values, v) } // an unresolved branch @@ -3873,11 +3882,17 @@ func (s *genState) genValue(v *ssa.Value) { return } p := Prog(movSizeByType(v.Type)) - n := autoVar(v.Args[0]) + n, off := autoVar(v.Args[0]) p.From.Type = obj.TYPE_MEM - p.From.Name = obj.NAME_AUTO p.From.Node = n p.From.Sym = Linksym(n.Sym) + p.From.Offset = off + if n.Class == PPARAM { + 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) @@ -3889,11 +3904,17 @@ func (s *genState) genValue(v *ssa.Value) { p := Prog(movSizeByType(v.Type)) p.From.Type = obj.TYPE_REG p.From.Reg = regnum(v.Args[0]) - n := autoVar(v) + n, off := autoVar(v) p.To.Type = obj.TYPE_MEM - p.To.Name = obj.NAME_AUTO p.To.Node = n p.To.Sym = Linksym(n.Sym) + p.To.Offset = off + if n.Class == PPARAM { + 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() { @@ -3912,9 +3933,10 @@ func (s *genState) genValue(v *ssa.Value) { v.Fatalf("const value %v shouldn't have a location", v) } - case ssa.OpArg: + case ssa.OpInitMem: // memory arg needs no code - // TODO: check that only mem arg goes here. + case ssa.OpArg: + // input args need no code case ssa.OpAMD64LoweredGetClosurePtr: // Output is hardwired to DX only, // and DX contains the closure pointer on @@ -4476,9 +4498,11 @@ func regnum(v *ssa.Value) int16 { return ssaRegToReg[reg.(*ssa.Register).Num] } -// autoVar returns a *Node representing the auto variable assigned to v. -func autoVar(v *ssa.Value) *Node { - return v.Block.Func.RegAlloc[v.ID].(*ssa.LocalSlot).N.(*Node) +// 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) + return loc.N.(*Node), loc.Off } // ssaExport exports a bunch of compiler services for the ssa backend. diff --git a/src/cmd/compile/internal/ssa/compile.go b/src/cmd/compile/internal/ssa/compile.go index af672eea99..01238f24ca 100644 --- a/src/cmd/compile/internal/ssa/compile.go +++ b/src/cmd/compile/internal/ssa/compile.go @@ -83,8 +83,8 @@ type pass struct { var passes = [...]pass{ {"phielim", phielim}, {"copyelim", copyelim}, - {"decompose", decompose}, {"early deadcode", deadcode}, // remove generated dead code to avoid doing pointless work during opt + {"decompose", decompose}, {"opt", opt}, {"opt deadcode", deadcode}, // remove any blocks orphaned during opt {"generic cse", cse}, diff --git a/src/cmd/compile/internal/ssa/config.go b/src/cmd/compile/internal/ssa/config.go index 014c960267..6d3a949a6a 100644 --- a/src/cmd/compile/internal/ssa/config.go +++ b/src/cmd/compile/internal/ssa/config.go @@ -103,7 +103,7 @@ func (c *Config) Frontend() Frontend { return c.fe } // NewFunc returns a new, empty function object func (c *Config) NewFunc() *Func { // TODO(khr): should this function take name, type, etc. as arguments? - return &Func{Config: c, NamedValues: map[GCNode][]*Value{}} + return &Func{Config: c, NamedValues: map[LocalSlot][]*Value{}} } func (c *Config) Logf(msg string, args ...interface{}) { c.fe.Logf(msg, args...) } diff --git a/src/cmd/compile/internal/ssa/deadcode.go b/src/cmd/compile/internal/ssa/deadcode.go index 3351589fda..e9d6525701 100644 --- a/src/cmd/compile/internal/ssa/deadcode.go +++ b/src/cmd/compile/internal/ssa/deadcode.go @@ -162,24 +162,38 @@ func deadcode(f *Func) { } f.Blocks = f.Blocks[:i] - // Remove dead entries from namedValues map. - for name, values := range f.NamedValues { - i := 0 + // Remove dead & duplicate entries from namedValues map. + s := newSparseSet(f.NumValues()) + i = 0 + for _, name := range f.Names { + j := 0 + s.clear() + values := f.NamedValues[name] for _, v := range values { for v.Op == OpCopy { v = v.Args[0] } - if live[v.ID] { - values[i] = v - i++ + if live[v.ID] && !s.contains(v.ID) { + values[j] = v + j++ + s.add(v.ID) } } - f.NamedValues[name] = values[:i] - tail := values[i:] - for j := range tail { - tail[j] = nil + 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] // TODO: renumber Blocks and Values densely? // TODO: save dead Values and Blocks for reuse? Or should we just let GC handle it? diff --git a/src/cmd/compile/internal/ssa/deadcode_test.go b/src/cmd/compile/internal/ssa/deadcode_test.go index 7f491c77f9..c59d77ea60 100644 --- a/src/cmd/compile/internal/ssa/deadcode_test.go +++ b/src/cmd/compile/internal/ssa/deadcode_test.go @@ -10,7 +10,7 @@ func TestDeadLoop(t *testing.T) { c := testConfig(t) fun := Fun(c, "entry", Bloc("entry", - Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Goto("exit")), Bloc("exit", Exit("mem")), @@ -40,7 +40,7 @@ func TestDeadValue(t *testing.T) { c := testConfig(t) fun := Fun(c, "entry", Bloc("entry", - Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Valu("deadval", OpConst64, TypeInt64, 37, nil), Goto("exit")), Bloc("exit", @@ -64,7 +64,7 @@ func TestNeverTaken(t *testing.T) { fun := Fun(c, "entry", Bloc("entry", Valu("cond", OpConstBool, TypeBool, 0, nil), - Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, ".mem"), If("cond", "then", "else")), Bloc("then", Goto("exit")), @@ -98,7 +98,7 @@ func TestNestedDeadBlocks(t *testing.T) { c := testConfig(t) fun := Fun(c, "entry", Bloc("entry", - Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Valu("cond", OpConstBool, TypeBool, 0, nil), If("cond", "b2", "b4")), Bloc("b2", diff --git a/src/cmd/compile/internal/ssa/deadstore_test.go b/src/cmd/compile/internal/ssa/deadstore_test.go index 159ac4e439..4514c99004 100644 --- a/src/cmd/compile/internal/ssa/deadstore_test.go +++ b/src/cmd/compile/internal/ssa/deadstore_test.go @@ -12,7 +12,7 @@ func TestDeadStore(t *testing.T) { ptrType := &TypeImpl{Size_: 8, Ptr: true, Name: "testptr", Elem_: elemType} // dummy for testing fun := Fun(c, "entry", Bloc("entry", - Valu("start", OpArg, TypeMem, 0, ".mem"), + Valu("start", OpInitMem, TypeMem, 0, ".mem"), Valu("sb", OpSB, TypeInvalid, 0, nil), Valu("v", OpConstBool, TypeBool, 1, nil), Valu("addr1", OpAddr, ptrType, 0, nil, "sb"), @@ -47,7 +47,7 @@ func TestDeadStorePhi(t *testing.T) { ptrType := &TypeImpl{Size_: 8, Ptr: true, Name: "testptr"} // dummy for testing fun := Fun(c, "entry", Bloc("entry", - Valu("start", OpArg, TypeMem, 0, ".mem"), + Valu("start", OpInitMem, TypeMem, 0, ".mem"), Valu("sb", OpSB, TypeInvalid, 0, nil), Valu("v", OpConstBool, TypeBool, 1, nil), Valu("addr", OpAddr, ptrType, 0, nil, "sb"), @@ -74,7 +74,7 @@ func TestDeadStoreTypes(t *testing.T) { t2 := &TypeImpl{Size_: 4, Ptr: true, Name: "t2"} fun := Fun(c, "entry", Bloc("entry", - Valu("start", OpArg, TypeMem, 0, ".mem"), + Valu("start", OpInitMem, TypeMem, 0, ".mem"), Valu("sb", OpSB, TypeInvalid, 0, nil), Valu("v", OpConstBool, TypeBool, 1, nil), Valu("addr1", OpAddr, t1, 0, nil, "sb"), diff --git a/src/cmd/compile/internal/ssa/decompose.go b/src/cmd/compile/internal/ssa/decompose.go index 2057d8ea5c..c8a1df281a 100644 --- a/src/cmd/compile/internal/ssa/decompose.go +++ b/src/cmd/compile/internal/ssa/decompose.go @@ -29,8 +29,75 @@ func decompose(f *Func) { } } } - // TODO: decompose complex? // TODO: decompose 64-bit ops on 32-bit archs? + + // 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.IsStruct(): + // TODO + case t.Size() > f.Config.IntSize: + f.Unimplementedf("undecomposed type %s", t) + } + } } func decomposeStringPhi(v *Value) { diff --git a/src/cmd/compile/internal/ssa/dom_test.go b/src/cmd/compile/internal/ssa/dom_test.go index eff7205fa3..84e0093799 100644 --- a/src/cmd/compile/internal/ssa/dom_test.go +++ b/src/cmd/compile/internal/ssa/dom_test.go @@ -20,7 +20,7 @@ func genLinear(size int) []bloc { var blocs []bloc blocs = append(blocs, Bloc("entry", - Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Goto(blockn(0)), ), ) @@ -43,7 +43,7 @@ func genFwdBack(size int) []bloc { var blocs []bloc blocs = append(blocs, Bloc("entry", - Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Valu("p", OpConstBool, TypeBool, 1, nil), Goto(blockn(0)), ), @@ -73,7 +73,7 @@ func genManyPred(size int) []bloc { var blocs []bloc blocs = append(blocs, Bloc("entry", - Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Valu("p", OpConstBool, TypeBool, 1, nil), Goto(blockn(0)), ), @@ -111,7 +111,7 @@ func genMaxPred(size int) []bloc { var blocs []bloc blocs = append(blocs, Bloc("entry", - Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Valu("p", OpConstBool, TypeBool, 1, nil), Goto(blockn(0)), ), @@ -136,7 +136,7 @@ func genMaxPredValue(size int) []bloc { var blocs []bloc blocs = append(blocs, Bloc("entry", - Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Valu("p", OpConstBool, TypeBool, 1, nil), Goto(blockn(0)), ), @@ -223,7 +223,7 @@ func TestDominatorsSingleBlock(t *testing.T) { c := testConfig(t) fun := Fun(c, "entry", Bloc("entry", - Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Exit("mem"))) doms := map[string]string{} @@ -238,7 +238,7 @@ func TestDominatorsSimple(t *testing.T) { c := testConfig(t) fun := Fun(c, "entry", Bloc("entry", - Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Goto("a")), Bloc("a", Goto("b")), @@ -266,7 +266,7 @@ func TestDominatorsMultPredFwd(t *testing.T) { c := testConfig(t) fun := Fun(c, "entry", Bloc("entry", - Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Valu("p", OpConstBool, TypeBool, 1, nil), If("p", "a", "c")), Bloc("a", @@ -294,7 +294,7 @@ func TestDominatorsDeadCode(t *testing.T) { c := testConfig(t) fun := Fun(c, "entry", Bloc("entry", - Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Valu("p", OpConstBool, TypeBool, 0, nil), If("p", "b3", "b5")), Bloc("b2", Exit("mem")), @@ -319,7 +319,7 @@ func TestDominatorsMultPredRev(t *testing.T) { Bloc("entry", Goto("first")), Bloc("first", - Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Valu("p", OpConstBool, TypeBool, 1, nil), Goto("a")), Bloc("a", @@ -348,7 +348,7 @@ func TestDominatorsMultPred(t *testing.T) { c := testConfig(t) fun := Fun(c, "entry", Bloc("entry", - Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Valu("p", OpConstBool, TypeBool, 1, nil), If("p", "a", "c")), Bloc("a", @@ -376,7 +376,7 @@ func TestPostDominators(t *testing.T) { c := testConfig(t) fun := Fun(c, "entry", Bloc("entry", - Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Valu("p", OpConstBool, TypeBool, 1, nil), If("p", "a", "c")), Bloc("a", @@ -403,7 +403,7 @@ func TestInfiniteLoop(t *testing.T) { // note lack of an exit block fun := Fun(c, "entry", Bloc("entry", - Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Valu("p", OpConstBool, TypeBool, 1, nil), Goto("a")), Bloc("a", diff --git a/src/cmd/compile/internal/ssa/func.go b/src/cmd/compile/internal/ssa/func.go index ce11b184f6..e5fbfdb5ff 100644 --- a/src/cmd/compile/internal/ssa/func.go +++ b/src/cmd/compile/internal/ssa/func.go @@ -26,12 +26,11 @@ type Func struct { // when register allocation is done, maps value ids to locations RegAlloc []Location - // map from *gc.Node to set of Values that represent that Node. - // The Node must be an ONAME with PPARAM, PPARAMOUT, or PAUTO class. - NamedValues map[GCNode][]*Value + // 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 []GCNode + Names []LocalSlot } // NumBlocks returns an integer larger than the id of any Block in the Func. diff --git a/src/cmd/compile/internal/ssa/func_test.go b/src/cmd/compile/internal/ssa/func_test.go index dc5d220db8..d35690a30c 100644 --- a/src/cmd/compile/internal/ssa/func_test.go +++ b/src/cmd/compile/internal/ssa/func_test.go @@ -18,7 +18,7 @@ // // fun := Fun("entry", // Bloc("entry", -// Valu("mem", OpArg, TypeMem, 0, ".mem"), +// Valu("mem", OpInitMem, TypeMem, 0, ".mem"), // Goto("exit")), // Bloc("exit", // Exit("mem")), @@ -263,7 +263,7 @@ func TestArgs(t *testing.T) { Valu("a", OpConst64, TypeInt64, 14, nil), Valu("b", OpConst64, TypeInt64, 26, nil), Valu("sum", OpAdd64, TypeInt64, 0, nil, "a", "b"), - Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Goto("exit")), Bloc("exit", Exit("mem"))) @@ -286,7 +286,7 @@ func TestEquiv(t *testing.T) { Valu("a", OpConst64, TypeInt64, 14, nil), Valu("b", OpConst64, TypeInt64, 26, nil), Valu("sum", OpAdd64, TypeInt64, 0, nil, "a", "b"), - Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Goto("exit")), Bloc("exit", Exit("mem"))), @@ -295,7 +295,7 @@ func TestEquiv(t *testing.T) { Valu("a", OpConst64, TypeInt64, 14, nil), Valu("b", OpConst64, TypeInt64, 26, nil), Valu("sum", OpAdd64, TypeInt64, 0, nil, "a", "b"), - Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Goto("exit")), Bloc("exit", Exit("mem"))), @@ -307,7 +307,7 @@ func TestEquiv(t *testing.T) { Valu("a", OpConst64, TypeInt64, 14, nil), Valu("b", OpConst64, TypeInt64, 26, nil), Valu("sum", OpAdd64, TypeInt64, 0, nil, "a", "b"), - Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Goto("exit")), Bloc("exit", Exit("mem"))), @@ -318,7 +318,7 @@ func TestEquiv(t *testing.T) { Valu("a", OpConst64, TypeInt64, 14, nil), Valu("b", OpConst64, TypeInt64, 26, nil), Valu("sum", OpAdd64, TypeInt64, 0, nil, "a", "b"), - Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Goto("exit"))), }, } @@ -335,26 +335,26 @@ func TestEquiv(t *testing.T) { { Fun(c, "entry", Bloc("entry", - Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Goto("exit")), Bloc("exit", Exit("mem"))), Fun(c, "entry", Bloc("entry", - Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Exit("mem"))), }, // value order changed { Fun(c, "entry", Bloc("entry", - Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Valu("b", OpConst64, TypeInt64, 26, nil), Valu("a", OpConst64, TypeInt64, 14, nil), Exit("mem"))), Fun(c, "entry", Bloc("entry", - Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Valu("a", OpConst64, TypeInt64, 14, nil), Valu("b", OpConst64, TypeInt64, 26, nil), Exit("mem"))), @@ -363,12 +363,12 @@ func TestEquiv(t *testing.T) { { Fun(c, "entry", Bloc("entry", - Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Valu("a", OpConst64, TypeInt64, 14, nil), Exit("mem"))), Fun(c, "entry", Bloc("entry", - Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Valu("a", OpConst64, TypeInt64, 26, nil), Exit("mem"))), }, @@ -376,12 +376,12 @@ func TestEquiv(t *testing.T) { { Fun(c, "entry", Bloc("entry", - Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Valu("a", OpConst64, TypeInt64, 0, 14), Exit("mem"))), Fun(c, "entry", Bloc("entry", - Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Valu("a", OpConst64, TypeInt64, 0, 26), Exit("mem"))), }, @@ -389,14 +389,14 @@ func TestEquiv(t *testing.T) { { Fun(c, "entry", Bloc("entry", - Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Valu("a", OpConst64, TypeInt64, 14, nil), Valu("b", OpConst64, TypeInt64, 26, nil), Valu("sum", OpAdd64, TypeInt64, 0, nil, "a", "b"), Exit("mem"))), Fun(c, "entry", Bloc("entry", - Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Valu("a", OpConst64, TypeInt64, 0, nil), Valu("b", OpConst64, TypeInt64, 14, nil), Valu("sum", OpAdd64, TypeInt64, 0, nil, "b", "a"), diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index bb347aea8b..9c1da92b7e 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -188,12 +188,12 @@ (Load ptr mem) && t.IsString() -> (StringMake (Load ptr mem) - (Load - (OffPtr [config.PtrSize] ptr) + (Load + (OffPtr [config.PtrSize] ptr) mem)) (Store [2*config.PtrSize] dst (StringMake ptr len) mem) -> (Store [config.PtrSize] - (OffPtr [config.PtrSize] dst) + (OffPtr [config.PtrSize] dst) len (Store [config.PtrSize] dst ptr mem)) @@ -215,18 +215,18 @@ (Load ptr mem) && t.IsSlice() -> (SliceMake (Load ptr mem) - (Load - (OffPtr [config.PtrSize] ptr) + (Load + (OffPtr [config.PtrSize] ptr) mem) - (Load - (OffPtr [2*config.PtrSize] ptr) + (Load + (OffPtr [2*config.PtrSize] ptr) mem)) (Store [3*config.PtrSize] dst (SliceMake ptr len cap) mem) -> (Store [config.PtrSize] - (OffPtr [2*config.PtrSize] dst) + (OffPtr [2*config.PtrSize] dst) cap (Store [config.PtrSize] - (OffPtr [config.PtrSize] dst) + (OffPtr [config.PtrSize] dst) len (Store [config.PtrSize] dst ptr mem))) @@ -261,3 +261,30 @@ // Get rid of Convert ops for pointer arithmetic on unsafe.Pointer. (Convert (Add64 (Convert ptr) off)) -> (Add64 ptr off) + +// Decompose compound argument values +(Arg {n} [off]) && v.Type.IsString() -> + (StringMake + (Arg {n} [off]) + (Arg {n} [off+config.PtrSize])) + +(Arg {n} [off]) && v.Type.IsSlice() -> + (SliceMake + (Arg {n} [off]) + (Arg {n} [off+config.PtrSize]) + (Arg {n} [off+2*config.PtrSize])) + +(Arg {n} [off]) && v.Type.IsInterface() -> + (IMake + (Arg {n} [off]) + (Arg {n} [off+config.PtrSize])) + +(Arg {n} [off]) && v.Type.IsComplex() && v.Type.Size() == 16 -> + (ComplexMake + (Arg {n} [off]) + (Arg {n} [off+8])) + +(Arg {n} [off]) && v.Type.IsComplex() && v.Type.Size() == 8 -> + (ComplexMake + (Arg {n} [off]) + (Arg {n} [off+4])) diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 162ee0dab4..8eb10a7d9b 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -260,7 +260,8 @@ var genericOps = []opData{ // TODO: Const32F, ... // Constant-like things - {name: "Arg"}, // memory input to the function. + {name: "InitMem"}, // memory input to the function. + {name: "Arg"}, // 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 diff --git a/src/cmd/compile/internal/ssa/html.go b/src/cmd/compile/internal/ssa/html.go index 68a432c676..9b8fc3750b 100644 --- a/src/cmd/compile/internal/ssa/html.go +++ b/src/cmd/compile/internal/ssa/html.go @@ -472,3 +472,7 @@ func (p htmlFuncPrinter) startDepCycle() { func (p htmlFuncPrinter) endDepCycle() { fmt.Fprintln(p.w, "") } + +func (p htmlFuncPrinter) named(n LocalSlot, vals []*Value) { + // TODO +} diff --git a/src/cmd/compile/internal/ssa/location.go b/src/cmd/compile/internal/ssa/location.go index 0f9fb33eeb..85f525565b 100644 --- a/src/cmd/compile/internal/ssa/location.go +++ b/src/cmd/compile/internal/ssa/location.go @@ -4,6 +4,8 @@ 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), ... @@ -21,10 +23,16 @@ func (r *Register) Name() string { } // 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 // a *gc.Node for an auto variable + 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 { - return s.N.String() +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 index 9c28bd10a5..bf3c15f78b 100644 --- a/src/cmd/compile/internal/ssa/lower.go +++ b/src/cmd/compile/internal/ssa/lower.go @@ -21,7 +21,7 @@ func checkLower(f *Func) { continue // lowered } switch v.Op { - case OpSP, OpSB, OpArg, OpCopy, OpPhi, OpVarDef, OpVarKill: + case OpSP, OpSB, OpInitMem, OpArg, OpCopy, OpPhi, OpVarDef, OpVarKill: continue // ok not to lower } s := "not lowered: " + v.Op.String() + " " + v.Type.SimpleString() diff --git a/src/cmd/compile/internal/ssa/nilcheck_test.go b/src/cmd/compile/internal/ssa/nilcheck_test.go index 8f32f32b1d..d4a55c0855 100644 --- a/src/cmd/compile/internal/ssa/nilcheck_test.go +++ b/src/cmd/compile/internal/ssa/nilcheck_test.go @@ -21,7 +21,7 @@ func benchmarkNilCheckDeep(b *testing.B, depth int) { var blocs []bloc blocs = append(blocs, Bloc("entry", - Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Valu("sb", OpSB, TypeInvalid, 0, nil), Goto(blockn(0)), ), @@ -67,7 +67,7 @@ func TestNilcheckSimple(t *testing.T) { c := NewConfig("amd64", DummyFrontend{t}, nil) fun := Fun(c, "entry", Bloc("entry", - Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Valu("sb", OpSB, TypeInvalid, 0, nil), Goto("checkPtr")), Bloc("checkPtr", @@ -104,7 +104,7 @@ func TestNilcheckDomOrder(t *testing.T) { c := NewConfig("amd64", DummyFrontend{t}, nil) fun := Fun(c, "entry", Bloc("entry", - Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Valu("sb", OpSB, TypeInvalid, 0, nil), Goto("checkPtr")), Bloc("checkPtr", @@ -140,7 +140,7 @@ func TestNilcheckAddr(t *testing.T) { c := NewConfig("amd64", DummyFrontend{t}, nil) fun := Fun(c, "entry", Bloc("entry", - Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Valu("sb", OpSB, TypeInvalid, 0, nil), Goto("checkPtr")), Bloc("checkPtr", @@ -173,7 +173,7 @@ func TestNilcheckAddPtr(t *testing.T) { c := NewConfig("amd64", DummyFrontend{t}, nil) fun := Fun(c, "entry", Bloc("entry", - Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Valu("sb", OpSB, TypeInvalid, 0, nil), Goto("checkPtr")), Bloc("checkPtr", @@ -207,7 +207,7 @@ func TestNilcheckPhi(t *testing.T) { c := NewConfig("amd64", DummyFrontend{t}, nil) fun := Fun(c, "entry", Bloc("entry", - Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Valu("sb", OpSB, TypeInvalid, 0, nil), Valu("sp", OpSP, TypeInvalid, 0, nil), Valu("baddr", OpAddr, TypeBool, 0, "b", "sp"), @@ -251,7 +251,7 @@ func TestNilcheckKeepRemove(t *testing.T) { c := NewConfig("amd64", DummyFrontend{t}, nil) fun := Fun(c, "entry", Bloc("entry", - Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Valu("sb", OpSB, TypeInvalid, 0, nil), Goto("checkPtr")), Bloc("checkPtr", @@ -299,7 +299,7 @@ func TestNilcheckInFalseBranch(t *testing.T) { c := NewConfig("amd64", DummyFrontend{t}, nil) fun := Fun(c, "entry", Bloc("entry", - Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Valu("sb", OpSB, TypeInvalid, 0, nil), Goto("checkPtr")), Bloc("checkPtr", @@ -350,7 +350,7 @@ func TestNilcheckUser(t *testing.T) { c := NewConfig("amd64", DummyFrontend{t}, nil) fun := Fun(c, "entry", Bloc("entry", - Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Valu("sb", OpSB, TypeInvalid, 0, nil), Goto("checkPtr")), Bloc("checkPtr", @@ -389,7 +389,7 @@ func TestNilcheckBug(t *testing.T) { c := NewConfig("amd64", DummyFrontend{t}, nil) fun := Fun(c, "entry", Bloc("entry", - Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Valu("sb", OpSB, TypeInvalid, 0, nil), Goto("checkPtr")), Bloc("checkPtr", diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 400f59e174..d043e076ea 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -475,6 +475,7 @@ const ( OpConst64F OpConstInterface OpConstSlice + OpInitMem OpArg OpAddr OpSP @@ -3987,6 +3988,10 @@ var opcodeTable = [...]opInfo{ name: "ConstSlice", generic: true, }, + { + name: "InitMem", + generic: true, + }, { name: "Arg", generic: true, diff --git a/src/cmd/compile/internal/ssa/print.go b/src/cmd/compile/internal/ssa/print.go index 192dc83b39..b61e6f1cc7 100644 --- a/src/cmd/compile/internal/ssa/print.go +++ b/src/cmd/compile/internal/ssa/print.go @@ -28,6 +28,7 @@ type funcPrinter interface { value(v *Value, live bool) startDepCycle() endDepCycle() + named(n LocalSlot, vals []*Value) } type stringFuncPrinter struct { @@ -73,6 +74,10 @@ func (p stringFuncPrinter) startDepCycle() { 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) @@ -136,4 +141,7 @@ func fprintFunc(p funcPrinter, f *Func) { p.endBlock(b) } + for name, vals := range f.NamedValues { + p.named(name, vals) + } } diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index 89deb14a4a..a751d66988 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -759,6 +759,16 @@ func (s *regAllocState) regalloc(f *Func) { pc++ 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) + pc++ + continue + } s.clearUses(pc*2 - 1) regspec := opcodeTable[v.Op].reg if regDebug { diff --git a/src/cmd/compile/internal/ssa/regalloc_test.go b/src/cmd/compile/internal/ssa/regalloc_test.go index dcd253ea14..08260fbbbb 100644 --- a/src/cmd/compile/internal/ssa/regalloc_test.go +++ b/src/cmd/compile/internal/ssa/regalloc_test.go @@ -10,7 +10,7 @@ func TestLiveControlOps(t *testing.T) { c := testConfig(t) f := Fun(c, "entry", Bloc("entry", - Valu("mem", OpArg, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Valu("x", OpAMD64MOVBconst, TypeInt8, 0, 1), Valu("y", OpAMD64MOVBconst, TypeInt8, 0, 2), Valu("a", OpAMD64TESTB, TypeBool, 0, nil, "x", "y"), diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index 2448b43547..c349603583 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -23,6 +23,8 @@ func rewriteValuegeneric(v *Value, config *Config) bool { 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: @@ -402,6 +404,156 @@ endeaf127389bd0d4b0e0e297830f8f463b: ; 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 {n} [off]) (Arg {n} [off+config.PtrSize])) + { + n := v.Aux + off := v.AuxInt + if !(v.Type.IsString()) { + goto end939d3f946bf61eb85b46b374e7afa9e9 + } + v.Op = OpStringMake + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpArg, TypeInvalid) + v0.Type = config.fe.TypeBytePtr() + v0.Aux = n + v0.AuxInt = off + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpArg, TypeInvalid) + v1.Type = config.fe.TypeInt() + v1.Aux = n + v1.AuxInt = off + config.PtrSize + v.AddArg(v1) + return true + } + goto end939d3f946bf61eb85b46b374e7afa9e9 +end939d3f946bf61eb85b46b374e7afa9e9: + ; + // match: (Arg {n} [off]) + // cond: v.Type.IsSlice() + // result: (SliceMake (Arg {n} [off]) (Arg {n} [off+config.PtrSize]) (Arg {n} [off+2*config.PtrSize])) + { + n := v.Aux + off := v.AuxInt + if !(v.Type.IsSlice()) { + goto endab4b93ad3b1cf55e5bf25d1fd9cd498e + } + v.Op = OpSliceMake + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpArg, TypeInvalid) + v0.Type = config.fe.TypeBytePtr() + v0.Aux = n + v0.AuxInt = off + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpArg, TypeInvalid) + v1.Type = config.fe.TypeInt() + v1.Aux = n + v1.AuxInt = off + config.PtrSize + v.AddArg(v1) + v2 := b.NewValue0(v.Line, OpArg, TypeInvalid) + v2.Type = config.fe.TypeInt() + v2.Aux = n + v2.AuxInt = off + 2*config.PtrSize + v.AddArg(v2) + return true + } + goto endab4b93ad3b1cf55e5bf25d1fd9cd498e +endab4b93ad3b1cf55e5bf25d1fd9cd498e: + ; + // match: (Arg {n} [off]) + // cond: v.Type.IsInterface() + // result: (IMake (Arg {n} [off]) (Arg {n} [off+config.PtrSize])) + { + n := v.Aux + off := v.AuxInt + if !(v.Type.IsInterface()) { + goto end851de8e588a39e81b4e2aef06566bf3e + } + v.Op = OpIMake + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpArg, TypeInvalid) + v0.Type = config.fe.TypeBytePtr() + v0.Aux = n + v0.AuxInt = off + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpArg, TypeInvalid) + v1.Type = config.fe.TypeBytePtr() + v1.Aux = n + v1.AuxInt = off + config.PtrSize + v.AddArg(v1) + return true + } + goto end851de8e588a39e81b4e2aef06566bf3e +end851de8e588a39e81b4e2aef06566bf3e: + ; + // match: (Arg {n} [off]) + // cond: v.Type.IsComplex() && v.Type.Size() == 16 + // result: (ComplexMake (Arg {n} [off]) (Arg {n} [off+8])) + { + n := v.Aux + off := v.AuxInt + if !(v.Type.IsComplex() && v.Type.Size() == 16) { + goto end0988fc6a62c810b2f4976cb6cf44387f + } + v.Op = OpComplexMake + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpArg, TypeInvalid) + v0.Type = config.fe.TypeFloat64() + v0.Aux = n + v0.AuxInt = off + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpArg, TypeInvalid) + v1.Type = config.fe.TypeFloat64() + v1.Aux = n + v1.AuxInt = off + 8 + v.AddArg(v1) + return true + } + goto end0988fc6a62c810b2f4976cb6cf44387f +end0988fc6a62c810b2f4976cb6cf44387f: + ; + // match: (Arg {n} [off]) + // cond: v.Type.IsComplex() && v.Type.Size() == 8 + // result: (ComplexMake (Arg {n} [off]) (Arg {n} [off+4])) + { + n := v.Aux + off := v.AuxInt + if !(v.Type.IsComplex() && v.Type.Size() == 8) { + goto enda348e93e0036873dd7089a2939c22e3e + } + v.Op = OpComplexMake + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpArg, TypeInvalid) + v0.Type = config.fe.TypeFloat32() + v0.Aux = n + v0.AuxInt = off + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpArg, TypeInvalid) + v1.Type = config.fe.TypeFloat32() + v1.Aux = n + v1.AuxInt = off + 4 + v.AddArg(v1) + return true + } + goto enda348e93e0036873dd7089a2939c22e3e +enda348e93e0036873dd7089a2939c22e3e: + ; + return false +} func rewriteValuegeneric_OpArrayIndex(v *Value, config *Config) bool { b := v.Block _ = b @@ -2115,13 +2267,13 @@ end1b106f89e0e3e26c613b957a7c98d8ad: ; // match: (Load ptr mem) // cond: t.IsString() - // result: (StringMake (Load ptr mem) (Load (OffPtr [config.PtrSize] ptr) mem)) + // result: (StringMake (Load ptr mem) (Load (OffPtr [config.PtrSize] ptr) mem)) { t := v.Type ptr := v.Args[0] mem := v.Args[1] if !(t.IsString()) { - goto end7c75255555bf9dd796298d9f6eaf9cf2 + goto enddd15a6f3d53a6ce7a19d4e181dd1c13a } v.Op = OpStringMake v.AuxInt = 0 @@ -2133,9 +2285,9 @@ end1b106f89e0e3e26c613b957a7c98d8ad: v0.AddArg(mem) v.AddArg(v0) v1 := b.NewValue0(v.Line, OpLoad, TypeInvalid) - v1.Type = config.fe.TypeUintptr() + v1.Type = config.fe.TypeInt() v2 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v2.Type = config.fe.TypeUintptr().PtrTo() + v2.Type = config.fe.TypeInt().PtrTo() v2.AuxInt = config.PtrSize v2.AddArg(ptr) v1.AddArg(v2) @@ -2143,18 +2295,18 @@ end1b106f89e0e3e26c613b957a7c98d8ad: v.AddArg(v1) return true } - goto end7c75255555bf9dd796298d9f6eaf9cf2 -end7c75255555bf9dd796298d9f6eaf9cf2: + goto enddd15a6f3d53a6ce7a19d4e181dd1c13a +enddd15a6f3d53a6ce7a19d4e181dd1c13a: ; // match: (Load ptr mem) // cond: t.IsSlice() - // result: (SliceMake (Load ptr mem) (Load (OffPtr [config.PtrSize] ptr) mem) (Load (OffPtr [2*config.PtrSize] ptr) mem)) + // result: (SliceMake (Load ptr mem) (Load (OffPtr [config.PtrSize] ptr) mem) (Load (OffPtr [2*config.PtrSize] ptr) mem)) { t := v.Type ptr := v.Args[0] mem := v.Args[1] if !(t.IsSlice()) { - goto end12c46556d962198680eb3238859e3016 + goto end65e8b0055aa7491b9b6066d9fe1b2c13 } v.Op = OpSliceMake v.AuxInt = 0 @@ -2166,18 +2318,18 @@ end7c75255555bf9dd796298d9f6eaf9cf2: v0.AddArg(mem) v.AddArg(v0) v1 := b.NewValue0(v.Line, OpLoad, TypeInvalid) - v1.Type = config.fe.TypeUintptr() + v1.Type = config.fe.TypeInt() v2 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v2.Type = config.fe.TypeUintptr().PtrTo() + v2.Type = 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, TypeInvalid) - v3.Type = config.fe.TypeUintptr() + v3.Type = config.fe.TypeInt() v4 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v4.Type = config.fe.TypeUintptr().PtrTo() + v4.Type = config.fe.TypeInt().PtrTo() v4.AuxInt = 2 * config.PtrSize v4.AddArg(ptr) v3.AddArg(v4) @@ -2185,8 +2337,8 @@ end7c75255555bf9dd796298d9f6eaf9cf2: v.AddArg(v3) return true } - goto end12c46556d962198680eb3238859e3016 -end12c46556d962198680eb3238859e3016: + goto end65e8b0055aa7491b9b6066d9fe1b2c13 +end65e8b0055aa7491b9b6066d9fe1b2c13: ; // match: (Load ptr mem) // cond: t.IsInterface() @@ -2916,14 +3068,14 @@ end3851a482d7bd37a93c4d81581e85b3ab: ; // match: (Store [2*config.PtrSize] dst (StringMake ptr len) mem) // cond: - // result: (Store [config.PtrSize] (OffPtr [config.PtrSize] dst) len (Store [config.PtrSize] dst ptr mem)) + // result: (Store [config.PtrSize] (OffPtr [config.PtrSize] dst) len (Store [config.PtrSize] dst ptr mem)) { if v.AuxInt != 2*config.PtrSize { - goto end12abe4021d24e76ed56d64b18730bffb + goto endd3a6ecebdad5899570a79fe5c62f34f1 } dst := v.Args[0] if v.Args[1].Op != OpStringMake { - goto end12abe4021d24e76ed56d64b18730bffb + goto endd3a6ecebdad5899570a79fe5c62f34f1 } ptr := v.Args[1].Args[0] len := v.Args[1].Args[1] @@ -2934,7 +3086,7 @@ end3851a482d7bd37a93c4d81581e85b3ab: v.resetArgs() v.AuxInt = config.PtrSize v0 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v0.Type = config.fe.TypeUintptr().PtrTo() + v0.Type = config.fe.TypeInt().PtrTo() v0.AuxInt = config.PtrSize v0.AddArg(dst) v.AddArg(v0) @@ -2948,19 +3100,19 @@ end3851a482d7bd37a93c4d81581e85b3ab: v.AddArg(v1) return true } - goto end12abe4021d24e76ed56d64b18730bffb -end12abe4021d24e76ed56d64b18730bffb: + goto endd3a6ecebdad5899570a79fe5c62f34f1 +endd3a6ecebdad5899570a79fe5c62f34f1: ; // match: (Store [3*config.PtrSize] dst (SliceMake ptr len cap) mem) // cond: - // result: (Store [config.PtrSize] (OffPtr [2*config.PtrSize] dst) cap (Store [config.PtrSize] (OffPtr [config.PtrSize] dst) len (Store [config.PtrSize] dst ptr mem))) + // result: (Store [config.PtrSize] (OffPtr [2*config.PtrSize] dst) cap (Store [config.PtrSize] (OffPtr [config.PtrSize] dst) len (Store [config.PtrSize] dst ptr mem))) { if v.AuxInt != 3*config.PtrSize { - goto end7498d25e17db5398cf073a8590e35cc2 + goto endd5cc8c3dad7d24c845b0b88fc51487ae } dst := v.Args[0] if v.Args[1].Op != OpSliceMake { - goto end7498d25e17db5398cf073a8590e35cc2 + goto endd5cc8c3dad7d24c845b0b88fc51487ae } ptr := v.Args[1].Args[0] len := v.Args[1].Args[1] @@ -2972,7 +3124,7 @@ end12abe4021d24e76ed56d64b18730bffb: v.resetArgs() v.AuxInt = config.PtrSize v0 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v0.Type = config.fe.TypeUintptr().PtrTo() + v0.Type = config.fe.TypeInt().PtrTo() v0.AuxInt = 2 * config.PtrSize v0.AddArg(dst) v.AddArg(v0) @@ -2980,7 +3132,7 @@ end12abe4021d24e76ed56d64b18730bffb: v1 := b.NewValue0(v.Line, OpStore, TypeInvalid) v1.AuxInt = config.PtrSize v2 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v2.Type = config.fe.TypeUintptr().PtrTo() + v2.Type = config.fe.TypeInt().PtrTo() v2.AuxInt = config.PtrSize v2.AddArg(dst) v1.AddArg(v2) @@ -2996,8 +3148,8 @@ end12abe4021d24e76ed56d64b18730bffb: v.AddArg(v1) return true } - goto end7498d25e17db5398cf073a8590e35cc2 -end7498d25e17db5398cf073a8590e35cc2: + goto endd5cc8c3dad7d24c845b0b88fc51487ae +endd5cc8c3dad7d24c845b0b88fc51487ae: ; // match: (Store [2*config.PtrSize] dst (IMake itab data) mem) // cond: diff --git a/src/cmd/compile/internal/ssa/schedule_test.go b/src/cmd/compile/internal/ssa/schedule_test.go index 7f62ab9e3b..30c029ef7c 100644 --- a/src/cmd/compile/internal/ssa/schedule_test.go +++ b/src/cmd/compile/internal/ssa/schedule_test.go @@ -11,7 +11,7 @@ func TestSchedule(t *testing.T) { cases := []fun{ Fun(c, "entry", Bloc("entry", - Valu("mem0", OpArg, TypeMem, 0, ".mem"), + Valu("mem0", OpInitMem, TypeMem, 0, ".mem"), Valu("ptr", OpConst64, TypeInt64, 0xABCD, nil), Valu("v", OpConst64, TypeInt64, 12, nil), Valu("mem1", OpStore, TypeMem, 8, nil, "ptr", "v", "mem0"), diff --git a/src/cmd/compile/internal/ssa/shift_test.go b/src/cmd/compile/internal/ssa/shift_test.go index 611b418b6d..9e7f0585a6 100644 --- a/src/cmd/compile/internal/ssa/shift_test.go +++ b/src/cmd/compile/internal/ssa/shift_test.go @@ -28,7 +28,7 @@ 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", OpArg, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Valu("SP", OpSP, TypeUInt64, 0, nil), Valu("argptr", OpOffPtr, ptyp, 8, nil, "SP"), Valu("resptr", OpOffPtr, ptyp, 16, nil, "SP"), diff --git a/src/cmd/compile/internal/ssa/stackalloc.go b/src/cmd/compile/internal/ssa/stackalloc.go index 793162a797..3eb5c3cf4a 100644 --- a/src/cmd/compile/internal/ssa/stackalloc.go +++ b/src/cmd/compile/internal/ssa/stackalloc.go @@ -44,6 +44,13 @@ func stackalloc(f *Func) { } case v.Op == OpLoadReg: s.add(v.Args[0].ID) + case v.Op == OpArg: + // This is an input argument which is pre-spilled. It is kind of + // like a StoreReg, but we don't remove 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. } } } @@ -51,7 +58,7 @@ func stackalloc(f *Func) { // 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([]GCNode, f.NumValues()) + names := make([]LocalSlot, f.NumValues()) for _, name := range f.Names { // Note: not "range f.NamedValues" above, because // that would be nondeterministic. @@ -74,9 +81,17 @@ func stackalloc(f *Func) { } } + // Allocate args to their assigned locations. + for _, v := range f.Entry.Values { + if v.Op != OpArg { + continue + } + f.setHome(v, LocalSlot{v.Aux.(GCNode), v.Type, v.AuxInt}) + } + // For each type, we keep track of all the stack slots we // have allocated for that type. - locations := map[Type][]*LocalSlot{} + 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]. @@ -99,16 +114,16 @@ func stackalloc(f *Func) { // If this is a named value, try to use the name as // the spill location. - var name GCNode + var name LocalSlot if v.Op == OpStoreReg { name = names[v.Args[0].ID] } else { name = names[v.ID] } - if name != nil && v.Type.Equal(name.Typ()) { + if name.N != nil && v.Type.Equal(name.Type) { for _, id := range interfere[v.ID] { h := f.getHome(id) - if h != nil && h.(*LocalSlot).N == name { + if h != nil && h.(LocalSlot) == name { // A variable can interfere with itself. // It is rare, but but it can happen. goto noname @@ -118,17 +133,16 @@ func stackalloc(f *Func) { for _, a := range v.Args { for _, id := range interfere[a.ID] { h := f.getHome(id) - if h != nil && h.(*LocalSlot).N == name { + if h != nil && h.(LocalSlot) == name { goto noname } } } } - loc := &LocalSlot{name} - f.setHome(v, loc) + f.setHome(v, name) if v.Op == OpPhi { for _, a := range v.Args { - f.setHome(a, loc) + f.setHome(a, name) } } continue @@ -169,7 +183,7 @@ func stackalloc(f *Func) { } // If there is no unused stack slot, allocate a new one. if i == len(locs) { - locs = append(locs, &LocalSlot{f.Config.fe.Auto(v.Type)}) + 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. diff --git a/src/cmd/compile/internal/ssa/tighten.go b/src/cmd/compile/internal/ssa/tighten.go index 4fa26d2d18..6726c06e76 100644 --- a/src/cmd/compile/internal/ssa/tighten.go +++ b/src/cmd/compile/internal/ssa/tighten.go @@ -54,8 +54,8 @@ func tighten(f *Func) { 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 { - // GetClosurePtr must stay in entry block. + 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 diff --git a/src/runtime/runtime-gdb_test.go b/src/runtime/runtime-gdb_test.go index 2843633ee1..48567f1b9c 100644 --- a/src/runtime/runtime-gdb_test.go +++ b/src/runtime/runtime-gdb_test.go @@ -94,9 +94,6 @@ func TestGdbPython(t *testing.T) { "-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 @@ -151,10 +148,6 @@ func TestGdbPython(t *testing.T) { 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) -- cgit v1.3 From d19bfc3b681029da32c1ac661b27764a532aa0fc Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Tue, 3 Nov 2015 09:30:17 -0800 Subject: [dev.ssa] cmd/compile: Handle ONOT in conditionals as well Might as well, for a && !(b && c) and the like. Change-Id: I2548b6e6ee5870e074bcef6edd56a7db6e81d70f Reviewed-on: https://go-review.googlesource.com/16600 Reviewed-by: David Chase Run-TryBot: David Chase --- src/cmd/compile/internal/gc/ssa.go | 5 +++++ 1 file changed, 5 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 2c935b7247..90abd8e05d 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -2026,6 +2026,11 @@ func (s *state) condBranch(cond *Node, yes, no *ssa.Block, likely int8) { // 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 -- cgit v1.3 From 170589ee1ce4ef87e6a91ad05ea03422cf3f0908 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Mon, 9 Nov 2015 20:54:34 -0800 Subject: [dev.ssa] cmd/compile: some SSA optimizations Some optimizations of things I've seen looking at generated code. (x+y)-x == y x-0 == x The ptr portion of the constant string "" can be nil. Also update TODO with recent changes. Change-Id: I02c41ca2f9e9e178bf889058d3e083b446672dbe Reviewed-on: https://go-review.googlesource.com/16771 Run-TryBot: Keith Randall Reviewed-by: David Chase --- src/cmd/compile/internal/ssa/TODO | 22 +-- src/cmd/compile/internal/ssa/gen/AMD64.rules | 17 +- src/cmd/compile/internal/ssa/gen/generic.rules | 18 +- src/cmd/compile/internal/ssa/gen/genericOps.go | 2 +- src/cmd/compile/internal/ssa/rewriteAMD64.go | 218 +++++++++++++++++++++ src/cmd/compile/internal/ssa/rewritegeneric.go | 252 ++++++++++++++++++++++++- 6 files changed, 501 insertions(+), 28 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/TODO b/src/cmd/compile/internal/ssa/TODO index 9d6014e312..e7b124d82b 100644 --- a/src/cmd/compile/internal/ssa/TODO +++ b/src/cmd/compile/internal/ssa/TODO @@ -6,11 +6,7 @@ Coverage Correctness ----------- -- Write barriers -- Debugging info -- Can/should we move control values out of their basic block? -- Anything to do for the race detector? -- Slicing details (avoid ptr to next object) [done for string] +- Debugging info (check & fix as much as we can) Optimizations (better compiled code) ------------------------------------ @@ -19,14 +15,15 @@ Optimizations (better compiled code) - Strength reduction: constant divides -> multiply - Expand current optimizations to all bit widths - Add a value range propagation pass (for bounds elim & bitwidth reduction) -- Combining nil checks with subsequent load -- Implement memory zeroing with REPSTOSQ and DuffZero -- Implement memory copying with REPMOVSQ and DuffCopy -- Stackalloc: organize values to allow good packing -- Regalloc: use arg slots as the home for arguments (don't copy args to locals) -- Reuse stack slots for noninterfering & compatible values (but see issue 8740) +- Make dead store pass inter-block - (x86) Combine loads into other ops - (x86) More combining address arithmetic into loads/stores +- (x86) use ADDQ instead of LEAQ when we can +- redundant CMP in sequences like this: + SUBQ $8, AX + CMP AX, $0 + JEQ ... +- Use better write barrier calls Optimizations (better compiler) ------------------------------- @@ -42,10 +39,9 @@ Optimizations (better compiler) Regalloc -------- - Make less arch-dependent -- Allow args and return values to be ssa-able +- Allow return values to be ssa-able - Handle 2-address instructions - Make liveness analysis non-quadratic -- Materialization of constants Future/other ------------ diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 79669cbb0d..4364022f41 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -639,8 +639,6 @@ (MOVSDstore [off1] {sym1} (LEAQ8 [off2] {sym2} ptr idx) val mem) && canMergeSym(sym1, sym2) -> (MOVSDstoreidx8 [addOff(off1, off2)] {mergeSym(sym1,sym2)} ptr idx val mem) -(ADDQconst [0] x) -> x - // lower Zero instructions with word sizes (Zero [0] _ mem) -> mem (Zero [1] destptr mem) -> (MOVBstoreconst [0] destptr mem) @@ -719,6 +717,16 @@ (SBBLcarrymask (CMPWconst [c] (MOVWconst [d]))) && !inBounds16(d, c) -> (MOVLconst [0]) (SBBLcarrymask (CMPBconst [c] (MOVBconst [d]))) && inBounds8(d, c) -> (MOVLconst [-1]) (SBBLcarrymask (CMPBconst [c] (MOVBconst [d]))) && !inBounds8(d, c) -> (MOVLconst [0]) + +// 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]) @@ -735,6 +743,10 @@ (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 @@ -805,3 +817,4 @@ (XORL x x) -> (MOVLconst [0]) (XORW x x) -> (MOVWconst [0]) (XORB x x) -> (MOVBconst [0]) + diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index 9c1da92b7e..d3de24d956 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -121,6 +121,16 @@ (Com32 (Com32 x)) -> x (Com64 (Com64 x)) -> x +// 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 + // user nil checks (NeqPtr p (ConstNil)) -> (IsNonNil p) (NeqPtr (ConstNil) p) -> (IsNonNil p) @@ -175,12 +185,16 @@ // string ops (StringPtr (StringMake ptr _)) -> ptr (StringLen (StringMake _ len)) -> len -(ConstString {s}) && config.PtrSize == 4 -> +(ConstString {s}) && config.PtrSize == 4 && s.(string) == "" -> + (StringMake (ConstNil) (Const32 [0])) +(ConstString {s}) && config.PtrSize == 8 && s.(string) == "" -> + (StringMake (ConstNil) (Const64 [0])) +(ConstString {s}) && config.PtrSize == 4 && s.(string) != "" -> (StringMake (Addr {config.fe.StringData(s.(string))} (SB)) (Const32 [int64(len(s.(string)))])) -(ConstString {s}) && config.PtrSize == 8 -> +(ConstString {s}) && config.PtrSize == 8 && s.(string) != "" -> (StringMake (Addr {config.fe.StringData(s.(string))} (SB)) diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 8eb10a7d9b..ead0cfd17a 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -248,7 +248,7 @@ var genericOps = []opData{ // bits of the AuxInt field matter. {name: "ConstBool"}, {name: "ConstString"}, - {name: "ConstNil"}, + {name: "ConstNil", typ: "BytePtr"}, {name: "Const8"}, {name: "Const16"}, {name: "Const32"}, diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index e0a6caa5f1..cfdd5a2851 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -764,6 +764,26 @@ end9464509b8874ffb00b43b843da01f0bc: func rewriteValueAMD64_OpAMD64ADDBconst(v *Value, config *Config) bool { b := v.Block _ = b + // match: (ADDBconst [c] x) + // cond: int8(c)==0 + // result: x + { + c := v.AuxInt + x := v.Args[0] + if !(int8(c) == 0) { + goto end3fbe38dfc1de8f48c755862c4c8b6bac + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end3fbe38dfc1de8f48c755862c4c8b6bac +end3fbe38dfc1de8f48c755862c4c8b6bac: + ; // match: (ADDBconst [c] (MOVBconst [d])) // cond: // result: (MOVBconst [c+d]) @@ -874,6 +894,26 @@ end9596df31f2685a49df67c6fb912a521d: func rewriteValueAMD64_OpAMD64ADDLconst(v *Value, config *Config) bool { b := v.Block _ = b + // match: (ADDLconst [c] x) + // cond: int32(c)==0 + // result: x + { + c := v.AuxInt + x := v.Args[0] + if !(int32(c) == 0) { + goto endf04fb6232fbd3b460bb0d1bdcdc57d65 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto endf04fb6232fbd3b460bb0d1bdcdc57d65 +endf04fb6232fbd3b460bb0d1bdcdc57d65: + ; // match: (ADDLconst [c] (MOVLconst [d])) // cond: // result: (MOVLconst [c+d]) @@ -1165,6 +1205,26 @@ end55cf2af0d75f3ec413528eeb799e94d5: func rewriteValueAMD64_OpAMD64ADDWconst(v *Value, config *Config) bool { b := v.Block _ = b + // match: (ADDWconst [c] x) + // cond: int16(c)==0 + // result: x + { + c := v.AuxInt + x := v.Args[0] + if !(int16(c) == 0) { + goto end8564670ff18b2a91eb92d5e5775464cd + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end8564670ff18b2a91eb92d5e5775464cd +end8564670ff18b2a91eb92d5e5775464cd: + ; // match: (ADDWconst [c] (MOVWconst [d])) // cond: // result: (MOVWconst [c+d]) @@ -11706,6 +11766,26 @@ ende8904403d937d95b0d6133d3ec92bb45: func rewriteValueAMD64_OpAMD64SUBBconst(v *Value, config *Config) bool { b := v.Block _ = b + // match: (SUBBconst [c] x) + // cond: int8(c) == 0 + // result: x + { + c := v.AuxInt + x := v.Args[0] + if !(int8(c) == 0) { + goto end974a26e947badc62fc104581f49138e6 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end974a26e947badc62fc104581f49138e6 +end974a26e947badc62fc104581f49138e6: + ; // match: (SUBBconst [c] (MOVBconst [d])) // cond: // result: (MOVBconst [d-c]) @@ -11817,6 +11897,26 @@ end332f1f641f875c69bea7289191e69133: func rewriteValueAMD64_OpAMD64SUBLconst(v *Value, config *Config) bool { b := v.Block _ = b + // match: (SUBLconst [c] x) + // cond: int32(c) == 0 + // result: x + { + c := v.AuxInt + x := v.Args[0] + if !(int32(c) == 0) { + goto end3fa10eaa42f9e283cf1757e1b2d3cac2 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end3fa10eaa42f9e283cf1757e1b2d3cac2 +end3fa10eaa42f9e283cf1757e1b2d3cac2: + ; // match: (SUBLconst [c] (MOVLconst [d])) // cond: // result: (MOVLconst [d-c]) @@ -11934,6 +12034,25 @@ endd87d1d839d2dc54d9c90fa4f73383480: func rewriteValueAMD64_OpAMD64SUBQconst(v *Value, config *Config) bool { b := v.Block _ = b + // match: (SUBQconst [0] x) + // cond: + // result: x + { + if v.AuxInt != 0 { + goto endfce1d3cec7c543c9dd80a27d944eb09e + } + x := v.Args[0] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto endfce1d3cec7c543c9dd80a27d944eb09e +endfce1d3cec7c543c9dd80a27d944eb09e: + ; // match: (SUBQconst [c] (MOVQconst [d])) // cond: // result: (MOVQconst [d-c]) @@ -12045,6 +12164,26 @@ endb970e7c318d04a1afe1dfe08a7ca0d9c: func rewriteValueAMD64_OpAMD64SUBWconst(v *Value, config *Config) bool { b := v.Block _ = b + // match: (SUBWconst [c] x) + // cond: int16(c) == 0 + // result: x + { + c := v.AuxInt + x := v.Args[0] + if !(int16(c) == 0) { + goto end1e7a493992465c9cc8314e3256ed6394 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end1e7a493992465c9cc8314e3256ed6394 +end1e7a493992465c9cc8314e3256ed6394: + ; // match: (SUBWconst [c] (MOVWconst [d])) // cond: // result: (MOVWconst [d-c]) @@ -12740,6 +12879,26 @@ end2afddc39503d04d572a3a07878f6c9c9: func rewriteValueAMD64_OpAMD64XORBconst(v *Value, config *Config) bool { b := v.Block _ = b + // match: (XORBconst [c] x) + // cond: int8(c)==0 + // result: x + { + c := v.AuxInt + x := v.Args[0] + if !(int8(c) == 0) { + goto end14b03b70e5579dfe3f9b243e02a887c3 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end14b03b70e5579dfe3f9b243e02a887c3 +end14b03b70e5579dfe3f9b243e02a887c3: + ; // match: (XORBconst [c] (MOVBconst [d])) // cond: // result: (MOVBconst [c^d]) @@ -12827,6 +12986,26 @@ end7bcf9cfeb69a0d7647389124eb53ce2a: func rewriteValueAMD64_OpAMD64XORLconst(v *Value, config *Config) bool { b := v.Block _ = b + // match: (XORLconst [c] x) + // cond: int32(c)==0 + // result: x + { + c := v.AuxInt + x := v.Args[0] + if !(int32(c) == 0) { + goto end99808ca9fb8e3220e42f5678e1042a08 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end99808ca9fb8e3220e42f5678e1042a08 +end99808ca9fb8e3220e42f5678e1042a08: + ; // match: (XORLconst [c] (MOVLconst [d])) // cond: // result: (MOVLconst [c^d]) @@ -12920,6 +13099,25 @@ end10575a5d711cf14e6d4dffbb0e8dfaeb: func rewriteValueAMD64_OpAMD64XORQconst(v *Value, config *Config) bool { b := v.Block _ = b + // match: (XORQconst [0] x) + // cond: + // result: x + { + if v.AuxInt != 0 { + goto end0ee8d195a97eff476cf1f69a4dc0ec75 + } + x := v.Args[0] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end0ee8d195a97eff476cf1f69a4dc0ec75 +end0ee8d195a97eff476cf1f69a4dc0ec75: + ; // match: (XORQconst [c] (MOVQconst [d])) // cond: // result: (MOVQconst [c^d]) @@ -13007,6 +13205,26 @@ end07f332e857be0c2707797ed480a2faf4: func rewriteValueAMD64_OpAMD64XORWconst(v *Value, config *Config) bool { b := v.Block _ = b + // match: (XORWconst [c] x) + // cond: int16(c)==0 + // result: x + { + c := v.AuxInt + x := v.Args[0] + if !(int16(c) == 0) { + goto enda371132353dee83828836da851240f0a + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto enda371132353dee83828836da851240f0a +enda371132353dee83828836da851240f0a: + ; // match: (XORWconst [c] (MOVWconst [d])) // cond: // result: (MOVWconst [c^d]) diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index c349603583..174967a194 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -818,12 +818,60 @@ func rewriteValuegeneric_OpConstString(v *Value, config *Config) bool { b := v.Block _ = b // match: (ConstString {s}) - // cond: config.PtrSize == 4 + // cond: config.PtrSize == 4 && s.(string) == "" + // result: (StringMake (ConstNil) (Const32 [0])) + { + s := v.Aux + if !(config.PtrSize == 4 && s.(string) == "") { + goto end85d5f388ba947643af63cdc68c1155a5 + } + v.Op = OpStringMake + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpConstNil, TypeInvalid) + v0.Type = config.fe.TypeBytePtr() + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpConst32, TypeInvalid) + v1.Type = config.fe.TypeInt() + v1.AuxInt = 0 + v.AddArg(v1) + return true + } + goto end85d5f388ba947643af63cdc68c1155a5 +end85d5f388ba947643af63cdc68c1155a5: + ; + // match: (ConstString {s}) + // cond: config.PtrSize == 8 && s.(string) == "" + // result: (StringMake (ConstNil) (Const64 [0])) + { + s := v.Aux + if !(config.PtrSize == 8 && s.(string) == "") { + goto endc807259a5ed2760fbbd3dc7386641343 + } + v.Op = OpStringMake + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpConstNil, TypeInvalid) + v0.Type = config.fe.TypeBytePtr() + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpConst64, TypeInvalid) + v1.Type = config.fe.TypeInt() + v1.AuxInt = 0 + v.AddArg(v1) + return true + } + goto endc807259a5ed2760fbbd3dc7386641343 +endc807259a5ed2760fbbd3dc7386641343: + ; + // match: (ConstString {s}) + // cond: config.PtrSize == 4 && s.(string) != "" // result: (StringMake (Addr {config.fe.StringData(s.(string))} (SB)) (Const32 [int64(len(s.(string)))])) { s := v.Aux - if !(config.PtrSize == 4) { - goto endaa2b20a40588873f370c5a12f084505a + if !(config.PtrSize == 4 && s.(string) != "") { + goto end107a700a4519d18f418602421444ddb6 } v.Op = OpStringMake v.AuxInt = 0 @@ -842,16 +890,16 @@ func rewriteValuegeneric_OpConstString(v *Value, config *Config) bool { v.AddArg(v2) return true } - goto endaa2b20a40588873f370c5a12f084505a -endaa2b20a40588873f370c5a12f084505a: + goto end107a700a4519d18f418602421444ddb6 +end107a700a4519d18f418602421444ddb6: ; // match: (ConstString {s}) - // cond: config.PtrSize == 8 + // cond: config.PtrSize == 8 && s.(string) != "" // result: (StringMake (Addr {config.fe.StringData(s.(string))} (SB)) (Const64 [int64(len(s.(string)))])) { s := v.Aux - if !(config.PtrSize == 8) { - goto endab37d89f3959d3cf1e71b57a3c61b8eb + if !(config.PtrSize == 8 && s.(string) != "") { + goto end7ce9db29d17866f26d21e6e12f442e54 } v.Op = OpStringMake v.AuxInt = 0 @@ -870,8 +918,8 @@ endaa2b20a40588873f370c5a12f084505a: v.AddArg(v2) return true } - goto endab37d89f3959d3cf1e71b57a3c61b8eb -endab37d89f3959d3cf1e71b57a3c61b8eb: + goto end7ce9db29d17866f26d21e6e12f442e54 +end7ce9db29d17866f26d21e6e12f442e54: ; return false } @@ -3383,6 +3431,52 @@ end5c6fab95c9dbeff5973119096bfd4e78: } goto end83da541391be564f2a08464e674a49e7 end83da541391be564f2a08464e674a49e7: + ; + // match: (Sub16 (Add16 x y) x) + // cond: + // result: y + { + if v.Args[0].Op != OpAdd16 { + goto end0dd8f250c457b9c005ecbed59fc2e758 + } + x := v.Args[0].Args[0] + y := v.Args[0].Args[1] + if v.Args[1] != x { + goto end0dd8f250c457b9c005ecbed59fc2e758 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = y.Type + v.AddArg(y) + return true + } + goto end0dd8f250c457b9c005ecbed59fc2e758 +end0dd8f250c457b9c005ecbed59fc2e758: + ; + // match: (Sub16 (Add16 x y) y) + // cond: + // result: x + { + if v.Args[0].Op != OpAdd16 { + goto end01c8db2e0bce69e048cf79f3bdc82b9b + } + x := v.Args[0].Args[0] + y := v.Args[0].Args[1] + if v.Args[1] != y { + goto end01c8db2e0bce69e048cf79f3bdc82b9b + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end01c8db2e0bce69e048cf79f3bdc82b9b +end01c8db2e0bce69e048cf79f3bdc82b9b: ; return false } @@ -3428,6 +3522,52 @@ end7623799db780e1bcc42c6ea0df9c49d3: } goto enda747581e798f199e07f4ad69747cd069 enda747581e798f199e07f4ad69747cd069: + ; + // match: (Sub32 (Add32 x y) x) + // cond: + // result: y + { + if v.Args[0].Op != OpAdd32 { + goto end70c1e60e58a6c106d060f10cd3f179ea + } + x := v.Args[0].Args[0] + y := v.Args[0].Args[1] + if v.Args[1] != x { + goto end70c1e60e58a6c106d060f10cd3f179ea + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = y.Type + v.AddArg(y) + return true + } + goto end70c1e60e58a6c106d060f10cd3f179ea +end70c1e60e58a6c106d060f10cd3f179ea: + ; + // match: (Sub32 (Add32 x y) y) + // cond: + // result: x + { + if v.Args[0].Op != OpAdd32 { + goto end20e42db178ec4f423cc56a991863a4a2 + } + x := v.Args[0].Args[0] + y := v.Args[0].Args[1] + if v.Args[1] != y { + goto end20e42db178ec4f423cc56a991863a4a2 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end20e42db178ec4f423cc56a991863a4a2 +end20e42db178ec4f423cc56a991863a4a2: ; return false } @@ -3473,6 +3613,52 @@ end5a84a285ff0ff48b8ad3c64b15e3459f: } goto end0387dc2b7bbe57d4aa54eab5d959da4b end0387dc2b7bbe57d4aa54eab5d959da4b: + ; + // match: (Sub64 (Add64 x y) x) + // cond: + // result: y + { + if v.Args[0].Op != OpAdd64 { + goto end7d177451cf8959cb781f52d5ded46fff + } + x := v.Args[0].Args[0] + y := v.Args[0].Args[1] + if v.Args[1] != x { + goto end7d177451cf8959cb781f52d5ded46fff + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = y.Type + v.AddArg(y) + return true + } + goto end7d177451cf8959cb781f52d5ded46fff +end7d177451cf8959cb781f52d5ded46fff: + ; + // match: (Sub64 (Add64 x y) y) + // cond: + // result: x + { + if v.Args[0].Op != OpAdd64 { + goto end6ea8172b21100cfe3dc86b7a850fbe97 + } + x := v.Args[0].Args[0] + y := v.Args[0].Args[1] + if v.Args[1] != y { + goto end6ea8172b21100cfe3dc86b7a850fbe97 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end6ea8172b21100cfe3dc86b7a850fbe97 +end6ea8172b21100cfe3dc86b7a850fbe97: ; return false } @@ -3518,6 +3704,52 @@ endc00ea11c7535529e211710574f5cff24: } goto end4e2ee15ef17611919a1a6b5f80bbfe18 end4e2ee15ef17611919a1a6b5f80bbfe18: + ; + // match: (Sub8 (Add8 x y) x) + // cond: + // result: y + { + if v.Args[0].Op != OpAdd8 { + goto endd79d561e14dc3d11da4c3bb20270b541 + } + x := v.Args[0].Args[0] + y := v.Args[0].Args[1] + if v.Args[1] != x { + goto endd79d561e14dc3d11da4c3bb20270b541 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = y.Type + v.AddArg(y) + return true + } + goto endd79d561e14dc3d11da4c3bb20270b541 +endd79d561e14dc3d11da4c3bb20270b541: + ; + // match: (Sub8 (Add8 x y) y) + // cond: + // result: x + { + if v.Args[0].Op != OpAdd8 { + goto endcb7111b11d6d068c97026a97ecff8248 + } + x := v.Args[0].Args[0] + y := v.Args[0].Args[1] + if v.Args[1] != y { + goto endcb7111b11d6d068c97026a97ecff8248 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto endcb7111b11d6d068c97026a97ecff8248 +endcb7111b11d6d068c97026a97ecff8248: ; return false } -- cgit v1.3 From 74e568f43a8dc5a2d52fe4b761ae256dadded8ce Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Mon, 9 Nov 2015 21:35:40 -0800 Subject: [dev.ssa] cmd/compile: Deduplicate panic{index,slice,divide} calls Panics are only distinguished by their type and line number, so if we can trigger two of those panics in the same line, use the same panic call. For example, in a[i]+b[j] we need only one panicindex call that both bounds checks can use. Change-Id: Ia2b6d3b1a67f2775df05fb72b8a1b149833572b7 Reviewed-on: https://go-review.googlesource.com/16772 Run-TryBot: Keith Randall Reviewed-by: David Chase --- src/cmd/compile/internal/gc/ssa.go | 26 ++++++++++++++++++++------ 1 file changed, 20 insertions(+), 6 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 90abd8e05d..0b674806fe 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -73,6 +73,7 @@ func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { 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 @@ -270,6 +271,15 @@ type state struct { // 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 +} + +type funcLine struct { + f *Node + line int32 } type ssaLabel struct { @@ -2517,14 +2527,18 @@ func (s *state) check(cmp *ssa.Value, fn *Node) { b.Control = cmp b.Likely = ssa.BranchLikely bNext := s.f.NewBlock(ssa.BlockPlain) - bPanic := 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(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) - s.startBlock(bNext) } -- cgit v1.3 From 7807bda91d4038241b857a8bd341e6b9baf3a264 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Tue, 10 Nov 2015 15:35:36 -0800 Subject: [dev.ssa] cmd/compile: be safer about uintptr/unsafe.Pointer conversions Make sure that when a pointer value is live across a function call, we save it as a pointer. (And similarly a uintptr live across a function call should not be saved as a pointer.) Add a nasty test case. This is probably what is preventing the merge from master to dev.ssa. Signs point to something like this bug happening in mallocgc. Change-Id: Ib23fa1251b8d1c50d82c6a448cb4a4fc28219029 Reviewed-on: https://go-review.googlesource.com/16830 Run-TryBot: Keith Randall TryBot-Result: Gobot Gobot Reviewed-by: David Chase --- src/cmd/compile/internal/gc/ssa.go | 4 +- src/cmd/compile/internal/gc/ssa_test.go | 2 + src/cmd/compile/internal/gc/testdata/unsafe_ssa.go | 129 +++++++++++++++++++++ src/cmd/compile/internal/ssa/gen/AMD64.rules | 2 +- src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 7 ++ src/cmd/compile/internal/ssa/gen/generic.rules | 3 +- src/cmd/compile/internal/ssa/gen/genericOps.go | 11 +- src/cmd/compile/internal/ssa/opGen.go | 13 +++ src/cmd/compile/internal/ssa/rewriteAMD64.go | 12 +- src/cmd/compile/internal/ssa/rewritegeneric.go | 37 +++++- 10 files changed, 203 insertions(+), 17 deletions(-) create mode 100644 src/cmd/compile/internal/gc/testdata/unsafe_ssa.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 0b674806fe..4cdfa5c265 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1375,7 +1375,7 @@ func (s *state) expr(n *Node) *ssa.Value { // as not-pointers or vice-versa because of copy // elision. if to.IsPtr() != from.IsPtr() { - return s.newValue1(ssa.OpConvert, to, x) + return s.newValue2(ssa.OpConvert, to, x, s.mem()) } v := s.newValue1(ssa.OpCopy, to, x) // ensure that v has the right type @@ -3886,7 +3886,7 @@ func (s *genState) genValue(v *ssa.Value) { p.To.Sym = Linksym(Pkglookup("duffcopy", Runtimepkg)) p.To.Offset = v.AuxInt - case ssa.OpCopy: // TODO: lower to MOVQ earlier? + case ssa.OpCopy, ssa.OpAMD64MOVQconvert: // TODO: lower Copy to MOVQ earlier? if v.Type.IsMemory() { return } diff --git a/src/cmd/compile/internal/gc/ssa_test.go b/src/cmd/compile/internal/gc/ssa_test.go index 5a881ed819..74fa847c92 100644 --- a/src/cmd/compile/internal/gc/ssa_test.go +++ b/src/cmd/compile/internal/gc/ssa_test.go @@ -93,3 +93,5 @@ 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") } 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 0000000000..bc292828d5 --- /dev/null +++ b/src/cmd/compile/internal/gc/testdata/unsafe_ssa.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 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 main() { + testf() + testg() +} diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 4364022f41..7d0aa4b2d3 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -281,7 +281,7 @@ (Store [1] ptr val mem) -> (MOVBstore ptr val mem) // We want this to stick out so the to/from ptr conversion is obvious -(Convert x) -> (LEAQ x) +(Convert x mem) -> (MOVQconvert x mem) // checks (IsNonNil p) -> (SETNE (TESTQ p p)) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index fa5072f7c5..ba53e81ddd 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -465,6 +465,13 @@ func init() { {name: "LoweredGetClosurePtr", reg: regInfo{outputs: []regMask{buildReg("DX")}}}, //arg0=ptr,arg1=mem, returns void. Faults if ptr is nil. {name: "LoweredNilCheck", 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", reg: gp11nf, asm: "MOVQ"}, } var AMD64blocks = []blockData{ diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index d3de24d956..5de877d31a 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -274,7 +274,8 @@ (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) off)) -> (Add64 ptr off) +(Convert (Add64 (Convert ptr mem) off) mem) -> (Add64 ptr off) +(Convert (Convert ptr mem) mem) -> ptr // Decompose compound argument values (Arg {n} [off]) && v.Type.IsString() -> diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index ead0cfd17a..e57dd932d8 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -236,9 +236,14 @@ var genericOps = []opData{ {name: "Sqrt"}, // sqrt(arg0), float64 only // Data movement - {name: "Phi"}, // select an argument based on which predecessor block we came from - {name: "Copy"}, // output = arg0 - {name: "Convert"}, // output = arg0 -- a copy that converts to/from a pointer + {name: "Phi"}, // select an argument based on which predecessor block we came from + {name: "Copy"}, // 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"}, // constants. Constant values are stored in the aux field. // booleans have a bool aux field, strings have a string aux diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index d043e076ea..132ca83f95 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -282,6 +282,7 @@ const ( OpAMD64LoweredGetG OpAMD64LoweredGetClosurePtr OpAMD64LoweredNilCheck + OpAMD64MOVQconvert OpAdd8 OpAdd16 @@ -3219,6 +3220,18 @@ var opcodeTable = [...]opInfo{ clobbers: 8589934592, // .FLAGS }, }, + { + name: "MOVQconvert", + 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: "Add8", diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index cfdd5a2851..3be94e37e7 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -2585,22 +2585,24 @@ endea557d921056c25b945a49649e4b9b91: func rewriteValueAMD64_OpConvert(v *Value, config *Config) bool { b := v.Block _ = b - // match: (Convert x) + // match: (Convert x mem) // cond: - // result: (LEAQ x) + // result: (MOVQconvert x mem) { t := v.Type x := v.Args[0] - v.Op = OpAMD64LEAQ + mem := v.Args[1] + v.Op = OpAMD64MOVQconvert v.AuxInt = 0 v.Aux = nil v.resetArgs() v.Type = t v.AddArg(x) + v.AddArg(mem) return true } - goto end1cac40a6074914d6ae3d4aa039a625ed -end1cac40a6074914d6ae3d4aa039a625ed: + goto end0aa5cd28888761ffab21bce45db361c8 +end0aa5cd28888761ffab21bce45db361c8: ; return false } diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index 174967a194..9563e878e8 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -926,18 +926,22 @@ end7ce9db29d17866f26d21e6e12f442e54: func rewriteValuegeneric_OpConvert(v *Value, config *Config) bool { b := v.Block _ = b - // match: (Convert (Add64 (Convert ptr) off)) + // match: (Convert (Add64 (Convert ptr mem) off) mem) // cond: // result: (Add64 ptr off) { if v.Args[0].Op != OpAdd64 { - goto end913a7ecf456c00ffbee36c2dbbf0e1af + goto endbbc9f1666b4d39a130e1b86f109e7c1b } if v.Args[0].Args[0].Op != OpConvert { - goto end913a7ecf456c00ffbee36c2dbbf0e1af + goto endbbc9f1666b4d39a130e1b86f109e7c1b } 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 { + goto endbbc9f1666b4d39a130e1b86f109e7c1b + } v.Op = OpAdd64 v.AuxInt = 0 v.Aux = nil @@ -946,8 +950,31 @@ func rewriteValuegeneric_OpConvert(v *Value, config *Config) bool { v.AddArg(off) return true } - goto end913a7ecf456c00ffbee36c2dbbf0e1af -end913a7ecf456c00ffbee36c2dbbf0e1af: + goto endbbc9f1666b4d39a130e1b86f109e7c1b +endbbc9f1666b4d39a130e1b86f109e7c1b: + ; + // match: (Convert (Convert ptr mem) mem) + // cond: + // result: ptr + { + if v.Args[0].Op != OpConvert { + goto end98c5e0ca257eb216989171786f91b42d + } + ptr := v.Args[0].Args[0] + mem := v.Args[0].Args[1] + if v.Args[1] != mem { + goto end98c5e0ca257eb216989171786f91b42d + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = ptr.Type + v.AddArg(ptr) + return true + } + goto end98c5e0ca257eb216989171786f91b42d +end98c5e0ca257eb216989171786f91b42d: ; return false } -- cgit v1.3 From 75102afce77f1376b0aab3f1d5fee9b881d0f68a Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Thu, 5 Nov 2015 14:59:47 -0800 Subject: [dev.ssa] cmd/compile: better register allocation Use a more precise computation of next use. It properly detects lifetime holes and deallocates values during those holes. It also uses a more precise version of distance to next use which affects which values get spilled. Change-Id: I49eb3ebe2d2cb64842ecdaa7fb4f3792f8afb90b Reviewed-on: https://go-review.googlesource.com/16760 Run-TryBot: Keith Randall Reviewed-by: David Chase --- src/cmd/compile/internal/ssa/regalloc.go | 421 +++++++++++++++++------------- src/cmd/compile/internal/ssa/sparsemap.go | 69 +++++ 2 files changed, 313 insertions(+), 177 deletions(-) create mode 100644 src/cmd/compile/internal/ssa/sparsemap.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index a751d66988..535885a9a7 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -202,41 +202,43 @@ func pickReg(r regMask) register { } } -// A use is a record of a position (2*pc for value uses, odd numbers for other uses) -// and a value ID that is used at that position. type use struct { - idx int32 - vid ID + 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 []int32 // sorted list of places where Value is used - usestorage [2]int32 - spill *Value // spilled copy of the Value - spill2 *Value // special alternate spill location used for phi resolution + uses *use // list of uses in this block + spill *Value // spilled copy of the Value + spill2 *Value // special alternate spill location used for phi resolution spillUsed bool spill2used bool } type regState struct { v *Value // Original (preregalloc) Value stored in this register. - c *Value // A Value equal to v which is currently in register. Might be v or a copy of it. + 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 value, whether it needs a register or not. + // Cached value of !v.Type.IsMemory() && !v.Type.IsVoid(). + needReg []bool + // 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 on each edge. live[b.ID][idx] is a list of value IDs - // which are live on b's idx'th successor edge. - live [][][]ID + // 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 @@ -254,14 +256,14 @@ type regAllocState struct { // mask of registers currently in use used regMask - // An ordered list (by idx) of all uses in the function - uses []use - // Home locations (registers) for Values home []Location // current block we're working on curBlock *Block + + // cache of use records + freeUseRecords *use } // freeReg frees up register r. Any current user of r is kicked out. @@ -350,18 +352,25 @@ func (s *regAllocState) allocReg(mask regMask) register { // 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 maxuse := int32(-1) for t := register(0); t < numRegs; t++ { if mask>>t&1 == 0 { continue } v := s.regs[t].v - if len(s.values[v.ID].uses) == 0 { + + if s.values[v.ID].uses == nil { + // No subsequent use. // This can happen when fixing up merge blocks at the end. // We've already run through the use lists so they are empty. // Any register would be ok at this point. @@ -369,7 +378,9 @@ func (s *regAllocState) allocReg(mask regMask) register { maxuse = 0 break } - if n := s.values[v.ID].uses[0]; n > maxuse { + 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 } @@ -402,7 +413,12 @@ func (s *regAllocState) allocValToReg(v *Value, mask regMask, nospill bool) *Val return s.regs[r].c } - mask &^= 1<<4 | 1<<32 // don't spill SP or SB + 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. @@ -484,18 +500,20 @@ func (s *regAllocState) init(f *Func) { } s.f = f + s.needReg = make([]bool, f.NumValues()) s.regs = make([]regState, numRegs) s.values = make([]valState, f.NumValues()) - for i := range s.values { - s.values[i].uses = s.values[i].usestorage[:0] - } s.orig = make([]*Value, f.NumValues()) for _, b := range f.Blocks { for _, v := range b.Values { + if v.Type.IsMemory() || v.Type.IsVoid() { + continue + } + s.needReg[v.ID] = true s.orig[v.ID] = v } } - s.live = f.live() + s.computeLive() // Compute block order. This array allows us to distinguish forward edges // from backward edges and compute how far they go. @@ -518,63 +536,41 @@ func (s *regAllocState) init(f *Func) { } s.primary[b.ID] = int32(best) } +} - // Compute uses. We assign a PC to each Value in the program, in f.Blocks - // and then b.Values order. Uses are recorded using this numbering. - // Uses by Values are recorded as 2*PC. Special uses (block control values, - // pseudo-uses for backedges) are recorded as 2*(last PC in block)+1. - var pc int32 - for _, b := range f.Blocks { - // uses in regular Values - for _, v := range b.Values { - for _, a := range v.Args { - s.values[a.ID].uses = append(s.values[a.ID].uses, pc*2) - s.uses = append(s.uses, use{pc * 2, a.ID}) - } - pc++ - } - // use as a block control value - endIdx := pc*2 - 1 - if b.Control != nil { - s.values[b.Control.ID].uses = append(s.values[b.Control.ID].uses, endIdx) - s.uses = append(s.uses, use{endIdx, b.Control.ID}) - } - // uses by backedges - // Backedges are treated as uses so that the uses span the entire live - // range of the value. - for i, c := range b.Succs { - if blockOrder[c.ID] > blockOrder[b.ID] { - continue // forward edge - } - for _, vid := range s.live[b.ID][i] { - s.values[vid].uses = append(s.values[vid].uses, endIdx) - s.uses = append(s.uses, use{endIdx, vid}) - } - } +// 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{} } - if pc*2 < 0 { - f.Fatalf("pc too large: function too big") + 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") } } -// clearUses drops any uses <= useIdx. Any values which have no future -// uses are dropped from registers. -func (s *regAllocState) clearUses(useIdx int32) { - for len(s.uses) > 0 && s.uses[0].idx <= useIdx { - idx := s.uses[0].idx - vid := s.uses[0].vid - s.uses = s.uses[1:] - - vi := &s.values[vid] - if vi.uses[0] != idx { - s.f.Fatalf("use mismatch for v%d\n", vid) - } - vi.uses = vi.uses[1:] - if len(vi.uses) != 0 { +// 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.needReg[a.ID] { continue } - // Value is dead, free all registers that hold it (except SP & SB). - s.freeRegs(vi.regs &^ (1<<4 | 1<<32)) + 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 } } @@ -601,28 +597,69 @@ func (s *regAllocState) compatRegs(v *Value) regMask { } func (s *regAllocState) regalloc(f *Func) { - liveset := newSparseSet(f.NumValues()) + liveSet := newSparseSet(f.NumValues()) argset := newSparseSet(f.NumValues()) var oldSched []*Value var phis []*Value var stackPhis []*Value var regPhis []*Value + var phiRegs []register + var args []*Value if f.Entry != f.Blocks[0] { f.Fatalf("entry block must be first") } - var phiRegs []register - // For each merge block, we record the starting register state (after phi ops) // for that merge block. Indexed by blockid/regnum. startRegs := make([][]*Value, f.NumBlocks()) // end state of registers for each block, idexed by blockid/regnum. endRegs := make([][]regState, f.NumBlocks()) - var pc int32 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 c := b.Control; c != nil && s.needReg[c.ID] { + s.addUse(c.ID, int32(len(b.Values))) // psuedo-use by control value + liveSet.add(c.ID) + } + for i := len(b.Values) - 1; i >= 0; i-- { + v := b.Values[i] + if v.Op == OpPhi { + break // Don't process phi ops. + } + liveSet.remove(v.ID) + for _, a := range v.Args { + if !s.needReg[a.ID] { + 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 @@ -648,6 +685,15 @@ func (s *regAllocState) regalloc(f *Func) { 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. @@ -663,25 +709,6 @@ func (s *regAllocState) regalloc(f *Func) { p := b.Preds[idx] s.setState(endRegs[p.ID]) - // Drop anything not live on the c->b edge. - var idx2 int - for idx2 = 0; idx2 < len(p.Succs); idx2++ { - if p.Succs[idx2] == b { - break - } - } - liveset.clear() - liveset.addAll(s.live[p.ID][idx2]) - for r := register(0); r < numRegs; r++ { - v := s.regs[r].v - if v == nil { - continue - } - if !liveset.contains(v.ID) { - s.freeReg(r) - } - } - // Decide on registers for phi ops. Use the registers determined // by the primary predecessor if we can. // TODO: pick best of (already processed) predecessors? @@ -742,21 +769,20 @@ func (s *regAllocState) regalloc(f *Func) { } // Process all the non-phi values. - pc += int32(nphi) - for _, v := range oldSched { + for idx, v := range oldSched { 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) - pc++ + s.advanceUses(v) continue } if v.Op == OpSB { s.assignReg(32, v, v) // TODO: arch-dependent b.Values = append(b.Values, v) - pc++ + s.advanceUses(v) continue } if v.Op == OpArg { @@ -766,19 +792,17 @@ func (s *regAllocState) regalloc(f *Func) { s.values[v.ID].spill = v s.values[v.ID].spillUsed = true // use is guaranteed b.Values = append(b.Values, v) - pc++ + s.advanceUses(v) continue } - s.clearUses(pc*2 - 1) regspec := opcodeTable[v.Op].reg if regDebug { - fmt.Printf("%d: working on %s %s %v\n", pc, v, v.LongString(), regspec) + fmt.Printf("%d: working on %s %s %v\n", idx, v, v.LongString(), regspec) } 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) - pc++ continue } @@ -786,22 +810,23 @@ func (s *regAllocState) regalloc(f *Func) { // Value is rematerializeable, don't issue it here. // It will get issued just before each use (see // allocValueToReg). - pc++ + s.advanceUses(v) continue } - // Move arguments to registers + // 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 { - a := v.Args[i.idx] - v.Args[i.idx] = s.allocValToReg(a, i.regs, true) + args[i.idx] = s.allocValToReg(v.Args[i.idx], i.regs, true) } // Now that all args are in regs, we're ready to issue the value itself. - // Before we pick a register for the value, allow input registers + // 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.clearUses(pc * 2) + s.advanceUses(v) // frees any registers holding args that are no longer live // Dump any registers which will be clobbered s.freeRegs(regspec.clobbers) @@ -818,34 +843,60 @@ func (s *regAllocState) regalloc(f *Func) { } // 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 !v.Type.IsFlags() { 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 } - - // Increment pc for next Value. - pc++ } - // Load control value into reg - if b.Control != nil && !b.Control.Type.IsMemory() && !b.Control.Type.IsVoid() { + if c := b.Control; c != nil && s.needReg[c.ID] { + // Load control value into reg. // TODO: regspec for block control values, instead of using // register set from the control op's output. - s.allocValToReg(b.Control, opcodeTable[b.Control.Op].reg.outputs[0], false) + s.allocValToReg(c, opcodeTable[c.Op].reg.outputs[0], false) + // Remove this use from the uses list. + u := s.values[c.ID].uses + s.values[c.ID].uses = u.next + u.next = s.freeUseRecords + s.freeUseRecords = u } // Record endRegs endRegs[b.ID] = make([]regState, numRegs) copy(endRegs[b.ID], s.regs) - // Allow control Values and Values live only on backedges to be dropped. - s.clearUses(pc*2 - 1) + // 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 + } } // Process merge block input edges. They are the tricky ones. @@ -1034,20 +1085,24 @@ func (v *Value) rematerializeable() bool { return false } -// live returns a map from block ID and successor edge index to a list -// of value IDs live on that edge. +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 (f *Func) live() [][][]ID { - live := make([][][]ID, f.NumBlocks()) - for _, b := range f.Blocks { - live[b.ID] = make([][]ID, len(b.Succs)) - } +func (s *regAllocState) computeLive() { + f := s.f + s.live = make([][]liveInfo, f.NumBlocks()) var phis []*Value - s := newSparseSet(f.NumValues()) - t := newSparseSet(f.NumValues()) + 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 @@ -1061,20 +1116,22 @@ func (f *Func) live() [][][]ID { po := postorder(f) for { for _, b := range po { - f.Logf("live %s %v\n", b, live[b.ID]) + f.Logf("live %s %v\n", b, s.live[b.ID]) } changed := false for _, b := range po { - // Start with known live values at the end of the block - s.clear() - for i := 0; i < len(b.Succs); i++ { - s.addAll(live[b.ID][i]) + // 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.add(b.Control.ID) + if b.Control != nil && s.needReg[b.Control.ID] { + live.set(b.Control.ID, int32(len(b.Values))) } // Propagate backwards to the start of the block @@ -1082,36 +1139,75 @@ func (f *Func) live() [][][]ID { phis := phis[:0] for i := len(b.Values) - 1; i >= 0; i-- { v := b.Values[i] - s.remove(v.ID) + live.remove(v.ID) if v.Op == OpPhi { // save phi ops for later phis = append(phis, v) continue } - s.addAllValues(v.Args) + for _, a := range v.Args { + if s.needReg[a.ID] { + live.set(a.ID, int32(i)) + } + } } - // 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 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 { - // Find index of b in p's successors. - var j int - for j = 0; j < len(p.Succs); j++ { - if p.Succs[j] == b { - break + // 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() - t.addAll(live[p.ID][j]) - t.addAll(s.contents()) + 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 { - t.add(v.Args[i].ID) + id := v.Args[i].ID + if s.needReg[id] && !t.contains(id) || delta < t.get(id) { + update = true + t.set(id, delta) + } } - if t.size() == len(live[p.ID][j]) { + + if !update { continue } - // grow p's live set - live[p.ID][j] = append(live[p.ID][j][:0], t.contents()...) + // The live set has changed, update it. + l := s.live[p.ID][:0] + for _, e := range t.contents() { + l = append(l, liveInfo{e.key, e.val}) + } + s.live[p.ID] = l changed = true } } @@ -1120,35 +1216,6 @@ func (f *Func) live() [][][]ID { break } } - - // Make sure that there is only one live memory variable in each set. - // Ideally we should check this at every instructiom, but at every - // edge seems good enough for now. - isMem := make([]bool, f.NumValues()) - for _, b := range f.Blocks { - for _, v := range b.Values { - isMem[v.ID] = v.Type.IsMemory() - } - } - for _, b := range f.Blocks { - for i, c := range b.Succs { - nmem := 0 - for _, id := range live[b.ID][i] { - if isMem[id] { - nmem++ - } - } - if nmem > 1 { - f.Fatalf("more than one mem live on edge %v->%v: %v", b, c, live[b.ID][i]) - } - // TODO: figure out why we get nmem==0 occasionally. - //if nmem == 0 { - // f.Fatalf("no mem live on edge %v->%v: %v", b, c, live[b.ID][i]) - //} - } - } - - return live } // reserved returns a mask of reserved registers. diff --git a/src/cmd/compile/internal/ssa/sparsemap.go b/src/cmd/compile/internal/ssa/sparsemap.go new file mode 100644 index 0000000000..6c0043b230 --- /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 +} -- cgit v1.3 From 09ffa0c4c772ff119d42820a8d90aba8b481397c Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Sun, 6 Dec 2015 21:25:24 -0600 Subject: [dev.ssa] test: use new go:noinline feature Replace old mechanisms for preventing inlining with go:noinline. Change-Id: I021a6450e6d644ec1042594730a9c64d695949a1 Reviewed-on: https://go-review.googlesource.com/17500 Reviewed-by: Brad Fitzpatrick --- src/cmd/compile/internal/gc/testdata/append_ssa.go | 7 +- .../internal/gc/testdata/arithBoundary_ssa.go | 159 ++++++++++----------- src/cmd/compile/internal/gc/testdata/arith_ssa.go | 48 +++---- src/cmd/compile/internal/gc/testdata/array_ssa.go | 15 +- src/cmd/compile/internal/gc/testdata/chan_ssa.go | 9 +- .../compile/internal/gc/testdata/closure_ssa.go | 3 +- src/cmd/compile/internal/gc/testdata/fp_ssa.go | 57 +++----- .../internal/gc/testdata/gen/arithBoundaryGen.go | 4 +- src/cmd/compile/internal/gc/testdata/map_ssa.go | 4 +- src/cmd/compile/internal/gc/testdata/short_ssa.go | 2 +- src/cmd/compile/internal/gc/testdata/string_ssa.go | 18 +-- 11 files changed, 138 insertions(+), 188 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/testdata/append_ssa.go b/src/cmd/compile/internal/gc/testdata/append_ssa.go index dba81736c8..03cd219c32 100644 --- a/src/cmd/compile/internal/gc/testdata/append_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/append_ssa.go @@ -9,14 +9,13 @@ import "fmt" var failed = false +//go:noinline func appendOne_ssa(a []int, x int) []int { - switch { // prevent inlining - } return append(a, x) } + +//go:noinline func appendThree_ssa(a []int, x, y, z int) []int { - switch { // prevent inlining - } return append(a, x, y, z) } diff --git a/src/cmd/compile/internal/gc/testdata/arithBoundary_ssa.go b/src/cmd/compile/internal/gc/testdata/arithBoundary_ssa.go index 9f1b9a4a60..929e4e1f0b 100644 --- a/src/cmd/compile/internal/gc/testdata/arithBoundary_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/arithBoundary_ssa.go @@ -35,204 +35,203 @@ type itd8 struct { add, sub, mul, div, mod int8 } +//go:noinline func add_uint64_ssa(a, b uint64) uint64 { - switch { - } // prevent inlining return a + b } + +//go:noinline func sub_uint64_ssa(a, b uint64) uint64 { - switch { - } // prevent inlining return a - b } + +//go:noinline func div_uint64_ssa(a, b uint64) uint64 { - switch { - } // prevent inlining return a / b } + +//go:noinline func mod_uint64_ssa(a, b uint64) uint64 { - switch { - } // prevent inlining return a % b } + +//go:noinline func mul_uint64_ssa(a, b uint64) uint64 { - switch { - } // prevent inlining return a * b } + +//go:noinline func add_int64_ssa(a, b int64) int64 { - switch { - } // prevent inlining return a + b } + +//go:noinline func sub_int64_ssa(a, b int64) int64 { - switch { - } // prevent inlining return a - b } + +//go:noinline func div_int64_ssa(a, b int64) int64 { - switch { - } // prevent inlining return a / b } + +//go:noinline func mod_int64_ssa(a, b int64) int64 { - switch { - } // prevent inlining return a % b } + +//go:noinline func mul_int64_ssa(a, b int64) int64 { - switch { - } // prevent inlining return a * b } + +//go:noinline func add_uint32_ssa(a, b uint32) uint32 { - switch { - } // prevent inlining return a + b } + +//go:noinline func sub_uint32_ssa(a, b uint32) uint32 { - switch { - } // prevent inlining return a - b } + +//go:noinline func div_uint32_ssa(a, b uint32) uint32 { - switch { - } // prevent inlining return a / b } + +//go:noinline func mod_uint32_ssa(a, b uint32) uint32 { - switch { - } // prevent inlining return a % b } + +//go:noinline func mul_uint32_ssa(a, b uint32) uint32 { - switch { - } // prevent inlining return a * b } + +//go:noinline func add_int32_ssa(a, b int32) int32 { - switch { - } // prevent inlining return a + b } + +//go:noinline func sub_int32_ssa(a, b int32) int32 { - switch { - } // prevent inlining return a - b } + +//go:noinline func div_int32_ssa(a, b int32) int32 { - switch { - } // prevent inlining return a / b } + +//go:noinline func mod_int32_ssa(a, b int32) int32 { - switch { - } // prevent inlining return a % b } + +//go:noinline func mul_int32_ssa(a, b int32) int32 { - switch { - } // prevent inlining return a * b } + +//go:noinline func add_uint16_ssa(a, b uint16) uint16 { - switch { - } // prevent inlining return a + b } + +//go:noinline func sub_uint16_ssa(a, b uint16) uint16 { - switch { - } // prevent inlining return a - b } + +//go:noinline func div_uint16_ssa(a, b uint16) uint16 { - switch { - } // prevent inlining return a / b } + +//go:noinline func mod_uint16_ssa(a, b uint16) uint16 { - switch { - } // prevent inlining return a % b } + +//go:noinline func mul_uint16_ssa(a, b uint16) uint16 { - switch { - } // prevent inlining return a * b } + +//go:noinline func add_int16_ssa(a, b int16) int16 { - switch { - } // prevent inlining return a + b } + +//go:noinline func sub_int16_ssa(a, b int16) int16 { - switch { - } // prevent inlining return a - b } + +//go:noinline func div_int16_ssa(a, b int16) int16 { - switch { - } // prevent inlining return a / b } + +//go:noinline func mod_int16_ssa(a, b int16) int16 { - switch { - } // prevent inlining return a % b } + +//go:noinline func mul_int16_ssa(a, b int16) int16 { - switch { - } // prevent inlining return a * b } + +//go:noinline func add_uint8_ssa(a, b uint8) uint8 { - switch { - } // prevent inlining return a + b } + +//go:noinline func sub_uint8_ssa(a, b uint8) uint8 { - switch { - } // prevent inlining return a - b } + +//go:noinline func div_uint8_ssa(a, b uint8) uint8 { - switch { - } // prevent inlining return a / b } + +//go:noinline func mod_uint8_ssa(a, b uint8) uint8 { - switch { - } // prevent inlining return a % b } + +//go:noinline func mul_uint8_ssa(a, b uint8) uint8 { - switch { - } // prevent inlining return a * b } + +//go:noinline func add_int8_ssa(a, b int8) int8 { - switch { - } // prevent inlining return a + b } + +//go:noinline func sub_int8_ssa(a, b int8) int8 { - switch { - } // prevent inlining return a - b } + +//go:noinline func div_int8_ssa(a, b int8) int8 { - switch { - } // prevent inlining return a / b } + +//go:noinline func mod_int8_ssa(a, b int8) int8 { - switch { - } // prevent inlining return a % b } + +//go:noinline func mul_int8_ssa(a, b int8) int8 { - switch { - } // prevent inlining return a * b } diff --git a/src/cmd/compile/internal/gc/testdata/arith_ssa.go b/src/cmd/compile/internal/gc/testdata/arith_ssa.go index f6f123c0be..af31245505 100644 --- a/src/cmd/compile/internal/gc/testdata/arith_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/arith_ssa.go @@ -17,9 +17,9 @@ func test64BitConstMult() { failed = true } } + +//go:noinline func test64BitConstMult_ssa(a, b int64) int64 { - switch { // prevent inlining - } return 34359738369*a + b*34359738370 } @@ -32,9 +32,9 @@ func test64BitConstAdd() { failed = true } } + +//go:noinline func test64BitConstAdd_ssa(a, b int64) int64 { - switch { // prevent inlining - } return a + 575815584948629622 + b + 2991856197886747025 } @@ -47,9 +47,9 @@ func testRegallocCVSpill() { failed = true } } + +//go:noinline func testRegallocCVSpill_ssa(a, b, c, d int8) int8 { - switch { // prevent inlining - } return a + -32 + b + 63*c*-87*d } @@ -105,45 +105,38 @@ func testBitwiseLogic() { } } +//go:noinline func testBitwiseAnd_ssa(a, b uint32) uint32 { - switch { // prevent inlining - } return a & b } +//go:noinline func testBitwiseOr_ssa(a, b uint32) uint32 { - switch { // prevent inlining - } return a | b } +//go:noinline func testBitwiseXor_ssa(a, b uint32) uint32 { - switch { // prevent inlining - } return a ^ b } +//go:noinline func testBitwiseLsh_ssa(a int32, b, c uint32) int32 { - switch { // prevent inlining - } return a << b << c } +//go:noinline func testBitwiseRsh_ssa(a int32, b, c uint32) int32 { - switch { // prevent inlining - } return a >> b >> c } +//go:noinline func testBitwiseRshU_ssa(a uint32, b, c uint32) uint32 { - switch { // prevent inlining - } return a >> b >> c } +//go:noinline func testShiftCX_ssa() int { - switch { - } // prevent inlining 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 @@ -172,9 +165,8 @@ func testSubqToNegq() { } } +//go:noinline func testSubqToNegq_ssa(a, b, c, d, e, f, g, h, i, j, k int64) int64 { - switch { // prevent inlining - } return a + 8207351403619448057 - b - 1779494519303207690 + c*8810076340510052032*d - 4465874067674546219 - e*4361839741470334295 - f + 8688847565426072650*g*8065564729145417479 } @@ -187,9 +179,8 @@ func testOcom() { } } +//go:noinline func testOcom_ssa(a, b int32) (int32, int32) { - switch { // prevent inlining - } return ^^^^a, ^^^^^b } @@ -201,21 +192,19 @@ func lrot1_ssa(w uint8, x uint16, y uint32, z uint64) (a uint8, b uint16, c uint 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. - switch { // prevents inlining - } 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. - switch { // prevents inlining - } return (w << 32) | (w >> (32 - 32)) } @@ -244,9 +233,8 @@ func testLrot() { } +//go:noinline func sub1_ssa() uint64 { - switch { - } // prevent inlining v1 := uint64(3) // uint64 return v1*v1 - (v1&v1)&v1 } diff --git a/src/cmd/compile/internal/gc/testdata/array_ssa.go b/src/cmd/compile/internal/gc/testdata/array_ssa.go index d7004ff26a..0334339d43 100644 --- a/src/cmd/compile/internal/gc/testdata/array_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/array_ssa.go @@ -2,23 +2,20 @@ package main var failed = false +//go:noinline func testSliceLenCap12_ssa(a [10]int, i, j int) (int, int) { - switch { // prevent inlining - } b := a[i:j] return len(b), cap(b) } +//go:noinline func testSliceLenCap1_ssa(a [10]int, i, j int) (int, int) { - switch { // prevent inlining - } b := a[i:] return len(b), cap(b) } +//go:noinline func testSliceLenCap2_ssa(a [10]int, i, j int) (int, int) { - switch { // prevent inlining - } b := a[:j] return len(b), cap(b) } @@ -55,9 +52,8 @@ func testSliceLenCap() { } } +//go:noinline func testSliceGetElement_ssa(a [10]int, i, j, p int) int { - switch { // prevent inlining - } return a[i:j][p] } @@ -81,9 +77,8 @@ func testSliceGetElement() { } } +//go:noinline func testSliceSetElement_ssa(a *[10]int, i, j, p, x int) { - switch { // prevent inlining - } (*a)[i:j][p] = x } diff --git a/src/cmd/compile/internal/gc/testdata/chan_ssa.go b/src/cmd/compile/internal/gc/testdata/chan_ssa.go index c527ba95be..0766fcda5b 100644 --- a/src/cmd/compile/internal/gc/testdata/chan_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/chan_ssa.go @@ -9,16 +9,13 @@ import "fmt" var failed = false +//go:noinline func lenChan_ssa(v chan int) int { - switch { // prevent inlining - - } return len(v) } -func capChan_ssa(v chan int) int { - switch { // prevent inlining - } +//go:noinline +func capChan_ssa(v chan int) int { return cap(v) } diff --git a/src/cmd/compile/internal/gc/testdata/closure_ssa.go b/src/cmd/compile/internal/gc/testdata/closure_ssa.go index ac1e51a23e..70181bc24b 100644 --- a/src/cmd/compile/internal/gc/testdata/closure_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/closure_ssa.go @@ -9,9 +9,8 @@ import "fmt" var failed = false +//go:noinline func testCFunc_ssa() int { - switch { // prevent inlining - } a := 0 b := func() { switch { diff --git a/src/cmd/compile/internal/gc/testdata/fp_ssa.go b/src/cmd/compile/internal/gc/testdata/fp_ssa.go index e7480a1138..cfbdcda251 100644 --- a/src/cmd/compile/internal/gc/testdata/fp_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/fp_ssa.go @@ -1466,118 +1466,99 @@ func expectCx64(s string, x, expected complex64) int { return 0 } +//go:noinline func cx128sum_ssa(a, b complex128) complex128 { - switch { // prevent inlining - } return a + b } +//go:noinline func cx128diff_ssa(a, b complex128) complex128 { - switch { // prevent inlining - } return a - b } +//go:noinline func cx128prod_ssa(a, b complex128) complex128 { - switch { // prevent inlining - } return a * b } +//go:noinline func cx128quot_ssa(a, b complex128) complex128 { - switch { // prevent inlining - } return a / b } +//go:noinline func cx128neg_ssa(a complex128) complex128 { - switch { // prevent inlining - } return -a } +//go:noinline func cx128real_ssa(a complex128) float64 { - switch { // prevent inlining - } return real(a) } +//go:noinline func cx128imag_ssa(a complex128) float64 { - switch { // prevent inlining - } return imag(a) } +//go:noinline func cx128cnst_ssa(a complex128) complex128 { - switch { // prevent inlining - } b := 2 + 3i return a * b } +//go:noinline func cx64sum_ssa(a, b complex64) complex64 { - switch { // prevent inlining - } return a + b } +//go:noinline func cx64diff_ssa(a, b complex64) complex64 { - switch { // prevent inlining - } return a - b } +//go:noinline func cx64prod_ssa(a, b complex64) complex64 { - switch { // prevent inlining - } return a * b } +//go:noinline func cx64quot_ssa(a, b complex64) complex64 { - switch { // prevent inlining - } return a / b } +//go:noinline func cx64neg_ssa(a complex64) complex64 { - switch { // prevent inlining - } return -a } +//go:noinline func cx64real_ssa(a complex64) float32 { - switch { // prevent inlining - } return real(a) } +//go:noinline func cx64imag_ssa(a complex64) float32 { - switch { // prevent inlining - } return imag(a) } +//go:noinline func cx128eq_ssa(a, b complex128) bool { - switch { // prevent inlining - } return a == b } +//go:noinline func cx128ne_ssa(a, b complex128) bool { - switch { // prevent inlining - } return a != b } +//go:noinline func cx64eq_ssa(a, b complex64) bool { - switch { // prevent inlining - } return a == b } +//go:noinline func cx64ne_ssa(a, b complex64) bool { - switch { // prevent inlining - } return a != b } diff --git a/src/cmd/compile/internal/gc/testdata/gen/arithBoundaryGen.go b/src/cmd/compile/internal/gc/testdata/gen/arithBoundaryGen.go index 19bb04b6f1..7c7d721a23 100644 --- a/src/cmd/compile/internal/gc/testdata/gen/arithBoundaryGen.go +++ b/src/cmd/compile/internal/gc/testdata/gen/arithBoundaryGen.go @@ -109,8 +109,8 @@ func main() { // the function being tested testFunc, err := template.New("testFunc").Parse( - `func {{.Name}}_{{.Stype}}_ssa(a, b {{.Stype}}) {{.Stype}} { - switch{} // prevent inlining + `//go:noinline + func {{.Name}}_{{.Stype}}_ssa(a, b {{.Stype}}) {{.Stype}} { return a {{.SymFirst}} b } `) diff --git a/src/cmd/compile/internal/gc/testdata/map_ssa.go b/src/cmd/compile/internal/gc/testdata/map_ssa.go index 41c949a9f2..4a466003c7 100644 --- a/src/cmd/compile/internal/gc/testdata/map_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/map_ssa.go @@ -9,10 +9,8 @@ import "fmt" var failed = false +//go:noinline func lenMap_ssa(v map[int]int) int { - switch { // prevent inlining - - } return len(v) } diff --git a/src/cmd/compile/internal/gc/testdata/short_ssa.go b/src/cmd/compile/internal/gc/testdata/short_ssa.go index 1aa7d3e677..fcec1baf09 100644 --- a/src/cmd/compile/internal/gc/testdata/short_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/short_ssa.go @@ -18,10 +18,10 @@ func or_ssa(arg1, arg2 bool) bool { var rightCalled bool +//go:noinline func rightCall(v bool) bool { rightCalled = true return v - select {} // hack to prevent inlining panic("unreached") } diff --git a/src/cmd/compile/internal/gc/testdata/string_ssa.go b/src/cmd/compile/internal/gc/testdata/string_ssa.go index 0ff6ce1a12..a949fbcefb 100644 --- a/src/cmd/compile/internal/gc/testdata/string_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/string_ssa.go @@ -7,21 +7,18 @@ package main var failed = false +//go:noinline func testStringSlice1_ssa(a string, i, j int) string { - switch { // prevent inlining - } return a[i:] } +//go:noinline func testStringSlice2_ssa(a string, i, j int) string { - switch { // prevent inlining - } return a[:j] } +//go:noinline func testStringSlice12_ssa(a string, i, j int) string { - switch { // prevent inlining - } return a[i:j] } @@ -91,9 +88,8 @@ const _Accuracy_name = "BelowExactAbove" var _Accuracy_index = [...]uint8{0, 5, 10, 15} +//go:noinline func testSmallIndexType_ssa(i int) string { - switch { // prevent inlining - } return _Accuracy_name[_Accuracy_index[i]:_Accuracy_index[i+1]] } @@ -115,9 +111,8 @@ func testSmallIndexType() { } } +//go:noinline func testStringElem_ssa(s string, i int) byte { - switch { // prevent inlining - } return s[i] } @@ -139,9 +134,8 @@ func testStringElem() { } } +//go:noinline func testStringElemConst_ssa(i int) byte { - switch { // prevent inlining - } s := "foobar" return s[i] } -- cgit v1.3 From c140df03267ab2e73ffd076002811aaa00fdc80e Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Wed, 9 Dec 2015 15:58:18 -0800 Subject: [dev.ssa] cmd/compile: allocate the flag register in a separate pass Spilling/restoring flag values is a pain to do during regalloc. Instead, allocate the flag register in a separate pass. Regalloc then operates normally on any flag recomputation instructions. Change-Id: Ia1c3d9e6eff678861193093c0b48a00f90e4156b Reviewed-on: https://go-review.googlesource.com/17694 Reviewed-by: David Chase --- src/cmd/compile/internal/ssa/compile.go | 11 ++- src/cmd/compile/internal/ssa/flagalloc.go | 123 ++++++++++++++++++++++++++ src/cmd/compile/internal/ssa/func_test.go | 5 ++ src/cmd/compile/internal/ssa/regalloc.go | 55 +++--------- src/cmd/compile/internal/ssa/regalloc_test.go | 9 +- src/cmd/compile/internal/ssa/value.go | 9 ++ 6 files changed, 162 insertions(+), 50 deletions(-) create mode 100644 src/cmd/compile/internal/ssa/flagalloc.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/compile.go b/src/cmd/compile/internal/ssa/compile.go index 01238f24ca..767b774ab0 100644 --- a/src/cmd/compile/internal/ssa/compile.go +++ b/src/cmd/compile/internal/ssa/compile.go @@ -97,9 +97,10 @@ var passes = [...]pass{ {"lowered cse", cse}, {"lowered deadcode", deadcode}, {"checkLower", checkLower}, - {"critical", critical}, // remove critical edges - {"layout", layout}, // schedule blocks - {"schedule", schedule}, // schedule values + {"critical", critical}, // remove critical edges + {"layout", layout}, // schedule blocks + {"schedule", schedule}, // schedule values + {"flagalloc", flagalloc}, // allocate flags register {"regalloc", regalloc}, {"stackalloc", stackalloc}, } @@ -142,6 +143,10 @@ var passOrder = [...]constraint{ // 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"}, } func init() { diff --git a/src/cmd/compile/internal/ssa/flagalloc.go b/src/cmd/compile/internal/ssa/flagalloc.go new file mode 100644 index 0000000000..c088158057 --- /dev/null +++ b/src/cmd/compile/internal/ssa/flagalloc.go @@ -0,0 +1,123 @@ +// 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 + } + } + } + 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. + 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 = c + } + // 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 = c + } + 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.) + } + } +} diff --git a/src/cmd/compile/internal/ssa/func_test.go b/src/cmd/compile/internal/ssa/func_test.go index d35690a30c..1dc134d8a8 100644 --- a/src/cmd/compile/internal/ssa/func_test.go +++ b/src/cmd/compile/internal/ssa/func_test.go @@ -232,6 +232,11 @@ 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. diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index 535885a9a7..2690b6188e 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -38,12 +38,6 @@ // 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. // -// Flags values are special. Instead of attempting to spill and restore the flags -// register, we recalculate it if needed. -// There are more efficient schemes (see the discussion in CL 13844), -// but flag restoration is empirically rare, and this approach is simple -// and architecture-independent. -// // 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). @@ -173,7 +167,6 @@ var registers = [...]Register{ Register{30, "X14"}, Register{31, "X15"}, Register{32, "SB"}, // pseudo-register for global base pointer (aka %rip) - Register{33, "FLAGS"}, // TODO: make arch-dependent } @@ -226,7 +219,7 @@ type regAllocState struct { f *Func // For each value, whether it needs a register or not. - // Cached value of !v.Type.IsMemory() && !v.Type.IsVoid(). + // Cached value of !v.Type.IsMemory() && !v.Type.IsVoid() && !v.Type.IsFlags(). needReg []bool // for each block, its primary predecessor. @@ -435,40 +428,9 @@ func (s *regAllocState) allocValToReg(v *Value, mask regMask, nospill bool) *Val c = s.curBlock.NewValue1(v.Line, OpCopy, v.Type, s.regs[r2].c) } else if v.rematerializeable() { // Rematerialize instead of loading from the spill location. - c = s.curBlock.NewValue0(v.Line, v.Op, v.Type) - c.Aux = v.Aux - c.AuxInt = v.AuxInt - c.AddArgs(v.Args...) + c = v.copyInto(s.curBlock) } else { switch { - // It is difficult to spill and reload flags on many architectures. - // Instead, we regenerate the flags register by issuing the same instruction again. - // This requires (possibly) spilling and reloading that instruction's args. - case v.Type.IsFlags(): - if logSpills { - fmt.Println("regalloc: regenerating flags") - } - ns := s.nospill - // Place v's arguments in registers, spilling and loading as needed - args := make([]*Value, 0, len(v.Args)) - regspec := opcodeTable[v.Op].reg - for _, i := range regspec.inputs { - // Extract the original arguments to v - a := s.orig[v.Args[i.idx].ID] - if a.Type.IsFlags() { - s.f.Fatalf("cannot load flags value with flags arg: %v has unwrapped arg %v", v.LongString(), a.LongString()) - } - cc := s.allocValToReg(a, i.regs, true) - args = append(args, cc) - } - s.nospill = ns - // Recalculate v - c = s.curBlock.NewValue0(v.Line, v.Op, v.Type) - c.Aux = v.Aux - c.AuxInt = v.AuxInt - c.resetArgs() - c.AddArgs(args...) - // Load v from its spill location. case vi.spill2 != nil: if logSpills { @@ -506,7 +468,7 @@ func (s *regAllocState) init(f *Func) { s.orig = make([]*Value, f.NumValues()) for _, b := range f.Blocks { for _, v := range b.Values { - if v.Type.IsMemory() || v.Type.IsVoid() { + if v.Type.IsMemory() || v.Type.IsVoid() || v.Type.IsFlags() { continue } s.needReg[v.ID] = true @@ -818,6 +780,10 @@ func (s *regAllocState) regalloc(f *Func) { // 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) } @@ -834,8 +800,11 @@ func (s *regAllocState) regalloc(f *Func) { // Pick register for output. var r register var mask regMask - if len(regspec.outputs) > 0 { + if s.needReg[v.ID] { 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(mask) @@ -858,7 +827,7 @@ func (s *regAllocState) regalloc(f *Func) { // f() // } // It would be good to have both spill and restore inside the IF. - if !v.Type.IsFlags() { + if s.needReg[v.ID] { spill := b.NewValue1(v.Line, OpStoreReg, v.Type, v) s.setOrig(spill, v) s.values[v.ID].spill = spill diff --git a/src/cmd/compile/internal/ssa/regalloc_test.go b/src/cmd/compile/internal/ssa/regalloc_test.go index 08260fbbbb..596a920858 100644 --- a/src/cmd/compile/internal/ssa/regalloc_test.go +++ b/src/cmd/compile/internal/ssa/regalloc_test.go @@ -13,12 +13,12 @@ func TestLiveControlOps(t *testing.T) { Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Valu("x", OpAMD64MOVBconst, TypeInt8, 0, 1), Valu("y", OpAMD64MOVBconst, TypeInt8, 0, 2), - Valu("a", OpAMD64TESTB, TypeBool, 0, nil, "x", "y"), - Valu("b", OpAMD64TESTB, TypeBool, 0, nil, "y", "x"), - If("a", "if", "exit"), + Valu("a", OpAMD64TESTB, TypeFlags, 0, nil, "x", "y"), + Valu("b", OpAMD64TESTB, TypeFlags, 0, nil, "y", "x"), + Eq("a", "if", "exit"), ), Bloc("if", - If("b", "plain", "exit"), + Eq("b", "plain", "exit"), ), Bloc("plain", Goto("exit"), @@ -27,6 +27,7 @@ func TestLiveControlOps(t *testing.T) { Exit("mem"), ), ) + flagalloc(f.f) regalloc(f.f) checkFunc(f.f) } diff --git a/src/cmd/compile/internal/ssa/value.go b/src/cmd/compile/internal/ssa/value.go index 661a05989a..fc318638ad 100644 --- a/src/cmd/compile/internal/ssa/value.go +++ b/src/cmd/compile/internal/ssa/value.go @@ -126,6 +126,15 @@ func (v *Value) resetArgs() { v.Args = v.argstorage[:0] } +// 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...) + return c +} + func (v *Value) Logf(msg string, args ...interface{}) { v.Block.Logf(msg, args...) } func (v *Value) Fatalf(msg string, args ...interface{}) { v.Block.Fatalf(msg, args...) } func (v *Value) Unimplementedf(msg string, args ...interface{}) { v.Block.Unimplementedf(msg, args...) } -- cgit v1.3 From 498933719287fbba1015c97d177a9bd4cfb9aada Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Fri, 11 Dec 2015 14:59:01 -0800 Subject: [dev.ssa] cmd/compile: allow control values to be CSEd With the separate flagalloc pass, it should be fine to allow CSE of control values. The worst that can happen is that the comparison gets un-CSEd by flagalloc. Fix bug in flagalloc where flag restores were getting clobbered by rematerialization during register allocation. Change-Id: If476cf98b69973e8f1a8eb29441136dd12fab8ad Reviewed-on: https://go-review.googlesource.com/17760 Reviewed-by: David Chase Run-TryBot: Keith Randall --- src/cmd/compile/internal/ssa/cse.go | 11 ++++++++++- src/cmd/compile/internal/ssa/flagalloc.go | 9 +++++++++ src/cmd/compile/internal/ssa/gen/AMD64.rules | 2 +- src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 2 +- src/cmd/compile/internal/ssa/opGen.go | 2 +- src/cmd/compile/internal/ssa/rewriteAMD64.go | 10 +++++----- 6 files changed, 27 insertions(+), 9 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/cse.go b/src/cmd/compile/internal/ssa/cse.go index 25f424fbee..58c52f23e6 100644 --- a/src/cmd/compile/internal/ssa/cse.go +++ b/src/cmd/compile/internal/ssa/cse.go @@ -153,7 +153,6 @@ func cse(f *Func) { i++ } } - // TODO(khr): if value is a control value, do we need to keep it block-local? } } @@ -166,6 +165,16 @@ func cse(f *Func) { } } } + 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 + } + } } } diff --git a/src/cmd/compile/internal/ssa/flagalloc.go b/src/cmd/compile/internal/ssa/flagalloc.go index c088158057..714ac016a2 100644 --- a/src/cmd/compile/internal/ssa/flagalloc.go +++ b/src/cmd/compile/internal/ssa/flagalloc.go @@ -21,6 +21,15 @@ func flagalloc(f *Func) { // Walk blocks backwards. Poor-man's postorder traversal. for i := len(f.Blocks) - 1; i >= 0; i-- { b := f.Blocks[i] + if len(b.Preds) > 1 { + // Don't use any flags register at the start + // of a merge block. This causes problems + // in regalloc because some of the rematerialization + // instructions used on incoming merge edges clobber + // the flags register. + // TODO: only for architectures where this matters? + continue + } // Walk values backwards to figure out what flag // value we want in the flag register at the start // of the block. diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 7d0aa4b2d3..0edbfdaa1a 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -370,7 +370,7 @@ (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) -> (EQF cmp yes no) +(If (SETNEF cmp) yes no) -> (NEF cmp yes no) (If cond yes no) -> (NE (TESTB cond cond) yes no) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index ba53e81ddd..461026bd7b 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -433,7 +433,7 @@ func init() { name: "DUFFCOPY", reg: regInfo{ inputs: []regMask{buildReg("DI"), buildReg("SI")}, - clobbers: buildReg("DI SI X0"), // uses X0 as a temporary + clobbers: buildReg("DI SI X0 FLAGS"), // uses X0 as a temporary }, }, diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 132ca83f95..bbedf2fb64 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -3177,7 +3177,7 @@ var opcodeTable = [...]opInfo{ {0, 128}, // .DI {1, 64}, // .SI }, - clobbers: 65728, // .SI .DI .X0 + clobbers: 8590000320, // .SI .DI .X0 .FLAGS }, }, { diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 3be94e37e7..5c2f3db4b2 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -14213,23 +14213,23 @@ func rewriteBlockAMD64(b *Block) bool { ; // match: (If (SETNEF cmp) yes no) // cond: - // result: (EQF cmp yes no) + // result: (NEF cmp yes no) { v := b.Control if v.Op != OpAMD64SETNEF { - goto endfe25939ca97349543bc2d2ce4f97ba41 + goto endaa989df10b5bbc5fdf8f7f0b81767e86 } cmp := v.Args[0] yes := b.Succs[0] no := b.Succs[1] - b.Kind = BlockAMD64EQF + b.Kind = BlockAMD64NEF b.Control = cmp b.Succs[0] = yes b.Succs[1] = no return true } - goto endfe25939ca97349543bc2d2ce4f97ba41 - endfe25939ca97349543bc2d2ce4f97ba41: + goto endaa989df10b5bbc5fdf8f7f0b81767e86 + endaa989df10b5bbc5fdf8f7f0b81767e86: ; // match: (If cond yes no) // cond: -- cgit v1.3 From 5b355a7907550d6fe457fdf6a92fc320d5a764d5 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Fri, 11 Dec 2015 20:41:52 -0800 Subject: [dev.ssa] cmd/compile: change ssa compilation trigger We used to compile everything with SSA and then decide whether to use the result or not. It was useful when we were working on coverage without much regard for correctness, but not so much now. Instead, let's decide what we're going to compile and go through the SSA compiler for only those functions. TODO: next CL: get rid of all the UnimplementedF stuff. Change-Id: If629addd8b62cd38ef553fd5d835114137885ce0 Reviewed-on: https://go-review.googlesource.com/17763 Reviewed-by: David Chase --- src/cmd/compile/internal/gc/pgen.go | 8 +-- src/cmd/compile/internal/gc/ssa.go | 117 ++++++++++++++++++++---------------- 2 files changed, 68 insertions(+), 57 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/pgen.go index c0d4a9f5b2..9b65f9c0f3 100644 --- a/src/cmd/compile/internal/gc/pgen.go +++ b/src/cmd/compile/internal/gc/pgen.go @@ -364,7 +364,6 @@ func compile(fn *Node) { var gcargs *Sym var gclocals *Sym var ssafn *ssa.Func - var usessa bool if fn.Nbody == nil { if pure_go != 0 || strings.HasPrefix(fn.Func.Nname.Sym.Name, "init.") { Yyerror("missing function body for %q", fn.Func.Nname.Sym.Name) @@ -417,9 +416,8 @@ func compile(fn *Node) { } // Build an SSA backend function. - // TODO: get rid of usessa. - if Thearch.Thestring == "amd64" { - ssafn, usessa = buildssa(Curfn) + if shouldssa(Curfn) { + ssafn = buildssa(Curfn) } continpc = nil @@ -485,7 +483,7 @@ func compile(fn *Node) { } } - if ssafn != nil && usessa { + if ssafn != nil { genssa(ssafn, ptxt, gcargs, gclocals) if Curfn.Func.Endlineno != 0 { lineno = Curfn.Func.Endlineno diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 4604fa682e..572fa962d8 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -21,14 +21,10 @@ import ( // Smallest possible faulting page at address zero. const minZeroPage = 4096 -// buildssa builds an SSA function -// and reports whether it should be used. -// Once the SSA implementation is complete, -// it will never return nil, and the bool can be removed. -func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { - name := fn.Func.Nname.Sym.Name - gossahash := os.Getenv("GOSSAHASH") - usessa = strings.HasSuffix(name, "_ssa") || strings.Contains(name, "_ssa.") || name == os.Getenv("GOSSAFUNC") +func shouldssa(fn *Node) bool { + if Thearch.Thestring != "amd64" { + return false + } // Environment variable control of SSA CG // 1. IF GOSSAFUNC == current function name THEN @@ -54,7 +50,63 @@ func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { // GOSSAHASH to n or N, or selectively with strings of // 0 and 1. - if usessa { + 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 + } + + gossahash := os.Getenv("GOSSAHASH") + if gossahash == "" || gossahash == "y" || gossahash == "Y" { + return true + } + if gossahash == "n" || gossahash == "N" { + return false + } + + // Check the hash of the name against a partial input hash. + // We use this feature to do a binary search within a package 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, gossahash) { + fmt.Printf("GOSSAHASH triggered %s\n", name) + return true + } + + // Iteratively try additional hashes to allow tests for multi-point + // failure. + for i := 0; true; i++ { + ev := fmt.Sprintf("GOSSAHASH%d", i) + evv := os.Getenv(ev) + if evv == "" { + break + } + if strings.HasSuffix(hstr, evv) { + fmt.Printf("%s triggered %s\n", ev, name) + return true + } + } + + return false +} + +// 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) dumplist("buildssa-enter", fn.Func.Enter) dumplist("buildssa-body", fn.Nbody) @@ -68,7 +120,7 @@ func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { // TODO(khr): build config just once at the start of the compiler binary var e ssaExport - e.log = usessa + e.log = printssa s.config = ssa.NewConfig(Thearch.Thestring, &e, Ctxt) s.f = s.config.NewFunc() s.f.Name = name @@ -82,7 +134,7 @@ func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { // TODO: generate and print a mapping from nodes to values and blocks } defer func() { - if !usessa { + if !printssa { s.config.HTML.Close() } }() @@ -170,7 +222,7 @@ func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { } if nerrors > 0 { - return nil, false + return nil } // Link up variable uses to variable definitions @@ -182,46 +234,7 @@ func buildssa(fn *Node) (ssafn *ssa.Func, usessa bool) { // Main call to ssa package to compile function ssa.Compile(s.f) - // gossahash = "y" is historical/symmetric-with-"n" -- i.e., not really needed. - if usessa || gossahash == "" || gossahash == "y" || gossahash == "Y" { - return s.f, true - } - if gossahash == "n" || gossahash == "N" { - if localpkg.Name != os.Getenv("GOSSAPKG") { - return s.f, false - } - // Use everything in the package - return s.f, true - } - - // Check the hash of the name against a partial input hash. - // We use this feature to do a binary search within a package 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, gossahash) { - fmt.Printf("GOSSAHASH triggered %s\n", name) - return s.f, true - } - - // Iteratively try additional hashes to allow tests for multi-point - // failure. - for i := 0; true; i++ { - ev := fmt.Sprintf("GOSSAHASH%d", i) - evv := os.Getenv(ev) - if evv == "" { - break - } - if strings.HasSuffix(hstr, evv) { - fmt.Printf("%s triggered %s\n", ev, name) - return s.f, true - } - } - - return s.f, false + return s.f } type state struct { -- cgit v1.3 From 7d9f1067d1c8a2d0252fa2a115f1d016f94f7087 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Thu, 17 Dec 2015 10:01:24 -0800 Subject: [dev.ssa] cmd/compile: better register allocator Reorder how register & stack allocation is done. We used to allocate registers, then fix up merge edges, then allocate stack slots. This lead to lots of unnecessary copies on merge edges: v2 = LoadReg v1 v3 = StoreReg v2 If v1 and v3 are allocated to the same stack slot, then this code is unnecessary. But at regalloc time we didn't know the homes of v1 and v3. To fix this problem, allocate all the stack slots before fixing up the merge edges. That way, we know what stack slots values use so we know what copies are required. Use a good technique for shuffling values around on merge edges. Improves performance of the go1 TimeParse benchmark by ~12% Change-Id: I731f43e4ff1a7e0dc4cd4aa428fcdb97812b86fa Reviewed-on: https://go-review.googlesource.com/17915 Reviewed-by: David Chase --- src/cmd/compile/internal/ssa/compile.go | 3 - src/cmd/compile/internal/ssa/flagalloc.go | 9 - src/cmd/compile/internal/ssa/regalloc.go | 898 ++++++++++++++++++++--------- src/cmd/compile/internal/ssa/stackalloc.go | 297 +++++----- 4 files changed, 793 insertions(+), 414 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/compile.go b/src/cmd/compile/internal/ssa/compile.go index 767b774ab0..20af6fd5bd 100644 --- a/src/cmd/compile/internal/ssa/compile.go +++ b/src/cmd/compile/internal/ssa/compile.go @@ -102,7 +102,6 @@ var passes = [...]pass{ {"schedule", schedule}, // schedule values {"flagalloc", flagalloc}, // allocate flags register {"regalloc", regalloc}, - {"stackalloc", stackalloc}, } // Double-check phase ordering constraints. @@ -138,8 +137,6 @@ var passOrder = [...]constraint{ {"critical", "regalloc"}, // regalloc requires all the values in a block to be scheduled {"schedule", "regalloc"}, - // stack allocation requires register allocation - {"regalloc", "stackalloc"}, // checkLower must run after lowering & subsequent dead code elim {"lower", "checkLower"}, {"lowered deadcode", "checkLower"}, diff --git a/src/cmd/compile/internal/ssa/flagalloc.go b/src/cmd/compile/internal/ssa/flagalloc.go index 714ac016a2..c088158057 100644 --- a/src/cmd/compile/internal/ssa/flagalloc.go +++ b/src/cmd/compile/internal/ssa/flagalloc.go @@ -21,15 +21,6 @@ func flagalloc(f *Func) { // Walk blocks backwards. Poor-man's postorder traversal. for i := len(f.Blocks) - 1; i >= 0; i-- { b := f.Blocks[i] - if len(b.Preds) > 1 { - // Don't use any flags register at the start - // of a merge block. This causes problems - // in regalloc because some of the rematerialization - // instructions used on incoming merge edges clobber - // the flags register. - // TODO: only for architectures where this matters? - continue - } // Walk values backwards to figure out what flag // value we want in the flag register at the start // of the block. diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index 2690b6188e..0f1068a337 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -99,7 +99,7 @@ import ( "unsafe" ) -const regDebug = false +const regDebug = false // TODO: compiler flag const logSpills = false // regalloc performs register allocation on f. It sets f.RegAlloc @@ -201,12 +201,12 @@ type use struct { } 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 - spill2 *Value // special alternate spill location used for phi resolution - spillUsed bool - spill2used bool + 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() } type regState struct { @@ -218,10 +218,6 @@ type regState struct { type regAllocState struct { f *Func - // For each value, whether it needs a register or not. - // Cached value of !v.Type.IsMemory() && !v.Type.IsVoid() && !v.Type.IsFlags(). - needReg []bool - // 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. @@ -249,14 +245,33 @@ type regAllocState struct { // mask of registers currently in use used regMask - // Home locations (registers) for Values - home []Location - // 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. @@ -268,7 +283,7 @@ func (s *regAllocState) freeReg(r register) { // Mark r as unused. if regDebug { - fmt.Printf("freeReg %d (dump %s/%s)\n", r, v, s.regs[r].c) + 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 @@ -282,21 +297,6 @@ func (s *regAllocState) freeRegs(m regMask) { } } -func (s *regAllocState) setHome(v *Value, r register) { - // Remember assignment. - for int(v.ID) >= len(s.home) { - s.home = append(s.home, nil) - s.home = s.home[:cap(s.home)] - } - s.home[v.ID] = ®isters[r] -} -func (s *regAllocState) getHome(v *Value) register { - if int(v.ID) >= len(s.home) || s.home[v.ID] == nil { - return noRegister - } - return register(s.home[v.ID].(*Register).Num) -} - // setOrig records that c's original value is the same as // v's original value. func (s *regAllocState) setOrig(c *Value, v *Value) { @@ -313,7 +313,7 @@ func (s *regAllocState) setOrig(c *Value, v *Value) { // r must be unused. func (s *regAllocState) assignReg(r register, v *Value, c *Value) { if regDebug { - fmt.Printf("assignReg %d %s/%s\n", r, v, c) + 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) @@ -323,7 +323,7 @@ func (s *regAllocState) assignReg(r register, v *Value, c *Value) { s.regs[r] = regState{v, c} s.values[v.ID].regs |= regMask(1) << r s.used |= regMask(1) << r - s.setHome(c, r) + s.f.setHome(c, ®isters[r]) } // allocReg picks an unused register from regmask. If there is no unused register, @@ -361,16 +361,6 @@ func (s *regAllocState) allocReg(mask regMask) register { continue } v := s.regs[t].v - - if s.values[v.ID].uses == nil { - // No subsequent use. - // This can happen when fixing up merge blocks at the end. - // We've already run through the use lists so they are empty. - // Any register would be ok at this point. - r = t - maxuse = 0 - break - } 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. @@ -432,12 +422,6 @@ func (s *regAllocState) allocValToReg(v *Value, mask regMask, nospill bool) *Val } else { switch { // Load v from its spill location. - case vi.spill2 != nil: - if logSpills { - fmt.Println("regalloc: load spill2") - } - c = s.curBlock.NewValue1(v.Line, OpLoadReg, v.Type, vi.spill2) - vi.spill2used = true case vi.spill != nil: if logSpills { fmt.Println("regalloc: load spill") @@ -462,17 +446,16 @@ func (s *regAllocState) init(f *Func) { } s.f = f - s.needReg = make([]bool, f.NumValues()) 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() { - continue + if !v.Type.IsMemory() && !v.Type.IsVoid() && !v.Type.IsFlags() { + s.values[v.ID].needReg = true + s.values[v.ID].rematerializeable = v.rematerializeable() + s.orig[v.ID] = v } - s.needReg[v.ID] = true - s.orig[v.ID] = v } } s.computeLive() @@ -498,6 +481,10 @@ func (s *regAllocState) init(f *Func) { } 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. @@ -521,7 +508,7 @@ func (s *regAllocState) addUse(id ID, dist int32) { // Any values which have no more uses are deallocated from registers. func (s *regAllocState) advanceUses(v *Value) { for _, a := range v.Args { - if !s.needReg[a.ID] { + if !s.values[a.ID].needReg { continue } ai := &s.values[a.ID] @@ -536,21 +523,18 @@ func (s *regAllocState) advanceUses(v *Value) { } } -// Sets the state of the registers to that encoded in state. -func (s *regAllocState) setState(state []regState) { +// Sets the state of the registers to that encoded in regs. +func (s *regAllocState) setState(regs []endReg) { s.freeRegs(s.used) - for r, x := range state { - if x.c == nil { - continue - } - s.assignReg(register(r), x.v, x.c) + for _, x := range regs { + s.assignReg(x.r, x.v, x.c) } } -// compatRegs returns the set of registers which can store v. -func (s *regAllocState) compatRegs(v *Value) regMask { +// compatRegs returns the set of registers which can store a type t. +func (s *regAllocState) compatRegs(t Type) regMask { var m regMask - if v.Type.IsFloat() { + if t.IsFloat() { m = 0xffff << 16 // X0-X15 } else { m = 0xffef << 0 // AX-R15, except SP @@ -560,11 +544,8 @@ func (s *regAllocState) compatRegs(v *Value) regMask { func (s *regAllocState) regalloc(f *Func) { liveSet := newSparseSet(f.NumValues()) - argset := newSparseSet(f.NumValues()) var oldSched []*Value var phis []*Value - var stackPhis []*Value - var regPhis []*Value var phiRegs []register var args []*Value @@ -572,11 +553,6 @@ func (s *regAllocState) regalloc(f *Func) { f.Fatalf("entry block must be first") } - // For each merge block, we record the starting register state (after phi ops) - // for that merge block. Indexed by blockid/regnum. - startRegs := make([][]*Value, f.NumBlocks()) - // end state of registers for each block, idexed by blockid/regnum. - endRegs := make([][]regState, f.NumBlocks()) for _, b := range f.Blocks { s.curBlock = b @@ -587,18 +563,21 @@ func (s *regAllocState) regalloc(f *Func) { s.addUse(e.ID, int32(len(b.Values))+e.dist) // pseudo-uses from beyond end of block liveSet.add(e.ID) } - if c := b.Control; c != nil && s.needReg[c.ID] { - s.addUse(c.ID, int32(len(b.Values))) // psuedo-use by control value - liveSet.add(c.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 { - break // Don't process phi ops. + // 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 } - liveSet.remove(v.ID) for _, a := range v.Args { - if !s.needReg[a.ID] { + if !s.values[a.ID].needReg { continue } s.addUse(a.ID, int32(i)) @@ -613,7 +592,7 @@ func (s *regAllocState) regalloc(f *Func) { if u == nil { continue } - fmt.Printf("v%d:", i) + fmt.Printf(" v%d:", i) for u != nil { fmt.Printf(" %d", u.dist) u = u.next @@ -643,7 +622,7 @@ func (s *regAllocState) regalloc(f *Func) { } } else if len(b.Preds) == 1 { // Start regalloc state with the end state of the previous block. - s.setState(endRegs[b.Preds[0].ID]) + s.setState(s.endRegs[b.Preds[0].ID]) if nphi > 0 { f.Fatalf("phis in single-predecessor block") } @@ -669,52 +648,83 @@ func (s *regAllocState) regalloc(f *Func) { f.Fatalf("block with no primary predecessor %s", b) } p := b.Preds[idx] - s.setState(endRegs[p.ID]) + 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 used regMask + var phiUsed regMask for _, v := range phis { - if v.Type.IsMemory() { + if !s.values[v.ID].needReg { phiRegs = append(phiRegs, noRegister) continue } - regs := s.values[v.Args[idx].ID].regs - m := regs &^ used + a := v.Args[idx] + m := s.values[a.ID].regs &^ phiUsed var r register if m != 0 { r = pickReg(m) - used |= regMask(1) << r + s.freeReg(r) + phiUsed |= regMask(1) << r + phiRegs = append(phiRegs, r) } else { - r = noRegister + 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) } - phiRegs = append(phiRegs, r) } - // Change register user from phi input to phi. Add phi spill code. + + // Third pass - pick registers for phis whose inputs + // were not in a register. for i, v := range phis { - if v.Type.IsMemory() { + 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 { - m := s.compatRegs(v) & ^s.used - if m == 0 { - // 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 - } - // Allocate phi to an unused register. - r = pickReg(m) - } else { - s.freeReg(r) + // 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 - // Transfer ownership of register from input arg to 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) @@ -723,15 +733,35 @@ func (s *regAllocState) regalloc(f *Func) { s.values[v.ID].spillUsed = false } - // Save the starting state for use by incoming edges below. - startRegs[b.ID] = make([]*Value, numRegs) + // Save the starting state for use by merge edges. + var regList []startReg for r := register(0); r < numRegs; r++ { - startRegs[b.ID][r] = s.regs[r].v + 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) + } } } // Process all the non-phi values. - for idx, v := range oldSched { + 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) } @@ -758,9 +788,6 @@ func (s *regAllocState) regalloc(f *Func) { continue } regspec := opcodeTable[v.Op].reg - if regDebug { - fmt.Printf("%d: working on %s %s %v\n", idx, v, v.LongString(), regspec) - } if len(regspec.inputs) == 0 && len(regspec.outputs) == 0 { // No register allocation required (or none specified yet) s.freeRegs(regspec.clobbers) @@ -768,7 +795,7 @@ func (s *regAllocState) regalloc(f *Func) { continue } - if v.rematerializeable() { + if s.values[v.ID].rematerializeable { // Value is rematerializeable, don't issue it here. // It will get issued just before each use (see // allocValueToReg). @@ -800,7 +827,7 @@ func (s *regAllocState) regalloc(f *Func) { // Pick register for output. var r register var mask regMask - if s.needReg[v.ID] { + 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()) @@ -827,7 +854,7 @@ func (s *regAllocState) regalloc(f *Func) { // f() // } // It would be good to have both spill and restore inside the IF. - if s.needReg[v.ID] { + 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 @@ -835,21 +862,70 @@ func (s *regAllocState) regalloc(f *Func) { } } - if c := b.Control; c != nil && s.needReg[c.ID] { + 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(c, opcodeTable[c.Op].reg.outputs[0], false) + s.allocValToReg(v, opcodeTable[v.Op].reg.outputs[0], false) // Remove this use from the uses list. - u := s.values[c.ID].uses - s.values[c.ID].uses = u.next + 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 } - // Record endRegs - endRegs[b.ID] = make([]regState, numRegs) - copy(endRegs[b.ID], s.regs) + // Save end-of-block register state. + var regList []endReg + 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 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 @@ -868,137 +944,6 @@ func (s *regAllocState) regalloc(f *Func) { } } - // Process merge block input edges. They are the tricky ones. - dst := make([]*Value, numRegs) - for _, b := range f.Blocks { - if len(b.Preds) <= 1 { - continue - } - for i, p := range b.Preds { - if regDebug { - fmt.Printf("processing %s->%s\n", p, b) - } - - // Find phis, separate them into stack & register classes. - stackPhis = stackPhis[:0] - regPhis = regPhis[:0] - for _, v := range b.Values { - if v.Op != OpPhi { - break - } - if v.Type.IsMemory() { - continue - } - if s.getHome(v) != noRegister { - regPhis = append(regPhis, v) - } else { - stackPhis = append(stackPhis, v) - } - } - - // Start with the state that exists at the end of the - // predecessor block. We'll be adding instructions here - // to shuffle registers & stack phis into the right spot. - s.setState(endRegs[p.ID]) - s.curBlock = p - - // Handle stack-based phi ops first. We need to handle them - // first because we need a register with which to copy them. - - // We must be careful not to overwrite any stack phis which are - // themselves args of other phis. For example: - // v1 = phi(v2, v3) : 8(SP) - // v2 = phi(v4, v5) : 16(SP) - // Here we must not write v2 until v2 is read and written to v1. - // The situation could be even more complicated, with cycles, etc. - // So in the interest of being simple, we find all the phis which - // are arguments of other phis and copy their values to a temporary - // location first. This temporary location is called "spill2" and - // represents a higher-priority but temporary spill location for the value. - // Note this is not a problem for register-based phis because - // if needed we will use the spilled location as the source, and - // the spill location is not clobbered by the code generated here. - argset.clear() - for _, v := range stackPhis { - argset.add(v.Args[i].ID) - } - for _, v := range regPhis { - argset.add(v.Args[i].ID) - } - for _, v := range stackPhis { - if !argset.contains(v.ID) { - continue - } - - // This stack-based phi is the argument of some other - // phi in this block. We must make a copy of its - // value so that we don't clobber it prematurely. - c := s.allocValToReg(v, s.compatRegs(v), false) - d := p.NewValue1(v.Line, OpStoreReg, v.Type, c) - s.setOrig(d, v) - s.values[v.ID].spill2 = d - } - - // Assign to stack-based phis. We do stack phis first because - // we might need a register to do the assignment. - for _, v := range stackPhis { - // Load phi arg into a register, then store it with a StoreReg. - // If already in a register, use that. If not, pick a compatible - // register. - w := v.Args[i] - c := s.allocValToReg(w, s.compatRegs(w), false) - v.Args[i] = p.NewValue1(v.Line, OpStoreReg, v.Type, c) - s.setOrig(v.Args[i], w) - } - // Figure out what value goes in each register. - for r := register(0); r < numRegs; r++ { - dst[r] = startRegs[b.ID][r] - } - // Handle register-based phi ops. - for _, v := range regPhis { - r := s.getHome(v) - if dst[r] != v { - f.Fatalf("dst not right") - } - v.Args[i] = s.allocValToReg(v.Args[i], regMask(1)<CX and CX->DX, do the latter first. Now if we do the - // former first then the latter must be a restore instead of a register move. - // Erase any spills we never used for i := range s.values { vi := s.values[i] @@ -1031,24 +976,450 @@ func (s *regAllocState) regalloc(f *Func) { // Not important now because this is the last phase that manipulates Values } - // Set final regalloc result. - f.RegAlloc = s.home + // 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) + } + + // 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) + x = e.p.NewValue1(x.Line, OpStoreReg, x.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, c.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, c.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 + } + } + } + + e.s.f.Fatalf("can't find empty register on edge %s->%s", e.p, e.b) + return nil } func (v *Value) rematerializeable() bool { // TODO: add a flags field to opInfo for this test? + regspec := opcodeTable[v.Op].reg // rematerializeable ops must be able to fill any register. - outputs := opcodeTable[v.Op].reg.outputs + outputs := regspec.outputs if len(outputs) == 0 || countRegs(outputs[0]) <= 1 { // Note: this case handles OpAMD64LoweredGetClosurePtr // which can't be moved. return false } + + // We can't rematerialize instructions which + // clobber the flags register. + if regspec.clobbers&flagRegMask != 0 { + if v.Op == OpAMD64MOVQconst && v.AuxInt != 0 || + v.Op == OpAMD64MOVLconst && int32(v.AuxInt) != 0 || + v.Op == OpAMD64MOVWconst && int16(v.AuxInt) != 0 || + v.Op == OpAMD64MOVBconst && int8(v.AuxInt) != 0 { + // These are marked as clobbering flags, but only + // the 0 versions actually do. TODO: fix MOV->XOR rewrites + // to understand when they are allowed to clobber flags? + return true + } + return false + } + if len(v.Args) == 0 { return true } if len(v.Args) == 1 && (v.Args[0].Op == OpSP || v.Args[0].Op == OpSB) { + // SP and SB (generated by OpSP and OpSB) are always available. return true } return false @@ -1084,9 +1455,6 @@ func (s *regAllocState) computeLive() { // out to all of them. po := postorder(f) for { - for _, b := range po { - f.Logf("live %s %v\n", b, s.live[b.ID]) - } changed := false for _, b := range po { @@ -1099,7 +1467,7 @@ func (s *regAllocState) computeLive() { } // Mark control value as live - if b.Control != nil && s.needReg[b.Control.ID] { + if b.Control != nil && s.values[b.Control.ID].needReg { live.set(b.Control.ID, int32(len(b.Values))) } @@ -1115,7 +1483,7 @@ func (s *regAllocState) computeLive() { continue } for _, a := range v.Args { - if s.needReg[a.ID] { + if s.values[a.ID].needReg { live.set(a.ID, int32(i)) } } @@ -1162,7 +1530,7 @@ func (s *regAllocState) computeLive() { // simultaneously happening at the start of the block). for _, v := range phis { id := v.Args[i].ID - if s.needReg[id] && !t.contains(id) || delta < t.get(id) { + if s.values[id].needReg && !t.contains(id) || delta < t.get(id) { update = true t.set(id, delta) } @@ -1185,6 +1553,16 @@ func (s *regAllocState) computeLive() { 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. diff --git a/src/cmd/compile/internal/ssa/stackalloc.go b/src/cmd/compile/internal/ssa/stackalloc.go index 3eb5c3cf4a..797a6b05e6 100644 --- a/src/cmd/compile/internal/ssa/stackalloc.go +++ b/src/cmd/compile/internal/ssa/stackalloc.go @@ -6,55 +6,65 @@ 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. -func stackalloc(f *Func) { - // Cache value types by ID. - types := make([]Type, f.NumValues()) - for _, b := range f.Blocks { - for _, v := range b.Values { - types[v.ID] = v.Type - } +// 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 +} - // Build interference graph among StoreReg and stack phi ops. - live := f.liveSpills() - interfere := make([][]ID, f.NumValues()) - s := newSparseSet(f.NumValues()) - for _, b := range f.Blocks { - // Start with known live values at the end of the block. - s.clear() - for i := 0; i < len(b.Succs); i++ { - s.addAll(live[b.ID][i]) - } +func (s *stackAllocState) init(f *Func, spillLive [][]ID) { + s.f = f - // Propagate backwards to the start of the block. - // Remember interfering sets. - for i := len(b.Values) - 1; i >= 0; i-- { - v := b.Values[i] - switch { - case v.Op == OpStoreReg, v.isStackPhi(): - s.remove(v.ID) - for _, id := range s.contents() { - if v.Type.Equal(types[id]) { - // Only need interferences between equivalent types. - interfere[v.ID] = append(interfere[v.ID], id) - interfere[id] = append(interfere[id], v.ID) - } - } - case v.Op == OpLoadReg: - s.add(v.Args[0].ID) - case v.Op == OpArg: - // This is an input argument which is pre-spilled. It is kind of - // like a StoreReg, but we don't remove 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. + // 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. @@ -67,49 +77,41 @@ func stackalloc(f *Func) { } } - // Figure out which StoreReg ops are phi args. We don't pick slots for - // phi args because a stack phi and its args must all use the same stack slot. - phiArg := make([]bool, f.NumValues()) - for _, b := range f.Blocks { - for _, v := range b.Values { - if !v.isStackPhi() { - continue - } - for _, a := range v.Args { - phiArg[a.ID] = true - } - } - } - // Allocate args to their assigned locations. for _, v := range f.Entry.Values { if v.Op != OpArg { continue } - f.setHome(v, LocalSlot{v.Aux.(GCNode), v.Type, v.AuxInt}) + 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]. - // TODO: share slots among equivalent types. slots := make([]int, f.NumValues()) for i := f.NumValues() - 1; i >= 0; i-- { slots[i] = -1 } - // Pick a stack slot for each non-phi-arg StoreReg and each stack phi. + // 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 v.Op != OpStoreReg && !v.isStackPhi() { + if !s.values[v.ID].needSlot { continue } - if phiArg[v.ID] { - continue + if v.Op == OpArg { + continue // already picked } // If this is a named value, try to use the name as @@ -121,7 +123,7 @@ func stackalloc(f *Func) { name = names[v.ID] } if name.N != nil && v.Type.Equal(name.Type) { - for _, id := range interfere[v.ID] { + for _, id := range s.interfere[v.ID] { h := f.getHome(id) if h != nil && h.(LocalSlot) == name { // A variable can interfere with itself. @@ -129,22 +131,10 @@ func stackalloc(f *Func) { goto noname } } - if v.Op == OpPhi { - for _, a := range v.Args { - for _, id := range interfere[a.ID] { - h := f.getHome(id) - if h != nil && h.(LocalSlot) == name { - goto noname - } - } - } + if stackDebug { + fmt.Printf("stackalloc %s to %s\n", v, name.Name()) } f.setHome(v, name) - if v.Op == OpPhi { - for _, a := range v.Args { - f.setHome(a, name) - } - } continue } @@ -155,25 +145,12 @@ func stackalloc(f *Func) { for i := 0; i < len(locs); i++ { used[i] = false } - for _, xid := range interfere[v.ID] { + for _, xid := range s.interfere[v.ID] { slot := slots[xid] if slot >= 0 { used[slot] = true } } - if v.Op == OpPhi { - // Stack phi and args must get the same stack slot, so - // anything the args interfere with is something the phi - // interferes with. - for _, a := range v.Args { - for _, xid := range interfere[a.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++ { @@ -188,83 +165,80 @@ func stackalloc(f *Func) { } // 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 - if v.Op == OpPhi { - for _, a := range v.Args { - f.setHome(a, loc) - slots[a.ID] = i - } - } } } } -// live returns a map from block ID and successor edge index to a list -// of StoreReg/stackphi value IDs live on that edge. +// 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 (f *Func) liveSpills() [][][]ID { - live := make([][][]ID, f.NumBlocks()) - for _, b := range f.Blocks { - live[b.ID] = make([][]ID, len(b.Succs)) - } +func (s *stackAllocState) computeLive(spillLive [][]ID) { + s.live = make([][]ID, s.f.NumBlocks()) var phis []*Value - - s := newSparseSet(f.NumValues()) - t := newSparseSet(f.NumValues()) + live := newSparseSet(s.f.NumValues()) + t := newSparseSet(s.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. - po := postorder(f) + po := postorder(s.f) for { changed := false for _, b := range po { // Start with known live values at the end of the block - s.clear() - for i := 0; i < len(b.Succs); i++ { - s.addAll(live[b.ID][i]) - } + 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] - switch { - case v.Op == OpStoreReg: - s.remove(v.ID) - case v.Op == OpLoadReg: - s.add(v.Args[0].ID) - case v.isStackPhi(): - s.remove(v.ID) - // save stack phi ops for later - phis = append(phis, v) + 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 { - // Find index of b in p's successors. - var j int - for j = 0; j < len(p.Succs); j++ { - if p.Succs[j] == b { - break - } - } t.clear() - t.addAll(live[p.ID][j]) - t.addAll(s.contents()) + t.addAll(s.live[p.ID]) + t.addAll(live.contents()) + t.addAll(spillLive[p.ID]) for _, v := range phis { - t.add(v.Args[i].ID) + 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(live[p.ID][j]) { + if t.size() == len(s.live[p.ID]) { continue } // grow p's live set - live[p.ID][j] = append(live[p.ID][j][:0], t.contents()...) + s.live[p.ID] = append(s.live[p.ID][:0], t.contents()...) changed = true } } @@ -273,7 +247,11 @@ func (f *Func) liveSpills() [][][]ID { break } } - return live + 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 { @@ -290,16 +268,51 @@ func (f *Func) setHome(v *Value, loc Location) { f.RegAlloc[v.ID] = loc } -func (v *Value) isStackPhi() bool { - if v.Op != OpPhi { - return false - } - if v.Type == TypeMem { - return false +func (s *stackAllocState) buildInterferenceGraph() { + f := s.f + s.interfere = make([][]ID, f.NumValues()) + live := newSparseSet(f.NumValues()) + 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 int(v.ID) >= len(v.Block.Func.RegAlloc) { - return true + 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() + } + } } - return v.Block.Func.RegAlloc[v.ID] == nil - // TODO: use a separate opcode for StackPhi? } -- cgit v1.3 From d7ad7b9efecf034e2d95fe48b455a8dbb2204f2e Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Mon, 4 Jan 2016 13:34:54 -0800 Subject: [dev.ssa] cmd/compile: zero register masks for each edge Forgot to reset these masks before each merge edge is processed. Change-Id: I2f593189b63f50a1cd12b2dd4645ca7b9614f1f3 Reviewed-on: https://go-review.googlesource.com/18223 Reviewed-by: David Chase Run-TryBot: David Chase --- src/cmd/compile/internal/ssa/regalloc.go | 9 +++++++++ 1 file changed, 9 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index 0f1068a337..d7c4674cfd 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -1052,6 +1052,9 @@ func (e *edgeState) setup(idx int, srcReg []endReg, dstReg []startReg, stacklive 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 { @@ -1384,6 +1387,12 @@ func (e *edgeState) findRegFor(typ Type) Location { } } + 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 } -- cgit v1.3 From 035fcc0c4d0354adb1a8c837035f4ef3426bb5ed Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Tue, 5 Jan 2016 16:30:08 -0800 Subject: [dev.ssa] cmd/compile: add some more TODOs Change-Id: If8b6b85d2165d6222b36f101adb95b7ee40371c1 Reviewed-on: https://go-review.googlesource.com/18300 Reviewed-by: David Chase --- src/cmd/compile/internal/ssa/TODO | 9 +++++++++ 1 file changed, 9 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/TODO b/src/cmd/compile/internal/ssa/TODO index 73d91fefd7..d4904e1dcf 100644 --- a/src/cmd/compile/internal/ssa/TODO +++ b/src/cmd/compile/internal/ssa/TODO @@ -26,6 +26,15 @@ Optimizations (better compiled code) CMP AX, $0 JEQ ... - Use better write barrier calls +- If there are a lot of MOVQ $0, ..., then load + 0 into a register and use the register as the source instead. +- Allow structs (and arrays of length 1?) 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 feilds being accessed) pass them in xmm registers? + Same for interfaces? +- boolean logic: movb/xorb$1/testb/jeq -> movb/testb/jne Optimizations (better compiler) ------------------------------- -- cgit v1.3 From 9094e3ada2de3cc8129b70730c2c0782a4040201 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Mon, 4 Jan 2016 13:34:54 -0800 Subject: [dev.ssa] cmd/compile: fix spill sizes In code that does: var x, z int32 var y int64 z = phi(x, int32(y)) We silently drop the int32 cast because truncation is a no-op. The phi operation needs to make sure it uses the size of the phi, not the size of its arguments, when generating spills. Change-Id: I1f7baf44f019256977a46fdd3dad1972be209042 Reviewed-on: https://go-review.googlesource.com/18390 Reviewed-by: David Chase --- src/cmd/compile/internal/gc/ssa.go | 3 + src/cmd/compile/internal/gc/ssa_test.go | 2 + src/cmd/compile/internal/gc/testdata/phi_ssa.go | 103 ++++++++++++++++++++++++ src/cmd/compile/internal/ssa/regalloc.go | 9 ++- 4 files changed, 114 insertions(+), 3 deletions(-) create mode 100644 src/cmd/compile/internal/gc/testdata/phi_ssa.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 55ab8ce283..eee3051c39 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -4536,6 +4536,9 @@ func regnum(v *ssa.Value) int16 { // 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 } diff --git a/src/cmd/compile/internal/gc/ssa_test.go b/src/cmd/compile/internal/gc/ssa_test.go index 74fa847c92..d0c44b5dce 100644 --- a/src/cmd/compile/internal/gc/ssa_test.go +++ b/src/cmd/compile/internal/gc/ssa_test.go @@ -95,3 +95,5 @@ 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/testdata/phi_ssa.go b/src/cmd/compile/internal/gc/testdata/phi_ssa.go new file mode 100644 index 0000000000..e855070fc3 --- /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/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index d7c4674cfd..27deeba718 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -1223,7 +1223,10 @@ func (e *edgeState) processDest(loc Location, vid ID, splice **Value) bool { r := e.findRegFor(v.Type) x = v.copyInto(e.p) e.set(r, vid, x, false) - x = e.p.NewValue1(x.Line, OpStoreReg, x.Type, x) + // 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. @@ -1232,7 +1235,7 @@ func (e *edgeState) processDest(loc Location, vid ID, splice **Value) bool { if dstReg { x = e.p.NewValue1(c.Line, OpCopy, c.Type, c) } else { - x = e.p.NewValue1(c.Line, OpStoreReg, c.Type, c) + x = e.p.NewValue1(c.Line, OpStoreReg, loc.(LocalSlot).Type, c) } } else { if dstReg { @@ -1255,7 +1258,7 @@ func (e *edgeState) processDest(loc Location, vid ID, splice **Value) bool { 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, c.Type, t) + x = e.p.NewValue1(c.Line, OpStoreReg, loc.(LocalSlot).Type, t) } } } -- cgit v1.3 From 3425295e915bc16236f2c021317705aca34319af Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Tue, 5 Jan 2016 14:56:26 -0800 Subject: [dev.ssa] cmd/compile: clean up comparisons Add new constant-flags opcodes. These can be generated from comparisons that we know the result of, like x&31 < 32. Constant-fold the constant-flags opcodes into all flag users. Reorder some CMPxconst args so they read in the comparison direction. Reorg deadcode removal a bit - it needs to remove the OpCopy ops it generates when strength-reducing Phi ops. So it needs to splice out all the dead blocks and do a copy elimination before it computes live values. Change-Id: Ie922602033592ad8212efe4345394973d3b94d9f Reviewed-on: https://go-review.googlesource.com/18267 Run-TryBot: Keith Randall Reviewed-by: David Chase --- src/cmd/compile/internal/gc/ssa.go | 2 + src/cmd/compile/internal/ssa/copyelim.go | 14 + src/cmd/compile/internal/ssa/deadcode.go | 144 +- src/cmd/compile/internal/ssa/gen/AMD64.rules | 287 ++- src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 13 + src/cmd/compile/internal/ssa/lower.go | 2 +- src/cmd/compile/internal/ssa/opGen.go | 25 + src/cmd/compile/internal/ssa/rewriteAMD64.go | 3213 +++++++++++++++++++++----- 8 files changed, 3019 insertions(+), 681 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index eee3051c39..c41a66f1ae 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -4108,6 +4108,8 @@ func (s *genState) genValue(v *ssa.Value) { 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) diff --git a/src/cmd/compile/internal/ssa/copyelim.go b/src/cmd/compile/internal/ssa/copyelim.go index 10c2dcc440..067d5e2606 100644 --- a/src/cmd/compile/internal/ssa/copyelim.go +++ b/src/cmd/compile/internal/ssa/copyelim.go @@ -26,4 +26,18 @@ func copyelim(f *Func) { 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 + } + } + } } diff --git a/src/cmd/compile/internal/ssa/deadcode.go b/src/cmd/compile/internal/ssa/deadcode.go index e9d6525701..429708213f 100644 --- a/src/cmd/compile/internal/ssa/deadcode.go +++ b/src/cmd/compile/internal/ssa/deadcode.go @@ -6,22 +6,14 @@ package ssa // findlive returns the reachable blocks and live values in f. func findlive(f *Func) (reachable []bool, live []bool) { - // After regalloc, consider all blocks and values to be reachable and live. - // See the comment at the top of regalloc.go and in deadcode for details. - if f.RegAlloc != nil { - reachable = make([]bool, f.NumBlocks()) - for i := range reachable { - reachable[i] = true - } - live = make([]bool, f.NumValues()) - for i := range live { - live[i] = true - } - return reachable, live - } + reachable = reachableBlocks(f) + live = liveValues(f, reachable) + return +} - // Find all reachable basic blocks. - reachable = make([]bool, f.NumBlocks()) +// 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 { @@ -40,10 +32,25 @@ func findlive(f *Func) (reachable []bool, live []bool) { } } } + 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 - live = make([]bool, f.NumValues()) // flag to set for each live value - var q []*Value // stack-like worklist of unscanned 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 { @@ -72,7 +79,7 @@ func findlive(f *Func) (reachable []bool, live []bool) { } } - return reachable, live + return live } // deadcode removes dead code from f. @@ -85,27 +92,8 @@ func deadcode(f *Func) { f.Fatalf("deadcode after regalloc") } - reachable, live := findlive(f) - - // Remove dead values from blocks' value list. Return dead - // value ids 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.vid.put(v.ID) - } - } - // aid GC - tail := b.Values[i:] - for j := range tail { - tail[j] = nil - } - b.Values = b.Values[:i] - } + // Find reachable blocks. + reachable := reachableBlocks(f) // Get rid of edges from dead to live code. for _, b := range f.Blocks { @@ -131,6 +119,7 @@ func deadcode(f *Func) { 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. @@ -138,41 +127,20 @@ func deadcode(f *Func) { } } - // Remove unreachable blocks. Return dead block ids 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) - } - b.Preds = nil - b.Succs = nil - b.Control = nil - b.Kind = BlockDead - f.bid.put(b.ID) - } - } - // zero remainder to help GC - tail := f.Blocks[i:] - for j := range tail { - tail[j] = nil - } - f.Blocks = f.Blocks[:i] + // 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 := newSparseSet(f.NumValues()) - i = 0 + i := 0 for _, name := range f.Names { j := 0 s.clear() values := f.NamedValues[name] for _, v := range values { - for v.Op == OpCopy { - v = v.Args[0] - } if live[v.ID] && !s.contains(v.ID) { values[j] = v j++ @@ -195,6 +163,50 @@ func deadcode(f *Func) { } f.Names = f.Names[:i] + // Remove dead values from blocks' value list. Return dead + // value ids 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.vid.put(v.ID) + } + } + // aid GC + tail := b.Values[i:] + for j := range tail { + tail[j] = nil + } + b.Values = b.Values[:i] + } + + // Remove unreachable blocks. Return dead block ids 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) + } + b.Preds = nil + b.Succs = nil + b.Control = nil + b.Kind = BlockDead + f.bid.put(b.ID) + } + } + // zero remainder to help GC + tail := f.Blocks[i:] + for j := range tail { + tail[j] = nil + } + f.Blocks = f.Blocks[:i] + // TODO: renumber Blocks and Values densely? // TODO: save dead Values and Blocks for reuse? Or should we just let GC handle it? } diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 0edbfdaa1a..9db3abb9f0 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -130,73 +130,73 @@ // 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 x y) -> (ANDQ (SHLQ x y) (SBBQcarrymask (CMPQconst [64] y))) -(Lsh64x32 x y) -> (ANDQ (SHLQ x y) (SBBQcarrymask (CMPLconst [64] y))) -(Lsh64x16 x y) -> (ANDQ (SHLQ x y) (SBBQcarrymask (CMPWconst [64] y))) -(Lsh64x8 x y) -> (ANDQ (SHLQ x y) (SBBQcarrymask (CMPBconst [64] y))) - -(Lsh32x64 x y) -> (ANDL (SHLL x y) (SBBLcarrymask (CMPQconst [32] y))) -(Lsh32x32 x y) -> (ANDL (SHLL x y) (SBBLcarrymask (CMPLconst [32] y))) -(Lsh32x16 x y) -> (ANDL (SHLL x y) (SBBLcarrymask (CMPWconst [32] y))) -(Lsh32x8 x y) -> (ANDL (SHLL x y) (SBBLcarrymask (CMPBconst [32] y))) - -(Lsh16x64 x y) -> (ANDW (SHLW x y) (SBBLcarrymask (CMPQconst [16] y))) -(Lsh16x32 x y) -> (ANDW (SHLW x y) (SBBLcarrymask (CMPLconst [16] y))) -(Lsh16x16 x y) -> (ANDW (SHLW x y) (SBBLcarrymask (CMPWconst [16] y))) -(Lsh16x8 x y) -> (ANDW (SHLW x y) (SBBLcarrymask (CMPBconst [16] y))) - -(Lsh8x64 x y) -> (ANDB (SHLB x y) (SBBLcarrymask (CMPQconst [8] y))) -(Lsh8x32 x y) -> (ANDB (SHLB x y) (SBBLcarrymask (CMPLconst [8] y))) -(Lsh8x16 x y) -> (ANDB (SHLB x y) (SBBLcarrymask (CMPWconst [8] y))) -(Lsh8x8 x y) -> (ANDB (SHLB x y) (SBBLcarrymask (CMPBconst [8] y))) +(Lsh64x64 x y) -> (ANDQ (SHLQ x y) (SBBQcarrymask (CMPQconst y [64]))) +(Lsh64x32 x y) -> (ANDQ (SHLQ x y) (SBBQcarrymask (CMPLconst y [64]))) +(Lsh64x16 x y) -> (ANDQ (SHLQ x y) (SBBQcarrymask (CMPWconst y [64]))) +(Lsh64x8 x y) -> (ANDQ (SHLQ x y) (SBBQcarrymask (CMPBconst y [64]))) + +(Lsh32x64 x y) -> (ANDL (SHLL x y) (SBBLcarrymask (CMPQconst y [32]))) +(Lsh32x32 x y) -> (ANDL (SHLL x y) (SBBLcarrymask (CMPLconst y [32]))) +(Lsh32x16 x y) -> (ANDL (SHLL x y) (SBBLcarrymask (CMPWconst y [32]))) +(Lsh32x8 x y) -> (ANDL (SHLL x y) (SBBLcarrymask (CMPBconst y [32]))) + +(Lsh16x64 x y) -> (ANDW (SHLW x y) (SBBLcarrymask (CMPQconst y [16]))) +(Lsh16x32 x y) -> (ANDW (SHLW x y) (SBBLcarrymask (CMPLconst y [16]))) +(Lsh16x16 x y) -> (ANDW (SHLW x y) (SBBLcarrymask (CMPWconst y [16]))) +(Lsh16x8 x y) -> (ANDW (SHLW x y) (SBBLcarrymask (CMPBconst y [16]))) + +(Lsh8x64 x y) -> (ANDB (SHLB x y) (SBBLcarrymask (CMPQconst y [8]))) +(Lsh8x32 x y) -> (ANDB (SHLB x y) (SBBLcarrymask (CMPLconst y [8]))) +(Lsh8x16 x y) -> (ANDB (SHLB x y) (SBBLcarrymask (CMPWconst y [8]))) +(Lsh8x8 x y) -> (ANDB (SHLB x y) (SBBLcarrymask (CMPBconst y [8]))) (Lrot64 x [c]) -> (ROLQconst [c&63] x) (Lrot32 x [c]) -> (ROLLconst [c&31] x) (Lrot16 x [c]) -> (ROLWconst [c&15] x) (Lrot8 x [c]) -> (ROLBconst [c&7] x) -(Rsh64Ux64 x y) -> (ANDQ (SHRQ x y) (SBBQcarrymask (CMPQconst [64] y))) -(Rsh64Ux32 x y) -> (ANDQ (SHRQ x y) (SBBQcarrymask (CMPLconst [64] y))) -(Rsh64Ux16 x y) -> (ANDQ (SHRQ x y) (SBBQcarrymask (CMPWconst [64] y))) -(Rsh64Ux8 x y) -> (ANDQ (SHRQ x y) (SBBQcarrymask (CMPBconst [64] y))) +(Rsh64Ux64 x y) -> (ANDQ (SHRQ x y) (SBBQcarrymask (CMPQconst y [64]))) +(Rsh64Ux32 x y) -> (ANDQ (SHRQ x y) (SBBQcarrymask (CMPLconst y [64]))) +(Rsh64Ux16 x y) -> (ANDQ (SHRQ x y) (SBBQcarrymask (CMPWconst y [64]))) +(Rsh64Ux8 x y) -> (ANDQ (SHRQ x y) (SBBQcarrymask (CMPBconst y [64]))) -(Rsh32Ux64 x y) -> (ANDL (SHRL x y) (SBBLcarrymask (CMPQconst [32] y))) -(Rsh32Ux32 x y) -> (ANDL (SHRL x y) (SBBLcarrymask (CMPLconst [32] y))) -(Rsh32Ux16 x y) -> (ANDL (SHRL x y) (SBBLcarrymask (CMPWconst [32] y))) -(Rsh32Ux8 x y) -> (ANDL (SHRL x y) (SBBLcarrymask (CMPBconst [32] y))) +(Rsh32Ux64 x y) -> (ANDL (SHRL x y) (SBBLcarrymask (CMPQconst y [32]))) +(Rsh32Ux32 x y) -> (ANDL (SHRL x y) (SBBLcarrymask (CMPLconst y [32]))) +(Rsh32Ux16 x y) -> (ANDL (SHRL x y) (SBBLcarrymask (CMPWconst y [32]))) +(Rsh32Ux8 x y) -> (ANDL (SHRL x y) (SBBLcarrymask (CMPBconst y [32]))) -(Rsh16Ux64 x y) -> (ANDW (SHRW x y) (SBBLcarrymask (CMPQconst [16] y))) -(Rsh16Ux32 x y) -> (ANDW (SHRW x y) (SBBLcarrymask (CMPLconst [16] y))) -(Rsh16Ux16 x y) -> (ANDW (SHRW x y) (SBBLcarrymask (CMPWconst [16] y))) -(Rsh16Ux8 x y) -> (ANDW (SHRW x y) (SBBLcarrymask (CMPBconst [16] y))) +(Rsh16Ux64 x y) -> (ANDW (SHRW x y) (SBBLcarrymask (CMPQconst y [16]))) +(Rsh16Ux32 x y) -> (ANDW (SHRW x y) (SBBLcarrymask (CMPLconst y [16]))) +(Rsh16Ux16 x y) -> (ANDW (SHRW x y) (SBBLcarrymask (CMPWconst y [16]))) +(Rsh16Ux8 x y) -> (ANDW (SHRW x y) (SBBLcarrymask (CMPBconst y [16]))) -(Rsh8Ux64 x y) -> (ANDB (SHRB x y) (SBBLcarrymask (CMPQconst [8] y))) -(Rsh8Ux32 x y) -> (ANDB (SHRB x y) (SBBLcarrymask (CMPLconst [8] y))) -(Rsh8Ux16 x y) -> (ANDB (SHRB x y) (SBBLcarrymask (CMPWconst [8] y))) -(Rsh8Ux8 x y) -> (ANDB (SHRB x y) (SBBLcarrymask (CMPBconst [8] y))) +(Rsh8Ux64 x y) -> (ANDB (SHRB x y) (SBBLcarrymask (CMPQconst y [8]))) +(Rsh8Ux32 x y) -> (ANDB (SHRB x y) (SBBLcarrymask (CMPLconst y [8]))) +(Rsh8Ux16 x y) -> (ANDB (SHRB x y) (SBBLcarrymask (CMPWconst y [8]))) +(Rsh8Ux8 x y) -> (ANDB (SHRB x y) (SBBLcarrymask (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 x y) -> (SARQ x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst [64] y))))) -(Rsh64x32 x y) -> (SARQ x (ORL y (NOTL (SBBLcarrymask (CMPLconst [64] y))))) -(Rsh64x16 x y) -> (SARQ x (ORW y (NOTL (SBBLcarrymask (CMPWconst [64] y))))) -(Rsh64x8 x y) -> (SARQ x (ORB y (NOTL (SBBLcarrymask (CMPBconst [64] y))))) - -(Rsh32x64 x y) -> (SARL x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst [32] y))))) -(Rsh32x32 x y) -> (SARL x (ORL y (NOTL (SBBLcarrymask (CMPLconst [32] y))))) -(Rsh32x16 x y) -> (SARL x (ORW y (NOTL (SBBLcarrymask (CMPWconst [32] y))))) -(Rsh32x8 x y) -> (SARL x (ORB y (NOTL (SBBLcarrymask (CMPBconst [32] y))))) - -(Rsh16x64 x y) -> (SARW x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst [16] y))))) -(Rsh16x32 x y) -> (SARW x (ORL y (NOTL (SBBLcarrymask (CMPLconst [16] y))))) -(Rsh16x16 x y) -> (SARW x (ORW y (NOTL (SBBLcarrymask (CMPWconst [16] y))))) -(Rsh16x8 x y) -> (SARW x (ORB y (NOTL (SBBLcarrymask (CMPBconst [16] y))))) - -(Rsh8x64 x y) -> (SARB x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst [8] y))))) -(Rsh8x32 x y) -> (SARB x (ORL y (NOTL (SBBLcarrymask (CMPLconst [8] y))))) -(Rsh8x16 x y) -> (SARB x (ORW y (NOTL (SBBLcarrymask (CMPWconst [8] y))))) -(Rsh8x8 x y) -> (SARB x (ORB y (NOTL (SBBLcarrymask (CMPBconst [8] y))))) +(Rsh64x64 x y) -> (SARQ x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst y [64]))))) +(Rsh64x32 x y) -> (SARQ x (ORL y (NOTL (SBBLcarrymask (CMPLconst y [64]))))) +(Rsh64x16 x y) -> (SARQ x (ORW y (NOTL (SBBLcarrymask (CMPWconst y [64]))))) +(Rsh64x8 x y) -> (SARQ x (ORB y (NOTL (SBBLcarrymask (CMPBconst y [64]))))) + +(Rsh32x64 x y) -> (SARL x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst y [32]))))) +(Rsh32x32 x y) -> (SARL x (ORL y (NOTL (SBBLcarrymask (CMPLconst y [32]))))) +(Rsh32x16 x y) -> (SARL x (ORW y (NOTL (SBBLcarrymask (CMPWconst y [32]))))) +(Rsh32x8 x y) -> (SARL x (ORB y (NOTL (SBBLcarrymask (CMPBconst y [32]))))) + +(Rsh16x64 x y) -> (SARW x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst y [16]))))) +(Rsh16x32 x y) -> (SARW x (ORL y (NOTL (SBBLcarrymask (CMPLconst y [16]))))) +(Rsh16x16 x y) -> (SARW x (ORW y (NOTL (SBBLcarrymask (CMPWconst y [16]))))) +(Rsh16x8 x y) -> (SARW x (ORB y (NOTL (SBBLcarrymask (CMPBconst y [16]))))) + +(Rsh8x64 x y) -> (SARB x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst y [8]))))) +(Rsh8x32 x y) -> (SARB x (ORL y (NOTL (SBBLcarrymask (CMPLconst y [8]))))) +(Rsh8x16 x y) -> (SARB x (ORW y (NOTL (SBBLcarrymask (CMPWconst y [8]))))) +(Rsh8x8 x y) -> (SARB x (ORB y (NOTL (SBBLcarrymask (CMPBconst y [8]))))) (Less64 x y) -> (SETL (CMPQ x y)) (Less32 x y) -> (SETL (CMPL x y)) @@ -700,23 +700,168 @@ (EQ (InvertFlags cmp) yes no) -> (EQ cmp yes no) (NE (InvertFlags cmp) yes no) -> (NE cmp yes no) -// get rid of overflow code for constant shifts -(SBBQcarrymask (CMPQconst [c] (MOVQconst [d]))) && inBounds64(d, c) -> (MOVQconst [-1]) -(SBBQcarrymask (CMPQconst [c] (MOVQconst [d]))) && !inBounds64(d, c) -> (MOVQconst [0]) -(SBBQcarrymask (CMPLconst [c] (MOVLconst [d]))) && inBounds32(d, c) -> (MOVQconst [-1]) -(SBBQcarrymask (CMPLconst [c] (MOVLconst [d]))) && !inBounds32(d, c) -> (MOVQconst [0]) -(SBBQcarrymask (CMPWconst [c] (MOVWconst [d]))) && inBounds16(d, c) -> (MOVQconst [-1]) -(SBBQcarrymask (CMPWconst [c] (MOVWconst [d]))) && !inBounds16(d, c) -> (MOVQconst [0]) -(SBBQcarrymask (CMPBconst [c] (MOVBconst [d]))) && inBounds8(d, c) -> (MOVQconst [-1]) -(SBBQcarrymask (CMPBconst [c] (MOVBconst [d]))) && !inBounds8(d, c) -> (MOVQconst [0]) -(SBBLcarrymask (CMPQconst [c] (MOVQconst [d]))) && inBounds64(d, c) -> (MOVLconst [-1]) -(SBBLcarrymask (CMPQconst [c] (MOVQconst [d]))) && !inBounds64(d, c) -> (MOVLconst [0]) -(SBBLcarrymask (CMPLconst [c] (MOVLconst [d]))) && inBounds32(d, c) -> (MOVLconst [-1]) -(SBBLcarrymask (CMPLconst [c] (MOVLconst [d]))) && !inBounds32(d, c) -> (MOVLconst [0]) -(SBBLcarrymask (CMPWconst [c] (MOVWconst [d]))) && inBounds16(d, c) -> (MOVLconst [-1]) -(SBBLcarrymask (CMPWconst [c] (MOVWconst [d]))) && !inBounds16(d, c) -> (MOVLconst [0]) -(SBBLcarrymask (CMPBconst [c] (MOVBconst [d]))) && inBounds8(d, c) -> (MOVLconst [-1]) -(SBBLcarrymask (CMPBconst [c] (MOVBconst [d]))) && !inBounds8(d, c) -> (MOVLconst [0]) +// Constant comparisons. +(CMPQconst (MOVQconst [x]) [y]) && x==y -> (FlagEQ) +(CMPQconst (MOVQconst [x]) [y]) && x (FlagLT_ULT) +(CMPQconst (MOVQconst [x]) [y]) && xuint64(y) -> (FlagLT_UGT) +(CMPQconst (MOVQconst [x]) [y]) && x>y && uint64(x) (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) (FlagLT_ULT) +(CMPLconst (MOVLconst [x]) [y]) && int32(x)uint32(y) -> (FlagLT_UGT) +(CMPLconst (MOVLconst [x]) [y]) && int32(x)>int32(y) && uint32(x) (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) (FlagLT_ULT) +(CMPWconst (MOVWconst [x]) [y]) && int16(x)uint16(y) -> (FlagLT_UGT) +(CMPWconst (MOVWconst [x]) [y]) && int16(x)>int16(y) && uint16(x) (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) (FlagLT_ULT) +(CMPBconst (MOVBconst [x]) [y]) && int8(x)uint8(y) -> (FlagLT_UGT) +(CMPBconst (MOVBconst [x]) [y]) && int8(x)>int8(y) && uint8(x) (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 diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 461026bd7b..daee7336b0 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -472,6 +472,19 @@ func init() { // gets correctly ordered with respect to GC safepoints. // arg0=ptr/int arg1=mem, output=int/ptr {name: "MOVQconvert", 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{ diff --git a/src/cmd/compile/internal/ssa/lower.go b/src/cmd/compile/internal/ssa/lower.go index bf3c15f78b..1b50eb642b 100644 --- a/src/cmd/compile/internal/ssa/lower.go +++ b/src/cmd/compile/internal/ssa/lower.go @@ -21,7 +21,7 @@ func checkLower(f *Func) { continue // lowered } switch v.Op { - case OpSP, OpSB, OpInitMem, OpArg, OpCopy, OpPhi, OpVarDef, OpVarKill: + case OpSP, OpSB, OpInitMem, OpArg, OpPhi, OpVarDef, OpVarKill: continue // ok not to lower } s := "not lowered: " + v.Op.String() + " " + v.Type.SimpleString() diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index bbedf2fb64..2fd7f6b7a4 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -283,6 +283,11 @@ const ( OpAMD64LoweredGetClosurePtr OpAMD64LoweredNilCheck OpAMD64MOVQconvert + OpAMD64FlagEQ + OpAMD64FlagLT_ULT + OpAMD64FlagLT_UGT + OpAMD64FlagGT_UGT + OpAMD64FlagGT_ULT OpAdd8 OpAdd16 @@ -3232,6 +3237,26 @@ var opcodeTable = [...]opInfo{ }, }, }, + { + name: "FlagEQ", + reg: regInfo{}, + }, + { + name: "FlagLT_ULT", + reg: regInfo{}, + }, + { + name: "FlagLT_UGT", + reg: regInfo{}, + }, + { + name: "FlagGT_UGT", + reg: regInfo{}, + }, + { + name: "FlagGT_ULT", + reg: regInfo{}, + }, { name: "Add8", diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 5c2f3db4b2..3d682f0040 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -65,12 +65,20 @@ func rewriteValueAMD64(v *Value, config *Config) bool { return rewriteValueAMD64_OpAnd8(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: @@ -2167,6 +2175,137 @@ end25ab646f9eb8749ea58c8fbbb4bf6bcd: ; 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) + { + if v.Args[0].Op != OpAMD64MOVBconst { + goto end1be300bd80b7d8cd0fa37e1907c75a77 + } + x := v.Args[0].AuxInt + y := v.AuxInt + if !(int8(x) == int8(y)) { + goto end1be300bd80b7d8cd0fa37e1907c75a77 + } + v.Op = OpAMD64FlagEQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + return true + } + goto end1be300bd80b7d8cd0fa37e1907c75a77 +end1be300bd80b7d8cd0fa37e1907c75a77: + ; + // match: (CMPBconst (MOVBconst [x]) [y]) + // cond: int8(x)uint8(y) + // result: (FlagLT_UGT) + { + if v.Args[0].Op != OpAMD64MOVBconst { + goto endbfa2ca974f69ec9ceb8a24ad6db45efb + } + x := v.Args[0].AuxInt + y := v.AuxInt + if !(int8(x) < int8(y) && uint8(x) > uint8(y)) { + goto endbfa2ca974f69ec9ceb8a24ad6db45efb + } + v.Op = OpAMD64FlagLT_UGT + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + return true + } + goto endbfa2ca974f69ec9ceb8a24ad6db45efb +endbfa2ca974f69ec9ceb8a24ad6db45efb: + ; + // match: (CMPBconst (MOVBconst [x]) [y]) + // cond: int8(x)>int8(y) && uint8(x) int8(y) && uint8(x) < uint8(y)) { + goto end68ac2e7dcb3704e235e1c292669320ed + } + v.Op = OpAMD64FlagGT_ULT + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + return true + } + goto end68ac2e7dcb3704e235e1c292669320ed +end68ac2e7dcb3704e235e1c292669320ed: + ; + // match: (CMPBconst (MOVBconst [x]) [y]) + // cond: int8(x)>int8(y) && uint8(x)>uint8(y) + // result: (FlagGT_UGT) + { + if v.Args[0].Op != OpAMD64MOVBconst { + goto endac1c49c82fb6b76dd324042c4588973c + } + x := v.Args[0].AuxInt + y := v.AuxInt + if !(int8(x) > int8(y) && uint8(x) > uint8(y)) { + goto endac1c49c82fb6b76dd324042c4588973c + } + v.Op = OpAMD64FlagGT_UGT + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + return true + } + goto endac1c49c82fb6b76dd324042c4588973c +endac1c49c82fb6b76dd324042c4588973c: + ; + // match: (CMPBconst (ANDBconst _ [m]) [n]) + // cond: int8(m)+1==int8(n) && isPowerOfTwo(int64(int8(n))) + // result: (FlagLT_ULT) + { + if v.Args[0].Op != OpAMD64ANDBconst { + goto end82aa9d89330cb5dc58592048bfc16ebc + } + m := v.Args[0].AuxInt + n := v.AuxInt + if !(int8(m)+1 == int8(n) && isPowerOfTwo(int64(int8(n)))) { + goto end82aa9d89330cb5dc58592048bfc16ebc + } + v.Op = OpAMD64FlagLT_ULT + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + return true + } + goto end82aa9d89330cb5dc58592048bfc16ebc +end82aa9d89330cb5dc58592048bfc16ebc: + ; + return false +} func rewriteValueAMD64_OpAMD64CMPL(v *Value, config *Config) bool { b := v.Block _ = b @@ -2215,6 +2354,137 @@ end7d89230086678ab4ed5cc96a3ae358d6: ; 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) + { + if v.Args[0].Op != OpAMD64MOVLconst { + goto end7c53f3fc20f710e60f327bf63b4c8d4e + } + x := v.Args[0].AuxInt + y := v.AuxInt + if !(int32(x) == int32(y)) { + goto end7c53f3fc20f710e60f327bf63b4c8d4e + } + v.Op = OpAMD64FlagEQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + return true + } + goto end7c53f3fc20f710e60f327bf63b4c8d4e +end7c53f3fc20f710e60f327bf63b4c8d4e: + ; + // match: (CMPLconst (MOVLconst [x]) [y]) + // cond: int32(x)uint32(y) + // result: (FlagLT_UGT) + { + if v.Args[0].Op != OpAMD64MOVLconst { + goto end66603988bfeb71e410328b40425c3418 + } + x := v.Args[0].AuxInt + y := v.AuxInt + if !(int32(x) < int32(y) && uint32(x) > uint32(y)) { + goto end66603988bfeb71e410328b40425c3418 + } + v.Op = OpAMD64FlagLT_UGT + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + return true + } + goto end66603988bfeb71e410328b40425c3418 +end66603988bfeb71e410328b40425c3418: + ; + // match: (CMPLconst (MOVLconst [x]) [y]) + // cond: int32(x)>int32(y) && uint32(x) int32(y) && uint32(x) < uint32(y)) { + goto endb1b0b14302e765637328dade12e1ce87 + } + v.Op = OpAMD64FlagGT_ULT + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + return true + } + goto endb1b0b14302e765637328dade12e1ce87 +endb1b0b14302e765637328dade12e1ce87: + ; + // match: (CMPLconst (MOVLconst [x]) [y]) + // cond: int32(x)>int32(y) && uint32(x)>uint32(y) + // result: (FlagGT_UGT) + { + if v.Args[0].Op != OpAMD64MOVLconst { + goto endc7b8e86e537d6e106e237023dc2c9a7b + } + x := v.Args[0].AuxInt + y := v.AuxInt + if !(int32(x) > int32(y) && uint32(x) > uint32(y)) { + goto endc7b8e86e537d6e106e237023dc2c9a7b + } + v.Op = OpAMD64FlagGT_UGT + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + return true + } + goto endc7b8e86e537d6e106e237023dc2c9a7b +endc7b8e86e537d6e106e237023dc2c9a7b: + ; + // match: (CMPLconst (ANDLconst _ [m]) [n]) + // cond: int32(m)+1==int32(n) && isPowerOfTwo(int64(int32(n))) + // result: (FlagLT_ULT) + { + if v.Args[0].Op != OpAMD64ANDLconst { + goto endf202b9830a1e45f3888f2598c762c702 + } + m := v.Args[0].AuxInt + n := v.AuxInt + if !(int32(m)+1 == int32(n) && isPowerOfTwo(int64(int32(n)))) { + goto endf202b9830a1e45f3888f2598c762c702 + } + v.Op = OpAMD64FlagLT_ULT + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + return true + } + goto endf202b9830a1e45f3888f2598c762c702 +endf202b9830a1e45f3888f2598c762c702: + ; + return false +} func rewriteValueAMD64_OpAMD64CMPQ(v *Value, config *Config) bool { b := v.Block _ = b @@ -2269,6 +2539,137 @@ end153e951c4d9890ee40bf6f189ff6280e: ; return false } +func rewriteValueAMD64_OpAMD64CMPQconst(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (CMPQconst (MOVQconst [x]) [y]) + // cond: x==y + // result: (FlagEQ) + { + if v.Args[0].Op != OpAMD64MOVQconst { + goto enda7a434ec055a51246d67ff14b48e455d + } + x := v.Args[0].AuxInt + y := v.AuxInt + if !(x == y) { + goto enda7a434ec055a51246d67ff14b48e455d + } + v.Op = OpAMD64FlagEQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + return true + } + goto enda7a434ec055a51246d67ff14b48e455d +enda7a434ec055a51246d67ff14b48e455d: + ; + // match: (CMPQconst (MOVQconst [x]) [y]) + // cond: xuint64(y) + // result: (FlagLT_UGT) + { + if v.Args[0].Op != OpAMD64MOVQconst { + goto end38a2207ac4547f3f0cfb2bc48748e033 + } + x := v.Args[0].AuxInt + y := v.AuxInt + if !(x < y && uint64(x) > uint64(y)) { + goto end38a2207ac4547f3f0cfb2bc48748e033 + } + v.Op = OpAMD64FlagLT_UGT + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + return true + } + goto end38a2207ac4547f3f0cfb2bc48748e033 +end38a2207ac4547f3f0cfb2bc48748e033: + ; + // match: (CMPQconst (MOVQconst [x]) [y]) + // cond: x>y && uint64(x) y && uint64(x) < uint64(y)) { + goto end0adaa13f82a881b97095d7a210b96f3c + } + v.Op = OpAMD64FlagGT_ULT + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + return true + } + goto end0adaa13f82a881b97095d7a210b96f3c +end0adaa13f82a881b97095d7a210b96f3c: + ; + // match: (CMPQconst (MOVQconst [x]) [y]) + // cond: x>y && uint64(x)>uint64(y) + // result: (FlagGT_UGT) + { + if v.Args[0].Op != OpAMD64MOVQconst { + goto end1248b87e4a141c78bc8eff05d3fac70e + } + x := v.Args[0].AuxInt + y := v.AuxInt + if !(x > y && uint64(x) > uint64(y)) { + goto end1248b87e4a141c78bc8eff05d3fac70e + } + v.Op = OpAMD64FlagGT_UGT + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + return true + } + goto end1248b87e4a141c78bc8eff05d3fac70e +end1248b87e4a141c78bc8eff05d3fac70e: + ; + // match: (CMPQconst (ANDQconst _ [m]) [n]) + // cond: m+1==n && isPowerOfTwo(n) + // result: (FlagLT_ULT) + { + if v.Args[0].Op != OpAMD64ANDQconst { + goto end934098fb12e383829b654938269abc12 + } + m := v.Args[0].AuxInt + n := v.AuxInt + if !(m+1 == n && isPowerOfTwo(n)) { + goto end934098fb12e383829b654938269abc12 + } + v.Op = OpAMD64FlagLT_ULT + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + return true + } + goto end934098fb12e383829b654938269abc12 +end934098fb12e383829b654938269abc12: + ; + return false +} func rewriteValueAMD64_OpAMD64CMPW(v *Value, config *Config) bool { b := v.Block _ = b @@ -2317,6 +2718,137 @@ end3c52d0ae6e3d186bf131b41276c21889: ; 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) + { + if v.Args[0].Op != OpAMD64MOVWconst { + goto endff7e81d2095a9997513cae77cd245b43 + } + x := v.Args[0].AuxInt + y := v.AuxInt + if !(int16(x) == int16(y)) { + goto endff7e81d2095a9997513cae77cd245b43 + } + v.Op = OpAMD64FlagEQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + return true + } + goto endff7e81d2095a9997513cae77cd245b43 +endff7e81d2095a9997513cae77cd245b43: + ; + // match: (CMPWconst (MOVWconst [x]) [y]) + // cond: int16(x)uint16(y) + // result: (FlagLT_UGT) + { + if v.Args[0].Op != OpAMD64MOVWconst { + goto ended901a2a49e592c431e45ffc17ca213d + } + x := v.Args[0].AuxInt + y := v.AuxInt + if !(int16(x) < int16(y) && uint16(x) > uint16(y)) { + goto ended901a2a49e592c431e45ffc17ca213d + } + v.Op = OpAMD64FlagLT_UGT + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + return true + } + goto ended901a2a49e592c431e45ffc17ca213d +ended901a2a49e592c431e45ffc17ca213d: + ; + // match: (CMPWconst (MOVWconst [x]) [y]) + // cond: int16(x)>int16(y) && uint16(x) int16(y) && uint16(x) < uint16(y)) { + goto end66b1d55596a00cdc04ad83bfdeb6be8b + } + v.Op = OpAMD64FlagGT_ULT + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + return true + } + goto end66b1d55596a00cdc04ad83bfdeb6be8b +end66b1d55596a00cdc04ad83bfdeb6be8b: + ; + // match: (CMPWconst (MOVWconst [x]) [y]) + // cond: int16(x)>int16(y) && uint16(x)>uint16(y) + // result: (FlagGT_UGT) + { + if v.Args[0].Op != OpAMD64MOVWconst { + goto end4493f5af38d242ebb4bc2f64055a0854 + } + x := v.Args[0].AuxInt + y := v.AuxInt + if !(int16(x) > int16(y) && uint16(x) > uint16(y)) { + goto end4493f5af38d242ebb4bc2f64055a0854 + } + v.Op = OpAMD64FlagGT_UGT + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + return true + } + goto end4493f5af38d242ebb4bc2f64055a0854 +end4493f5af38d242ebb4bc2f64055a0854: + ; + // match: (CMPWconst (ANDWconst _ [m]) [n]) + // cond: int16(m)+1==int16(n) && isPowerOfTwo(int64(int16(n))) + // result: (FlagLT_ULT) + { + if v.Args[0].Op != OpAMD64ANDWconst { + goto endfcea07d93ded49b0e02d5fa0059309a4 + } + m := v.Args[0].AuxInt + n := v.AuxInt + if !(int16(m)+1 == int16(n) && isPowerOfTwo(int64(int16(n)))) { + goto endfcea07d93ded49b0e02d5fa0059309a4 + } + v.Op = OpAMD64FlagLT_ULT + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + return true + } + goto endfcea07d93ded49b0e02d5fa0059309a4 +endfcea07d93ded49b0e02d5fa0059309a4: + ; + return false +} func rewriteValueAMD64_OpClosureCall(v *Value, config *Config) bool { b := v.Block _ = b @@ -4782,7 +5314,7 @@ func rewriteValueAMD64_OpLsh16x16(v *Value, config *Config) bool { _ = b // match: (Lsh16x16 x y) // cond: - // result: (ANDW (SHLW x y) (SBBLcarrymask (CMPWconst [16] y))) + // result: (ANDW (SHLW x y) (SBBLcarrymask (CMPWconst y [16]))) { t := v.Type x := v.Args[0] @@ -4799,15 +5331,15 @@ func rewriteValueAMD64_OpLsh16x16(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) - v2.AuxInt = 16 v2.AddArg(y) + v2.AuxInt = 16 v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end7ffc4f31c526f7fcb2283215b458f589 -end7ffc4f31c526f7fcb2283215b458f589: + goto ende1a6e1781dd669bd74d66fc34c97218f +ende1a6e1781dd669bd74d66fc34c97218f: ; return false } @@ -4816,7 +5348,7 @@ func rewriteValueAMD64_OpLsh16x32(v *Value, config *Config) bool { _ = b // match: (Lsh16x32 x y) // cond: - // result: (ANDW (SHLW x y) (SBBLcarrymask (CMPLconst [16] y))) + // result: (ANDW (SHLW x y) (SBBLcarrymask (CMPLconst y [16]))) { t := v.Type x := v.Args[0] @@ -4833,15 +5365,15 @@ func rewriteValueAMD64_OpLsh16x32(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) - v2.AuxInt = 16 v2.AddArg(y) + v2.AuxInt = 16 v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto enddcc0e751d315967423c99518c0cc065e -enddcc0e751d315967423c99518c0cc065e: + goto end711e661a5b6682f98e7993c2dfa72f45 +end711e661a5b6682f98e7993c2dfa72f45: ; return false } @@ -4850,7 +5382,7 @@ func rewriteValueAMD64_OpLsh16x64(v *Value, config *Config) bool { _ = b // match: (Lsh16x64 x y) // cond: - // result: (ANDW (SHLW x y) (SBBLcarrymask (CMPQconst [16] y))) + // result: (ANDW (SHLW x y) (SBBLcarrymask (CMPQconst y [16]))) { t := v.Type x := v.Args[0] @@ -4867,15 +5399,15 @@ func rewriteValueAMD64_OpLsh16x64(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) - v2.AuxInt = 16 v2.AddArg(y) + v2.AuxInt = 16 v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto endf6368b59d046ca83050cd75fbe8715d2 -endf6368b59d046ca83050cd75fbe8715d2: + goto end4800d2b7d4f0e5acafcdf4e765941570 +end4800d2b7d4f0e5acafcdf4e765941570: ; return false } @@ -4884,7 +5416,7 @@ func rewriteValueAMD64_OpLsh16x8(v *Value, config *Config) bool { _ = b // match: (Lsh16x8 x y) // cond: - // result: (ANDW (SHLW x y) (SBBLcarrymask (CMPBconst [16] y))) + // result: (ANDW (SHLW x y) (SBBLcarrymask (CMPBconst y [16]))) { t := v.Type x := v.Args[0] @@ -4901,15 +5433,15 @@ func rewriteValueAMD64_OpLsh16x8(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) - v2.AuxInt = 16 v2.AddArg(y) + v2.AuxInt = 16 v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end8730d944c8fb358001ba2d165755bdc4 -end8730d944c8fb358001ba2d165755bdc4: + goto endbe15f4a70f6c490f30f12a5db0f24ec4 +endbe15f4a70f6c490f30f12a5db0f24ec4: ; return false } @@ -4918,7 +5450,7 @@ func rewriteValueAMD64_OpLsh32x16(v *Value, config *Config) bool { _ = b // match: (Lsh32x16 x y) // cond: - // result: (ANDL (SHLL x y) (SBBLcarrymask (CMPWconst [32] y))) + // result: (ANDL (SHLL x y) (SBBLcarrymask (CMPWconst y [32]))) { t := v.Type x := v.Args[0] @@ -4935,15 +5467,15 @@ func rewriteValueAMD64_OpLsh32x16(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) - v2.AuxInt = 32 v2.AddArg(y) + v2.AuxInt = 32 v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end5a43b7e9b0780e62f622bac0a68524d2 -end5a43b7e9b0780e62f622bac0a68524d2: + goto end6e9dfb6e850fc86393b2f6b1d509287f +end6e9dfb6e850fc86393b2f6b1d509287f: ; return false } @@ -4952,7 +5484,7 @@ func rewriteValueAMD64_OpLsh32x32(v *Value, config *Config) bool { _ = b // match: (Lsh32x32 x y) // cond: - // result: (ANDL (SHLL x y) (SBBLcarrymask (CMPLconst [32] y))) + // result: (ANDL (SHLL x y) (SBBLcarrymask (CMPLconst y [32]))) { t := v.Type x := v.Args[0] @@ -4969,15 +5501,15 @@ func rewriteValueAMD64_OpLsh32x32(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) - v2.AuxInt = 32 v2.AddArg(y) + v2.AuxInt = 32 v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end9ce0ab6f9095c24ea46ca8fe2d7e5507 -end9ce0ab6f9095c24ea46ca8fe2d7e5507: + goto end9a4d057653a8fdad133aaf4a6b4f2b74 +end9a4d057653a8fdad133aaf4a6b4f2b74: ; return false } @@ -4986,7 +5518,7 @@ func rewriteValueAMD64_OpLsh32x64(v *Value, config *Config) bool { _ = b // match: (Lsh32x64 x y) // cond: - // result: (ANDL (SHLL x y) (SBBLcarrymask (CMPQconst [32] y))) + // result: (ANDL (SHLL x y) (SBBLcarrymask (CMPQconst y [32]))) { t := v.Type x := v.Args[0] @@ -5003,15 +5535,15 @@ func rewriteValueAMD64_OpLsh32x64(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) - v2.AuxInt = 32 v2.AddArg(y) + v2.AuxInt = 32 v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end646b5471b709d5ea6c21f49a2815236f -end646b5471b709d5ea6c21f49a2815236f: + goto endae1486be93eb21ebac539419b5a109cb +endae1486be93eb21ebac539419b5a109cb: ; return false } @@ -5020,7 +5552,7 @@ func rewriteValueAMD64_OpLsh32x8(v *Value, config *Config) bool { _ = b // match: (Lsh32x8 x y) // cond: - // result: (ANDL (SHLL x y) (SBBLcarrymask (CMPBconst [32] y))) + // result: (ANDL (SHLL x y) (SBBLcarrymask (CMPBconst y [32]))) { t := v.Type x := v.Args[0] @@ -5037,15 +5569,15 @@ func rewriteValueAMD64_OpLsh32x8(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) - v2.AuxInt = 32 v2.AddArg(y) + v2.AuxInt = 32 v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end96a677c71370e7c9179125f92cbdfda8 -end96a677c71370e7c9179125f92cbdfda8: + goto endede3d7bbbb6e7ac26b598b75409703f5 +endede3d7bbbb6e7ac26b598b75409703f5: ; return false } @@ -5054,7 +5586,7 @@ func rewriteValueAMD64_OpLsh64x16(v *Value, config *Config) bool { _ = b // match: (Lsh64x16 x y) // cond: - // result: (ANDQ (SHLQ x y) (SBBQcarrymask (CMPWconst [64] y))) + // result: (ANDQ (SHLQ x y) (SBBQcarrymask (CMPWconst y [64]))) { t := v.Type x := v.Args[0] @@ -5071,15 +5603,15 @@ func rewriteValueAMD64_OpLsh64x16(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) - v2.AuxInt = 64 v2.AddArg(y) + v2.AuxInt = 64 v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end5f88f241d68d38954222d81559cd7f9f -end5f88f241d68d38954222d81559cd7f9f: + goto end4dc49d47e1079e618e480ee95c20df6d +end4dc49d47e1079e618e480ee95c20df6d: ; return false } @@ -5088,7 +5620,7 @@ func rewriteValueAMD64_OpLsh64x32(v *Value, config *Config) bool { _ = b // match: (Lsh64x32 x y) // cond: - // result: (ANDQ (SHLQ x y) (SBBQcarrymask (CMPLconst [64] y))) + // result: (ANDQ (SHLQ x y) (SBBQcarrymask (CMPLconst y [64]))) { t := v.Type x := v.Args[0] @@ -5105,15 +5637,15 @@ func rewriteValueAMD64_OpLsh64x32(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) - v2.AuxInt = 64 v2.AddArg(y) + v2.AuxInt = 64 v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto endae1705f03ed3d6f43cd63b53496a910a -endae1705f03ed3d6f43cd63b53496a910a: + goto end52a5e8c44a38fe265cf0619081d1723b +end52a5e8c44a38fe265cf0619081d1723b: ; return false } @@ -5122,7 +5654,7 @@ func rewriteValueAMD64_OpLsh64x64(v *Value, config *Config) bool { _ = b // match: (Lsh64x64 x y) // cond: - // result: (ANDQ (SHLQ x y) (SBBQcarrymask (CMPQconst [64] y))) + // result: (ANDQ (SHLQ x y) (SBBQcarrymask (CMPQconst y [64]))) { t := v.Type x := v.Args[0] @@ -5139,15 +5671,15 @@ func rewriteValueAMD64_OpLsh64x64(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) - v2.AuxInt = 64 v2.AddArg(y) + v2.AuxInt = 64 v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end1f6f5f510c5c68e4ce4a78643e6d85a1 -end1f6f5f510c5c68e4ce4a78643e6d85a1: + goto enda2931f1f1a64c3e0251febeb894666b0 +enda2931f1f1a64c3e0251febeb894666b0: ; return false } @@ -5156,7 +5688,7 @@ func rewriteValueAMD64_OpLsh64x8(v *Value, config *Config) bool { _ = b // match: (Lsh64x8 x y) // cond: - // result: (ANDQ (SHLQ x y) (SBBQcarrymask (CMPBconst [64] y))) + // result: (ANDQ (SHLQ x y) (SBBQcarrymask (CMPBconst y [64]))) { t := v.Type x := v.Args[0] @@ -5173,15 +5705,15 @@ func rewriteValueAMD64_OpLsh64x8(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) - v2.AuxInt = 64 v2.AddArg(y) + v2.AuxInt = 64 v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto endd14f5c89e3496b0e425aa1ae366f4b53 -endd14f5c89e3496b0e425aa1ae366f4b53: + goto end8535fcd7c1fc28bbc53844b29ffbdb22 +end8535fcd7c1fc28bbc53844b29ffbdb22: ; return false } @@ -5190,7 +5722,7 @@ func rewriteValueAMD64_OpLsh8x16(v *Value, config *Config) bool { _ = b // match: (Lsh8x16 x y) // cond: - // result: (ANDB (SHLB x y) (SBBLcarrymask (CMPWconst [8] y))) + // result: (ANDB (SHLB x y) (SBBLcarrymask (CMPWconst y [8]))) { t := v.Type x := v.Args[0] @@ -5207,15 +5739,15 @@ func rewriteValueAMD64_OpLsh8x16(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) - v2.AuxInt = 8 v2.AddArg(y) + v2.AuxInt = 8 v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end0926c3d8b9a0776ba5058946f6e1a4b7 -end0926c3d8b9a0776ba5058946f6e1a4b7: + goto endc4b0328ed4d6943ac1af3662b93ad8e2 +endc4b0328ed4d6943ac1af3662b93ad8e2: ; return false } @@ -5224,7 +5756,7 @@ func rewriteValueAMD64_OpLsh8x32(v *Value, config *Config) bool { _ = b // match: (Lsh8x32 x y) // cond: - // result: (ANDB (SHLB x y) (SBBLcarrymask (CMPLconst [8] y))) + // result: (ANDB (SHLB x y) (SBBLcarrymask (CMPLconst y [8]))) { t := v.Type x := v.Args[0] @@ -5241,15 +5773,15 @@ func rewriteValueAMD64_OpLsh8x32(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) - v2.AuxInt = 8 v2.AddArg(y) + v2.AuxInt = 8 v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end5987682d77f197ef0fd95251f413535a -end5987682d77f197ef0fd95251f413535a: + goto end1e6cfcdb7439ccc73f4f59874f3559b2 +end1e6cfcdb7439ccc73f4f59874f3559b2: ; return false } @@ -5258,7 +5790,7 @@ func rewriteValueAMD64_OpLsh8x64(v *Value, config *Config) bool { _ = b // match: (Lsh8x64 x y) // cond: - // result: (ANDB (SHLB x y) (SBBLcarrymask (CMPQconst [8] y))) + // result: (ANDB (SHLB x y) (SBBLcarrymask (CMPQconst y [8]))) { t := v.Type x := v.Args[0] @@ -5275,15 +5807,15 @@ func rewriteValueAMD64_OpLsh8x64(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) - v2.AuxInt = 8 v2.AddArg(y) + v2.AuxInt = 8 v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end9ffe6731d7d6514b8c0482f1645eee18 -end9ffe6731d7d6514b8c0482f1645eee18: + goto endf3ea2e740c7fd7ea2caa24357b0bf798 +endf3ea2e740c7fd7ea2caa24357b0bf798: ; return false } @@ -5292,7 +5824,7 @@ func rewriteValueAMD64_OpLsh8x8(v *Value, config *Config) bool { _ = b // match: (Lsh8x8 x y) // cond: - // result: (ANDB (SHLB x y) (SBBLcarrymask (CMPBconst [8] y))) + // result: (ANDB (SHLB x y) (SBBLcarrymask (CMPBconst y [8]))) { t := v.Type x := v.Args[0] @@ -5309,15 +5841,15 @@ func rewriteValueAMD64_OpLsh8x8(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) - v2.AuxInt = 8 v2.AddArg(y) + v2.AuxInt = 8 v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end2b75242a31c3713ffbfdd8f0288b1c12 -end2b75242a31c3713ffbfdd8f0288b1c12: + goto end5d557e41670b7ac83d122eeb4029363d +end5d557e41670b7ac83d122eeb4029363d: ; return false } @@ -9516,7 +10048,7 @@ func rewriteValueAMD64_OpRsh16Ux16(v *Value, config *Config) bool { _ = b // match: (Rsh16Ux16 x y) // cond: - // result: (ANDW (SHRW x y) (SBBLcarrymask (CMPWconst [16] y))) + // result: (ANDW (SHRW x y) (SBBLcarrymask (CMPWconst y [16]))) { t := v.Type x := v.Args[0] @@ -9533,15 +10065,15 @@ func rewriteValueAMD64_OpRsh16Ux16(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) - v2.AuxInt = 16 v2.AddArg(y) + v2.AuxInt = 16 v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end4d5e000764dcea396f2d86472c2af6eb -end4d5e000764dcea396f2d86472c2af6eb: + goto end291acf0117b46a676e5e1fe524459800 +end291acf0117b46a676e5e1fe524459800: ; return false } @@ -9550,7 +10082,7 @@ func rewriteValueAMD64_OpRsh16Ux32(v *Value, config *Config) bool { _ = b // match: (Rsh16Ux32 x y) // cond: - // result: (ANDW (SHRW x y) (SBBLcarrymask (CMPLconst [16] y))) + // result: (ANDW (SHRW x y) (SBBLcarrymask (CMPLconst y [16]))) { t := v.Type x := v.Args[0] @@ -9567,15 +10099,15 @@ func rewriteValueAMD64_OpRsh16Ux32(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) - v2.AuxInt = 16 v2.AddArg(y) + v2.AuxInt = 16 v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end9ef4fe2ea4565865cd4b3aa9c7596c00 -end9ef4fe2ea4565865cd4b3aa9c7596c00: + goto endea051fe538151b144cd630ce63d35bf7 +endea051fe538151b144cd630ce63d35bf7: ; return false } @@ -9584,7 +10116,7 @@ func rewriteValueAMD64_OpRsh16Ux64(v *Value, config *Config) bool { _ = b // match: (Rsh16Ux64 x y) // cond: - // result: (ANDW (SHRW x y) (SBBLcarrymask (CMPQconst [16] y))) + // result: (ANDW (SHRW x y) (SBBLcarrymask (CMPQconst y [16]))) { t := v.Type x := v.Args[0] @@ -9601,15 +10133,15 @@ func rewriteValueAMD64_OpRsh16Ux64(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) - v2.AuxInt = 16 v2.AddArg(y) + v2.AuxInt = 16 v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end48bc94b9a68aad454eaabc42b2e1d646 -end48bc94b9a68aad454eaabc42b2e1d646: + goto endd1a8f3aa91391fbd13c2dcd03a75283a +endd1a8f3aa91391fbd13c2dcd03a75283a: ; return false } @@ -9618,7 +10150,7 @@ func rewriteValueAMD64_OpRsh16Ux8(v *Value, config *Config) bool { _ = b // match: (Rsh16Ux8 x y) // cond: - // result: (ANDW (SHRW x y) (SBBLcarrymask (CMPBconst [16] y))) + // result: (ANDW (SHRW x y) (SBBLcarrymask (CMPBconst y [16]))) { t := v.Type x := v.Args[0] @@ -9635,15 +10167,15 @@ func rewriteValueAMD64_OpRsh16Ux8(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) - v2.AuxInt = 16 v2.AddArg(y) + v2.AuxInt = 16 v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto ende98f618fa53b1f1d5d3f79781d5cb2cc -ende98f618fa53b1f1d5d3f79781d5cb2cc: + goto end9de32652fceccadca5a6206066bcbb10 +end9de32652fceccadca5a6206066bcbb10: ; return false } @@ -9652,7 +10184,7 @@ func rewriteValueAMD64_OpRsh16x16(v *Value, config *Config) bool { _ = b // match: (Rsh16x16 x y) // cond: - // result: (SARW x (ORW y (NOTL (SBBLcarrymask (CMPWconst [16] y))))) + // result: (SARW x (ORW y (NOTL (SBBLcarrymask (CMPWconst y [16]))))) { t := v.Type x := v.Args[0] @@ -9671,8 +10203,8 @@ func rewriteValueAMD64_OpRsh16x16(v *Value, config *Config) bool { v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v2.Type = y.Type v3 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) - v3.AuxInt = 16 v3.AddArg(y) + v3.AuxInt = 16 v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) @@ -9680,8 +10212,8 @@ func rewriteValueAMD64_OpRsh16x16(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end1de548dcf8d7c7222c7a739809597526 -end1de548dcf8d7c7222c7a739809597526: + goto end71e3cf43426d4351f7fac15145ca6cd9 +end71e3cf43426d4351f7fac15145ca6cd9: ; return false } @@ -9690,7 +10222,7 @@ func rewriteValueAMD64_OpRsh16x32(v *Value, config *Config) bool { _ = b // match: (Rsh16x32 x y) // cond: - // result: (SARW x (ORL y (NOTL (SBBLcarrymask (CMPLconst [16] y))))) + // result: (SARW x (ORL y (NOTL (SBBLcarrymask (CMPLconst y [16]))))) { t := v.Type x := v.Args[0] @@ -9709,8 +10241,8 @@ func rewriteValueAMD64_OpRsh16x32(v *Value, config *Config) bool { v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v2.Type = y.Type v3 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) - v3.AuxInt = 16 v3.AddArg(y) + v3.AuxInt = 16 v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) @@ -9718,8 +10250,8 @@ func rewriteValueAMD64_OpRsh16x32(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end74419e1036ea7e0c3a09d05b1eabad22 -end74419e1036ea7e0c3a09d05b1eabad22: + goto endfc3bf56711046c6b29b676b155af7c98 +endfc3bf56711046c6b29b676b155af7c98: ; return false } @@ -9728,7 +10260,7 @@ func rewriteValueAMD64_OpRsh16x64(v *Value, config *Config) bool { _ = b // match: (Rsh16x64 x y) // cond: - // result: (SARW x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst [16] y))))) + // result: (SARW x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst y [16]))))) { t := v.Type x := v.Args[0] @@ -9747,8 +10279,8 @@ func rewriteValueAMD64_OpRsh16x64(v *Value, config *Config) bool { v2 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) v2.Type = y.Type v3 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) - v3.AuxInt = 16 v3.AddArg(y) + v3.AuxInt = 16 v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) @@ -9756,8 +10288,8 @@ func rewriteValueAMD64_OpRsh16x64(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto ende35d1c2918196fae04fca22e80936bab -ende35d1c2918196fae04fca22e80936bab: + goto endeaf40562fd3394586c63adceca4d9559 +endeaf40562fd3394586c63adceca4d9559: ; return false } @@ -9766,7 +10298,7 @@ func rewriteValueAMD64_OpRsh16x8(v *Value, config *Config) bool { _ = b // match: (Rsh16x8 x y) // cond: - // result: (SARW x (ORB y (NOTL (SBBLcarrymask (CMPBconst [16] y))))) + // result: (SARW x (ORB y (NOTL (SBBLcarrymask (CMPBconst y [16]))))) { t := v.Type x := v.Args[0] @@ -9785,8 +10317,8 @@ func rewriteValueAMD64_OpRsh16x8(v *Value, config *Config) bool { v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v2.Type = y.Type v3 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) - v3.AuxInt = 16 v3.AddArg(y) + v3.AuxInt = 16 v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) @@ -9794,8 +10326,8 @@ func rewriteValueAMD64_OpRsh16x8(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto endaa6a45afc4c6552c1a90a13160578fba -endaa6a45afc4c6552c1a90a13160578fba: + goto endc6cd0d3ecc71bc1830e01c07f274ff7b +endc6cd0d3ecc71bc1830e01c07f274ff7b: ; return false } @@ -9804,7 +10336,7 @@ func rewriteValueAMD64_OpRsh32Ux16(v *Value, config *Config) bool { _ = b // match: (Rsh32Ux16 x y) // cond: - // result: (ANDL (SHRL x y) (SBBLcarrymask (CMPWconst [32] y))) + // result: (ANDL (SHRL x y) (SBBLcarrymask (CMPWconst y [32]))) { t := v.Type x := v.Args[0] @@ -9821,15 +10353,15 @@ func rewriteValueAMD64_OpRsh32Ux16(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) - v2.AuxInt = 32 v2.AddArg(y) + v2.AuxInt = 32 v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end74495683df77023ed619b4ecee98d94a -end74495683df77023ed619b4ecee98d94a: + goto end74ddc1443f6ffb1fe911f455ff982bfb +end74ddc1443f6ffb1fe911f455ff982bfb: ; return false } @@ -9838,7 +10370,7 @@ func rewriteValueAMD64_OpRsh32Ux32(v *Value, config *Config) bool { _ = b // match: (Rsh32Ux32 x y) // cond: - // result: (ANDL (SHRL x y) (SBBLcarrymask (CMPLconst [32] y))) + // result: (ANDL (SHRL x y) (SBBLcarrymask (CMPLconst y [32]))) { t := v.Type x := v.Args[0] @@ -9855,15 +10387,15 @@ func rewriteValueAMD64_OpRsh32Ux32(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) - v2.AuxInt = 32 v2.AddArg(y) + v2.AuxInt = 32 v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto enda7d6c92ab2d7467102db447d6b431b28 -enda7d6c92ab2d7467102db447d6b431b28: + goto enda93828d8aa54be68080640034f94ed96 +enda93828d8aa54be68080640034f94ed96: ; return false } @@ -9872,7 +10404,7 @@ func rewriteValueAMD64_OpRsh32Ux64(v *Value, config *Config) bool { _ = b // match: (Rsh32Ux64 x y) // cond: - // result: (ANDL (SHRL x y) (SBBLcarrymask (CMPQconst [32] y))) + // result: (ANDL (SHRL x y) (SBBLcarrymask (CMPQconst y [32]))) { t := v.Type x := v.Args[0] @@ -9889,15 +10421,15 @@ func rewriteValueAMD64_OpRsh32Ux64(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) - v2.AuxInt = 32 v2.AddArg(y) + v2.AuxInt = 32 v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end7c0829166a6219a15de2c0aa688a9bb3 -end7c0829166a6219a15de2c0aa688a9bb3: + goto end4f644f3f89ef842f4b0567fc385a58e3 +end4f644f3f89ef842f4b0567fc385a58e3: ; return false } @@ -9906,7 +10438,7 @@ func rewriteValueAMD64_OpRsh32Ux8(v *Value, config *Config) bool { _ = b // match: (Rsh32Ux8 x y) // cond: - // result: (ANDL (SHRL x y) (SBBLcarrymask (CMPBconst [32] y))) + // result: (ANDL (SHRL x y) (SBBLcarrymask (CMPBconst y [32]))) { t := v.Type x := v.Args[0] @@ -9923,15 +10455,15 @@ func rewriteValueAMD64_OpRsh32Ux8(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) - v2.AuxInt = 32 v2.AddArg(y) + v2.AuxInt = 32 v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end221315aa8a09c9d8d2f243bf445446ea -end221315aa8a09c9d8d2f243bf445446ea: + goto end2a8f279bb4900b9bf3846378f36d7994 +end2a8f279bb4900b9bf3846378f36d7994: ; return false } @@ -9940,7 +10472,7 @@ func rewriteValueAMD64_OpRsh32x16(v *Value, config *Config) bool { _ = b // match: (Rsh32x16 x y) // cond: - // result: (SARL x (ORW y (NOTL (SBBLcarrymask (CMPWconst [32] y))))) + // result: (SARL x (ORW y (NOTL (SBBLcarrymask (CMPWconst y [32]))))) { t := v.Type x := v.Args[0] @@ -9959,8 +10491,8 @@ func rewriteValueAMD64_OpRsh32x16(v *Value, config *Config) bool { v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v2.Type = y.Type v3 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) - v3.AuxInt = 32 v3.AddArg(y) + v3.AuxInt = 32 v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) @@ -9968,8 +10500,8 @@ func rewriteValueAMD64_OpRsh32x16(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end521b60d91648f07fe1be359f1cdbde29 -end521b60d91648f07fe1be359f1cdbde29: + goto end1b3a698a50c89c656aa6f7acd72e3f5e +end1b3a698a50c89c656aa6f7acd72e3f5e: ; return false } @@ -9978,7 +10510,7 @@ func rewriteValueAMD64_OpRsh32x32(v *Value, config *Config) bool { _ = b // match: (Rsh32x32 x y) // cond: - // result: (SARL x (ORL y (NOTL (SBBLcarrymask (CMPLconst [32] y))))) + // result: (SARL x (ORL y (NOTL (SBBLcarrymask (CMPLconst y [32]))))) { t := v.Type x := v.Args[0] @@ -9997,8 +10529,8 @@ func rewriteValueAMD64_OpRsh32x32(v *Value, config *Config) bool { v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v2.Type = y.Type v3 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) - v3.AuxInt = 32 v3.AddArg(y) + v3.AuxInt = 32 v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) @@ -10006,8 +10538,8 @@ func rewriteValueAMD64_OpRsh32x32(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end0fc03188975afbca2139e28c38b7cd17 -end0fc03188975afbca2139e28c38b7cd17: + goto endc6596de1c198fd84c4076aaa3c6486e5 +endc6596de1c198fd84c4076aaa3c6486e5: ; return false } @@ -10016,7 +10548,7 @@ func rewriteValueAMD64_OpRsh32x64(v *Value, config *Config) bool { _ = b // match: (Rsh32x64 x y) // cond: - // result: (SARL x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst [32] y))))) + // result: (SARL x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst y [32]))))) { t := v.Type x := v.Args[0] @@ -10035,8 +10567,8 @@ func rewriteValueAMD64_OpRsh32x64(v *Value, config *Config) bool { v2 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) v2.Type = y.Type v3 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) - v3.AuxInt = 32 v3.AddArg(y) + v3.AuxInt = 32 v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) @@ -10044,8 +10576,8 @@ func rewriteValueAMD64_OpRsh32x64(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto endf36790cc7ba330d448b403a450a7c1d4 -endf36790cc7ba330d448b403a450a7c1d4: + goto enddda2e730607e2d13b18f1006316e0ebb +enddda2e730607e2d13b18f1006316e0ebb: ; return false } @@ -10054,7 +10586,7 @@ func rewriteValueAMD64_OpRsh32x8(v *Value, config *Config) bool { _ = b // match: (Rsh32x8 x y) // cond: - // result: (SARL x (ORB y (NOTL (SBBLcarrymask (CMPBconst [32] y))))) + // result: (SARL x (ORB y (NOTL (SBBLcarrymask (CMPBconst y [32]))))) { t := v.Type x := v.Args[0] @@ -10073,8 +10605,8 @@ func rewriteValueAMD64_OpRsh32x8(v *Value, config *Config) bool { v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v2.Type = y.Type v3 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) - v3.AuxInt = 32 v3.AddArg(y) + v3.AuxInt = 32 v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) @@ -10082,8 +10614,8 @@ func rewriteValueAMD64_OpRsh32x8(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end1242709228488be2f2505ead8eabb871 -end1242709228488be2f2505ead8eabb871: + goto endd9cb28c7e3a43fbd7a877750f34df72a +endd9cb28c7e3a43fbd7a877750f34df72a: ; return false } @@ -10092,7 +10624,7 @@ func rewriteValueAMD64_OpRsh64Ux16(v *Value, config *Config) bool { _ = b // match: (Rsh64Ux16 x y) // cond: - // result: (ANDQ (SHRQ x y) (SBBQcarrymask (CMPWconst [64] y))) + // result: (ANDQ (SHRQ x y) (SBBQcarrymask (CMPWconst y [64]))) { t := v.Type x := v.Args[0] @@ -10109,15 +10641,15 @@ func rewriteValueAMD64_OpRsh64Ux16(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) - v2.AuxInt = 64 v2.AddArg(y) + v2.AuxInt = 64 v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end0bc6c36a57ebaf0b90fc418f976fe210 -end0bc6c36a57ebaf0b90fc418f976fe210: + goto end04dfdfa8a2dcffaf7ab1ee93a96b8677 +end04dfdfa8a2dcffaf7ab1ee93a96b8677: ; return false } @@ -10126,7 +10658,7 @@ func rewriteValueAMD64_OpRsh64Ux32(v *Value, config *Config) bool { _ = b // match: (Rsh64Ux32 x y) // cond: - // result: (ANDQ (SHRQ x y) (SBBQcarrymask (CMPLconst [64] y))) + // result: (ANDQ (SHRQ x y) (SBBQcarrymask (CMPLconst y [64]))) { t := v.Type x := v.Args[0] @@ -10143,15 +10675,15 @@ func rewriteValueAMD64_OpRsh64Ux32(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) - v2.AuxInt = 64 v2.AddArg(y) + v2.AuxInt = 64 v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto ende3f52062f53bc3b5aa0461a644e38a1b -ende3f52062f53bc3b5aa0461a644e38a1b: + goto end2b2f03d14fb01fd490115a96d893ddb3 +end2b2f03d14fb01fd490115a96d893ddb3: ; return false } @@ -10160,7 +10692,7 @@ func rewriteValueAMD64_OpRsh64Ux64(v *Value, config *Config) bool { _ = b // match: (Rsh64Ux64 x y) // cond: - // result: (ANDQ (SHRQ x y) (SBBQcarrymask (CMPQconst [64] y))) + // result: (ANDQ (SHRQ x y) (SBBQcarrymask (CMPQconst y [64]))) { t := v.Type x := v.Args[0] @@ -10177,15 +10709,15 @@ func rewriteValueAMD64_OpRsh64Ux64(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) - v2.AuxInt = 64 v2.AddArg(y) + v2.AuxInt = 64 v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto endaec410d0544f817303c79bad739c50fd -endaec410d0544f817303c79bad739c50fd: + goto endb24ca32f261a5c799d3e5a572f7cdcff +endb24ca32f261a5c799d3e5a572f7cdcff: ; return false } @@ -10194,7 +10726,7 @@ func rewriteValueAMD64_OpRsh64Ux8(v *Value, config *Config) bool { _ = b // match: (Rsh64Ux8 x y) // cond: - // result: (ANDQ (SHRQ x y) (SBBQcarrymask (CMPBconst [64] y))) + // result: (ANDQ (SHRQ x y) (SBBQcarrymask (CMPBconst y [64]))) { t := v.Type x := v.Args[0] @@ -10211,15 +10743,15 @@ func rewriteValueAMD64_OpRsh64Ux8(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) - v2.AuxInt = 64 v2.AddArg(y) + v2.AuxInt = 64 v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end0318851ecb02e4ad8a2669034adf7862 -end0318851ecb02e4ad8a2669034adf7862: + goto end05a9a99310c9e282df012d5c48b58475 +end05a9a99310c9e282df012d5c48b58475: ; return false } @@ -10228,7 +10760,7 @@ func rewriteValueAMD64_OpRsh64x16(v *Value, config *Config) bool { _ = b // match: (Rsh64x16 x y) // cond: - // result: (SARQ x (ORW y (NOTL (SBBLcarrymask (CMPWconst [64] y))))) + // result: (SARQ x (ORW y (NOTL (SBBLcarrymask (CMPWconst y [64]))))) { t := v.Type x := v.Args[0] @@ -10247,8 +10779,8 @@ func rewriteValueAMD64_OpRsh64x16(v *Value, config *Config) bool { v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v2.Type = y.Type v3 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) - v3.AuxInt = 64 v3.AddArg(y) + v3.AuxInt = 64 v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) @@ -10256,8 +10788,8 @@ func rewriteValueAMD64_OpRsh64x16(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto endcf8bbca9a7a848fbebaaaa8b699cd086 -endcf8bbca9a7a848fbebaaaa8b699cd086: + goto endb97b88b7c4e431bd64ced5690f0e85c4 +endb97b88b7c4e431bd64ced5690f0e85c4: ; return false } @@ -10266,7 +10798,7 @@ func rewriteValueAMD64_OpRsh64x32(v *Value, config *Config) bool { _ = b // match: (Rsh64x32 x y) // cond: - // result: (SARQ x (ORL y (NOTL (SBBLcarrymask (CMPLconst [64] y))))) + // result: (SARQ x (ORL y (NOTL (SBBLcarrymask (CMPLconst y [64]))))) { t := v.Type x := v.Args[0] @@ -10285,8 +10817,8 @@ func rewriteValueAMD64_OpRsh64x32(v *Value, config *Config) bool { v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v2.Type = y.Type v3 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) - v3.AuxInt = 64 v3.AddArg(y) + v3.AuxInt = 64 v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) @@ -10294,8 +10826,8 @@ func rewriteValueAMD64_OpRsh64x32(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end7604d45b06ee69bf2feddf88b2f33cb6 -end7604d45b06ee69bf2feddf88b2f33cb6: + goto end95f72c0d315e6b1d70015b31a0f5f4ca +end95f72c0d315e6b1d70015b31a0f5f4ca: ; return false } @@ -10304,7 +10836,7 @@ func rewriteValueAMD64_OpRsh64x64(v *Value, config *Config) bool { _ = b // match: (Rsh64x64 x y) // cond: - // result: (SARQ x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst [64] y))))) + // result: (SARQ x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst y [64]))))) { t := v.Type x := v.Args[0] @@ -10323,8 +10855,8 @@ func rewriteValueAMD64_OpRsh64x64(v *Value, config *Config) bool { v2 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) v2.Type = y.Type v3 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) - v3.AuxInt = 64 v3.AddArg(y) + v3.AuxInt = 64 v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) @@ -10332,8 +10864,8 @@ func rewriteValueAMD64_OpRsh64x64(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end12a3b44af604b515ad5530502336486f -end12a3b44af604b515ad5530502336486f: + goto enda8ddfaa8e519c0ed70c344a136ba9126 +enda8ddfaa8e519c0ed70c344a136ba9126: ; return false } @@ -10342,7 +10874,7 @@ func rewriteValueAMD64_OpRsh64x8(v *Value, config *Config) bool { _ = b // match: (Rsh64x8 x y) // cond: - // result: (SARQ x (ORB y (NOTL (SBBLcarrymask (CMPBconst [64] y))))) + // result: (SARQ x (ORB y (NOTL (SBBLcarrymask (CMPBconst y [64]))))) { t := v.Type x := v.Args[0] @@ -10361,8 +10893,8 @@ func rewriteValueAMD64_OpRsh64x8(v *Value, config *Config) bool { v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v2.Type = y.Type v3 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) - v3.AuxInt = 64 v3.AddArg(y) + v3.AuxInt = 64 v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) @@ -10370,8 +10902,8 @@ func rewriteValueAMD64_OpRsh64x8(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end4e2a83809914aad301a2f74d3c38fbbb -end4e2a83809914aad301a2f74d3c38fbbb: + goto end62f4adae0bbd0c4d5d6eb7d5eda6a5e3 +end62f4adae0bbd0c4d5d6eb7d5eda6a5e3: ; return false } @@ -10380,7 +10912,7 @@ func rewriteValueAMD64_OpRsh8Ux16(v *Value, config *Config) bool { _ = b // match: (Rsh8Ux16 x y) // cond: - // result: (ANDB (SHRB x y) (SBBLcarrymask (CMPWconst [8] y))) + // result: (ANDB (SHRB x y) (SBBLcarrymask (CMPWconst y [8]))) { t := v.Type x := v.Args[0] @@ -10397,15 +10929,15 @@ func rewriteValueAMD64_OpRsh8Ux16(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) - v2.AuxInt = 8 v2.AddArg(y) + v2.AuxInt = 8 v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end724175a51b6efac60c6bb9d83d81215a -end724175a51b6efac60c6bb9d83d81215a: + goto endb791c8283bd486da9809520a7262d5ba +endb791c8283bd486da9809520a7262d5ba: ; return false } @@ -10414,7 +10946,7 @@ func rewriteValueAMD64_OpRsh8Ux32(v *Value, config *Config) bool { _ = b // match: (Rsh8Ux32 x y) // cond: - // result: (ANDB (SHRB x y) (SBBLcarrymask (CMPLconst [8] y))) + // result: (ANDB (SHRB x y) (SBBLcarrymask (CMPLconst y [8]))) { t := v.Type x := v.Args[0] @@ -10431,15 +10963,15 @@ func rewriteValueAMD64_OpRsh8Ux32(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) - v2.AuxInt = 8 v2.AddArg(y) + v2.AuxInt = 8 v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end9d973431bed6682c1d557a535cf440ed -end9d973431bed6682c1d557a535cf440ed: + goto end5f360ab34942dc218e8f75624c86bbb2 +end5f360ab34942dc218e8f75624c86bbb2: ; return false } @@ -10448,7 +10980,7 @@ func rewriteValueAMD64_OpRsh8Ux64(v *Value, config *Config) bool { _ = b // match: (Rsh8Ux64 x y) // cond: - // result: (ANDB (SHRB x y) (SBBLcarrymask (CMPQconst [8] y))) + // result: (ANDB (SHRB x y) (SBBLcarrymask (CMPQconst y [8]))) { t := v.Type x := v.Args[0] @@ -10465,15 +10997,15 @@ func rewriteValueAMD64_OpRsh8Ux64(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) - v2.AuxInt = 8 v2.AddArg(y) + v2.AuxInt = 8 v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto end9586937cdeb7946c337d46cd30cb9a11 -end9586937cdeb7946c337d46cd30cb9a11: + goto end7138df590f00234cd21cf02da8ed109e +end7138df590f00234cd21cf02da8ed109e: ; return false } @@ -10482,7 +11014,7 @@ func rewriteValueAMD64_OpRsh8Ux8(v *Value, config *Config) bool { _ = b // match: (Rsh8Ux8 x y) // cond: - // result: (ANDB (SHRB x y) (SBBLcarrymask (CMPBconst [8] y))) + // result: (ANDB (SHRB x y) (SBBLcarrymask (CMPBconst y [8]))) { t := v.Type x := v.Args[0] @@ -10499,15 +11031,15 @@ func rewriteValueAMD64_OpRsh8Ux8(v *Value, config *Config) bool { v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v1.Type = t v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) - v2.AuxInt = 8 v2.AddArg(y) + v2.AuxInt = 8 v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true } - goto endc5a55ef63d86e6b8d4d366a947bf563d -endc5a55ef63d86e6b8d4d366a947bf563d: + goto end3aab873310bf7b2f3f90705fbd082b93 +end3aab873310bf7b2f3f90705fbd082b93: ; return false } @@ -10516,7 +11048,7 @@ func rewriteValueAMD64_OpRsh8x16(v *Value, config *Config) bool { _ = b // match: (Rsh8x16 x y) // cond: - // result: (SARB x (ORW y (NOTL (SBBLcarrymask (CMPWconst [8] y))))) + // result: (SARB x (ORW y (NOTL (SBBLcarrymask (CMPWconst y [8]))))) { t := v.Type x := v.Args[0] @@ -10535,8 +11067,8 @@ func rewriteValueAMD64_OpRsh8x16(v *Value, config *Config) bool { v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v2.Type = y.Type v3 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) - v3.AuxInt = 8 v3.AddArg(y) + v3.AuxInt = 8 v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) @@ -10544,8 +11076,8 @@ func rewriteValueAMD64_OpRsh8x16(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto endfa967d6583c1bb9644514c2013b919f8 -endfa967d6583c1bb9644514c2013b919f8: + goto ende275bad06ac788b484b038f1bb3afc8d +ende275bad06ac788b484b038f1bb3afc8d: ; return false } @@ -10554,7 +11086,7 @@ func rewriteValueAMD64_OpRsh8x32(v *Value, config *Config) bool { _ = b // match: (Rsh8x32 x y) // cond: - // result: (SARB x (ORL y (NOTL (SBBLcarrymask (CMPLconst [8] y))))) + // result: (SARB x (ORL y (NOTL (SBBLcarrymask (CMPLconst y [8]))))) { t := v.Type x := v.Args[0] @@ -10573,8 +11105,8 @@ func rewriteValueAMD64_OpRsh8x32(v *Value, config *Config) bool { v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v2.Type = y.Type v3 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) - v3.AuxInt = 8 v3.AddArg(y) + v3.AuxInt = 8 v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) @@ -10582,8 +11114,8 @@ func rewriteValueAMD64_OpRsh8x32(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto ende5a630810624a1bd3677618c2cbc8619 -ende5a630810624a1bd3677618c2cbc8619: + goto end00833cba5173dc390952b6c4644af376 +end00833cba5173dc390952b6c4644af376: ; return false } @@ -10592,7 +11124,7 @@ func rewriteValueAMD64_OpRsh8x64(v *Value, config *Config) bool { _ = b // match: (Rsh8x64 x y) // cond: - // result: (SARB x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst [8] y))))) + // result: (SARB x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst y [8]))))) { t := v.Type x := v.Args[0] @@ -10611,8 +11143,8 @@ func rewriteValueAMD64_OpRsh8x64(v *Value, config *Config) bool { v2 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) v2.Type = y.Type v3 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) - v3.AuxInt = 8 v3.AddArg(y) + v3.AuxInt = 8 v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) @@ -10620,8 +11152,8 @@ func rewriteValueAMD64_OpRsh8x64(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end23c55e49d8bc44afc680b2a4eade5af6 -end23c55e49d8bc44afc680b2a4eade5af6: + goto end039cf4d3a939b89164b058d09f532fb5 +end039cf4d3a939b89164b058d09f532fb5: ; return false } @@ -10630,7 +11162,7 @@ func rewriteValueAMD64_OpRsh8x8(v *Value, config *Config) bool { _ = b // match: (Rsh8x8 x y) // cond: - // result: (SARB x (ORB y (NOTL (SBBLcarrymask (CMPBconst [8] y))))) + // result: (SARB x (ORB y (NOTL (SBBLcarrymask (CMPBconst y [8]))))) { t := v.Type x := v.Args[0] @@ -10649,8 +11181,8 @@ func rewriteValueAMD64_OpRsh8x8(v *Value, config *Config) bool { v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) v2.Type = y.Type v3 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) - v3.AuxInt = 8 v3.AddArg(y) + v3.AuxInt = 8 v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) @@ -10658,8 +11190,8 @@ func rewriteValueAMD64_OpRsh8x8(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto enddab0c33c56e2e9434b880e1718621979 -enddab0c33c56e2e9434b880e1718621979: + goto end6453a48c573d0dc7c8b0163a266c6218 +end6453a48c573d0dc7c8b0163a266c6218: ; return false } @@ -10862,45 +11394,12 @@ endca23e80dba22ab574f843c7a4cef24ab: func rewriteValueAMD64_OpAMD64SBBLcarrymask(v *Value, config *Config) bool { b := v.Block _ = b - // match: (SBBLcarrymask (CMPQconst [c] (MOVQconst [d]))) - // cond: inBounds64(d, c) - // result: (MOVLconst [-1]) - { - if v.Args[0].Op != OpAMD64CMPQconst { - goto end490c8a7039bab41e90e564fbb8500233 - } - c := v.Args[0].AuxInt - if v.Args[0].Args[0].Op != OpAMD64MOVQconst { - goto end490c8a7039bab41e90e564fbb8500233 - } - d := v.Args[0].Args[0].AuxInt - if !(inBounds64(d, c)) { - goto end490c8a7039bab41e90e564fbb8500233 - } - v.Op = OpAMD64MOVLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = -1 - return true - } - goto end490c8a7039bab41e90e564fbb8500233 -end490c8a7039bab41e90e564fbb8500233: - ; - // match: (SBBLcarrymask (CMPQconst [c] (MOVQconst [d]))) - // cond: !inBounds64(d, c) + // match: (SBBLcarrymask (FlagEQ)) + // cond: // result: (MOVLconst [0]) { - if v.Args[0].Op != OpAMD64CMPQconst { - goto end95e703eabe71d831b7a3d2f9fabe7de9 - } - c := v.Args[0].AuxInt - if v.Args[0].Args[0].Op != OpAMD64MOVQconst { - goto end95e703eabe71d831b7a3d2f9fabe7de9 - } - d := v.Args[0].Args[0].AuxInt - if !(!inBounds64(d, c)) { - goto end95e703eabe71d831b7a3d2f9fabe7de9 + if v.Args[0].Op != OpAMD64FlagEQ { + goto end49bb4f49864044e2cd06c9c8e2c05f12 } v.Op = OpAMD64MOVLconst v.AuxInt = 0 @@ -10909,23 +11408,15 @@ end490c8a7039bab41e90e564fbb8500233: v.AuxInt = 0 return true } - goto end95e703eabe71d831b7a3d2f9fabe7de9 -end95e703eabe71d831b7a3d2f9fabe7de9: + goto end49bb4f49864044e2cd06c9c8e2c05f12 +end49bb4f49864044e2cd06c9c8e2c05f12: ; - // match: (SBBLcarrymask (CMPLconst [c] (MOVLconst [d]))) - // cond: inBounds32(d, c) + // match: (SBBLcarrymask (FlagLT_ULT)) + // cond: // result: (MOVLconst [-1]) { - if v.Args[0].Op != OpAMD64CMPLconst { - goto end00c0a561340b0172c9a21f63648b86e2 - } - c := v.Args[0].AuxInt - if v.Args[0].Args[0].Op != OpAMD64MOVLconst { - goto end00c0a561340b0172c9a21f63648b86e2 - } - d := v.Args[0].Args[0].AuxInt - if !(inBounds32(d, c)) { - goto end00c0a561340b0172c9a21f63648b86e2 + if v.Args[0].Op != OpAMD64FlagLT_ULT { + goto ende534d42c655e8b95b051e7ec44d4fdf9 } v.Op = OpAMD64MOVLconst v.AuxInt = 0 @@ -10934,23 +11425,15 @@ end95e703eabe71d831b7a3d2f9fabe7de9: v.AuxInt = -1 return true } - goto end00c0a561340b0172c9a21f63648b86e2 -end00c0a561340b0172c9a21f63648b86e2: + goto ende534d42c655e8b95b051e7ec44d4fdf9 +ende534d42c655e8b95b051e7ec44d4fdf9: ; - // match: (SBBLcarrymask (CMPLconst [c] (MOVLconst [d]))) - // cond: !inBounds32(d, c) + // match: (SBBLcarrymask (FlagLT_UGT)) + // cond: // result: (MOVLconst [0]) { - if v.Args[0].Op != OpAMD64CMPLconst { - goto enda73c8bf14f7b45dd97c6a006e317b0b8 - } - c := v.Args[0].AuxInt - if v.Args[0].Args[0].Op != OpAMD64MOVLconst { - goto enda73c8bf14f7b45dd97c6a006e317b0b8 - } - d := v.Args[0].Args[0].AuxInt - if !(!inBounds32(d, c)) { - goto enda73c8bf14f7b45dd97c6a006e317b0b8 + if v.Args[0].Op != OpAMD64FlagLT_UGT { + goto end212628069f217f165eaf49dcfd9e8c76 } v.Op = OpAMD64MOVLconst v.AuxInt = 0 @@ -10959,23 +11442,15 @@ end00c0a561340b0172c9a21f63648b86e2: v.AuxInt = 0 return true } - goto enda73c8bf14f7b45dd97c6a006e317b0b8 -enda73c8bf14f7b45dd97c6a006e317b0b8: + goto end212628069f217f165eaf49dcfd9e8c76 +end212628069f217f165eaf49dcfd9e8c76: ; - // match: (SBBLcarrymask (CMPWconst [c] (MOVWconst [d]))) - // cond: inBounds16(d, c) + // match: (SBBLcarrymask (FlagGT_ULT)) + // cond: // result: (MOVLconst [-1]) { - if v.Args[0].Op != OpAMD64CMPWconst { - goto endb94dc44cd77f66ed3bf3742874b666fc - } - c := v.Args[0].AuxInt - if v.Args[0].Args[0].Op != OpAMD64MOVWconst { - goto endb94dc44cd77f66ed3bf3742874b666fc - } - d := v.Args[0].Args[0].AuxInt - if !(inBounds16(d, c)) { - goto endb94dc44cd77f66ed3bf3742874b666fc + if v.Args[0].Op != OpAMD64FlagGT_ULT { + goto end4df0bf7db9772a6011ed89bd3ce95f1d } v.Op = OpAMD64MOVLconst v.AuxInt = 0 @@ -10984,23 +11459,15 @@ enda73c8bf14f7b45dd97c6a006e317b0b8: v.AuxInt = -1 return true } - goto endb94dc44cd77f66ed3bf3742874b666fc -endb94dc44cd77f66ed3bf3742874b666fc: + goto end4df0bf7db9772a6011ed89bd3ce95f1d +end4df0bf7db9772a6011ed89bd3ce95f1d: ; - // match: (SBBLcarrymask (CMPWconst [c] (MOVWconst [d]))) - // cond: !inBounds16(d, c) + // match: (SBBLcarrymask (FlagGT_UGT)) + // cond: // result: (MOVLconst [0]) { - if v.Args[0].Op != OpAMD64CMPWconst { - goto end7a02def6194822f7ab937d78088504d2 - } - c := v.Args[0].AuxInt - if v.Args[0].Args[0].Op != OpAMD64MOVWconst { - goto end7a02def6194822f7ab937d78088504d2 - } - d := v.Args[0].Args[0].AuxInt - if !(!inBounds16(d, c)) { - goto end7a02def6194822f7ab937d78088504d2 + if v.Args[0].Op != OpAMD64FlagGT_UGT { + goto end4d9d1509d6d260332f0a345332ce89e2 } v.Op = OpAMD64MOVLconst v.AuxInt = 0 @@ -11009,78 +11476,37 @@ endb94dc44cd77f66ed3bf3742874b666fc: v.AuxInt = 0 return true } - goto end7a02def6194822f7ab937d78088504d2 -end7a02def6194822f7ab937d78088504d2: - ; - // match: (SBBLcarrymask (CMPBconst [c] (MOVBconst [d]))) - // cond: inBounds8(d, c) - // result: (MOVLconst [-1]) - { - if v.Args[0].Op != OpAMD64CMPBconst { - goto end79c8e4a20761df731521e6cd956c4245 - } - c := v.Args[0].AuxInt - if v.Args[0].Args[0].Op != OpAMD64MOVBconst { - goto end79c8e4a20761df731521e6cd956c4245 - } - d := v.Args[0].Args[0].AuxInt - if !(inBounds8(d, c)) { - goto end79c8e4a20761df731521e6cd956c4245 - } - v.Op = OpAMD64MOVLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() - v.AuxInt = -1 - return true - } - goto end79c8e4a20761df731521e6cd956c4245 -end79c8e4a20761df731521e6cd956c4245: + goto end4d9d1509d6d260332f0a345332ce89e2 +end4d9d1509d6d260332f0a345332ce89e2: ; - // match: (SBBLcarrymask (CMPBconst [c] (MOVBconst [d]))) - // cond: !inBounds8(d, c) - // result: (MOVLconst [0]) + return false +} +func rewriteValueAMD64_OpAMD64SBBQcarrymask(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (SBBQcarrymask (FlagEQ)) + // cond: + // result: (MOVQconst [0]) { - if v.Args[0].Op != OpAMD64CMPBconst { - goto end95b5b21dd7756ae41575759a1eff2bea + if v.Args[0].Op != OpAMD64FlagEQ { + goto end6b4a6f105b53df8063846a528bab0abb } - c := v.Args[0].AuxInt - if v.Args[0].Args[0].Op != OpAMD64MOVBconst { - goto end95b5b21dd7756ae41575759a1eff2bea - } - d := v.Args[0].Args[0].AuxInt - if !(!inBounds8(d, c)) { - goto end95b5b21dd7756ae41575759a1eff2bea - } - v.Op = OpAMD64MOVLconst + v.Op = OpAMD64MOVQconst v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AuxInt = 0 return true } - goto end95b5b21dd7756ae41575759a1eff2bea -end95b5b21dd7756ae41575759a1eff2bea: + goto end6b4a6f105b53df8063846a528bab0abb +end6b4a6f105b53df8063846a528bab0abb: ; - return false -} -func rewriteValueAMD64_OpAMD64SBBQcarrymask(v *Value, config *Config) bool { - b := v.Block - _ = b - // match: (SBBQcarrymask (CMPQconst [c] (MOVQconst [d]))) - // cond: inBounds64(d, c) + // match: (SBBQcarrymask (FlagLT_ULT)) + // cond: // result: (MOVQconst [-1]) { - if v.Args[0].Op != OpAMD64CMPQconst { - goto end0c26df98feb38f149eca12f33c15de1b - } - c := v.Args[0].AuxInt - if v.Args[0].Args[0].Op != OpAMD64MOVQconst { - goto end0c26df98feb38f149eca12f33c15de1b - } - d := v.Args[0].Args[0].AuxInt - if !(inBounds64(d, c)) { - goto end0c26df98feb38f149eca12f33c15de1b + if v.Args[0].Op != OpAMD64FlagLT_ULT { + goto endbfed0a1a93d6d8570f304898550d9558 } v.Op = OpAMD64MOVQconst v.AuxInt = 0 @@ -11089,23 +11515,15 @@ func rewriteValueAMD64_OpAMD64SBBQcarrymask(v *Value, config *Config) bool { v.AuxInt = -1 return true } - goto end0c26df98feb38f149eca12f33c15de1b -end0c26df98feb38f149eca12f33c15de1b: + goto endbfed0a1a93d6d8570f304898550d9558 +endbfed0a1a93d6d8570f304898550d9558: ; - // match: (SBBQcarrymask (CMPQconst [c] (MOVQconst [d]))) - // cond: !inBounds64(d, c) + // match: (SBBQcarrymask (FlagLT_UGT)) + // cond: // result: (MOVQconst [0]) { - if v.Args[0].Op != OpAMD64CMPQconst { - goto end8965aa1e1153e5ecd123bbb31a618570 - } - c := v.Args[0].AuxInt - if v.Args[0].Args[0].Op != OpAMD64MOVQconst { - goto end8965aa1e1153e5ecd123bbb31a618570 - } - d := v.Args[0].Args[0].AuxInt - if !(!inBounds64(d, c)) { - goto end8965aa1e1153e5ecd123bbb31a618570 + if v.Args[0].Op != OpAMD64FlagLT_UGT { + goto end8edf88458891c571a6ea6e52e0267b40 } v.Op = OpAMD64MOVQconst v.AuxInt = 0 @@ -11114,23 +11532,15 @@ end0c26df98feb38f149eca12f33c15de1b: v.AuxInt = 0 return true } - goto end8965aa1e1153e5ecd123bbb31a618570 -end8965aa1e1153e5ecd123bbb31a618570: + goto end8edf88458891c571a6ea6e52e0267b40 +end8edf88458891c571a6ea6e52e0267b40: ; - // match: (SBBQcarrymask (CMPLconst [c] (MOVLconst [d]))) - // cond: inBounds32(d, c) + // match: (SBBQcarrymask (FlagGT_ULT)) + // cond: // result: (MOVQconst [-1]) { - if v.Args[0].Op != OpAMD64CMPLconst { - goto end8772ede6098981a61af0f478841d7d54 - } - c := v.Args[0].AuxInt - if v.Args[0].Args[0].Op != OpAMD64MOVLconst { - goto end8772ede6098981a61af0f478841d7d54 - } - d := v.Args[0].Args[0].AuxInt - if !(inBounds32(d, c)) { - goto end8772ede6098981a61af0f478841d7d54 + if v.Args[0].Op != OpAMD64FlagGT_ULT { + goto end4663340439f2fa7a666e81f0ebc68436 } v.Op = OpAMD64MOVQconst v.AuxInt = 0 @@ -11139,23 +11549,15 @@ end8965aa1e1153e5ecd123bbb31a618570: v.AuxInt = -1 return true } - goto end8772ede6098981a61af0f478841d7d54 -end8772ede6098981a61af0f478841d7d54: + goto end4663340439f2fa7a666e81f0ebc68436 +end4663340439f2fa7a666e81f0ebc68436: ; - // match: (SBBQcarrymask (CMPLconst [c] (MOVLconst [d]))) - // cond: !inBounds32(d, c) + // match: (SBBQcarrymask (FlagGT_UGT)) + // cond: // result: (MOVQconst [0]) { - if v.Args[0].Op != OpAMD64CMPLconst { - goto end2d535e90075ee777fc616e6b9847a384 - } - c := v.Args[0].AuxInt - if v.Args[0].Args[0].Op != OpAMD64MOVLconst { - goto end2d535e90075ee777fc616e6b9847a384 - } - d := v.Args[0].Args[0].AuxInt - if !(!inBounds32(d, c)) { - goto end2d535e90075ee777fc616e6b9847a384 + if v.Args[0].Op != OpAMD64FlagGT_UGT { + goto end7262400b0380a163bd65b88e0c3db985 } v.Op = OpAMD64MOVQconst v.AuxInt = 0 @@ -11164,131 +11566,116 @@ end8772ede6098981a61af0f478841d7d54: v.AuxInt = 0 return true } - goto end2d535e90075ee777fc616e6b9847a384 -end2d535e90075ee777fc616e6b9847a384: + goto end7262400b0380a163bd65b88e0c3db985 +end7262400b0380a163bd65b88e0c3db985: ; - // match: (SBBQcarrymask (CMPWconst [c] (MOVWconst [d]))) - // cond: inBounds16(d, c) - // result: (MOVQconst [-1]) + return false +} +func rewriteValueAMD64_OpAMD64SETA(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (SETA (InvertFlags x)) + // cond: + // result: (SETB x) { - if v.Args[0].Op != OpAMD64CMPWconst { - goto end3103c51e14b4fc894b4170f16f37eebc - } - c := v.Args[0].AuxInt - if v.Args[0].Args[0].Op != OpAMD64MOVWconst { - goto end3103c51e14b4fc894b4170f16f37eebc - } - d := v.Args[0].Args[0].AuxInt - if !(inBounds16(d, c)) { - goto end3103c51e14b4fc894b4170f16f37eebc + if v.Args[0].Op != OpAMD64InvertFlags { + goto enda4ac36e94fc279d762b5a6c7c6cc665d } - v.Op = OpAMD64MOVQconst + x := v.Args[0].Args[0] + v.Op = OpAMD64SETB v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = -1 + v.AddArg(x) return true } - goto end3103c51e14b4fc894b4170f16f37eebc -end3103c51e14b4fc894b4170f16f37eebc: + goto enda4ac36e94fc279d762b5a6c7c6cc665d +enda4ac36e94fc279d762b5a6c7c6cc665d: ; - // match: (SBBQcarrymask (CMPWconst [c] (MOVWconst [d]))) - // cond: !inBounds16(d, c) - // result: (MOVQconst [0]) + // match: (SETA (FlagEQ)) + // cond: + // result: (MOVBconst [0]) { - if v.Args[0].Op != OpAMD64CMPWconst { - goto enddae2191a59cfef5efb04ebab9354745c - } - c := v.Args[0].AuxInt - if v.Args[0].Args[0].Op != OpAMD64MOVWconst { - goto enddae2191a59cfef5efb04ebab9354745c + if v.Args[0].Op != OpAMD64FlagEQ { + goto end1521942d06b7f0caba92883aee0bb90e } - d := v.Args[0].Args[0].AuxInt - if !(!inBounds16(d, c)) { - goto enddae2191a59cfef5efb04ebab9354745c - } - v.Op = OpAMD64MOVQconst + v.Op = OpAMD64MOVBconst v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AuxInt = 0 return true } - goto enddae2191a59cfef5efb04ebab9354745c -enddae2191a59cfef5efb04ebab9354745c: + goto end1521942d06b7f0caba92883aee0bb90e +end1521942d06b7f0caba92883aee0bb90e: ; - // match: (SBBQcarrymask (CMPBconst [c] (MOVBconst [d]))) - // cond: inBounds8(d, c) - // result: (MOVQconst [-1]) + // match: (SETA (FlagLT_ULT)) + // cond: + // result: (MOVBconst [0]) { - if v.Args[0].Op != OpAMD64CMPBconst { - goto end72e088325ca005b0251b1ee82da3c5d9 - } - c := v.Args[0].AuxInt - if v.Args[0].Args[0].Op != OpAMD64MOVBconst { - goto end72e088325ca005b0251b1ee82da3c5d9 + if v.Args[0].Op != OpAMD64FlagLT_ULT { + goto endf79d69b18a140d5c6669216ad65f60f0 } - d := v.Args[0].Args[0].AuxInt - if !(inBounds8(d, c)) { - goto end72e088325ca005b0251b1ee82da3c5d9 - } - v.Op = OpAMD64MOVQconst + v.Op = OpAMD64MOVBconst v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = -1 + v.AuxInt = 0 return true } - goto end72e088325ca005b0251b1ee82da3c5d9 -end72e088325ca005b0251b1ee82da3c5d9: + goto endf79d69b18a140d5c6669216ad65f60f0 +endf79d69b18a140d5c6669216ad65f60f0: ; - // match: (SBBQcarrymask (CMPBconst [c] (MOVBconst [d]))) - // cond: !inBounds8(d, c) - // result: (MOVQconst [0]) + // match: (SETA (FlagLT_UGT)) + // cond: + // result: (MOVBconst [1]) { - if v.Args[0].Op != OpAMD64CMPBconst { - goto endcb388100f5b933aa94095096d2bb425e - } - c := v.Args[0].AuxInt - if v.Args[0].Args[0].Op != OpAMD64MOVBconst { - goto endcb388100f5b933aa94095096d2bb425e + if v.Args[0].Op != OpAMD64FlagLT_UGT { + goto end272c1e5fca714e319fb1c335023826db } - d := v.Args[0].Args[0].AuxInt - if !(!inBounds8(d, c)) { - goto endcb388100f5b933aa94095096d2bb425e + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 1 + return true + } + goto end272c1e5fca714e319fb1c335023826db +end272c1e5fca714e319fb1c335023826db: + ; + // match: (SETA (FlagGT_ULT)) + // cond: + // result: (MOVBconst [0]) + { + if v.Args[0].Op != OpAMD64FlagGT_ULT { + goto ende0cf0104de1315266d93ded9a092302c } - v.Op = OpAMD64MOVQconst + v.Op = OpAMD64MOVBconst v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AuxInt = 0 return true } - goto endcb388100f5b933aa94095096d2bb425e -endcb388100f5b933aa94095096d2bb425e: + goto ende0cf0104de1315266d93ded9a092302c +ende0cf0104de1315266d93ded9a092302c: ; - return false -} -func rewriteValueAMD64_OpAMD64SETA(v *Value, config *Config) bool { - b := v.Block - _ = b - // match: (SETA (InvertFlags x)) + // match: (SETA (FlagGT_UGT)) // cond: - // result: (SETB x) + // result: (MOVBconst [1]) { - if v.Args[0].Op != OpAMD64InvertFlags { - goto enda4ac36e94fc279d762b5a6c7c6cc665d + if v.Args[0].Op != OpAMD64FlagGT_UGT { + goto end85507f7549319577f9994826ee379f3b } - x := v.Args[0].Args[0] - v.Op = OpAMD64SETB + v.Op = OpAMD64MOVBconst v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AddArg(x) + v.AuxInt = 1 return true } - goto enda4ac36e94fc279d762b5a6c7c6cc665d -enda4ac36e94fc279d762b5a6c7c6cc665d: + goto end85507f7549319577f9994826ee379f3b +end85507f7549319577f9994826ee379f3b: ; return false } @@ -11313,19 +11700,104 @@ func rewriteValueAMD64_OpAMD64SETAE(v *Value, config *Config) bool { goto end0468f5be6caf682fdea6b91d6648991e end0468f5be6caf682fdea6b91d6648991e: ; - return false -} -func rewriteValueAMD64_OpAMD64SETB(v *Value, config *Config) bool { - b := v.Block - _ = b - // match: (SETB (InvertFlags x)) + // match: (SETAE (FlagEQ)) // cond: - // result: (SETA x) + // result: (MOVBconst [1]) { - if v.Args[0].Op != OpAMD64InvertFlags { - goto endc9eba7aa1e54a228570d2f5cc96f3565 + if v.Args[0].Op != OpAMD64FlagEQ { + goto endc6396df3825db703a99be0e624c6396f } - x := v.Args[0].Args[0] + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 1 + return true + } + goto endc6396df3825db703a99be0e624c6396f +endc6396df3825db703a99be0e624c6396f: + ; + // match: (SETAE (FlagLT_ULT)) + // cond: + // result: (MOVBconst [0]) + { + if v.Args[0].Op != OpAMD64FlagLT_ULT { + goto end2392c77d6746969c65a422c68ad193bc + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end2392c77d6746969c65a422c68ad193bc +end2392c77d6746969c65a422c68ad193bc: + ; + // match: (SETAE (FlagLT_UGT)) + // cond: + // result: (MOVBconst [1]) + { + if v.Args[0].Op != OpAMD64FlagLT_UGT { + goto end081f3b2b98d3a990739d2a5562d4f254 + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 1 + return true + } + goto end081f3b2b98d3a990739d2a5562d4f254 +end081f3b2b98d3a990739d2a5562d4f254: + ; + // match: (SETAE (FlagGT_ULT)) + // cond: + // result: (MOVBconst [0]) + { + if v.Args[0].Op != OpAMD64FlagGT_ULT { + goto end47a6cc5efdd00e349c5e23be3624d719 + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end47a6cc5efdd00e349c5e23be3624d719 +end47a6cc5efdd00e349c5e23be3624d719: + ; + // match: (SETAE (FlagGT_UGT)) + // cond: + // result: (MOVBconst [1]) + { + if v.Args[0].Op != OpAMD64FlagGT_UGT { + goto endd47bb51035b00c560b5347b3be19e20e + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 1 + return true + } + goto endd47bb51035b00c560b5347b3be19e20e +endd47bb51035b00c560b5347b3be19e20e: + ; + return false +} +func rewriteValueAMD64_OpAMD64SETB(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (SETB (InvertFlags x)) + // cond: + // result: (SETA x) + { + if v.Args[0].Op != OpAMD64InvertFlags { + goto endc9eba7aa1e54a228570d2f5cc96f3565 + } + x := v.Args[0].Args[0] v.Op = OpAMD64SETA v.AuxInt = 0 v.Aux = nil @@ -11333,100 +11805,525 @@ func rewriteValueAMD64_OpAMD64SETB(v *Value, config *Config) bool { v.AddArg(x) return true } - goto endc9eba7aa1e54a228570d2f5cc96f3565 -endc9eba7aa1e54a228570d2f5cc96f3565: + goto endc9eba7aa1e54a228570d2f5cc96f3565 +endc9eba7aa1e54a228570d2f5cc96f3565: + ; + // match: (SETB (FlagEQ)) + // cond: + // result: (MOVBconst [0]) + { + if v.Args[0].Op != OpAMD64FlagEQ { + goto endaf8a2c61689b00c8ad90dd090e634c81 + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto endaf8a2c61689b00c8ad90dd090e634c81 +endaf8a2c61689b00c8ad90dd090e634c81: + ; + // match: (SETB (FlagLT_ULT)) + // cond: + // result: (MOVBconst [1]) + { + if v.Args[0].Op != OpAMD64FlagLT_ULT { + goto endab96387d5f049ab9c87863473a5d6510 + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 1 + return true + } + goto endab96387d5f049ab9c87863473a5d6510 +endab96387d5f049ab9c87863473a5d6510: + ; + // match: (SETB (FlagLT_UGT)) + // cond: + // result: (MOVBconst [0]) + { + if v.Args[0].Op != OpAMD64FlagLT_UGT { + goto endbf7af56278add8851974cd1a538b3b7f + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto endbf7af56278add8851974cd1a538b3b7f +endbf7af56278add8851974cd1a538b3b7f: + ; + // match: (SETB (FlagGT_ULT)) + // cond: + // result: (MOVBconst [1]) + { + if v.Args[0].Op != OpAMD64FlagGT_ULT { + goto end2d07a10db28e5160fccf66ee44c4823e + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 1 + return true + } + goto end2d07a10db28e5160fccf66ee44c4823e +end2d07a10db28e5160fccf66ee44c4823e: + ; + // match: (SETB (FlagGT_UGT)) + // cond: + // result: (MOVBconst [0]) + { + if v.Args[0].Op != OpAMD64FlagGT_UGT { + goto end87ec5187683c0ee498c0a2c4de59f4c0 + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end87ec5187683c0ee498c0a2c4de59f4c0 +end87ec5187683c0ee498c0a2c4de59f4c0: + ; + return false +} +func rewriteValueAMD64_OpAMD64SETBE(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (SETBE (InvertFlags x)) + // cond: + // result: (SETAE x) + { + if v.Args[0].Op != OpAMD64InvertFlags { + goto end9d9031643469798b14b8cad1f5a7a1ba + } + x := v.Args[0].Args[0] + v.Op = OpAMD64SETAE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end9d9031643469798b14b8cad1f5a7a1ba +end9d9031643469798b14b8cad1f5a7a1ba: + ; + // match: (SETBE (FlagEQ)) + // cond: + // result: (MOVBconst [1]) + { + if v.Args[0].Op != OpAMD64FlagEQ { + goto ende6a02d3ce0e1584e806c7861de97eb5b + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 1 + return true + } + goto ende6a02d3ce0e1584e806c7861de97eb5b +ende6a02d3ce0e1584e806c7861de97eb5b: + ; + // match: (SETBE (FlagLT_ULT)) + // cond: + // result: (MOVBconst [1]) + { + if v.Args[0].Op != OpAMD64FlagLT_ULT { + goto end7ea0208cd10e6311655d09e8aa354169 + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 1 + return true + } + goto end7ea0208cd10e6311655d09e8aa354169 +end7ea0208cd10e6311655d09e8aa354169: + ; + // match: (SETBE (FlagLT_UGT)) + // cond: + // result: (MOVBconst [0]) + { + if v.Args[0].Op != OpAMD64FlagLT_UGT { + goto enddbfa0595802c67348d3a3bd22b198231 + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto enddbfa0595802c67348d3a3bd22b198231 +enddbfa0595802c67348d3a3bd22b198231: + ; + // match: (SETBE (FlagGT_ULT)) + // cond: + // result: (MOVBconst [1]) + { + if v.Args[0].Op != OpAMD64FlagGT_ULT { + goto end5b26e1d28d6a517ed004b0f9b80df27b + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 1 + return true + } + goto end5b26e1d28d6a517ed004b0f9b80df27b +end5b26e1d28d6a517ed004b0f9b80df27b: + ; + // match: (SETBE (FlagGT_UGT)) + // cond: + // result: (MOVBconst [0]) + { + if v.Args[0].Op != OpAMD64FlagGT_UGT { + goto end679e2e0ccd0dd526ea781fc64102cb88 + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end679e2e0ccd0dd526ea781fc64102cb88 +end679e2e0ccd0dd526ea781fc64102cb88: + ; + return false +} +func rewriteValueAMD64_OpAMD64SETEQ(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (SETEQ (InvertFlags x)) + // cond: + // result: (SETEQ x) + { + if v.Args[0].Op != OpAMD64InvertFlags { + goto end5d2039c9368d8c0cfba23b5a85b459e1 + } + x := v.Args[0].Args[0] + v.Op = OpAMD64SETEQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end5d2039c9368d8c0cfba23b5a85b459e1 +end5d2039c9368d8c0cfba23b5a85b459e1: + ; + // match: (SETEQ (FlagEQ)) + // cond: + // result: (MOVBconst [1]) + { + if v.Args[0].Op != OpAMD64FlagEQ { + goto end74e09087ca9d4bdf7740f4f052d2b9d3 + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 1 + return true + } + goto end74e09087ca9d4bdf7740f4f052d2b9d3 +end74e09087ca9d4bdf7740f4f052d2b9d3: + ; + // match: (SETEQ (FlagLT_ULT)) + // cond: + // result: (MOVBconst [0]) + { + if v.Args[0].Op != OpAMD64FlagLT_ULT { + goto ende5d3756d09e616648de68d364b2c308f + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto ende5d3756d09e616648de68d364b2c308f +ende5d3756d09e616648de68d364b2c308f: + ; + // match: (SETEQ (FlagLT_UGT)) + // cond: + // result: (MOVBconst [0]) + { + if v.Args[0].Op != OpAMD64FlagLT_UGT { + goto end1a86a603a5c6e0f328f63b9279137bcc + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end1a86a603a5c6e0f328f63b9279137bcc +end1a86a603a5c6e0f328f63b9279137bcc: + ; + // match: (SETEQ (FlagGT_ULT)) + // cond: + // result: (MOVBconst [0]) + { + if v.Args[0].Op != OpAMD64FlagGT_ULT { + goto endbf907332cd6004c73b88f43b5e20275f + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto endbf907332cd6004c73b88f43b5e20275f +endbf907332cd6004c73b88f43b5e20275f: + ; + // match: (SETEQ (FlagGT_UGT)) + // cond: + // result: (MOVBconst [0]) + { + if v.Args[0].Op != OpAMD64FlagGT_UGT { + goto end707540a9904307c186884f60e425ca62 + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end707540a9904307c186884f60e425ca62 +end707540a9904307c186884f60e425ca62: + ; + return false +} +func rewriteValueAMD64_OpAMD64SETG(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (SETG (InvertFlags x)) + // cond: + // result: (SETL x) + { + if v.Args[0].Op != OpAMD64InvertFlags { + goto endf7586738694c9cd0b74ae28bbadb649f + } + x := v.Args[0].Args[0] + v.Op = OpAMD64SETL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto endf7586738694c9cd0b74ae28bbadb649f +endf7586738694c9cd0b74ae28bbadb649f: + ; + // match: (SETG (FlagEQ)) + // cond: + // result: (MOVBconst [0]) + { + if v.Args[0].Op != OpAMD64FlagEQ { + goto endc952db8883f26126822bac29276b0690 + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto endc952db8883f26126822bac29276b0690 +endc952db8883f26126822bac29276b0690: + ; + // match: (SETG (FlagLT_ULT)) + // cond: + // result: (MOVBconst [0]) + { + if v.Args[0].Op != OpAMD64FlagLT_ULT { + goto end3b6d659c9285d30eba022a85c6c6f1c9 + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end3b6d659c9285d30eba022a85c6c6f1c9 +end3b6d659c9285d30eba022a85c6c6f1c9: + ; + // match: (SETG (FlagLT_UGT)) + // cond: + // result: (MOVBconst [0]) + { + if v.Args[0].Op != OpAMD64FlagLT_UGT { + goto end2eabfc908ca06e7d5d217142dd48af33 + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end2eabfc908ca06e7d5d217142dd48af33 +end2eabfc908ca06e7d5d217142dd48af33: + ; + // match: (SETG (FlagGT_ULT)) + // cond: + // result: (MOVBconst [1]) + { + if v.Args[0].Op != OpAMD64FlagGT_ULT { + goto end7c059e63a98776c77bb8e43759d2d864 + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 1 + return true + } + goto end7c059e63a98776c77bb8e43759d2d864 +end7c059e63a98776c77bb8e43759d2d864: + ; + // match: (SETG (FlagGT_UGT)) + // cond: + // result: (MOVBconst [1]) + { + if v.Args[0].Op != OpAMD64FlagGT_UGT { + goto enddcb3196491c82060bcb90da722ffa8bd + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 1 + return true + } + goto enddcb3196491c82060bcb90da722ffa8bd +enddcb3196491c82060bcb90da722ffa8bd: + ; + return false +} +func rewriteValueAMD64_OpAMD64SETGE(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (SETGE (InvertFlags x)) + // cond: + // result: (SETLE x) + { + if v.Args[0].Op != OpAMD64InvertFlags { + goto end82c11eff6f842159f564f2dad3d2eedc + } + x := v.Args[0].Args[0] + v.Op = OpAMD64SETLE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto end82c11eff6f842159f564f2dad3d2eedc +end82c11eff6f842159f564f2dad3d2eedc: ; - return false -} -func rewriteValueAMD64_OpAMD64SETBE(v *Value, config *Config) bool { - b := v.Block - _ = b - // match: (SETBE (InvertFlags x)) + // match: (SETGE (FlagEQ)) // cond: - // result: (SETAE x) + // result: (MOVBconst [1]) { - if v.Args[0].Op != OpAMD64InvertFlags { - goto end9d9031643469798b14b8cad1f5a7a1ba + if v.Args[0].Op != OpAMD64FlagEQ { + goto end1152b03b15fb4ea1822b2cc1c6815887 } - x := v.Args[0].Args[0] - v.Op = OpAMD64SETAE + v.Op = OpAMD64MOVBconst v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AddArg(x) + v.AuxInt = 1 return true } - goto end9d9031643469798b14b8cad1f5a7a1ba -end9d9031643469798b14b8cad1f5a7a1ba: + goto end1152b03b15fb4ea1822b2cc1c6815887 +end1152b03b15fb4ea1822b2cc1c6815887: ; - return false -} -func rewriteValueAMD64_OpAMD64SETEQ(v *Value, config *Config) bool { - b := v.Block - _ = b - // match: (SETEQ (InvertFlags x)) + // match: (SETGE (FlagLT_ULT)) // cond: - // result: (SETEQ x) + // result: (MOVBconst [0]) { - if v.Args[0].Op != OpAMD64InvertFlags { - goto end5d2039c9368d8c0cfba23b5a85b459e1 + if v.Args[0].Op != OpAMD64FlagLT_ULT { + goto endd55763184b306cc32397b421df6fc994 } - x := v.Args[0].Args[0] - v.Op = OpAMD64SETEQ + v.Op = OpAMD64MOVBconst v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AddArg(x) + v.AuxInt = 0 return true } - goto end5d2039c9368d8c0cfba23b5a85b459e1 -end5d2039c9368d8c0cfba23b5a85b459e1: + goto endd55763184b306cc32397b421df6fc994 +endd55763184b306cc32397b421df6fc994: ; - return false -} -func rewriteValueAMD64_OpAMD64SETG(v *Value, config *Config) bool { - b := v.Block - _ = b - // match: (SETG (InvertFlags x)) + // match: (SETGE (FlagLT_UGT)) // cond: - // result: (SETL x) + // result: (MOVBconst [0]) { - if v.Args[0].Op != OpAMD64InvertFlags { - goto endf7586738694c9cd0b74ae28bbadb649f + if v.Args[0].Op != OpAMD64FlagLT_UGT { + goto end209fbc531c4d6696b0b226c1ac016add } - x := v.Args[0].Args[0] - v.Op = OpAMD64SETL + v.Op = OpAMD64MOVBconst v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AddArg(x) + v.AuxInt = 0 return true } - goto endf7586738694c9cd0b74ae28bbadb649f -endf7586738694c9cd0b74ae28bbadb649f: + goto end209fbc531c4d6696b0b226c1ac016add +end209fbc531c4d6696b0b226c1ac016add: ; - return false -} -func rewriteValueAMD64_OpAMD64SETGE(v *Value, config *Config) bool { - b := v.Block - _ = b - // match: (SETGE (InvertFlags x)) + // match: (SETGE (FlagGT_ULT)) // cond: - // result: (SETLE x) + // result: (MOVBconst [1]) { - if v.Args[0].Op != OpAMD64InvertFlags { - goto end82c11eff6f842159f564f2dad3d2eedc + if v.Args[0].Op != OpAMD64FlagGT_ULT { + goto end41600cc6b5af1497fc534af49eaf60a2 } - x := v.Args[0].Args[0] - v.Op = OpAMD64SETLE + v.Op = OpAMD64MOVBconst v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AddArg(x) + v.AuxInt = 1 return true } - goto end82c11eff6f842159f564f2dad3d2eedc -end82c11eff6f842159f564f2dad3d2eedc: + goto end41600cc6b5af1497fc534af49eaf60a2 +end41600cc6b5af1497fc534af49eaf60a2: + ; + // match: (SETGE (FlagGT_UGT)) + // cond: + // result: (MOVBconst [1]) + { + if v.Args[0].Op != OpAMD64FlagGT_UGT { + goto endaa33fb1204dba90a141a9a945a9643a2 + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 1 + return true + } + goto endaa33fb1204dba90a141a9a945a9643a2 +endaa33fb1204dba90a141a9a945a9643a2: ; return false } @@ -11450,6 +12347,91 @@ func rewriteValueAMD64_OpAMD64SETL(v *Value, config *Config) bool { } goto ende33160cd86b9d4d3b77e02fb4658d5d3 ende33160cd86b9d4d3b77e02fb4658d5d3: + ; + // match: (SETL (FlagEQ)) + // cond: + // result: (MOVBconst [0]) + { + if v.Args[0].Op != OpAMD64FlagEQ { + goto end52e421ca76fa5dfba6b9bc35b220c0bf + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end52e421ca76fa5dfba6b9bc35b220c0bf +end52e421ca76fa5dfba6b9bc35b220c0bf: + ; + // match: (SETL (FlagLT_ULT)) + // cond: + // result: (MOVBconst [1]) + { + if v.Args[0].Op != OpAMD64FlagLT_ULT { + goto end4d9781536010887bcf6f6ffd563e6aac + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 1 + return true + } + goto end4d9781536010887bcf6f6ffd563e6aac +end4d9781536010887bcf6f6ffd563e6aac: + ; + // match: (SETL (FlagLT_UGT)) + // cond: + // result: (MOVBconst [1]) + { + if v.Args[0].Op != OpAMD64FlagLT_UGT { + goto end9d0dd525ca800cb3ec73e94d60c3cbf1 + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 1 + return true + } + goto end9d0dd525ca800cb3ec73e94d60c3cbf1 +end9d0dd525ca800cb3ec73e94d60c3cbf1: + ; + // match: (SETL (FlagGT_ULT)) + // cond: + // result: (MOVBconst [0]) + { + if v.Args[0].Op != OpAMD64FlagGT_ULT { + goto end6d77da1539ee0ebebee0e162c55e8f6e + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end6d77da1539ee0ebebee0e162c55e8f6e +end6d77da1539ee0ebebee0e162c55e8f6e: + ; + // match: (SETL (FlagGT_UGT)) + // cond: + // result: (MOVBconst [0]) + { + if v.Args[0].Op != OpAMD64FlagGT_UGT { + goto end6c129bef0cc197325a338d17720516d1 + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end6c129bef0cc197325a338d17720516d1 +end6c129bef0cc197325a338d17720516d1: ; return false } @@ -11473,6 +12455,91 @@ func rewriteValueAMD64_OpAMD64SETLE(v *Value, config *Config) bool { } goto end9307d96753efbeb888d1c98a6aba7a29 end9307d96753efbeb888d1c98a6aba7a29: + ; + // match: (SETLE (FlagEQ)) + // cond: + // result: (MOVBconst [1]) + { + if v.Args[0].Op != OpAMD64FlagEQ { + goto end43f998d2f9524fcdf45bab9fe672aa7c + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 1 + return true + } + goto end43f998d2f9524fcdf45bab9fe672aa7c +end43f998d2f9524fcdf45bab9fe672aa7c: + ; + // match: (SETLE (FlagLT_ULT)) + // cond: + // result: (MOVBconst [1]) + { + if v.Args[0].Op != OpAMD64FlagLT_ULT { + goto end80212f1ca6a01bccdf4bbd5aa15d5aab + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 1 + return true + } + goto end80212f1ca6a01bccdf4bbd5aa15d5aab +end80212f1ca6a01bccdf4bbd5aa15d5aab: + ; + // match: (SETLE (FlagLT_UGT)) + // cond: + // result: (MOVBconst [1]) + { + if v.Args[0].Op != OpAMD64FlagLT_UGT { + goto endd5ab2a8df7344cd7c8e1092d78bfd871 + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 1 + return true + } + goto endd5ab2a8df7344cd7c8e1092d78bfd871 +endd5ab2a8df7344cd7c8e1092d78bfd871: + ; + // match: (SETLE (FlagGT_ULT)) + // cond: + // result: (MOVBconst [0]) + { + if v.Args[0].Op != OpAMD64FlagGT_ULT { + goto enda74997e85c6f82ff1c530e6051d01e21 + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto enda74997e85c6f82ff1c530e6051d01e21 +enda74997e85c6f82ff1c530e6051d01e21: + ; + // match: (SETLE (FlagGT_UGT)) + // cond: + // result: (MOVBconst [0]) + { + if v.Args[0].Op != OpAMD64FlagGT_UGT { + goto end7694b41632545d10fcc6339063c53f07 + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end7694b41632545d10fcc6339063c53f07 +end7694b41632545d10fcc6339063c53f07: ; return false } @@ -11486,16 +12553,101 @@ func rewriteValueAMD64_OpAMD64SETNE(v *Value, config *Config) bool { if v.Args[0].Op != OpAMD64InvertFlags { goto endbc71811b789475308014550f638026eb } - x := v.Args[0].Args[0] - v.Op = OpAMD64SETNE + x := v.Args[0].Args[0] + v.Op = OpAMD64SETNE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + return true + } + goto endbc71811b789475308014550f638026eb +endbc71811b789475308014550f638026eb: + ; + // match: (SETNE (FlagEQ)) + // cond: + // result: (MOVBconst [0]) + { + if v.Args[0].Op != OpAMD64FlagEQ { + goto end6b66ea2ed518a926a071fe0d3dce46d8 + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end6b66ea2ed518a926a071fe0d3dce46d8 +end6b66ea2ed518a926a071fe0d3dce46d8: + ; + // match: (SETNE (FlagLT_ULT)) + // cond: + // result: (MOVBconst [1]) + { + if v.Args[0].Op != OpAMD64FlagLT_ULT { + goto ende4d3b99f9dff014be3067a577ba0b016 + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 1 + return true + } + goto ende4d3b99f9dff014be3067a577ba0b016 +ende4d3b99f9dff014be3067a577ba0b016: + ; + // match: (SETNE (FlagLT_UGT)) + // cond: + // result: (MOVBconst [1]) + { + if v.Args[0].Op != OpAMD64FlagLT_UGT { + goto endb98d73ed6e5d3d21c2ea33840ab2a21c + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 1 + return true + } + goto endb98d73ed6e5d3d21c2ea33840ab2a21c +endb98d73ed6e5d3d21c2ea33840ab2a21c: + ; + // match: (SETNE (FlagGT_ULT)) + // cond: + // result: (MOVBconst [1]) + { + if v.Args[0].Op != OpAMD64FlagGT_ULT { + goto end3bceb5cece8d0112cc8cd53435d64ef4 + } + v.Op = OpAMD64MOVBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 1 + return true + } + goto end3bceb5cece8d0112cc8cd53435d64ef4 +end3bceb5cece8d0112cc8cd53435d64ef4: + ; + // match: (SETNE (FlagGT_UGT)) + // cond: + // result: (MOVBconst [1]) + { + if v.Args[0].Op != OpAMD64FlagGT_UGT { + goto end9249b3ed3e1e582dd5435fb73cbc13ac + } + v.Op = OpAMD64MOVBconst v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AddArg(x) + v.AuxInt = 1 return true } - goto endbc71811b789475308014550f638026eb -endbc71811b789475308014550f638026eb: + goto end9249b3ed3e1e582dd5435fb73cbc13ac +end9249b3ed3e1e582dd5435fb73cbc13ac: ; return false } @@ -13908,6 +15060,105 @@ func rewriteBlockAMD64(b *Block) bool { goto end6b8e9afc73b1c4d528f31a60d2575fae end6b8e9afc73b1c4d528f31a60d2575fae: ; + // match: (EQ (FlagEQ) yes no) + // cond: + // result: (First nil yes no) + { + v := b.Control + if v.Op != OpAMD64FlagEQ { + goto end9ff0ac95bed10cc8e2b88351720bf254 + } + yes := b.Succs[0] + no := b.Succs[1] + b.Kind = BlockFirst + b.Control = nil + b.Succs[0] = yes + b.Succs[1] = no + return true + } + goto end9ff0ac95bed10cc8e2b88351720bf254 + end9ff0ac95bed10cc8e2b88351720bf254: + ; + // match: (EQ (FlagLT_ULT) yes no) + // cond: + // result: (First nil no yes) + { + v := b.Control + if v.Op != OpAMD64FlagLT_ULT { + goto endb087fca771315fb0f3e36b4f3daa1b4f + } + 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 + } + goto endb087fca771315fb0f3e36b4f3daa1b4f + endb087fca771315fb0f3e36b4f3daa1b4f: + ; + // match: (EQ (FlagLT_UGT) yes no) + // cond: + // result: (First nil no yes) + { + v := b.Control + if v.Op != OpAMD64FlagLT_UGT { + goto endd1884731c9bd3c1cc1b27617e4573add + } + 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 + } + goto endd1884731c9bd3c1cc1b27617e4573add + endd1884731c9bd3c1cc1b27617e4573add: + ; + // match: (EQ (FlagGT_ULT) yes no) + // cond: + // result: (First nil no yes) + { + v := b.Control + if v.Op != OpAMD64FlagGT_ULT { + goto end13acc127fef124a130ad1e79fd6a58c9 + } + 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 + } + goto end13acc127fef124a130ad1e79fd6a58c9 + end13acc127fef124a130ad1e79fd6a58c9: + ; + // match: (EQ (FlagGT_UGT) yes no) + // cond: + // result: (First nil no yes) + { + v := b.Control + if v.Op != OpAMD64FlagGT_UGT { + goto end4bdb3694a7ed9860cc65f54840b11e84 + } + 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 + } + goto end4bdb3694a7ed9860cc65f54840b11e84 + end4bdb3694a7ed9860cc65f54840b11e84: + ; case BlockAMD64GE: // match: (GE (InvertFlags cmp) yes no) // cond: @@ -13929,6 +15180,103 @@ func rewriteBlockAMD64(b *Block) bool { goto end0610f000a6988ee8310307ec2ea138f8 end0610f000a6988ee8310307ec2ea138f8: ; + // match: (GE (FlagEQ) yes no) + // cond: + // result: (First nil yes no) + { + v := b.Control + if v.Op != OpAMD64FlagEQ { + goto end24ae40580bbb8675d15f6d1451beeb56 + } + yes := b.Succs[0] + no := b.Succs[1] + b.Kind = BlockFirst + b.Control = nil + b.Succs[0] = yes + b.Succs[1] = no + return true + } + goto end24ae40580bbb8675d15f6d1451beeb56 + end24ae40580bbb8675d15f6d1451beeb56: + ; + // match: (GE (FlagLT_ULT) yes no) + // cond: + // result: (First nil no yes) + { + v := b.Control + if v.Op != OpAMD64FlagLT_ULT { + goto end40cf2bb5d1a99146cc6ce5e9a9dc7eee + } + 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 + } + goto end40cf2bb5d1a99146cc6ce5e9a9dc7eee + end40cf2bb5d1a99146cc6ce5e9a9dc7eee: + ; + // match: (GE (FlagLT_UGT) yes no) + // cond: + // result: (First nil no yes) + { + v := b.Control + if v.Op != OpAMD64FlagLT_UGT { + goto end2d4809306e6243116f4c1b27c7c9e503 + } + 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 + } + goto end2d4809306e6243116f4c1b27c7c9e503 + end2d4809306e6243116f4c1b27c7c9e503: + ; + // match: (GE (FlagGT_ULT) yes no) + // cond: + // result: (First nil yes no) + { + v := b.Control + if v.Op != OpAMD64FlagGT_ULT { + goto end842c411ddb1c5583e1e986f2826bb3cf + } + yes := b.Succs[0] + no := b.Succs[1] + b.Kind = BlockFirst + b.Control = nil + b.Succs[0] = yes + b.Succs[1] = no + return true + } + goto end842c411ddb1c5583e1e986f2826bb3cf + end842c411ddb1c5583e1e986f2826bb3cf: + ; + // match: (GE (FlagGT_UGT) yes no) + // cond: + // result: (First nil yes no) + { + v := b.Control + if v.Op != OpAMD64FlagGT_UGT { + goto end7402ddc29ccc96070353e9a04e126444 + } + yes := b.Succs[0] + no := b.Succs[1] + b.Kind = BlockFirst + b.Control = nil + b.Succs[0] = yes + b.Succs[1] = no + return true + } + goto end7402ddc29ccc96070353e9a04e126444 + end7402ddc29ccc96070353e9a04e126444: + ; case BlockAMD64GT: // match: (GT (InvertFlags cmp) yes no) // cond: @@ -13950,6 +15298,104 @@ func rewriteBlockAMD64(b *Block) bool { goto endf60c0660b6a8aa9565c97fc87f04eb34 endf60c0660b6a8aa9565c97fc87f04eb34: ; + // match: (GT (FlagEQ) yes no) + // cond: + // result: (First nil no yes) + { + v := b.Control + if v.Op != OpAMD64FlagEQ { + goto end2ba8650a12af813cee310b2a81b9ba1b + } + 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 + } + goto end2ba8650a12af813cee310b2a81b9ba1b + end2ba8650a12af813cee310b2a81b9ba1b: + ; + // match: (GT (FlagLT_ULT) yes no) + // cond: + // result: (First nil no yes) + { + v := b.Control + if v.Op != OpAMD64FlagLT_ULT { + goto endbe873b5adbcdd272c99e04e063f9b7ce + } + 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 + } + goto endbe873b5adbcdd272c99e04e063f9b7ce + endbe873b5adbcdd272c99e04e063f9b7ce: + ; + // match: (GT (FlagLT_UGT) yes no) + // cond: + // result: (First nil no yes) + { + v := b.Control + if v.Op != OpAMD64FlagLT_UGT { + goto ende5dd5906f7fdb5c0e59eeed92a3684d3 + } + 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 + } + goto ende5dd5906f7fdb5c0e59eeed92a3684d3 + ende5dd5906f7fdb5c0e59eeed92a3684d3: + ; + // match: (GT (FlagGT_ULT) yes no) + // cond: + // result: (First nil yes no) + { + v := b.Control + if v.Op != OpAMD64FlagGT_ULT { + goto end7d92e57429ee02c3707f39d861c94f4c + } + yes := b.Succs[0] + no := b.Succs[1] + b.Kind = BlockFirst + b.Control = nil + b.Succs[0] = yes + b.Succs[1] = no + return true + } + goto end7d92e57429ee02c3707f39d861c94f4c + end7d92e57429ee02c3707f39d861c94f4c: + ; + // match: (GT (FlagGT_UGT) yes no) + // cond: + // result: (First nil yes no) + { + v := b.Control + if v.Op != OpAMD64FlagGT_UGT { + goto end9d77d9a15c1b0938558a4ce821d50aa1 + } + yes := b.Succs[0] + no := b.Succs[1] + b.Kind = BlockFirst + b.Control = nil + b.Succs[0] = yes + b.Succs[1] = no + return true + } + goto end9d77d9a15c1b0938558a4ce821d50aa1 + end9d77d9a15c1b0938558a4ce821d50aa1: + ; case BlockIf: // match: (If (SETL cmp) yes no) // cond: @@ -14273,6 +15719,103 @@ func rewriteBlockAMD64(b *Block) bool { goto end0d49d7d087fe7578e8015cf13dae37e3 end0d49d7d087fe7578e8015cf13dae37e3: ; + // match: (LE (FlagEQ) yes no) + // cond: + // result: (First nil yes no) + { + v := b.Control + if v.Op != OpAMD64FlagEQ { + goto end794469f5273ff9b2867ec900775c72d2 + } + yes := b.Succs[0] + no := b.Succs[1] + b.Kind = BlockFirst + b.Control = nil + b.Succs[0] = yes + b.Succs[1] = no + return true + } + goto end794469f5273ff9b2867ec900775c72d2 + end794469f5273ff9b2867ec900775c72d2: + ; + // match: (LE (FlagLT_ULT) yes no) + // cond: + // result: (First nil yes no) + { + v := b.Control + if v.Op != OpAMD64FlagLT_ULT { + goto end0b9fee7a7eb47fe268039bc0e529d6ac + } + yes := b.Succs[0] + no := b.Succs[1] + b.Kind = BlockFirst + b.Control = nil + b.Succs[0] = yes + b.Succs[1] = no + return true + } + goto end0b9fee7a7eb47fe268039bc0e529d6ac + end0b9fee7a7eb47fe268039bc0e529d6ac: + ; + // match: (LE (FlagLT_UGT) yes no) + // cond: + // result: (First nil yes no) + { + v := b.Control + if v.Op != OpAMD64FlagLT_UGT { + goto end519d8c93a652b9062fba49942dc7d28d + } + yes := b.Succs[0] + no := b.Succs[1] + b.Kind = BlockFirst + b.Control = nil + b.Succs[0] = yes + b.Succs[1] = no + return true + } + goto end519d8c93a652b9062fba49942dc7d28d + end519d8c93a652b9062fba49942dc7d28d: + ; + // match: (LE (FlagGT_ULT) yes no) + // cond: + // result: (First nil no yes) + { + v := b.Control + if v.Op != OpAMD64FlagGT_ULT { + goto endbd11ec75f000579a43fd6507282b307d + } + 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 + } + goto endbd11ec75f000579a43fd6507282b307d + endbd11ec75f000579a43fd6507282b307d: + ; + // match: (LE (FlagGT_UGT) yes no) + // cond: + // result: (First nil no yes) + { + v := b.Control + if v.Op != OpAMD64FlagGT_UGT { + goto end3828ab56cc3c548c96ac30592e5f865a + } + 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 + } + goto end3828ab56cc3c548c96ac30592e5f865a + end3828ab56cc3c548c96ac30592e5f865a: + ; case BlockAMD64LT: // match: (LT (InvertFlags cmp) yes no) // cond: @@ -14291,8 +15834,106 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end6a408cde0fee0ae7b7da0443c8d902bf - end6a408cde0fee0ae7b7da0443c8d902bf: + goto end6a408cde0fee0ae7b7da0443c8d902bf + end6a408cde0fee0ae7b7da0443c8d902bf: + ; + // match: (LT (FlagEQ) yes no) + // cond: + // result: (First nil no yes) + { + v := b.Control + if v.Op != OpAMD64FlagEQ { + goto enda9dfcd37198ce9684d4bb3a2e54feea9 + } + 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 + } + goto enda9dfcd37198ce9684d4bb3a2e54feea9 + enda9dfcd37198ce9684d4bb3a2e54feea9: + ; + // match: (LT (FlagLT_ULT) yes no) + // cond: + // result: (First nil yes no) + { + v := b.Control + if v.Op != OpAMD64FlagLT_ULT { + goto ende2b678683d46e68bb0b1503f351917dc + } + yes := b.Succs[0] + no := b.Succs[1] + b.Kind = BlockFirst + b.Control = nil + b.Succs[0] = yes + b.Succs[1] = no + return true + } + goto ende2b678683d46e68bb0b1503f351917dc + ende2b678683d46e68bb0b1503f351917dc: + ; + // match: (LT (FlagLT_UGT) yes no) + // cond: + // result: (First nil yes no) + { + v := b.Control + if v.Op != OpAMD64FlagLT_UGT { + goto end24e744700aa56591fbd23e1335d6e293 + } + yes := b.Succs[0] + no := b.Succs[1] + b.Kind = BlockFirst + b.Control = nil + b.Succs[0] = yes + b.Succs[1] = no + return true + } + goto end24e744700aa56591fbd23e1335d6e293 + end24e744700aa56591fbd23e1335d6e293: + ; + // match: (LT (FlagGT_ULT) yes no) + // cond: + // result: (First nil no yes) + { + v := b.Control + if v.Op != OpAMD64FlagGT_ULT { + goto enda178f2150e3da5c17e768a4f81af5f9a + } + 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 + } + goto enda178f2150e3da5c17e768a4f81af5f9a + enda178f2150e3da5c17e768a4f81af5f9a: + ; + // match: (LT (FlagGT_UGT) yes no) + // cond: + // result: (First nil no yes) + { + v := b.Control + if v.Op != OpAMD64FlagGT_UGT { + goto end361a42127127ede8ea30e991bb099ebb + } + 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 + } + goto end361a42127127ede8ea30e991bb099ebb + end361a42127127ede8ea30e991bb099ebb: ; case BlockAMD64NE: // match: (NE (TESTB (SETL cmp)) yes no) @@ -14637,6 +16278,102 @@ func rewriteBlockAMD64(b *Block) bool { goto end713001aba794e50b582fbff930e110af end713001aba794e50b582fbff930e110af: ; + // match: (NE (FlagEQ) yes no) + // cond: + // result: (First nil no yes) + { + v := b.Control + if v.Op != OpAMD64FlagEQ { + goto end55cc491bc7fc08ef27cadaa80d197545 + } + 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 + } + goto end55cc491bc7fc08ef27cadaa80d197545 + end55cc491bc7fc08ef27cadaa80d197545: + ; + // match: (NE (FlagLT_ULT) yes no) + // cond: + // result: (First nil yes no) + { + v := b.Control + if v.Op != OpAMD64FlagLT_ULT { + goto end3293c7b37d9fcc6bd5add16c94108a4b + } + yes := b.Succs[0] + no := b.Succs[1] + b.Kind = BlockFirst + b.Control = nil + b.Succs[0] = yes + b.Succs[1] = no + return true + } + goto end3293c7b37d9fcc6bd5add16c94108a4b + end3293c7b37d9fcc6bd5add16c94108a4b: + ; + // match: (NE (FlagLT_UGT) yes no) + // cond: + // result: (First nil yes no) + { + v := b.Control + if v.Op != OpAMD64FlagLT_UGT { + goto end1a49ef88420e9d7fd745f9675ca01d6e + } + yes := b.Succs[0] + no := b.Succs[1] + b.Kind = BlockFirst + b.Control = nil + b.Succs[0] = yes + b.Succs[1] = no + return true + } + goto end1a49ef88420e9d7fd745f9675ca01d6e + end1a49ef88420e9d7fd745f9675ca01d6e: + ; + // match: (NE (FlagGT_ULT) yes no) + // cond: + // result: (First nil yes no) + { + v := b.Control + if v.Op != OpAMD64FlagGT_ULT { + goto endbd468825bdf21bca47f8d83d580794ec + } + yes := b.Succs[0] + no := b.Succs[1] + b.Kind = BlockFirst + b.Control = nil + b.Succs[0] = yes + b.Succs[1] = no + return true + } + goto endbd468825bdf21bca47f8d83d580794ec + endbd468825bdf21bca47f8d83d580794ec: + ; + // match: (NE (FlagGT_UGT) yes no) + // cond: + // result: (First nil yes no) + { + v := b.Control + if v.Op != OpAMD64FlagGT_UGT { + goto end43cf7171afb4610818c4b63cc14c1f30 + } + yes := b.Succs[0] + no := b.Succs[1] + b.Kind = BlockFirst + b.Control = nil + b.Succs[0] = yes + b.Succs[1] = no + return true + } + goto end43cf7171afb4610818c4b63cc14c1f30 + end43cf7171afb4610818c4b63cc14c1f30: + ; case BlockAMD64UGE: // match: (UGE (InvertFlags cmp) yes no) // cond: @@ -14658,6 +16395,103 @@ func rewriteBlockAMD64(b *Block) bool { goto ende3e4ddc183ca1a46598b11c2d0d13966 ende3e4ddc183ca1a46598b11c2d0d13966: ; + // match: (UGE (FlagEQ) yes no) + // cond: + // result: (First nil yes no) + { + v := b.Control + if v.Op != OpAMD64FlagEQ { + goto end13b873811b0cfc7b08501fa2b96cbaa5 + } + yes := b.Succs[0] + no := b.Succs[1] + b.Kind = BlockFirst + b.Control = nil + b.Succs[0] = yes + b.Succs[1] = no + return true + } + goto end13b873811b0cfc7b08501fa2b96cbaa5 + end13b873811b0cfc7b08501fa2b96cbaa5: + ; + // match: (UGE (FlagLT_ULT) yes no) + // cond: + // result: (First nil no yes) + { + v := b.Control + if v.Op != OpAMD64FlagLT_ULT { + goto end399c10dc3dcdb5864558ecbac4566b7d + } + 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 + } + goto end399c10dc3dcdb5864558ecbac4566b7d + end399c10dc3dcdb5864558ecbac4566b7d: + ; + // match: (UGE (FlagLT_UGT) yes no) + // cond: + // result: (First nil yes no) + { + v := b.Control + if v.Op != OpAMD64FlagLT_UGT { + goto end3013dbd3841b20b5030bafb98ee5e38f + } + yes := b.Succs[0] + no := b.Succs[1] + b.Kind = BlockFirst + b.Control = nil + b.Succs[0] = yes + b.Succs[1] = no + return true + } + goto end3013dbd3841b20b5030bafb98ee5e38f + end3013dbd3841b20b5030bafb98ee5e38f: + ; + // match: (UGE (FlagGT_ULT) yes no) + // cond: + // result: (First nil no yes) + { + v := b.Control + if v.Op != OpAMD64FlagGT_ULT { + goto end9727eb4bb399457be62dc382bb9a0913 + } + 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 + } + goto end9727eb4bb399457be62dc382bb9a0913 + end9727eb4bb399457be62dc382bb9a0913: + ; + // match: (UGE (FlagGT_UGT) yes no) + // cond: + // result: (First nil yes no) + { + v := b.Control + if v.Op != OpAMD64FlagGT_UGT { + goto ende4099f954bd6511668fda560c56e89b1 + } + yes := b.Succs[0] + no := b.Succs[1] + b.Kind = BlockFirst + b.Control = nil + b.Succs[0] = yes + b.Succs[1] = no + return true + } + goto ende4099f954bd6511668fda560c56e89b1 + ende4099f954bd6511668fda560c56e89b1: + ; case BlockAMD64UGT: // match: (UGT (InvertFlags cmp) yes no) // cond: @@ -14679,6 +16513,104 @@ func rewriteBlockAMD64(b *Block) bool { goto end49818853af2e5251175d06c62768cae7 end49818853af2e5251175d06c62768cae7: ; + // match: (UGT (FlagEQ) yes no) + // cond: + // result: (First nil no yes) + { + v := b.Control + if v.Op != OpAMD64FlagEQ { + goto end97e91c3348cb91e9278902aaa7fb050a + } + 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 + } + goto end97e91c3348cb91e9278902aaa7fb050a + end97e91c3348cb91e9278902aaa7fb050a: + ; + // match: (UGT (FlagLT_ULT) yes no) + // cond: + // result: (First nil no yes) + { + v := b.Control + if v.Op != OpAMD64FlagLT_ULT { + goto ende2c57da783c6ad18203c9c418ab0de6a + } + 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 + } + goto ende2c57da783c6ad18203c9c418ab0de6a + ende2c57da783c6ad18203c9c418ab0de6a: + ; + // match: (UGT (FlagLT_UGT) yes no) + // cond: + // result: (First nil yes no) + { + v := b.Control + if v.Op != OpAMD64FlagLT_UGT { + goto end65100b76cf3975a42b235b0e10fea2b1 + } + yes := b.Succs[0] + no := b.Succs[1] + b.Kind = BlockFirst + b.Control = nil + b.Succs[0] = yes + b.Succs[1] = no + return true + } + goto end65100b76cf3975a42b235b0e10fea2b1 + end65100b76cf3975a42b235b0e10fea2b1: + ; + // match: (UGT (FlagGT_ULT) yes no) + // cond: + // result: (First nil no yes) + { + v := b.Control + if v.Op != OpAMD64FlagGT_ULT { + goto end5db8fa9a32980847176e980aa1899bb3 + } + 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 + } + goto end5db8fa9a32980847176e980aa1899bb3 + end5db8fa9a32980847176e980aa1899bb3: + ; + // match: (UGT (FlagGT_UGT) yes no) + // cond: + // result: (First nil yes no) + { + v := b.Control + if v.Op != OpAMD64FlagGT_UGT { + goto end1095a388cf1534294952f4ef4ce3e940 + } + yes := b.Succs[0] + no := b.Succs[1] + b.Kind = BlockFirst + b.Control = nil + b.Succs[0] = yes + b.Succs[1] = no + return true + } + goto end1095a388cf1534294952f4ef4ce3e940 + end1095a388cf1534294952f4ef4ce3e940: + ; case BlockAMD64ULE: // match: (ULE (InvertFlags cmp) yes no) // cond: @@ -14700,6 +16632,103 @@ func rewriteBlockAMD64(b *Block) bool { goto endd6698aac0d67261293b558c95ea17b4f endd6698aac0d67261293b558c95ea17b4f: ; + // match: (ULE (FlagEQ) yes no) + // cond: + // result: (First nil yes no) + { + v := b.Control + if v.Op != OpAMD64FlagEQ { + goto end2d801e9ad76753e9ff3e19ee7c9f8a86 + } + yes := b.Succs[0] + no := b.Succs[1] + b.Kind = BlockFirst + b.Control = nil + b.Succs[0] = yes + b.Succs[1] = no + return true + } + goto end2d801e9ad76753e9ff3e19ee7c9f8a86 + end2d801e9ad76753e9ff3e19ee7c9f8a86: + ; + // match: (ULE (FlagLT_ULT) yes no) + // cond: + // result: (First nil yes no) + { + v := b.Control + if v.Op != OpAMD64FlagLT_ULT { + goto end93b751a70b8587ce2c2dc0545a77246c + } + yes := b.Succs[0] + no := b.Succs[1] + b.Kind = BlockFirst + b.Control = nil + b.Succs[0] = yes + b.Succs[1] = no + return true + } + goto end93b751a70b8587ce2c2dc0545a77246c + end93b751a70b8587ce2c2dc0545a77246c: + ; + // match: (ULE (FlagLT_UGT) yes no) + // cond: + // result: (First nil no yes) + { + v := b.Control + if v.Op != OpAMD64FlagLT_UGT { + goto enda318623645491582b19f9de9b3da20e9 + } + 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 + } + goto enda318623645491582b19f9de9b3da20e9 + enda318623645491582b19f9de9b3da20e9: + ; + // match: (ULE (FlagGT_ULT) yes no) + // cond: + // result: (First nil yes no) + { + v := b.Control + if v.Op != OpAMD64FlagGT_ULT { + goto end1dfb9e417c0a518e1fa9c92edd57723e + } + yes := b.Succs[0] + no := b.Succs[1] + b.Kind = BlockFirst + b.Control = nil + b.Succs[0] = yes + b.Succs[1] = no + return true + } + goto end1dfb9e417c0a518e1fa9c92edd57723e + end1dfb9e417c0a518e1fa9c92edd57723e: + ; + // match: (ULE (FlagGT_UGT) yes no) + // cond: + // result: (First nil no yes) + { + v := b.Control + if v.Op != OpAMD64FlagGT_UGT { + goto end7c9881aac5c0b34d8df3572c8f7b50f3 + } + 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 + } + goto end7c9881aac5c0b34d8df3572c8f7b50f3 + end7c9881aac5c0b34d8df3572c8f7b50f3: + ; case BlockAMD64ULT: // match: (ULT (InvertFlags cmp) yes no) // cond: @@ -14720,6 +16749,104 @@ func rewriteBlockAMD64(b *Block) bool { } goto end35105dbc9646f02577167e45ae2f2fd2 end35105dbc9646f02577167e45ae2f2fd2: + ; + // match: (ULT (FlagEQ) yes no) + // cond: + // result: (First nil no yes) + { + v := b.Control + if v.Op != OpAMD64FlagEQ { + goto end4f7ea32f328981623154b68f21c9585f + } + 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 + } + goto end4f7ea32f328981623154b68f21c9585f + end4f7ea32f328981623154b68f21c9585f: + ; + // match: (ULT (FlagLT_ULT) yes no) + // cond: + // result: (First nil yes no) + { + v := b.Control + if v.Op != OpAMD64FlagLT_ULT { + goto endf8739cbf4e7cdcb02b891bbfc103654a + } + yes := b.Succs[0] + no := b.Succs[1] + b.Kind = BlockFirst + b.Control = nil + b.Succs[0] = yes + b.Succs[1] = no + return true + } + goto endf8739cbf4e7cdcb02b891bbfc103654a + endf8739cbf4e7cdcb02b891bbfc103654a: + ; + // match: (ULT (FlagLT_UGT) yes no) + // cond: + // result: (First nil no yes) + { + v := b.Control + if v.Op != OpAMD64FlagLT_UGT { + goto enddb12a8de4bdb237aa8a1b6186a0f5f01 + } + 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 + } + goto enddb12a8de4bdb237aa8a1b6186a0f5f01 + enddb12a8de4bdb237aa8a1b6186a0f5f01: + ; + // match: (ULT (FlagGT_ULT) yes no) + // cond: + // result: (First nil yes no) + { + v := b.Control + if v.Op != OpAMD64FlagGT_ULT { + goto end5ceb130f54533e645b6be48ac28dd7a1 + } + yes := b.Succs[0] + no := b.Succs[1] + b.Kind = BlockFirst + b.Control = nil + b.Succs[0] = yes + b.Succs[1] = no + return true + } + goto end5ceb130f54533e645b6be48ac28dd7a1 + end5ceb130f54533e645b6be48ac28dd7a1: + ; + // match: (ULT (FlagGT_UGT) yes no) + // cond: + // result: (First nil no yes) + { + v := b.Control + if v.Op != OpAMD64FlagGT_UGT { + goto end17191a994592b633cbf6f935efbeaf72 + } + 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 + } + goto end17191a994592b633cbf6f935efbeaf72 + end17191a994592b633cbf6f935efbeaf72: } return false } -- cgit v1.3 From da8af47710818617d765a25f0ff487fe8d633250 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Wed, 13 Jan 2016 11:14:57 -0800 Subject: [dev.ssa] cmd/compile: report better line numbers for Unimplemented/Fatal If a failure occurs in SSA processing, we always report the last line of the function we're compiling. Modify the callbacks from SSA to the GC compiler so we can pass a line number back and use it in Fatalf. Change-Id: Ifbfad50d5e167e997e0a96f0775bcc369f5c397e Reviewed-on: https://go-review.googlesource.com/18599 Run-TryBot: Keith Randall Reviewed-by: David Chase --- src/cmd/compile/internal/gc/ssa.go | 16 ++++++++++------ src/cmd/compile/internal/ssa/config.go | 14 ++++++++------ src/cmd/compile/internal/ssa/export_test.go | 9 ++++++--- src/cmd/compile/internal/ssa/func.go | 8 +++++--- src/cmd/compile/internal/ssa/html.go | 6 +++--- src/cmd/compile/internal/ssa/value.go | 10 +++++++--- 6 files changed, 39 insertions(+), 24 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index c41a66f1ae..1367b22d89 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -130,7 +130,7 @@ func buildssa(fn *Node) *ssa.Func { 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, name) + s.config.HTML = ssa.NewHTMLWriter("ssa.html", s.config, name) // TODO: generate and print a mapping from nodes to values and blocks } defer func() { @@ -320,9 +320,11 @@ func (s *state) label(sym *Sym) *ssaLabel { return lab } -func (s *state) Logf(msg string, args ...interface{}) { s.config.Logf(msg, args...) } -func (s *state) Fatalf(msg string, args ...interface{}) { s.config.Fatalf(msg, args...) } -func (s *state) Unimplementedf(msg string, args ...interface{}) { s.config.Unimplementedf(msg, args...) } +func (s *state) Logf(msg string, args ...interface{}) { s.config.Logf(msg, args...) } +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() } @@ -4594,17 +4596,19 @@ func (e *ssaExport) Logf(msg string, args ...interface{}) { } // Fatal reports a compiler error and exits. -func (e *ssaExport) Fatalf(msg string, args ...interface{}) { +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(msg string, args ...interface{}) { +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 diff --git a/src/cmd/compile/internal/ssa/config.go b/src/cmd/compile/internal/ssa/config.go index 6d3a949a6a..7ef2fbd2fc 100644 --- a/src/cmd/compile/internal/ssa/config.go +++ b/src/cmd/compile/internal/ssa/config.go @@ -44,11 +44,11 @@ type Logger interface { Logf(string, ...interface{}) // Fatal reports a compiler error and exits. - Fatalf(string, ...interface{}) + 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(msg string, args ...interface{}) + 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{}) @@ -91,7 +91,7 @@ func NewConfig(arch string, fe Frontend, ctxt *obj.Link) *Config { c.lowerBlock = rewriteBlockAMD64 c.lowerValue = rewriteValueAMD64 // TODO(khr): full 32-bit support default: - fe.Unimplementedf("arch %s not implemented", arch) + fe.Unimplementedf(0, "arch %s not implemented", arch) } c.ctxt = ctxt @@ -106,9 +106,11 @@ func (c *Config) NewFunc() *Func { return &Func{Config: c, NamedValues: map[LocalSlot][]*Value{}} } -func (c *Config) Logf(msg string, args ...interface{}) { c.fe.Logf(msg, args...) } -func (c *Config) Fatalf(msg string, args ...interface{}) { c.fe.Fatalf(msg, args...) } -func (c *Config) Unimplementedf(msg string, args ...interface{}) { c.fe.Unimplementedf(msg, args...) } +func (c *Config) Logf(msg string, args ...interface{}) { c.fe.Logf(msg, args...) } +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() } diff --git a/src/cmd/compile/internal/ssa/export_test.go b/src/cmd/compile/internal/ssa/export_test.go index c37db75803..f4d8d58549 100644 --- a/src/cmd/compile/internal/ssa/export_test.go +++ b/src/cmd/compile/internal/ssa/export_test.go @@ -32,9 +32,12 @@ func (DummyFrontend) Auto(t Type) GCNode { return nil } -func (d DummyFrontend) Logf(msg string, args ...interface{}) { d.t.Logf(msg, args...) } -func (d DummyFrontend) Fatalf(msg string, args ...interface{}) { d.t.Fatalf(msg, args...) } -func (d DummyFrontend) Unimplementedf(msg string, args ...interface{}) { d.t.Fatalf(msg, args...) } +func (d DummyFrontend) Logf(msg string, args ...interface{}) { d.t.Logf(msg, args...) } + +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 } diff --git a/src/cmd/compile/internal/ssa/func.go b/src/cmd/compile/internal/ssa/func.go index e5fbfdb5ff..371dae3b17 100644 --- a/src/cmd/compile/internal/ssa/func.go +++ b/src/cmd/compile/internal/ssa/func.go @@ -305,6 +305,8 @@ func (f *Func) ConstFloat64(line int32, t Type, c float64) *Value { return f.Entry.NewValue0I(line, OpConst64F, t, int64(math.Float64bits(c))) } -func (f *Func) Logf(msg string, args ...interface{}) { f.Config.Logf(msg, args...) } -func (f *Func) Fatalf(msg string, args ...interface{}) { f.Config.Fatalf(msg, args...) } -func (f *Func) Unimplementedf(msg string, args ...interface{}) { f.Config.Unimplementedf(msg, args...) } +func (f *Func) Logf(msg string, args ...interface{}) { f.Config.Logf(msg, args...) } +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...) +} diff --git a/src/cmd/compile/internal/ssa/html.go b/src/cmd/compile/internal/ssa/html.go index 9b8fc3750b..bb88a3ebde 100644 --- a/src/cmd/compile/internal/ssa/html.go +++ b/src/cmd/compile/internal/ssa/html.go @@ -20,7 +20,7 @@ type HTMLWriter struct { 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("%v", err) + logger.Fatalf(0, "%v", err) } html := HTMLWriter{File: out, Logger: logger} html.start(funcname) @@ -326,13 +326,13 @@ func (w *HTMLWriter) WriteColumn(title string, html string) { func (w *HTMLWriter) Printf(msg string, v ...interface{}) { if _, err := fmt.Fprintf(w.File, msg, v...); err != nil { - w.Fatalf("%v", err) + w.Fatalf(0, "%v", err) } } func (w *HTMLWriter) WriteString(s string) { if _, err := w.File.WriteString(s); err != nil { - w.Fatalf("%v", err) + w.Fatalf(0, "%v", err) } } diff --git a/src/cmd/compile/internal/ssa/value.go b/src/cmd/compile/internal/ssa/value.go index fc318638ad..420c408e88 100644 --- a/src/cmd/compile/internal/ssa/value.go +++ b/src/cmd/compile/internal/ssa/value.go @@ -135,9 +135,13 @@ func (v *Value) copyInto(b *Block) *Value { return c } -func (v *Value) Logf(msg string, args ...interface{}) { v.Block.Logf(msg, args...) } -func (v *Value) Fatalf(msg string, args ...interface{}) { v.Block.Fatalf(msg, args...) } -func (v *Value) Unimplementedf(msg string, args ...interface{}) { v.Block.Unimplementedf(msg, args...) } +func (v *Value) Logf(msg string, args ...interface{}) { v.Block.Logf(msg, args...) } +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. -- cgit v1.3 From 90065eaba42c044af0a35cfc2abda76e9c58ccd3 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Fri, 15 Jan 2016 08:45:47 -0800 Subject: [dev.ssa] cmd/compile: use wider move instruction for floats Distinguish move/load/store ops. Unify some of this code a bit. Reduces Mandelbrot slowdown with SSA from 58% to 12%. Change-Id: I3276eaebcbcdd9de3f8299c79b5f25c0429194c4 Reviewed-on: https://go-review.googlesource.com/18677 Run-TryBot: Keith Randall Reviewed-by: David Chase --- src/cmd/compile/internal/gc/ssa.go | 78 +++++++++++++++++++------------------- 1 file changed, 39 insertions(+), 39 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 1367b22d89..46aaaa7d87 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -3503,7 +3503,7 @@ func (s *genState) genValue(v *ssa.Value) { x := regnum(v.Args[0]) y := regnum(v.Args[1]) if x != r && y != r { - opregreg(regMoveByTypeAMD64(v.Type), r, x) + opregreg(moveByType(v.Type), r, x) x = r } p := Prog(v.Op.Asm()) @@ -3527,7 +3527,7 @@ func (s *genState) genValue(v *ssa.Value) { neg = true } if x != r { - opregreg(regMoveByTypeAMD64(v.Type), r, x) + opregreg(moveByType(v.Type), r, x) } opregreg(v.Op.Asm(), r, y) @@ -3547,11 +3547,11 @@ func (s *genState) genValue(v *ssa.Value) { // register move y to x15 // register move x to y // rename y with x15 - opregreg(regMoveByTypeAMD64(v.Type), x15, y) - opregreg(regMoveByTypeAMD64(v.Type), r, x) + opregreg(moveByType(v.Type), x15, y) + opregreg(moveByType(v.Type), r, x) y = x15 } else if x != r { - opregreg(regMoveByTypeAMD64(v.Type), r, x) + opregreg(moveByType(v.Type), r, x) } opregreg(v.Op.Asm(), r, y) @@ -3669,7 +3669,7 @@ func (s *genState) genValue(v *ssa.Value) { if r == x86.REG_CX { v.Fatalf("can't implement %s, target and shift both in CX", v.LongString()) } - p := Prog(regMoveAMD64(v.Type.Size())) + p := Prog(moveByType(v.Type)) p.From.Type = obj.TYPE_REG p.From.Reg = x p.To.Type = obj.TYPE_REG @@ -3701,7 +3701,7 @@ func (s *genState) genValue(v *ssa.Value) { r := regnum(v) x := regnum(v.Args[0]) if r != x { - p := Prog(regMoveAMD64(v.Type.Size())) + p := Prog(moveByType(v.Type)) p.From.Type = obj.TYPE_REG p.From.Reg = x p.To.Type = obj.TYPE_REG @@ -3731,7 +3731,7 @@ func (s *genState) genValue(v *ssa.Value) { x := regnum(v.Args[0]) r := regnum(v) if x != r { - p := Prog(regMoveAMD64(v.Type.Size())) + p := Prog(moveByType(v.Type)) p.From.Type = obj.TYPE_REG p.From.Reg = x p.To.Type = obj.TYPE_REG @@ -3910,14 +3910,14 @@ func (s *genState) genValue(v *ssa.Value) { x := regnum(v.Args[0]) y := regnum(v) if x != y { - opregreg(regMoveByTypeAMD64(v.Type), y, x) + 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(movSizeByType(v.Type)) + p := Prog(loadByType(v.Type)) n, off := autoVar(v.Args[0]) p.From.Type = obj.TYPE_MEM p.From.Node = n @@ -3937,7 +3937,7 @@ func (s *genState) genValue(v *ssa.Value) { v.Unimplementedf("store flags not implemented: %v", v.LongString()) return } - p := Prog(movSizeByType(v.Type)) + p := Prog(storeByType(v.Type)) p.From.Type = obj.TYPE_REG p.From.Reg = regnum(v.Args[0]) n, off := autoVar(v) @@ -4060,7 +4060,7 @@ func (s *genState) genValue(v *ssa.Value) { x := regnum(v.Args[0]) r := regnum(v) if x != r { - p := Prog(regMoveAMD64(v.Type.Size())) + p := Prog(moveByType(v.Type)) p.From.Type = obj.TYPE_REG p.From.Reg = x p.To.Type = obj.TYPE_REG @@ -4170,14 +4170,6 @@ func (s *genState) genValue(v *ssa.Value) { } } -// movSizeByType returns the MOV instruction of the given type. -func movSizeByType(t ssa.Type) (asm int) { - // For x86, there's no difference between reg move opcodes - // and memory move opcodes. - asm = regMoveByTypeAMD64(t) - return -} - // 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) @@ -4477,24 +4469,14 @@ var ssaRegToReg = [...]int16{ // TODO: arch-dependent } -// regMoveAMD64 returns the register->register move opcode for the given width. -// TODO: generalize for all architectures? -func regMoveAMD64(width int64) int { - switch width { - case 1: - return x86.AMOVB - case 2: - return x86.AMOVW - case 4: - return x86.AMOVL - case 8: - return x86.AMOVQ - default: - panic("bad int register width") - } +// loadByType returns the load instruction of the given type. +func loadByType(t ssa.Type) int { + // For x86, there's no difference between load and store opcodes. + return storeByType(t) } -func regMoveByTypeAMD64(t ssa.Type) int { +// storeByType returns the store instruction of the given type. +func storeByType(t ssa.Type) int { width := t.Size() if t.IsFloat() { switch width { @@ -4502,11 +4484,30 @@ func regMoveByTypeAMD64(t ssa.Type) int { return x86.AMOVSS case 8: return x86.AMOVSD - default: - panic("bad float register width") } } 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. + return x86.AMOVAPD + } else { + switch t.Size() { case 1: return x86.AMOVB case 2: @@ -4519,7 +4520,6 @@ func regMoveByTypeAMD64(t ssa.Type) int { panic("bad int register width") } } - panic("bad register type") } -- cgit v1.3 From b5c5efd5de4c4668b149d1dba4d9b00c88dd0b80 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Thu, 14 Jan 2016 16:02:23 -0800 Subject: [dev.ssa] cmd/compile: optimize phi ops Redo how we keep track of forward references when building SSA. When the forward reference is resolved, update the Value node in place. Improve the phi elimination pass so it can simplify phis of phis. Give SSA package access to decoded line numbers. Fix line numbers for constant booleans. Change-Id: I3dc9896148d260be2f3dd14cbe5db639ec9fa6b7 Reviewed-on: https://go-review.googlesource.com/18674 Reviewed-by: David Chase Run-TryBot: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 153 +++++++++++++------------ src/cmd/compile/internal/ssa/compile.go | 8 +- src/cmd/compile/internal/ssa/config.go | 3 + src/cmd/compile/internal/ssa/export_test.go | 3 + src/cmd/compile/internal/ssa/gen/genericOps.go | 3 + src/cmd/compile/internal/ssa/opGen.go | 5 + src/cmd/compile/internal/ssa/phielim.go | 59 +++++++--- src/cmd/compile/internal/ssa/print.go | 2 + 8 files changed, 143 insertions(+), 93 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index be9af60bd8..42f484d5f2 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -139,11 +139,6 @@ func buildssa(fn *Node) *ssa.Func { } }() - // We construct SSA using an algorithm similar to - // Brau, Buchwald, Hack, Leißa, Mallon, and Zwinkau - // http://pp.info.uni-karlsruhe.de/uploads/publikationen/braun13cc.pdf - // TODO: check this comment - // Allocate starting block s.f.Entry = s.f.NewBlock(ssa.BlockPlain) @@ -285,6 +280,9 @@ type state struct { // 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 } type funcLine struct { @@ -1327,7 +1325,14 @@ func (s *state) expr(n *Node) *ssa.Value { case CTSTR: return s.entryNewValue0A(ssa.OpConstString, n.Type, n.Val().U) case CTBOOL: - return s.constBool(n.Val().U.(bool)) + 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 { @@ -3172,9 +3177,10 @@ func (s *state) checkgoto(from *Node, to *Node) { func (s *state) variable(name *Node, t ssa.Type) *ssa.Value { v := s.vars[name] if v == nil { - // TODO: get type? Take Sym as arg? v = s.newValue0A(ssa.OpFwdRef, t, name) + s.fwdRefs = append(s.fwdRefs, v) s.vars[name] = v + s.addNamedValue(name, v) } return v } @@ -3184,40 +3190,38 @@ func (s *state) mem() *ssa.Value { } func (s *state) linkForwardReferences() { - // Build ssa graph. Each variable on its first use in a basic block + // 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 Brau, Buchwald, Hack, Leißa, Mallon, and Zwinkau: + // described by Braun, Buchwald, Hack, Leißa, Mallon, and Zwinkau: // http://pp.info.uni-karlsruhe.de/uploads/publikationen/braun13cc.pdf - for _, b := range s.f.Blocks { - for _, v := range b.Values { - if v.Op != ssa.OpFwdRef { - continue - } - name := v.Aux.(*Node) - v.Op = ssa.OpCopy - v.Aux = nil - v.SetArgs1(s.lookupVarIncoming(b, v.Type, name)) - } + // 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) } } -// lookupVarIncoming finds the variable's value at the start of block b. -func (s *state) lookupVarIncoming(b *ssa.Block, t ssa.Type, name *Node) *ssa.Value { - // TODO(khr): have lookupVarIncoming overwrite the fwdRef or copy it - // will be used in, instead of having the result used in a copy value. +// 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 { - if name == &memVar { - return s.startmem - } + // Live variable at start of function. if canSSA(name) { - v := s.entryNewValue0A(ssa.OpArg, t, name) - // v starts with AuxInt == 0. - s.addNamedValue(name, v) - return v + v.Op = ssa.OpArg + v.Aux = name + return } - // variable is live at the entry block. Load it. + // Not SSAable. Load it. addr := s.decladdrs[name] if addr == nil { // TODO: closure args reach here. @@ -3226,64 +3230,69 @@ func (s *state) lookupVarIncoming(b *ssa.Block, t ssa.Type, name *Node) *ssa.Val 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) } - return s.entryNewValue2(ssa.OpLoad, t, addr, s.startmem) + 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 } - var vals []*ssa.Value + // Find variable value on each predecessor. + var argstore [4]*ssa.Value + args := argstore[:0] for _, p := range b.Preds { - vals = append(vals, s.lookupVarOutgoing(p, t, name)) + args = append(args, s.lookupVarOutgoing(p, v.Type, name, v.Line)) } - if len(vals) == 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, - // so use the default/zero value. - if name == &memVar { - return s.startmem + + // 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 } - return s.zeroVal(name.Type) - } - v0 := vals[0] - for i := 1; i < len(vals); i++ { - if vals[i] != v0 { - // need a phi value - v := b.NewValue0(s.peekLine(), ssa.OpPhi, t) - v.AddArgs(vals...) - s.addNamedValue(name, v) - return v + 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) } - return v0 + // 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) *ssa.Value { +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 v, a copy value which - // will be the outgoing value of the variable. Then - // look up w, the incoming value of the variable. - // Make v = copy(w). We need the extra copy to - // prevent infinite recursion when looking up the - // incoming value of the variable. - v := b.NewValue0(s.peekLine(), ssa.OpCopy, 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 - v.AddArg(s.lookupVarIncoming(b, t, name)) + s.addNamedValue(name, v) return v } -// TODO: the above mutually recursive functions can lead to very deep stacks. Fix that. - func (s *state) addNamedValue(n *Node, v *ssa.Value) { if n.Class == Pxxx { // Don't track our dummy nodes (&memVar etc.). return } - if n.Sym == nil { - // TODO: What the heck is this? - return - } if strings.HasPrefix(n.Sym.Name, "autotmp_") { // Don't track autotmp_ variables. return @@ -3910,7 +3919,7 @@ func (s *genState) genValue(v *ssa.Value) { p.To.Sym = Linksym(Pkglookup("duffcopy", Runtimepkg)) p.To.Offset = v.AuxInt - case ssa.OpCopy, ssa.OpAMD64MOVQconvert: // TODO: lower Copy to MOVQ earlier? + case ssa.OpCopy, ssa.OpAMD64MOVQconvert: // TODO: use MOVQreg for reg->reg copies instead of OpCopy? if v.Type.IsMemory() { return } @@ -3970,12 +3979,6 @@ func (s *genState) genValue(v *ssa.Value) { 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.OpConst8, ssa.OpConst16, ssa.OpConst32, ssa.OpConst64, ssa.OpConstString, ssa.OpConstNil, ssa.OpConstBool, - ssa.OpConst32F, ssa.OpConst64F: - if v.Block.Func.RegAlloc[v.ID] != nil { - v.Fatalf("const value %v shouldn't have a location", v) - } - case ssa.OpInitMem: // memory arg needs no code case ssa.OpArg: @@ -4596,6 +4599,10 @@ 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. diff --git a/src/cmd/compile/internal/ssa/compile.go b/src/cmd/compile/internal/ssa/compile.go index 20af6fd5bd..64c1412f9d 100644 --- a/src/cmd/compile/internal/ssa/compile.go +++ b/src/cmd/compile/internal/ssa/compile.go @@ -81,8 +81,9 @@ type pass struct { // list of passes for the compiler var passes = [...]pass{ - {"phielim", phielim}, - {"copyelim", copyelim}, + // TODO: combine phielim and copyelim into a single pass? + {"early phielim", phielim}, + {"early copyelim", copyelim}, {"early deadcode", deadcode}, // remove generated dead code to avoid doing pointless work during opt {"decompose", decompose}, {"opt", opt}, @@ -97,6 +98,9 @@ var passes = [...]pass{ {"lowered cse", cse}, {"lowered deadcode", deadcode}, {"checkLower", checkLower}, + {"late phielim", phielim}, + {"late copyelim", copyelim}, + {"late deadcode", deadcode}, {"critical", critical}, // remove critical edges {"layout", layout}, // schedule blocks {"schedule", schedule}, // schedule values diff --git a/src/cmd/compile/internal/ssa/config.go b/src/cmd/compile/internal/ssa/config.go index 7ef2fbd2fc..fb0d886b88 100644 --- a/src/cmd/compile/internal/ssa/config.go +++ b/src/cmd/compile/internal/ssa/config.go @@ -67,6 +67,9 @@ type Frontend interface { // 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 diff --git a/src/cmd/compile/internal/ssa/export_test.go b/src/cmd/compile/internal/ssa/export_test.go index f4d8d58549..badafadd70 100644 --- a/src/cmd/compile/internal/ssa/export_test.go +++ b/src/cmd/compile/internal/ssa/export_test.go @@ -31,6 +31,9 @@ func (DummyFrontend) StringData(s string) interface{} { 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...) } diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index d17f558978..5c1a7af363 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -371,6 +371,9 @@ var genericOps = []opData{ // 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", typ: "Mem"}, // aux is a *gc.Node of a variable that is about to be initialized. arg0=mem, returns mem {name: "VarKill"}, // aux is a *gc.Node of a variable that is known to be dead. arg0=mem, returns mem {name: "VarLive"}, // aux is a *gc.Node of a variable that must be kept live. arg0=mem, returns mem diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 433794a03b..e3fc8aba3b 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -550,6 +550,7 @@ const ( OpStoreReg OpLoadReg OpFwdRef + OpUnknown OpVarDef OpVarKill OpVarLive @@ -4303,6 +4304,10 @@ var opcodeTable = [...]opInfo{ name: "FwdRef", generic: true, }, + { + name: "Unknown", + generic: true, + }, { name: "VarDef", generic: true, diff --git a/src/cmd/compile/internal/ssa/phielim.go b/src/cmd/compile/internal/ssa/phielim.go index be9503248b..aaa0a0f238 100644 --- a/src/cmd/compile/internal/ssa/phielim.go +++ b/src/cmd/compile/internal/ssa/phielim.go @@ -10,29 +10,52 @@ package ssa // 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) { - argSet := newSparseSet(f.NumValues()) - var args []*Value - for _, b := range f.Blocks { - for _, v := range b.Values { - if v.Op != OpPhi { - continue - } - argSet.clear() - args = args[:0] - for _, x := range v.Args { - for x.Op == OpCopy { - x = x.Args[0] + for { + changed := false + for _, b := range f.Blocks { + nextv: + for _, v := range b.Values { + if v.Op != OpPhi { + continue } - if x != v && !argSet.contains(x.ID) { - argSet.add(x.ID) - args = append(args, x) + // 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 _, x := range v.Args { + for x.Op == OpCopy { + x = x.Args[0] + } + if x == v { + continue + } + if x == w { + continue + } + if w != nil { + continue nextv + } + w = x + } + if w == nil { + // v references only itself. It must be in + // a dead code loop. Don't bother modifying it. + continue } - } - if len(args) == 1 { v.Op = OpCopy - v.SetArgs1(args[0]) + v.SetArgs1(w) + changed = true } } + if !changed { + break + } } } diff --git a/src/cmd/compile/internal/ssa/print.go b/src/cmd/compile/internal/ssa/print.go index b61e6f1cc7..c6f84ab6cb 100644 --- a/src/cmd/compile/internal/ssa/print.go +++ b/src/cmd/compile/internal/ssa/print.go @@ -61,6 +61,8 @@ func (p stringFuncPrinter) endBlock(b *Block) { 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") -- cgit v1.3 From a734bbc95349a487c78ff02eda07e3f219808be3 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Mon, 11 Jan 2016 21:05:33 -0800 Subject: [dev.ssa] cmd/compile: Allow structs to be SSAd Break small structs up into their components so they can be registerized. Change StructSelect to use field indexes instead of field offsets, as field offsets aren't unique in the presence of zero-sized fields. Change-Id: I2f1dc89f7fa58e1cf58aa1a32b238959d53f62e4 Reviewed-on: https://go-review.googlesource.com/18570 Run-TryBot: Keith Randall Reviewed-by: David Chase --- src/cmd/compile/internal/gc/ssa.go | 94 +++- src/cmd/compile/internal/ssa/TODO | 4 +- src/cmd/compile/internal/ssa/decompose.go | 91 +++- src/cmd/compile/internal/ssa/gen/generic.rules | 86 ++- src/cmd/compile/internal/ssa/gen/genericOps.go | 15 +- src/cmd/compile/internal/ssa/opGen.go | 35 +- src/cmd/compile/internal/ssa/rewritegeneric.go | 726 ++++++++++++++++++++++++- 7 files changed, 1004 insertions(+), 47 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 42f484d5f2..b57958a24d 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1802,7 +1802,11 @@ func (s *state) expr(n *Node) *ssa.Value { return s.newValue2(ssa.OpLoad, n.Type, p, s.mem()) case ODOT: - // TODO: fix when we can SSA struct types. + 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()) @@ -1876,6 +1880,7 @@ func (s *state) expr(n *Node) *ssa.Value { // 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(): @@ -1887,7 +1892,7 @@ func (s *state) expr(n *Node) *ssa.Value { // eface type could also be struct{p *byte; q [0]int} continue } - data = s.newValue1I(ssa.OpStructSelect, f, data.Type.FieldOff(i), data) + data = s.newValue1I(ssa.OpStructSelect, f, i, data) break } default: @@ -2093,7 +2098,42 @@ func (s *state) assign(left *Node, right *ssa.Value, wb bool, line int32) { } right = s.zeroVal(t) } - if left.Op == ONAME && canSSA(left) { + if canSSA(left) { + 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, line) + // TODO: do we need to update named values here? + return + } // Update variable assignment. s.vars[left] = right s.addNamedValue(left, right) @@ -2157,6 +2197,13 @@ func (s *state) zeroVal(t *Type) *ssa.Value { 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 @@ -2440,8 +2487,11 @@ func (s *state) addr(n *Node, bounded bool) *ssa.Value { } // canSSA reports whether n is SSA-able. -// n must be an ONAME. +// n must be an ONAME (or an ODOT sequence with an ONAME base). func canSSA(n *Node) bool { + for n.Op == ODOT { + n = n.Left + } if n.Op != ONAME { return false } @@ -2485,10 +2535,7 @@ func canSSAType(t *Type) bool { // introduced by the compiler for variadic functions. return false case TSTRUCT: - if countfield(t) > 4 { - // 4 is an arbitrary constant. Same reasoning - // as above, lots of small fields would waste - // register space needed by other values. + if countfield(t) > ssa.MaxStruct { return false } for t1 := t.Type; t1 != nil; t1 = t1.Down { @@ -2496,8 +2543,7 @@ func canSSAType(t *Type) bool { return false } } - return false // until it is implemented - //return true + return true default: return true } @@ -4558,6 +4604,34 @@ func autoVar(v *ssa.Value) (*Node, int64) { 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 diff --git a/src/cmd/compile/internal/ssa/TODO b/src/cmd/compile/internal/ssa/TODO index d4904e1dcf..23f8abb6ca 100644 --- a/src/cmd/compile/internal/ssa/TODO +++ b/src/cmd/compile/internal/ssa/TODO @@ -9,6 +9,8 @@ Correctness - Debugging info (check & fix as much as we can) - Fix write barriers so cgo tests work (misc/cgo/errors/ptr.go) - Re-enable TestStackBarrierProfiling (src/runtime/pprof/pprof_test.go) +- @ directive in rewrites might read overwritten data. Save @loc + in variable before modifying v. Optimizations (better compiled code) ------------------------------------ @@ -28,7 +30,7 @@ Optimizations (better compiled code) - Use better write barrier calls - If there are a lot of MOVQ $0, ..., then load 0 into a register and use the register as the source instead. -- Allow structs (and arrays of length 1?) to be SSAable. +- 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 diff --git a/src/cmd/compile/internal/ssa/decompose.go b/src/cmd/compile/internal/ssa/decompose.go index c8a1df281a..6dc11250ca 100644 --- a/src/cmd/compile/internal/ssa/decompose.go +++ b/src/cmd/compile/internal/ssa/decompose.go @@ -13,23 +13,9 @@ func decompose(f *Func) { if v.Op != OpPhi { continue } - 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.IsStruct(): - // decomposeStructPhi(v) - case v.Type.Size() > f.Config.IntSize: - f.Unimplementedf("undecomposed type %s", v.Type) - } + decomposePhi(v) } } - // TODO: decompose 64-bit ops on 32-bit archs? // Split up named values into their components. // NOTE: the component values we are making are dead at this point. @@ -92,14 +78,39 @@ func decompose(f *Func) { f.NamedValues[typeName] = append(f.NamedValues[typeName], typ) f.NamedValues[dataName] = append(f.NamedValues[dataName], data) } - //case t.IsStruct(): - // TODO + 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) + } + } case t.Size() > f.Config.IntSize: - f.Unimplementedf("undecomposed type %s", t) + f.Unimplementedf("undecomposed named type %s", t) } } } +func decomposePhi(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.IsStruct(): + decomposeStructPhi(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() @@ -184,5 +195,47 @@ func decomposeInterfacePhi(v *Value) { v.AddArg(data) } func decomposeStructPhi(v *Value) { - // TODO + 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.Op = StructMakeOp(n) + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArgs(fields[:n]...) + + // Recursively decompose phis for each field. + for _, f := range fields[:n] { + decomposePhi(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/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index 5de877d31a..3b7209a2b2 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -150,7 +150,70 @@ (ArrayIndex (Load ptr mem) idx) && b == v.Args[0].Block -> (Load (PtrIndex ptr idx) mem) (PtrIndex ptr idx) && config.PtrSize == 4 -> (AddPtr ptr (Mul32 idx (Const32 [t.Elem().Size()]))) (PtrIndex ptr idx) && config.PtrSize == 8 -> (AddPtr ptr (Mul64 idx (Const64 [t.Elem().Size()]))) -(StructSelect [idx] (Load ptr mem)) -> @v.Args[0].Block (Load (OffPtr [idx] ptr) mem) + +// 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.IsStruct() && t.NumFields() == 0 && config.fe.CanSSA(t) -> + (StructMake0) +(Load ptr mem) && t.IsStruct() && t.NumFields() == 1 && config.fe.CanSSA(t) -> + (StructMake1 + (Load ptr mem)) +(Load ptr mem) && t.IsStruct() && t.NumFields() == 2 && config.fe.CanSSA(t) -> + (StructMake2 + (Load ptr mem) + (Load (OffPtr [t.FieldOff(1)] ptr) mem)) +(Load ptr mem) && t.IsStruct() && t.NumFields() == 3 && config.fe.CanSSA(t) -> + (StructMake3 + (Load ptr mem) + (Load (OffPtr [t.FieldOff(1)] ptr) mem) + (Load (OffPtr [t.FieldOff(2)] ptr) mem)) +(Load ptr mem) && t.IsStruct() && t.NumFields() == 4 && config.fe.CanSSA(t) -> + (StructMake4 + (Load ptr mem) + (Load (OffPtr [t.FieldOff(1)] ptr) mem) + (Load (OffPtr [t.FieldOff(2)] ptr) mem) + (Load (OffPtr [t.FieldOff(3)] ptr) mem)) + +(StructSelect [i] (Load ptr mem)) && !config.fe.CanSSA(t) -> + @v.Args[0].Block (Load (OffPtr [t.FieldOff(i)] ptr) mem) + +(Store _ (StructMake0) mem) -> mem +(Store dst (StructMake1 f0) mem) -> + (Store [t.FieldType(0).Size()] dst f0 mem) +(Store dst (StructMake2 f0 f1) mem) -> + (Store [t.FieldType(1).Size()] + (OffPtr [t.FieldOff(1)] dst) + f1 + (Store [t.FieldType(0).Size()] dst f0 mem)) +(Store dst (StructMake3 f0 f1 f2) mem) -> + (Store [t.FieldType(2).Size()] + (OffPtr [t.FieldOff(2)] dst) + f2 + (Store [t.FieldType(1).Size()] + (OffPtr [t.FieldOff(1)] dst) + f1 + (Store [t.FieldType(0).Size()] dst f0 mem))) +(Store dst (StructMake4 f0 f1 f2 f3) mem) -> + (Store [t.FieldType(3).Size()] + (OffPtr [t.FieldOff(3)] dst) + f3 + (Store [t.FieldType(2).Size()] + (OffPtr [t.FieldOff(2)] dst) + f2 + (Store [t.FieldType(1).Size()] + (OffPtr [t.FieldOff(1)] dst) + f1 + (Store [t.FieldType(0).Size()] dst f0 mem)))) // complex ops (ComplexReal (ComplexMake real _ )) -> real @@ -303,3 +366,24 @@ (ComplexMake (Arg {n} [off]) (Arg {n} [off+4])) + +(Arg ) && t.IsStruct() && t.NumFields() == 0 && config.fe.CanSSA(t) -> + (StructMake0) +(Arg {n} [off]) && t.IsStruct() && t.NumFields() == 1 && config.fe.CanSSA(t) -> + (StructMake1 + (Arg {n} [off+t.FieldOff(0)])) +(Arg {n} [off]) && t.IsStruct() && t.NumFields() == 2 && config.fe.CanSSA(t) -> + (StructMake2 + (Arg {n} [off+t.FieldOff(0)]) + (Arg {n} [off+t.FieldOff(1)])) +(Arg {n} [off]) && t.IsStruct() && t.NumFields() == 3 && config.fe.CanSSA(t) -> + (StructMake3 + (Arg {n} [off+t.FieldOff(0)]) + (Arg {n} [off+t.FieldOff(1)]) + (Arg {n} [off+t.FieldOff(2)])) +(Arg {n} [off]) && t.IsStruct() && t.NumFields() == 4 && config.fe.CanSSA(t) -> + (StructMake4 + (Arg {n} [off+t.FieldOff(0)]) + (Arg {n} [off+t.FieldOff(1)]) + (Arg {n} [off+t.FieldOff(2)]) + (Arg {n} [off+t.FieldOff(3)])) diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 5c1a7af363..107c145dac 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -335,10 +335,9 @@ var genericOps = []opData{ {name: "GetClosurePtr"}, // get closure pointer from dedicated register // Indexing operations - {name: "ArrayIndex"}, // arg0=array, arg1=index. Returns a[i] - {name: "PtrIndex"}, // arg0=ptr, arg1=index. Computes ptr+sizeof(*v.type)*index, where index is extended to ptrwidth type - {name: "OffPtr"}, // arg0 + auxint (arg0 and result are pointers) - {name: "StructSelect"}, // arg0=struct, auxint=field offset. Returns field at that offset (size=size of result type) + {name: "ArrayIndex"}, // arg0=array, arg1=index. Returns a[i] + {name: "PtrIndex"}, // arg0=ptr, arg1=index. Computes ptr+sizeof(*v.type)*index, where index is extended to ptrwidth type + {name: "OffPtr"}, // arg0 + auxint (arg0 and result are pointers) // Slices {name: "SliceMake"}, // arg0=ptr, arg1=len, arg2=cap @@ -361,6 +360,14 @@ var genericOps = []opData{ {name: "ITab", typ: "BytePtr"}, // arg0=interface, returns itable field {name: "IData"}, // arg0=interface, returns data field + // Structs + {name: "StructMake0"}, // Returns struct with 0 fields. + {name: "StructMake1"}, // arg0=field0. Returns struct. + {name: "StructMake2"}, // arg0,arg1=field0,field1. Returns struct. + {name: "StructMake3"}, // arg0..2=field0..2. Returns struct. + {name: "StructMake4"}, // arg0..3=field0..3. Returns struct. + {name: "StructSelect"}, // 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 diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index e3fc8aba3b..497b690192 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -533,7 +533,6 @@ const ( OpArrayIndex OpPtrIndex OpOffPtr - OpStructSelect OpSliceMake OpSlicePtr OpSliceLen @@ -547,6 +546,12 @@ const ( OpIMake OpITab OpIData + OpStructMake0 + OpStructMake1 + OpStructMake2 + OpStructMake3 + OpStructMake4 + OpStructSelect OpStoreReg OpLoadReg OpFwdRef @@ -4236,10 +4241,6 @@ var opcodeTable = [...]opInfo{ name: "OffPtr", generic: true, }, - { - name: "StructSelect", - generic: true, - }, { name: "SliceMake", generic: true, @@ -4292,6 +4293,30 @@ var opcodeTable = [...]opInfo{ name: "IData", generic: true, }, + { + name: "StructMake0", + generic: true, + }, + { + name: "StructMake1", + generic: true, + }, + { + name: "StructMake2", + generic: true, + }, + { + name: "StructMake3", + generic: true, + }, + { + name: "StructMake4", + generic: true, + }, + { + name: "StructSelect", + generic: true, + }, { name: "StoreReg", generic: true, diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index 9563e878e8..149553dbc2 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -551,6 +551,149 @@ end0988fc6a62c810b2f4976cb6cf44387f: } goto enda348e93e0036873dd7089a2939c22e3e enda348e93e0036873dd7089a2939c22e3e: + ; + // match: (Arg ) + // cond: t.IsStruct() && t.NumFields() == 0 && config.fe.CanSSA(t) + // result: (StructMake0) + { + t := v.Type + if !(t.IsStruct() && t.NumFields() == 0 && config.fe.CanSSA(t)) { + goto ende233eeefa826638b0e541bcca531d701 + } + v.Op = OpStructMake0 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + return true + } + goto ende233eeefa826638b0e541bcca531d701 +ende233eeefa826638b0e541bcca531d701: + ; + // match: (Arg {n} [off]) + // cond: t.IsStruct() && t.NumFields() == 1 && config.fe.CanSSA(t) + // result: (StructMake1 (Arg {n} [off+t.FieldOff(0)])) + { + t := v.Type + n := v.Aux + off := v.AuxInt + if !(t.IsStruct() && t.NumFields() == 1 && config.fe.CanSSA(t)) { + goto ende953e77a0617051dd3f7ad4d58c9ab37 + } + v.Op = OpStructMake1 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpArg, TypeInvalid) + v0.Type = t.FieldType(0) + v0.Aux = n + v0.AuxInt = off + t.FieldOff(0) + v.AddArg(v0) + return true + } + goto ende953e77a0617051dd3f7ad4d58c9ab37 +ende953e77a0617051dd3f7ad4d58c9ab37: + ; + // match: (Arg {n} [off]) + // cond: t.IsStruct() && t.NumFields() == 2 && config.fe.CanSSA(t) + // result: (StructMake2 (Arg {n} [off+t.FieldOff(0)]) (Arg {n} [off+t.FieldOff(1)])) + { + t := v.Type + n := v.Aux + off := v.AuxInt + if !(t.IsStruct() && t.NumFields() == 2 && config.fe.CanSSA(t)) { + goto end9a008048978aabad9de0723212e60631 + } + v.Op = OpStructMake2 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpArg, TypeInvalid) + v0.Type = t.FieldType(0) + v0.Aux = n + v0.AuxInt = off + t.FieldOff(0) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpArg, TypeInvalid) + v1.Type = t.FieldType(1) + v1.Aux = n + v1.AuxInt = off + t.FieldOff(1) + v.AddArg(v1) + return true + } + goto end9a008048978aabad9de0723212e60631 +end9a008048978aabad9de0723212e60631: + ; + // match: (Arg {n} [off]) + // cond: t.IsStruct() && t.NumFields() == 3 && config.fe.CanSSA(t) + // result: (StructMake3 (Arg {n} [off+t.FieldOff(0)]) (Arg {n} [off+t.FieldOff(1)]) (Arg {n} [off+t.FieldOff(2)])) + { + t := v.Type + n := v.Aux + off := v.AuxInt + if !(t.IsStruct() && t.NumFields() == 3 && config.fe.CanSSA(t)) { + goto end0196e61dbeebc6402f3aa1e9a182210b + } + v.Op = OpStructMake3 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpArg, TypeInvalid) + v0.Type = t.FieldType(0) + v0.Aux = n + v0.AuxInt = off + t.FieldOff(0) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpArg, TypeInvalid) + v1.Type = t.FieldType(1) + v1.Aux = n + v1.AuxInt = off + t.FieldOff(1) + v.AddArg(v1) + v2 := b.NewValue0(v.Line, OpArg, TypeInvalid) + v2.Type = t.FieldType(2) + v2.Aux = n + v2.AuxInt = off + t.FieldOff(2) + v.AddArg(v2) + return true + } + goto end0196e61dbeebc6402f3aa1e9a182210b +end0196e61dbeebc6402f3aa1e9a182210b: + ; + // match: (Arg {n} [off]) + // cond: t.IsStruct() && t.NumFields() == 4 && config.fe.CanSSA(t) + // result: (StructMake4 (Arg {n} [off+t.FieldOff(0)]) (Arg {n} [off+t.FieldOff(1)]) (Arg {n} [off+t.FieldOff(2)]) (Arg {n} [off+t.FieldOff(3)])) + { + t := v.Type + n := v.Aux + off := v.AuxInt + if !(t.IsStruct() && t.NumFields() == 4 && config.fe.CanSSA(t)) { + goto end6bc133c93e50cb14c2e6cc9401850738 + } + v.Op = OpStructMake4 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpArg, TypeInvalid) + v0.Type = t.FieldType(0) + v0.Aux = n + v0.AuxInt = off + t.FieldOff(0) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpArg, TypeInvalid) + v1.Type = t.FieldType(1) + v1.Aux = n + v1.AuxInt = off + t.FieldOff(1) + v.AddArg(v1) + v2 := b.NewValue0(v.Line, OpArg, TypeInvalid) + v2.Type = t.FieldType(2) + v2.Aux = n + v2.AuxInt = off + t.FieldOff(2) + v.AddArg(v2) + v3 := b.NewValue0(v.Line, OpArg, TypeInvalid) + v3.Type = t.FieldType(3) + v3.Aux = n + v3.AuxInt = off + t.FieldOff(3) + v.AddArg(v3) + return true + } + goto end6bc133c93e50cb14c2e6cc9401850738 +end6bc133c93e50cb14c2e6cc9401850738: ; return false } @@ -2274,6 +2417,173 @@ end263ecdc279924bff8771dd1ac3f42222: func rewriteValuegeneric_OpLoad(v *Value, config *Config) bool { b := v.Block _ = b + // match: (Load _ _) + // cond: t.IsStruct() && t.NumFields() == 0 && config.fe.CanSSA(t) + // result: (StructMake0) + { + t := v.Type + if !(t.IsStruct() && t.NumFields() == 0 && config.fe.CanSSA(t)) { + goto end8d25f5c949948132921b6be29ede6bde + } + v.Op = OpStructMake0 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + return true + } + goto end8d25f5c949948132921b6be29ede6bde +end8d25f5c949948132921b6be29ede6bde: + ; + // match: (Load ptr mem) + // cond: t.IsStruct() && t.NumFields() == 1 && config.fe.CanSSA(t) + // result: (StructMake1 (Load ptr mem)) + { + t := v.Type + ptr := v.Args[0] + mem := v.Args[1] + if !(t.IsStruct() && t.NumFields() == 1 && config.fe.CanSSA(t)) { + goto endfe908e5a8617dd39df2f9b2b92e93ae5 + } + v.Op = OpStructMake1 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpLoad, TypeInvalid) + v0.Type = t.FieldType(0) + v0.AddArg(ptr) + v0.AddArg(mem) + v.AddArg(v0) + return true + } + goto endfe908e5a8617dd39df2f9b2b92e93ae5 +endfe908e5a8617dd39df2f9b2b92e93ae5: + ; + // match: (Load ptr mem) + // cond: t.IsStruct() && t.NumFields() == 2 && config.fe.CanSSA(t) + // result: (StructMake2 (Load ptr mem) (Load (OffPtr [t.FieldOff(1)] ptr) mem)) + { + t := v.Type + ptr := v.Args[0] + mem := v.Args[1] + if !(t.IsStruct() && t.NumFields() == 2 && config.fe.CanSSA(t)) { + goto end20e20e64004b765012cfb80c575ef27b + } + v.Op = OpStructMake2 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpLoad, TypeInvalid) + v0.Type = t.FieldType(0) + v0.AddArg(ptr) + v0.AddArg(mem) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpLoad, TypeInvalid) + v1.Type = t.FieldType(1) + v2 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) + v2.Type = t.FieldType(1).PtrTo() + v2.AuxInt = t.FieldOff(1) + v2.AddArg(ptr) + v1.AddArg(v2) + v1.AddArg(mem) + v.AddArg(v1) + return true + } + goto end20e20e64004b765012cfb80c575ef27b +end20e20e64004b765012cfb80c575ef27b: + ; + // match: (Load ptr mem) + // cond: t.IsStruct() && t.NumFields() == 3 && config.fe.CanSSA(t) + // result: (StructMake3 (Load ptr mem) (Load (OffPtr [t.FieldOff(1)] ptr) mem) (Load (OffPtr [t.FieldOff(2)] ptr) mem)) + { + t := v.Type + ptr := v.Args[0] + mem := v.Args[1] + if !(t.IsStruct() && t.NumFields() == 3 && config.fe.CanSSA(t)) { + goto ende612bf71067ed67541735cdc8b5a3288 + } + v.Op = OpStructMake3 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpLoad, TypeInvalid) + v0.Type = t.FieldType(0) + v0.AddArg(ptr) + v0.AddArg(mem) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpLoad, TypeInvalid) + v1.Type = t.FieldType(1) + v2 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) + v2.Type = 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, TypeInvalid) + v3.Type = t.FieldType(2) + v4 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) + v4.Type = t.FieldType(2).PtrTo() + v4.AuxInt = t.FieldOff(2) + v4.AddArg(ptr) + v3.AddArg(v4) + v3.AddArg(mem) + v.AddArg(v3) + return true + } + goto ende612bf71067ed67541735cdc8b5a3288 +ende612bf71067ed67541735cdc8b5a3288: + ; + // match: (Load ptr mem) + // cond: t.IsStruct() && t.NumFields() == 4 && config.fe.CanSSA(t) + // result: (StructMake4 (Load ptr mem) (Load (OffPtr [t.FieldOff(1)] ptr) mem) (Load (OffPtr [t.FieldOff(2)] ptr) mem) (Load (OffPtr [t.FieldOff(3)] ptr) mem)) + { + t := v.Type + ptr := v.Args[0] + mem := v.Args[1] + if !(t.IsStruct() && t.NumFields() == 4 && config.fe.CanSSA(t)) { + goto end46c66c64d9030f2cc9a7a767f67953d1 + } + v.Op = OpStructMake4 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpLoad, TypeInvalid) + v0.Type = t.FieldType(0) + v0.AddArg(ptr) + v0.AddArg(mem) + v.AddArg(v0) + v1 := b.NewValue0(v.Line, OpLoad, TypeInvalid) + v1.Type = t.FieldType(1) + v2 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) + v2.Type = 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, TypeInvalid) + v3.Type = t.FieldType(2) + v4 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) + v4.Type = 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, TypeInvalid) + v5.Type = t.FieldType(3) + v6 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) + v6.Type = t.FieldType(3).PtrTo() + v6.AuxInt = t.FieldOff(3) + v6.AddArg(ptr) + v5.AddArg(v6) + v5.AddArg(mem) + v.AddArg(v5) + return true + } + goto end46c66c64d9030f2cc9a7a767f67953d1 +end46c66c64d9030f2cc9a7a767f67953d1: + ; // match: (Load ptr mem) // cond: t.IsComplex() && t.Size() == 8 // result: (ComplexMake (Load ptr mem) (Load (OffPtr [4] ptr) mem) ) @@ -3067,6 +3377,187 @@ end526acc0a705137a5d25577499206720b: func rewriteValuegeneric_OpStore(v *Value, config *Config) bool { b := v.Block _ = b + // match: (Store _ (StructMake0) mem) + // cond: + // result: mem + { + if v.Args[1].Op != OpStructMake0 { + goto endd4f364b0adfc229d8c200af183d4c808 + } + mem := v.Args[2] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = mem.Type + v.AddArg(mem) + return true + } + goto endd4f364b0adfc229d8c200af183d4c808 +endd4f364b0adfc229d8c200af183d4c808: + ; + // match: (Store dst (StructMake1 f0) mem) + // cond: + // result: (Store [t.FieldType(0).Size()] dst f0 mem) + { + dst := v.Args[0] + if v.Args[1].Op != OpStructMake1 { + goto end2cff6d06f4440132f48ca374b6b1e9d8 + } + t := v.Args[1].Type + f0 := v.Args[1].Args[0] + mem := v.Args[2] + v.Op = OpStore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = t.FieldType(0).Size() + v.AddArg(dst) + v.AddArg(f0) + v.AddArg(mem) + return true + } + goto end2cff6d06f4440132f48ca374b6b1e9d8 +end2cff6d06f4440132f48ca374b6b1e9d8: + ; + // match: (Store dst (StructMake2 f0 f1) mem) + // cond: + // result: (Store [t.FieldType(1).Size()] (OffPtr [t.FieldOff(1)] dst) f1 (Store [t.FieldType(0).Size()] dst f0 mem)) + { + dst := v.Args[0] + if v.Args[1].Op != OpStructMake2 { + goto end4e8ede6cc575a287795971da6b637973 + } + t := v.Args[1].Type + f0 := v.Args[1].Args[0] + f1 := v.Args[1].Args[1] + mem := v.Args[2] + v.Op = OpStore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = t.FieldType(1).Size() + v0 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) + v0.Type = t.FieldType(1).PtrTo() + v0.AuxInt = t.FieldOff(1) + v0.AddArg(dst) + v.AddArg(v0) + v.AddArg(f1) + v1 := b.NewValue0(v.Line, OpStore, TypeInvalid) + v1.AuxInt = t.FieldType(0).Size() + v1.AddArg(dst) + v1.AddArg(f0) + v1.AddArg(mem) + v1.Type = TypeMem + v.AddArg(v1) + return true + } + goto end4e8ede6cc575a287795971da6b637973 +end4e8ede6cc575a287795971da6b637973: + ; + // match: (Store dst (StructMake3 f0 f1 f2) mem) + // cond: + // result: (Store [t.FieldType(2).Size()] (OffPtr [t.FieldOff(2)] dst) f2 (Store [t.FieldType(1).Size()] (OffPtr [t.FieldOff(1)] dst) f1 (Store [t.FieldType(0).Size()] dst f0 mem))) + { + dst := v.Args[0] + if v.Args[1].Op != OpStructMake3 { + goto end6ad675267724a87c8f852dd1e185e911 + } + 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.Op = OpStore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = t.FieldType(2).Size() + v0 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) + v0.Type = t.FieldType(2).PtrTo() + v0.AuxInt = t.FieldOff(2) + v0.AddArg(dst) + v.AddArg(v0) + v.AddArg(f2) + v1 := b.NewValue0(v.Line, OpStore, TypeInvalid) + v1.AuxInt = t.FieldType(1).Size() + v2 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) + v2.Type = t.FieldType(1).PtrTo() + v2.AuxInt = t.FieldOff(1) + v2.AddArg(dst) + v1.AddArg(v2) + v1.AddArg(f1) + v3 := b.NewValue0(v.Line, OpStore, TypeInvalid) + v3.AuxInt = t.FieldType(0).Size() + v3.AddArg(dst) + v3.AddArg(f0) + v3.AddArg(mem) + v3.Type = TypeMem + v1.AddArg(v3) + v1.Type = TypeMem + v.AddArg(v1) + return true + } + goto end6ad675267724a87c8f852dd1e185e911 +end6ad675267724a87c8f852dd1e185e911: + ; + // match: (Store dst (StructMake4 f0 f1 f2 f3) mem) + // cond: + // result: (Store [t.FieldType(3).Size()] (OffPtr [t.FieldOff(3)] dst) f3 (Store [t.FieldType(2).Size()] (OffPtr [t.FieldOff(2)] dst) f2 (Store [t.FieldType(1).Size()] (OffPtr [t.FieldOff(1)] dst) f1 (Store [t.FieldType(0).Size()] dst f0 mem)))) + { + dst := v.Args[0] + if v.Args[1].Op != OpStructMake4 { + goto end7ea91abd44794f7653374502a5a405ea + } + 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.Op = OpStore + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = t.FieldType(3).Size() + v0 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) + v0.Type = t.FieldType(3).PtrTo() + v0.AuxInt = t.FieldOff(3) + v0.AddArg(dst) + v.AddArg(v0) + v.AddArg(f3) + v1 := b.NewValue0(v.Line, OpStore, TypeInvalid) + v1.AuxInt = t.FieldType(2).Size() + v2 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) + v2.Type = t.FieldType(2).PtrTo() + v2.AuxInt = t.FieldOff(2) + v2.AddArg(dst) + v1.AddArg(v2) + v1.AddArg(f2) + v3 := b.NewValue0(v.Line, OpStore, TypeInvalid) + v3.AuxInt = t.FieldType(1).Size() + v4 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) + v4.Type = t.FieldType(1).PtrTo() + v4.AuxInt = t.FieldOff(1) + v4.AddArg(dst) + v3.AddArg(v4) + v3.AddArg(f1) + v5 := b.NewValue0(v.Line, OpStore, TypeInvalid) + v5.AuxInt = t.FieldType(0).Size() + v5.AddArg(dst) + v5.AddArg(f0) + v5.AddArg(mem) + v5.Type = TypeMem + v3.AddArg(v5) + v3.Type = TypeMem + v1.AddArg(v3) + v1.Type = TypeMem + v.AddArg(v1) + return true + } + goto end7ea91abd44794f7653374502a5a405ea +end7ea91abd44794f7653374502a5a405ea: + ; // match: (Store [8] dst (ComplexMake real imag) mem) // cond: // result: (Store [4] (OffPtr [4] dst) imag (Store [4] dst real mem)) @@ -3386,16 +3877,237 @@ end061edc5d85c73ad909089af2556d9380: func rewriteValuegeneric_OpStructSelect(v *Value, config *Config) bool { b := v.Block _ = b - // match: (StructSelect [idx] (Load ptr mem)) + // match: (StructSelect (StructMake1 x)) + // cond: + // result: x + { + if v.Args[0].Op != OpStructMake1 { + goto end17af582e7eba5216b4a51fe6c9206d3c + } + x := v.Args[0].Args[0] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end17af582e7eba5216b4a51fe6c9206d3c +end17af582e7eba5216b4a51fe6c9206d3c: + ; + // match: (StructSelect [0] (StructMake2 x _)) // cond: - // result: @v.Args[0].Block (Load (OffPtr [idx] ptr) mem) + // result: x { - idx := v.AuxInt + if v.AuxInt != 0 { + goto end355cfff99c8e9af975c3ae450d49b7f9 + } + if v.Args[0].Op != OpStructMake2 { + goto end355cfff99c8e9af975c3ae450d49b7f9 + } + x := v.Args[0].Args[0] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end355cfff99c8e9af975c3ae450d49b7f9 +end355cfff99c8e9af975c3ae450d49b7f9: + ; + // match: (StructSelect [1] (StructMake2 _ x)) + // cond: + // result: x + { + if v.AuxInt != 1 { + goto end69baa65e494ef9ae154e0943b53734f9 + } + if v.Args[0].Op != OpStructMake2 { + goto end69baa65e494ef9ae154e0943b53734f9 + } + x := v.Args[0].Args[1] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end69baa65e494ef9ae154e0943b53734f9 +end69baa65e494ef9ae154e0943b53734f9: + ; + // match: (StructSelect [0] (StructMake3 x _ _)) + // cond: + // result: x + { + if v.AuxInt != 0 { + goto endb0d98e2c46bb51c9abd4c3543392e0ec + } + if v.Args[0].Op != OpStructMake3 { + goto endb0d98e2c46bb51c9abd4c3543392e0ec + } + x := v.Args[0].Args[0] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto endb0d98e2c46bb51c9abd4c3543392e0ec +endb0d98e2c46bb51c9abd4c3543392e0ec: + ; + // match: (StructSelect [1] (StructMake3 _ x _)) + // cond: + // result: x + { + if v.AuxInt != 1 { + goto end2e40457286d26c2f14ad4fd127946773 + } + if v.Args[0].Op != OpStructMake3 { + goto end2e40457286d26c2f14ad4fd127946773 + } + x := v.Args[0].Args[1] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end2e40457286d26c2f14ad4fd127946773 +end2e40457286d26c2f14ad4fd127946773: + ; + // match: (StructSelect [2] (StructMake3 _ _ x)) + // cond: + // result: x + { + if v.AuxInt != 2 { + goto end3e3b96ad431206175d002ece87aa1409 + } + if v.Args[0].Op != OpStructMake3 { + goto end3e3b96ad431206175d002ece87aa1409 + } + x := v.Args[0].Args[2] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end3e3b96ad431206175d002ece87aa1409 +end3e3b96ad431206175d002ece87aa1409: + ; + // match: (StructSelect [0] (StructMake4 x _ _ _)) + // cond: + // result: x + { + if v.AuxInt != 0 { + goto end09f8a1ffa3d8c3124bc6d4083b941108 + } + if v.Args[0].Op != OpStructMake4 { + goto end09f8a1ffa3d8c3124bc6d4083b941108 + } + x := v.Args[0].Args[0] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end09f8a1ffa3d8c3124bc6d4083b941108 +end09f8a1ffa3d8c3124bc6d4083b941108: + ; + // match: (StructSelect [1] (StructMake4 _ x _ _)) + // cond: + // result: x + { + if v.AuxInt != 1 { + goto endd3ef25e605a927e9251be6d9221f4acf + } + if v.Args[0].Op != OpStructMake4 { + goto endd3ef25e605a927e9251be6d9221f4acf + } + x := v.Args[0].Args[1] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto endd3ef25e605a927e9251be6d9221f4acf +endd3ef25e605a927e9251be6d9221f4acf: + ; + // match: (StructSelect [2] (StructMake4 _ _ x _)) + // cond: + // result: x + { + if v.AuxInt != 2 { + goto end0438e22cc8f41123fa42009a81ee723a + } + if v.Args[0].Op != OpStructMake4 { + goto end0438e22cc8f41123fa42009a81ee723a + } + x := v.Args[0].Args[2] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end0438e22cc8f41123fa42009a81ee723a +end0438e22cc8f41123fa42009a81ee723a: + ; + // match: (StructSelect [3] (StructMake4 _ _ _ x)) + // cond: + // result: x + { + if v.AuxInt != 3 { + goto end56a7c7781fee35eeff0a3652dc206012 + } + if v.Args[0].Op != OpStructMake4 { + goto end56a7c7781fee35eeff0a3652dc206012 + } + x := v.Args[0].Args[3] + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end56a7c7781fee35eeff0a3652dc206012 +end56a7c7781fee35eeff0a3652dc206012: + ; + // match: (StructSelect [i] (Load ptr mem)) + // cond: !config.fe.CanSSA(t) + // result: @v.Args[0].Block (Load (OffPtr [t.FieldOff(i)] ptr) mem) + { + i := v.AuxInt if v.Args[0].Op != OpLoad { - goto end27abc5bf0299ce1bd5457af6ce8e3fba + goto end2afd47b4fcaaab7a73325bd8a75e3e8e } + t := v.Args[0].Type ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] + if !(!config.fe.CanSSA(t)) { + goto end2afd47b4fcaaab7a73325bd8a75e3e8e + } v0 := v.Args[0].Block.NewValue0(v.Line, OpLoad, TypeInvalid) v.Op = OpCopy v.AuxInt = 0 @@ -3405,14 +4117,14 @@ func rewriteValuegeneric_OpStructSelect(v *Value, config *Config) bool { v0.Type = v.Type v1 := v.Args[0].Block.NewValue0(v.Line, OpOffPtr, TypeInvalid) v1.Type = v.Type.PtrTo() - v1.AuxInt = idx + v1.AuxInt = t.FieldOff(i) v1.AddArg(ptr) v0.AddArg(v1) v0.AddArg(mem) return true } - goto end27abc5bf0299ce1bd5457af6ce8e3fba -end27abc5bf0299ce1bd5457af6ce8e3fba: + goto end2afd47b4fcaaab7a73325bd8a75e3e8e +end2afd47b4fcaaab7a73325bd8a75e3e8e: ; return false } -- cgit v1.3 From 7730880f7ceda51c025a3c6bd296e1fa2de52318 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Wed, 20 Jan 2016 14:06:17 -0800 Subject: [dev.ssa] cmd/compile: update SSA TODOs Change-Id: I78743987dcb45d821212caf95a00ae15b7a6cfd8 Reviewed-on: https://go-review.googlesource.com/18773 Reviewed-by: Andrew Gerrand --- src/cmd/compile/internal/ssa/TODO | 14 ++++++++++++++ 1 file changed, 14 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/TODO b/src/cmd/compile/internal/ssa/TODO index 23f8abb6ca..403f98cf40 100644 --- a/src/cmd/compile/internal/ssa/TODO +++ b/src/cmd/compile/internal/ssa/TODO @@ -37,6 +37,20 @@ Optimizations (better compiled code) and len feilds being accessed) pass them in xmm registers? Same for interfaces? - boolean logic: movb/xorb$1/testb/jeq -> movb/testb/jne +- (ADDQconst (SUBQconst x)) and vice-versa +- (CMP (Load ...)) and (CMPconst (Load ...)) in one instruction + (all instructions, really) +- combine LEAQs +- store followed by load to same address +- short circuit blocks which are just a jump (undo critical edge processing when no instructions are put in it by regalloc) +- (CMPconst [0] (AND x y)) -> (TEST x y) +- more (LOAD (ADDQ )) -> LOADIDX +- CMPL/SETEQ/TESTB/JEQ -> CMPL/JEQ + CMPL/SETGE/TESTB/JEQ +- blockEQ (CMP x x) +- better computing of &&/|| in non-if/for contexts +- OpArrayIndex should take its index in AuxInt, not a full value. +- remove FLAGS from REP instruction clobbers Optimizations (better compiler) ------------------------------- -- cgit v1.3 From 3c26c0db3923451f1340e10524e985597da5bba2 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Thu, 21 Jan 2016 13:27:01 -0800 Subject: [dev.ssa] cmd/compile: short-circuit empty blocks Empty blocks are introduced to remove critical edges. After regalloc, we can remove any of the added blocks that are still empty. Change-Id: I0b40e95ac3a6cc1e632a479443479532b6c5ccd9 Reviewed-on: https://go-review.googlesource.com/18833 TryBot-Result: Gobot Gobot Reviewed-by: David Chase --- src/cmd/compile/internal/gc/ssa.go | 15 ++++++++++++- src/cmd/compile/internal/ssa/TODO | 1 - src/cmd/compile/internal/ssa/check.go | 11 ++++++---- src/cmd/compile/internal/ssa/compile.go | 5 ++++- src/cmd/compile/internal/ssa/trim.go | 37 +++++++++++++++++++++++++++++++++ test/nilptr3_ssa.go | 2 +- 6 files changed, 63 insertions(+), 8 deletions(-) create mode 100644 src/cmd/compile/internal/ssa/trim.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index b57958a24d..9dd5859735 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -4183,23 +4183,36 @@ func (s *genState) genValue(v *ssa.Value) { 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] != v.Args[1] { + 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: 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.StoreConst(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 } } diff --git a/src/cmd/compile/internal/ssa/TODO b/src/cmd/compile/internal/ssa/TODO index 403f98cf40..2f7973c5a3 100644 --- a/src/cmd/compile/internal/ssa/TODO +++ b/src/cmd/compile/internal/ssa/TODO @@ -42,7 +42,6 @@ Optimizations (better compiled code) (all instructions, really) - combine LEAQs - store followed by load to same address -- short circuit blocks which are just a jump (undo critical edge processing when no instructions are put in it by regalloc) - (CMPconst [0] (AND x y)) -> (TEST x y) - more (LOAD (ADDQ )) -> LOADIDX - CMPL/SETEQ/TESTB/JEQ -> CMPL/JEQ diff --git a/src/cmd/compile/internal/ssa/check.go b/src/cmd/compile/internal/ssa/check.go index ca3bbfe494..b74371008c 100644 --- a/src/cmd/compile/internal/ssa/check.go +++ b/src/cmd/compile/internal/ssa/check.go @@ -18,10 +18,12 @@ func checkFunc(f *Func) { f.Fatalf("%s.Func=%s, want %s", b, b.Func.Name, f.Name) } - 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) + 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) + } } } } @@ -34,6 +36,7 @@ func checkFunc(f *Func) { // 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 diff --git a/src/cmd/compile/internal/ssa/compile.go b/src/cmd/compile/internal/ssa/compile.go index 64c1412f9d..7a515f898c 100644 --- a/src/cmd/compile/internal/ssa/compile.go +++ b/src/cmd/compile/internal/ssa/compile.go @@ -105,7 +105,8 @@ var passes = [...]pass{ {"layout", layout}, // schedule blocks {"schedule", schedule}, // schedule values {"flagalloc", flagalloc}, // allocate flags register - {"regalloc", regalloc}, + {"regalloc", regalloc}, // allocate int & float registers + {"trim", trim}, // remove empty blocks } // Double-check phase ordering constraints. @@ -148,6 +149,8 @@ var passOrder = [...]constraint{ {"schedule", "flagalloc"}, // regalloc needs flags to be allocated first. {"flagalloc", "regalloc"}, + // trim needs regalloc to be done first. + {"regalloc", "trim"}, } func init() { diff --git a/src/cmd/compile/internal/ssa/trim.go b/src/cmd/compile/internal/ssa/trim.go new file mode 100644 index 0000000000..594d2aa372 --- /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/test/nilptr3_ssa.go b/test/nilptr3_ssa.go index 9824ce1cc0..d324076114 100644 --- a/test/nilptr3_ssa.go +++ b/test/nilptr3_ssa.go @@ -156,7 +156,7 @@ func f4(x *[10]int) { // 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 "generated nil check" // bug would like to remove before indirect + _ = x[9] // ERROR "removed nil check" for { if x[9] != 0 { // ERROR "removed nil check" -- cgit v1.3 From 733bf6ef67013b8410c51a72697c6fbff53ad30d Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Mon, 25 Jan 2016 20:26:06 -0800 Subject: [dev.ssa] cmd/compile: get rid of +0.0 hack The conversion from -0.0 to +0.0 happens inside mpgetflt now. The SSA code doesn't need this fix any more. Change-Id: I6cd4f4a4e75b13cf284ebbb95b08af050ed9891c Reviewed-on: https://go-review.googlesource.com/18942 Reviewed-by: Brad Fitzpatrick Run-TryBot: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 16 ++++++---------- 1 file changed, 6 insertions(+), 10 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 9dd5859735..5b8d2423d7 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1347,11 +1347,9 @@ func (s *state) expr(n *Node) *ssa.Value { f := n.Val().U.(*Mpflt) switch n.Type.Size() { case 4: - // -0.0 literals need to be treated as if they were 0.0, adding 0.0 here - // accomplishes this while not affecting other values. - return s.constFloat32(n.Type, mpgetflt32(f)+0.0) + return s.constFloat32(n.Type, mpgetflt32(f)) case 8: - return s.constFloat64(n.Type, mpgetflt(f)+0.0) + return s.constFloat64(n.Type, mpgetflt(f)) default: s.Fatalf("bad float size %d", n.Type.Size()) return nil @@ -1364,18 +1362,16 @@ func (s *state) expr(n *Node) *ssa.Value { case 8: { pt := Types[TFLOAT32] - // -0.0 literals need to be treated as if they were 0.0, adding 0.0 here - // accomplishes this while not affecting other values. return s.newValue2(ssa.OpComplexMake, n.Type, - s.constFloat32(pt, mpgetflt32(r)+0.0), - s.constFloat32(pt, mpgetflt32(i)+0.0)) + 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)+0.0), - s.constFloat64(pt, mpgetflt(i)+0.0)) + s.constFloat64(pt, mpgetflt(r)), + s.constFloat64(pt, mpgetflt(i))) } default: s.Fatalf("bad float size %d", n.Type.Size()) -- cgit v1.3 From 7b773946c09e075ed50c49e76e08f61c16616ee4 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Fri, 22 Jan 2016 13:44:58 -0800 Subject: [dev.ssa] cmd/compile: disable xor clearing when flags must be preserved The x86 backend automatically rewrites MOV $0, AX to XOR AX, AX. That rewrite isn't ok when the flags register is live across the MOV. Keep track of which moves care about preserving flags, then disable this rewrite for them. On x86, Prog.Mark was being used to hold the length of the instruction. We already store that in Prog.Isize, so no need to store it in Prog.Mark also. This frees up Prog.Mark to hold a bitmask on x86 just like all the other architectures. Update #12405 Change-Id: Ibad8a8f41fc6222bec1e4904221887d3cc3ca029 Reviewed-on: https://go-review.googlesource.com/18861 Reviewed-by: David Chase Reviewed-by: Russ Cox --- src/cmd/compile/internal/gc/ssa.go | 29 ++++++++++++++++++++++++++++ src/cmd/compile/internal/ssa/block.go | 3 +++ src/cmd/compile/internal/ssa/flagalloc.go | 5 +++++ src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 11 ++++------- src/cmd/compile/internal/ssa/opGen.go | 4 ---- src/cmd/compile/internal/ssa/regalloc.go | 9 --------- src/cmd/internal/obj/link.go | 6 +++--- src/cmd/internal/obj/pass.go | 1 - src/cmd/internal/obj/x86/a.out.go | 6 ++++++ src/cmd/internal/obj/x86/asm6.go | 9 ++++++--- src/cmd/internal/obj/x86/obj6.go | 20 +++++++++---------- 11 files changed, 66 insertions(+), 37 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 5b8d2423d7..de00fe9651 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -3405,6 +3405,7 @@ func genssa(f *ssa.Func, ptxt *obj.Prog, gcargs, gclocals *Sym) { 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) @@ -3864,6 +3865,11 @@ func (s *genState) genValue(v *ssa.Value) { p.From.Offset = i 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()) @@ -4237,6 +4243,29 @@ func (s *genState) genValue(v *ssa.Value) { } } +// 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.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) diff --git a/src/cmd/compile/internal/ssa/block.go b/src/cmd/compile/internal/ssa/block.go index 5fb93cd5a7..02673f0650 100644 --- a/src/cmd/compile/internal/ssa/block.go +++ b/src/cmd/compile/internal/ssa/block.go @@ -50,6 +50,9 @@ type Block struct { // 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 } // kind control successors diff --git a/src/cmd/compile/internal/ssa/flagalloc.go b/src/cmd/compile/internal/ssa/flagalloc.go index c088158057..f4e289e782 100644 --- a/src/cmd/compile/internal/ssa/flagalloc.go +++ b/src/cmd/compile/internal/ssa/flagalloc.go @@ -120,4 +120,9 @@ func flagalloc(f *Func) { // 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/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index daee7336b0..dcffb49f63 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -93,7 +93,6 @@ func init() { // Common regInfo var ( gp01 = regInfo{inputs: []regMask{}, outputs: gponly} - gp01flags = regInfo{inputs: []regMask{}, outputs: gponly, clobbers: flags} 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} @@ -340,12 +339,10 @@ func init() { {name: "MOVLQSX", reg: gp11nf, asm: "MOVLQSX"}, // sign extend arg0 from int32 to int64 {name: "MOVLQZX", reg: gp11nf, asm: "MOVLQZX"}, // zero extend arg0 from int32 to int64 - // clobbers flags as liblink will rewrite these to XOR reg, reg if the constant is zero - // TODO: revisit when issue 12405 is fixed - {name: "MOVBconst", reg: gp01flags, asm: "MOVB", typ: "UInt8"}, // 8 low bits of auxint - {name: "MOVWconst", reg: gp01flags, asm: "MOVW", typ: "UInt16"}, // 16 low bits of auxint - {name: "MOVLconst", reg: gp01flags, asm: "MOVL", typ: "UInt32"}, // 32 low bits of auxint - {name: "MOVQconst", reg: gp01flags, asm: "MOVQ", typ: "UInt64"}, // auxint + {name: "MOVBconst", reg: gp01, asm: "MOVB", typ: "UInt8"}, // 8 low bits of auxint + {name: "MOVWconst", reg: gp01, asm: "MOVW", typ: "UInt16"}, // 16 low bits of auxint + {name: "MOVLconst", reg: gp01, asm: "MOVL", typ: "UInt32"}, // 32 low bits of auxint + {name: "MOVQconst", reg: gp01, asm: "MOVQ", typ: "UInt64"}, // auxint {name: "CVTTSD2SL", reg: fpgp, asm: "CVTTSD2SL"}, // convert float64 to int32 {name: "CVTTSD2SQ", reg: fpgp, asm: "CVTTSD2SQ"}, // convert float64 to int64 diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 497b690192..d391b2435e 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -2694,7 +2694,6 @@ var opcodeTable = [...]opInfo{ name: "MOVBconst", asm: x86.AMOVB, reg: regInfo{ - clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -2704,7 +2703,6 @@ var opcodeTable = [...]opInfo{ name: "MOVWconst", asm: x86.AMOVW, reg: regInfo{ - clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -2714,7 +2712,6 @@ var opcodeTable = [...]opInfo{ name: "MOVLconst", asm: x86.AMOVL, reg: regInfo{ - clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, @@ -2724,7 +2721,6 @@ var opcodeTable = [...]opInfo{ name: "MOVQconst", asm: x86.AMOVQ, reg: regInfo{ - clobbers: 8589934592, // .FLAGS outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 }, diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index 27deeba718..7cbd30311f 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -1415,15 +1415,6 @@ func (v *Value) rematerializeable() bool { // We can't rematerialize instructions which // clobber the flags register. if regspec.clobbers&flagRegMask != 0 { - if v.Op == OpAMD64MOVQconst && v.AuxInt != 0 || - v.Op == OpAMD64MOVLconst && int32(v.AuxInt) != 0 || - v.Op == OpAMD64MOVWconst && int16(v.AuxInt) != 0 || - v.Op == OpAMD64MOVBconst && int8(v.AuxInt) != 0 { - // These are marked as clobbering flags, but only - // the 0 versions actually do. TODO: fix MOV->XOR rewrites - // to understand when they are allowed to clobber flags? - return true - } return false } diff --git a/src/cmd/internal/obj/link.go b/src/cmd/internal/obj/link.go index bc898235c1..f3d1a9557a 100644 --- a/src/cmd/internal/obj/link.go +++ b/src/cmd/internal/obj/link.go @@ -214,14 +214,14 @@ type Prog struct { 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/pass.go b/src/cmd/internal/obj/pass.go index b92dfe23fb..14c9b6aaba 100644 --- a/src/cmd/internal/obj/pass.go +++ b/src/cmd/internal/obj/pass.go @@ -203,7 +203,6 @@ func linkpatch(ctxt *Link, sym *LSym) { } 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/x86/a.out.go b/src/cmd/internal/obj/x86/a.out.go index 4ee8cfbc6c..f163505fd0 100644 --- a/src/cmd/internal/obj/x86/a.out.go +++ b/src/cmd/internal/obj/x86/a.out.go @@ -34,6 +34,12 @@ import "cmd/internal/obj" //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 */ diff --git a/src/cmd/internal/obj/x86/asm6.go b/src/cmd/internal/obj/x86/asm6.go index 164dbd6064..8d0f86681f 100644 --- a/src/cmd/internal/obj/x86/asm6.go +++ b/src/cmd/internal/obj/x86/asm6.go @@ -1748,7 +1748,7 @@ func span6(ctxt *obj.Link, s *obj.LSym) { // 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++ @@ -1761,7 +1761,7 @@ func span6(ctxt *obj.Link, s *obj.LSym) { 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) @@ -1784,7 +1784,6 @@ func span6(ctxt *obj.Link, s *obj.LSym) { obj.Symgrow(ctxt, s, p.Pc+int64(m)) copy(s.P[p.Pc:][:m], ctxt.And[:m]) - p.Mark = uint16(m) c += int32(m) } @@ -2157,6 +2156,10 @@ func oclass(ctxt *obj.Link, p *obj.Prog, a *obj.Addr) int { 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 eff6c004c6..e545374828 100644 --- a/src/cmd/internal/obj/x86/obj6.go +++ b/src/cmd/internal/obj/x86/obj6.go @@ -1214,16 +1214,16 @@ loop: 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. @@ -1246,7 +1246,7 @@ loop: 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 { @@ -1260,10 +1260,10 @@ loop: 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 } @@ -1273,7 +1273,7 @@ loop: q.Link = p xfol(ctxt, q.Link, last) p = q.Link - if p.Mark != 0 { + if p.Mark&DONE != 0 { return } goto loop @@ -1290,7 +1290,7 @@ loop: } /* emit p */ - p.Mark = 1 + p.Mark |= DONE (*last).Link = p *last = p @@ -1328,7 +1328,7 @@ loop: } } 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 @@ -1338,7 +1338,7 @@ loop: } xfol(ctxt, p.Link, last) - if p.Pcond.Mark != 0 { + if p.Pcond.Mark&DONE != 0 { return } p = p.Pcond -- cgit v1.3 From 6a96a2fe5a95375e2f8cccca6d848728fef0e09f Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Wed, 27 Jan 2016 16:47:23 -0800 Subject: [dev.ssa] cmd/compile: make cse faster It is one of the slowest compiler phases right now, and we run two of them. Instead of using a map to make the initial partition, use a sort. It is much less memory intensive. Do a few optimizations to avoid work for size-1 equivalence classes. Implement -N. Change-Id: I1d2d85d3771abc918db4dd7cc30b0b2d854b15e1 Reviewed-on: https://go-review.googlesource.com/19024 Reviewed-by: David Chase --- src/cmd/compile/internal/gc/ssa.go | 2 +- src/cmd/compile/internal/ssa/compile.go | 58 ++++---- src/cmd/compile/internal/ssa/config.go | 4 +- src/cmd/compile/internal/ssa/cse.go | 200 ++++++++++++++++++++------ src/cmd/compile/internal/ssa/dom_test.go | 2 +- src/cmd/compile/internal/ssa/export_test.go | 2 +- src/cmd/compile/internal/ssa/nilcheck_test.go | 20 +-- src/cmd/compile/internal/ssa/regalloc.go | 6 + test/nilcheck.go | 1 - test/nilcheck_ssa.go | 187 ------------------------ 10 files changed, 206 insertions(+), 276 deletions(-) delete mode 100644 test/nilcheck_ssa.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index de00fe9651..203de6421c 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -121,7 +121,7 @@ func buildssa(fn *Node) *ssa.Func { var e ssaExport e.log = printssa - s.config = ssa.NewConfig(Thearch.Thestring, &e, Ctxt) + s.config = ssa.NewConfig(Thearch.Thestring, &e, Ctxt, Debug['N'] == 0) s.f = s.config.NewFunc() s.f.Name = name s.exitCode = fn.Func.Exit diff --git a/src/cmd/compile/internal/ssa/compile.go b/src/cmd/compile/internal/ssa/compile.go index 7a515f898c..048f189ffe 100644 --- a/src/cmd/compile/internal/ssa/compile.go +++ b/src/cmd/compile/internal/ssa/compile.go @@ -40,6 +40,9 @@ func Compile(f *Func) { checkFunc(f) const logMemStats = false for _, p := range passes { + if !f.Config.optimize && !p.required { + continue + } phaseName = p.name f.Logf(" pass %s begin\n", p.name) // TODO: capture logging during this pass, add it to the HTML @@ -75,38 +78,39 @@ func Compile(f *Func) { } type pass struct { - name string - fn func(*Func) + name string + fn func(*Func) + required bool } // list of passes for the compiler var passes = [...]pass{ // TODO: combine phielim and copyelim into a single pass? - {"early phielim", phielim}, - {"early copyelim", copyelim}, - {"early deadcode", deadcode}, // remove generated dead code to avoid doing pointless work during opt - {"decompose", decompose}, - {"opt", opt}, - {"opt deadcode", deadcode}, // remove any blocks orphaned during opt - {"generic cse", cse}, - {"nilcheckelim", nilcheckelim}, - {"generic deadcode", deadcode}, - {"fuse", fuse}, - {"dse", dse}, - {"tighten", tighten}, // move values closer to their uses - {"lower", lower}, - {"lowered cse", cse}, - {"lowered deadcode", deadcode}, - {"checkLower", checkLower}, - {"late phielim", phielim}, - {"late copyelim", copyelim}, - {"late deadcode", deadcode}, - {"critical", critical}, // remove critical edges - {"layout", layout}, // schedule blocks - {"schedule", schedule}, // schedule values - {"flagalloc", flagalloc}, // allocate flags register - {"regalloc", regalloc}, // allocate int & float registers - {"trim", trim}, // remove empty blocks + {"early phielim", phielim, false}, + {"early copyelim", copyelim, false}, + {"early deadcode", deadcode, false}, // remove generated dead code to avoid doing pointless work during opt + {"decompose", decompose, true}, + {"opt", opt, true}, // TODO: split required rules and optimizing rules + {"opt deadcode", deadcode, false}, // remove any blocks orphaned during opt + {"generic cse", cse, false}, + {"nilcheckelim", nilcheckelim, false}, + {"generic deadcode", deadcode, false}, + {"fuse", fuse, false}, + {"dse", dse, false}, + {"tighten", tighten, false}, // move values closer to their uses + {"lower", lower, true}, + {"lowered cse", cse, false}, + {"lowered deadcode", deadcode, true}, + {"checkLower", checkLower, true}, + {"late phielim", phielim, false}, + {"late copyelim", copyelim, false}, + {"late deadcode", deadcode, false}, + {"critical", critical, true}, // remove critical edges + {"layout", layout, true}, // schedule blocks + {"schedule", schedule, true}, // schedule values + {"flagalloc", flagalloc, true}, // allocate flags register + {"regalloc", regalloc, true}, // allocate int & float registers + stack slots + {"trim", trim, false}, // remove empty blocks } // Double-check phase ordering constraints. diff --git a/src/cmd/compile/internal/ssa/config.go b/src/cmd/compile/internal/ssa/config.go index fb0d886b88..7325873a15 100644 --- a/src/cmd/compile/internal/ssa/config.go +++ b/src/cmd/compile/internal/ssa/config.go @@ -15,6 +15,7 @@ type Config struct { fe Frontend // callbacks into compiler frontend HTML *HTMLWriter // html writer, for debugging ctxt *obj.Link // Generic arch information + optimize bool // Do optimization // TODO: more stuff. Compiler flags of interest, ... } @@ -80,7 +81,7 @@ type GCNode interface { } // NewConfig returns a new configuration object for the given architecture. -func NewConfig(arch string, fe Frontend, ctxt *obj.Link) *Config { +func NewConfig(arch string, fe Frontend, ctxt *obj.Link, optimize bool) *Config { c := &Config{arch: arch, fe: fe} switch arch { case "amd64": @@ -97,6 +98,7 @@ func NewConfig(arch string, fe Frontend, ctxt *obj.Link) *Config { fe.Unimplementedf(0, "arch %s not implemented", arch) } c.ctxt = ctxt + c.optimize = optimize return c } diff --git a/src/cmd/compile/internal/ssa/cse.go b/src/cmd/compile/internal/ssa/cse.go index 58c52f23e6..7603e17ecf 100644 --- a/src/cmd/compile/internal/ssa/cse.go +++ b/src/cmd/compile/internal/ssa/cse.go @@ -25,56 +25,29 @@ func cse(f *Func) { // It starts with a coarse partition and iteratively refines it // until it reaches a fixed point. - // Make initial partition based on opcode, type-name, aux, auxint, nargs, phi-block, and the ops of v's first args - type key struct { - op Op - typ string - aux interface{} - auxint int64 - nargs int - block ID // block id for phi vars, -1 otherwise - arg0op Op // v.Args[0].Op if len(v.Args) > 0, OpInvalid otherwise - arg1op Op // v.Args[1].Op if len(v.Args) > 1, OpInvalid otherwise - } - m := map[key]eqclass{} + // Make initial coarse partitions by using a subset of the conditions above. + a := make([]*Value, 0, f.NumValues()) for _, b := range f.Blocks { for _, v := range b.Values { - bid := ID(-1) - if v.Op == OpPhi { - bid = b.ID + if v.Type.IsMemory() { + continue // memory values can never cse } - arg0op := OpInvalid - if len(v.Args) > 0 { - arg0op = v.Args[0].Op - } - arg1op := OpInvalid - if len(v.Args) > 1 { - arg1op = v.Args[1].Op - } - - // This assumes that floats are stored in AuxInt - // instead of Aux. If not, then we need to use the - // float bits as part of the key, otherwise since 0.0 == -0.0 - // this would incorrectly treat 0.0 and -0.0 as identical values - k := key{v.Op, v.Type.String(), v.Aux, v.AuxInt, len(v.Args), bid, arg0op, arg1op} - m[k] = append(m[k], v) + a = append(a, v) } } - - // A partition is a set of disjoint eqclasses. - var partition []eqclass - for _, v := range m { - partition = append(partition, v) - } - // TODO: Sort partition here for perfect reproducibility? - // Sort by what? Partition size? - // (Could that improve efficiency by discovering splits earlier?) + partition := partitionValues(a) // map from value id back to eqclass id - valueEqClass := make([]int, f.NumValues()) + 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 { for _, v := range e { - valueEqClass[v.ID] = i + valueEqClass[v.ID] = ID(i) } } @@ -104,7 +77,7 @@ func cse(f *Func) { // 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] = len(partition) + valueEqClass[w.ID] = ID(len(partition)) changed = true continue eqloop } @@ -131,7 +104,6 @@ func cse(f *Func) { // if v and w are in the same equivalence class and v dominates w. rewrite := make([]*Value, f.NumValues()) for _, e := range partition { - sort.Sort(e) // ensure deterministic ordering for len(e) > 1 { // Find a maximal dominant element in e v := e[0] @@ -197,7 +169,141 @@ func dom(b, c *Block, idom []*Block) bool { // final equivalence classes. type eqclass []*Value -// Sort an equivalence class by value ID. -func (e eqclass) Len() int { return len(e) } -func (e eqclass) Swap(i, j int) { e[i], e[j] = e[j], e[i] } -func (e eqclass) Less(i, j int) bool { return e[i].ID < e[j].ID } +// 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 +// 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) []eqclass { + typNames := map[Type]string{} + auxIDs := map[interface{}]int32{} + sort.Sort(sortvalues{a, typNames, auxIDs}) + + var partition []eqclass + for len(a) > 0 { + v := a[0] + j := 1 + for ; j < len(a); j++ { + w := a[j] + if v.Op != w.Op || + v.AuxInt != w.AuxInt || + len(v.Args) != len(w.Args) || + v.Op == OpPhi && v.Block != w.Block || + v.Aux != w.Aux || + len(v.Args) >= 1 && v.Args[0].Op != w.Args[0].Op || + len(v.Args) >= 2 && v.Args[1].Op != w.Args[1].Op || + typNames[v.Type] != typNames[w.Type] { + break + } + } + if j > 1 { + partition = append(partition, a[:j]) + } + a = a[j:] + } + + return partition +} + +// Sort values to make the initial partition. +type sortvalues struct { + a []*Value // array of values + typNames map[Type]string // type -> type ID map + auxIDs map[interface{}]int32 // 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 v.Op != w.Op { + return v.Op < w.Op + } + if v.AuxInt != w.AuxInt { + return v.AuxInt < w.AuxInt + } + if v.Aux == nil && w.Aux != nil { // cheap aux check - expensive one below. + return true + } + if v.Aux != nil && w.Aux == nil { + return false + } + if len(v.Args) != len(w.Args) { + return len(v.Args) < len(w.Args) + } + if v.Op == OpPhi && v.Block.ID != w.Block.ID { + return v.Block.ID < w.Block.ID + } + if len(v.Args) >= 1 { + x := v.Args[0].Op + y := w.Args[0].Op + if x != y { + return x < y + } + if len(v.Args) >= 2 { + x = v.Args[1].Op + y = w.Args[1].Op + if x != y { + return x < y + } + } + } + + // Sort by type. Types are just interfaces, so we can't compare + // them with < directly. Instead, map types to their names and + // sort on that. + if v.Type != w.Type { + x := sv.typNames[v.Type] + if x == "" { + x = v.Type.String() + sv.typNames[v.Type] = x + } + y := sv.typNames[w.Type] + if y == "" { + y = w.Type.String() + sv.typNames[w.Type] = y + } + if x != y { + return x < y + } + } + + // Same deal for aux fields. + if v.Aux != w.Aux { + x := sv.auxIDs[v.Aux] + if x == 0 { + x = int32(len(sv.auxIDs)) + 1 + sv.auxIDs[v.Aux] = x + } + y := sv.auxIDs[w.Aux] + if y == 0 { + y = int32(len(sv.auxIDs)) + 1 + sv.auxIDs[w.Aux] = y + } + if x != y { + return x < y + } + } + + // TODO(khr): is the above really ok to do? We're building + // the aux->auxID map online as sort is asking about it. If + // sort has some internal randomness, then the numbering might + // change from run to run. That will make the ordering of + // partitions random. It won't break the compiler but may + // make it nondeterministic. We could fix this by computing + // the aux->auxID map ahead of time, but the hope is here that + // we won't need to compute the mapping for many aux fields + // because the values they are in are otherwise unique. + + // Sort by value ID last to keep the sort result deterministic. + return v.ID < w.ID +} diff --git a/src/cmd/compile/internal/ssa/dom_test.go b/src/cmd/compile/internal/ssa/dom_test.go index 84e0093799..7174f10e4d 100644 --- a/src/cmd/compile/internal/ssa/dom_test.go +++ b/src/cmd/compile/internal/ssa/dom_test.go @@ -160,7 +160,7 @@ func genMaxPredValue(size int) []bloc { var domBenchRes []*Block func benchmarkDominators(b *testing.B, size int, bg blockGen) { - c := NewConfig("amd64", DummyFrontend{b}, nil) + c := NewConfig("amd64", DummyFrontend{b}, nil, true) fun := Fun(c, "entry", bg(size)...) CheckFunc(fun.f) diff --git a/src/cmd/compile/internal/ssa/export_test.go b/src/cmd/compile/internal/ssa/export_test.go index badafadd70..962dc52a5f 100644 --- a/src/cmd/compile/internal/ssa/export_test.go +++ b/src/cmd/compile/internal/ssa/export_test.go @@ -16,7 +16,7 @@ var Deadcode = deadcode func testConfig(t *testing.T) *Config { testCtxt := &obj.Link{} - return NewConfig("amd64", DummyFrontend{t}, testCtxt) + return NewConfig("amd64", DummyFrontend{t}, testCtxt, true) } // DummyFrontend is a test-only frontend. diff --git a/src/cmd/compile/internal/ssa/nilcheck_test.go b/src/cmd/compile/internal/ssa/nilcheck_test.go index d4a55c0855..c4aff58d76 100644 --- a/src/cmd/compile/internal/ssa/nilcheck_test.go +++ b/src/cmd/compile/internal/ssa/nilcheck_test.go @@ -40,7 +40,7 @@ func benchmarkNilCheckDeep(b *testing.B, depth int) { Bloc("exit", Exit("mem")), ) - c := NewConfig("amd64", DummyFrontend{b}, nil) + c := NewConfig("amd64", DummyFrontend{b}, nil, true) fun := Fun(c, "entry", blocs...) CheckFunc(fun.f) @@ -64,7 +64,7 @@ func isNilCheck(b *Block) bool { // 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) + c := NewConfig("amd64", DummyFrontend{t}, nil, true) fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpInitMem, TypeMem, 0, ".mem"), @@ -101,7 +101,7 @@ func TestNilcheckSimple(t *testing.T) { // 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) + c := NewConfig("amd64", DummyFrontend{t}, nil, true) fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpInitMem, TypeMem, 0, ".mem"), @@ -137,7 +137,7 @@ func TestNilcheckDomOrder(t *testing.T) { // 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) + c := NewConfig("amd64", DummyFrontend{t}, nil, true) fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpInitMem, TypeMem, 0, ".mem"), @@ -170,7 +170,7 @@ func TestNilcheckAddr(t *testing.T) { // 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) + c := NewConfig("amd64", DummyFrontend{t}, nil, true) fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpInitMem, TypeMem, 0, ".mem"), @@ -204,7 +204,7 @@ func TestNilcheckAddPtr(t *testing.T) { // 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) + c := NewConfig("amd64", DummyFrontend{t}, nil, true) fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpInitMem, TypeMem, 0, ".mem"), @@ -248,7 +248,7 @@ func TestNilcheckPhi(t *testing.T) { // 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) + c := NewConfig("amd64", DummyFrontend{t}, nil, true) fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpInitMem, TypeMem, 0, ".mem"), @@ -296,7 +296,7 @@ func TestNilcheckKeepRemove(t *testing.T) { // 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) + c := NewConfig("amd64", DummyFrontend{t}, nil, true) fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpInitMem, TypeMem, 0, ".mem"), @@ -347,7 +347,7 @@ func TestNilcheckInFalseBranch(t *testing.T) { // 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) + c := NewConfig("amd64", DummyFrontend{t}, nil, true) fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpInitMem, TypeMem, 0, ".mem"), @@ -386,7 +386,7 @@ func TestNilcheckUser(t *testing.T) { // 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) + c := NewConfig("amd64", DummyFrontend{t}, nil, true) fun := Fun(c, "entry", Bloc("entry", Valu("mem", OpInitMem, TypeMem, 0, ".mem"), diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index 7cbd30311f..9238999074 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -316,6 +316,12 @@ func (s *regAllocState) assignReg(r register, v *Value, c *Value) { fmt.Printf("assignReg %s %s/%s\n", registers[r].Name(), v, c) } if s.regs[r].v != nil { + if v.Op == OpSB && !v.Block.Func.Config.optimize { + // Rewrite rules may introduce multiple OpSB, and with + // -N they don't get CSEd. Ignore the extra assignments. + s.f.setHome(c, ®isters[r]) + return + } 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) } diff --git a/test/nilcheck.go b/test/nilcheck.go index 173fcb33a6..ab28b33d41 100644 --- a/test/nilcheck.go +++ b/test/nilcheck.go @@ -1,4 +1,3 @@ -// +build !amd64 // errorcheck -0 -N -d=nil // Copyright 2013 The Go Authors. All rights reserved. diff --git a/test/nilcheck_ssa.go b/test/nilcheck_ssa.go deleted file mode 100644 index a20cfd8ae6..0000000000 --- a/test/nilcheck_ssa.go +++ /dev/null @@ -1,187 +0,0 @@ -// +build amd64 -// errorcheck -0 -N -d=nil - -// 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 inserted. -// Optimization is disabled, so redundant checks are not removed. - -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 "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" -} - -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 "nil check" - _ = *arrayp // ERROR "nil check" - _ = *array0p // ERROR "nil check" - _ = *array0p // ERROR "removed nil check" - _ = *intp // ERROR "removed nil check" - _ = *arrayp // ERROR "removed nil check" - _ = *structp // ERROR "nil check" - _ = *emptyp // ERROR "nil check" - _ = *arrayp // ERROR "removed nil check" - _ = *bigarrayp // ERROR "nil check" - _ = *bigstructp // ERROR "nil check" - _ = *empty1p // ERROR "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 "nil check" - - for { - if x[9999] != 0 { // ERROR "removed nil check" - break - } - } - - x = fx10k() - _ = x[9999] // ERROR "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 "nil check" - } else { - _ = x[9999] // ERROR "nil check" - } - _ = x[9999] // ERROR "nil check" - - fx10k() - // SSA nilcheck removal works across calls. - _ = x[9999] // ERROR "removed nil check" -} - -func f3a() { - x := fx10k() - y := fx10k() - z := fx10k() - _ = &x[9] // ERROR "nil check" - y = z - _ = &x[9] // ERROR "removed nil check" - x = y - _ = &x[9] // ERROR "nil check" -} - -func f3b() { - x := fx10k() - y := fx10k() - _ = &x[9] // ERROR "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 "nil check" - - for { - if x[9] != 0 { // ERROR "removed nil check" - break - } - } - - x = fx10() - _ = x[9] // ERROR "nil check" - 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 "nil check" - } else { - _ = &x[9] // ERROR "nil check" - } - _ = x[9] // ERROR "nil check" - - fx10() - _ = x[9] // ERROR "removed nil check" - - x = fx10() - y := fx10() - _ = &x[9] // ERROR "nil check" - y = x - _ = &x[9] // ERROR "removed nil check" - x = y - _ = &x[9] // ERROR "removed nil check" -} - -func f5(m map[string]struct{}) bool { - // Existence-only map lookups should not generate a nil check - _, ok := m[""] - return ok -} -- cgit v1.3 From 2f57d0fe024c19b1b7a86084d72e7267863415a6 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Thu, 28 Jan 2016 13:46:30 -0800 Subject: [dev.ssa] cmd/compile: preallocate small-numbered values and blocks Speeds up the compiler ~5%. Change-Id: Ia5cf0bcd58701fd14018ec77d01f03d5c7d6385b Reviewed-on: https://go-review.googlesource.com/19060 Reviewed-by: Brad Fitzpatrick --- src/cmd/compile/internal/gc/pgen.go | 1 + src/cmd/compile/internal/gc/ssa.go | 13 +- src/cmd/compile/internal/ssa/check.go | 12 +- src/cmd/compile/internal/ssa/config.go | 26 ++- src/cmd/compile/internal/ssa/deadcode.go | 6 +- src/cmd/compile/internal/ssa/func.go | 269 ++++++++++++++----------------- src/cmd/compile/internal/ssa/id.go | 11 -- src/cmd/compile/internal/ssa/regalloc.go | 4 +- 8 files changed, 167 insertions(+), 175 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/pgen.go index 6e7e10e163..6f5913406e 100644 --- a/src/cmd/compile/internal/gc/pgen.go +++ b/src/cmd/compile/internal/gc/pgen.go @@ -496,6 +496,7 @@ func compile(fn *Node) { if Curfn.Func.Endlineno != 0 { lineno = Curfn.Func.Endlineno } + ssafn.Free() return } Genlist(Curfn.Func.Enter) diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 203de6421c..ae747324be 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -21,6 +21,9 @@ import ( // Smallest possible faulting page at address zero. const minZeroPage = 4096 +var ssaConfig *ssa.Config +var ssaExp ssaExport + func shouldssa(fn *Node) bool { if Thearch.Thestring != "amd64" { return false @@ -119,9 +122,13 @@ func buildssa(fn *Node) *ssa.Func { // TODO(khr): build config just once at the start of the compiler binary - var e ssaExport - e.log = printssa - s.config = ssa.NewConfig(Thearch.Thestring, &e, Ctxt, Debug['N'] == 0) + ssaExp.log = printssa + ssaExp.unimplemented = false + ssaExp.mustImplement = true + if ssaConfig == nil { + ssaConfig = ssa.NewConfig(Thearch.Thestring, &ssaExp, Ctxt, Debug['N'] == 0) + } + s.config = ssaConfig s.f = s.config.NewFunc() s.f.Name = name s.exitCode = fn.Func.Exit diff --git a/src/cmd/compile/internal/ssa/check.go b/src/cmd/compile/internal/ssa/check.go index b74371008c..e6f8716d5b 100644 --- a/src/cmd/compile/internal/ssa/check.go +++ b/src/cmd/compile/internal/ssa/check.go @@ -219,14 +219,14 @@ func checkFunc(f *Func) { f.Fatalf("control value for %s is missing: %v", b, b.Control) } } - for _, id := range f.bid.free { - if blockMark[id] { - f.Fatalf("used block b%d in free list", id) + for b := f.freeBlocks; b != nil; b = b.Aux.(*Block) { + if blockMark[b.ID] { + f.Fatalf("used block b%d in free list", b.ID) } } - for _, id := range f.vid.free { - if valueMark[id] { - f.Fatalf("used value v%d in free list", 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) } } diff --git a/src/cmd/compile/internal/ssa/config.go b/src/cmd/compile/internal/ssa/config.go index 7325873a15..52e772ce81 100644 --- a/src/cmd/compile/internal/ssa/config.go +++ b/src/cmd/compile/internal/ssa/config.go @@ -16,8 +16,13 @@ type Config struct { 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, ... + + // Storage for low-numbered values and blocks. + values [2000]Value + blocks [200]Block } type TypeSource interface { @@ -100,15 +105,29 @@ func NewConfig(arch string, fe Frontend, ctxt *obj.Link, optimize bool) *Config 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) + } + return c } func (c *Config) Frontend() Frontend { return c.fe } -// NewFunc returns a new, empty function object +// 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? - return &Func{Config: c, NamedValues: map[LocalSlot][]*Value{}} + 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...) } @@ -118,6 +137,3 @@ func (c *Config) Unimplementedf(line int32, msg string, args ...interface{}) { } 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() } - -// TODO(khr): do we really need a separate Config, or can we just -// store all its fields inside a Func? diff --git a/src/cmd/compile/internal/ssa/deadcode.go b/src/cmd/compile/internal/ssa/deadcode.go index 429708213f..faf16a3816 100644 --- a/src/cmd/compile/internal/ssa/deadcode.go +++ b/src/cmd/compile/internal/ssa/deadcode.go @@ -164,7 +164,7 @@ func deadcode(f *Func) { f.Names = f.Names[:i] // Remove dead values from blocks' value list. Return dead - // value ids to the allocator. + // values to the allocator. for _, b := range f.Blocks { i := 0 for _, v := range b.Values { @@ -172,7 +172,7 @@ func deadcode(f *Func) { b.Values[i] = v i++ } else { - f.vid.put(v.ID) + f.freeValue(v) } } // aid GC @@ -197,7 +197,7 @@ func deadcode(f *Func) { b.Succs = nil b.Control = nil b.Kind = BlockDead - f.bid.put(b.ID) + f.freeBlock(b) } } // zero remainder to help GC diff --git a/src/cmd/compile/internal/ssa/func.go b/src/cmd/compile/internal/ssa/func.go index 371dae3b17..26e4283a23 100644 --- a/src/cmd/compile/internal/ssa/func.go +++ b/src/cmd/compile/internal/ssa/func.go @@ -4,10 +4,7 @@ package ssa -import ( - "math" - "sync" -) +import "math" // A Func represents a Go func declaration (or function literal) and // its body. This package compiles each Func independently. @@ -31,6 +28,9 @@ type Func struct { // 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 Aux.(*Block). All other fields except ID are 0/nil. } // NumBlocks returns an integer larger than the id of any Block in the Func. @@ -43,68 +43,85 @@ func (f *Func) NumValues() int { return f.vid.num() } -const ( - blockSize = 100 -) - -// blockPool provides a contiguous array of Blocks which -// improves the speed of traversing dominator trees. -type blockPool struct { - blocks []Block - mu sync.Mutex +// 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 } -func (bp *blockPool) newBlock() *Block { - bp.mu.Lock() - defer bp.mu.Unlock() - - if len(bp.blocks) == 0 { - bp.blocks = make([]Block, blockSize, blockSize) +// freeValue frees a value. It must no longer be referenced. +func (f *Func) freeValue(v *Value) { + if v.Type == nil { + f.Fatalf("trying to free an already freed value") } - - res := &bp.blocks[0] - bp.blocks = bp.blocks[1:] - return res + // Clear everything but ID (which we reuse). + id := v.ID + *v = Value{} + v.ID = id + v.argstorage[0] = f.freeValues + f.freeValues = v } -var bp blockPool - -// NewBlock returns a new block of the given kind and appends it to f.Blocks. +// 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 { - b := bp.newBlock() - b.ID = f.bid.get() + var b *Block + if f.freeBlocks != nil { + b = f.freeBlocks + f.freeBlocks = b.Aux.(*Block) + b.Aux = 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 f.Blocks = append(f.Blocks, b) return b } +func (f *Func) freeBlock(b *Block) { + // Clear everything but ID (which we reuse). + id := b.ID + *b = Block{} + b.ID = id + b.Aux = 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 := &Value{ - ID: b.Func.vid.get(), - Op: op, - Type: t, - Block: b, - Line: line, - } + v := b.Func.newValue(op, t, b, line) + v.AuxInt = 0 v.Args = v.argstorage[:0] - b.Values = append(b.Values, v) 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 := &Value{ - ID: b.Func.vid.get(), - Op: op, - Type: t, - AuxInt: auxint, - Block: b, - Line: line, - } + v := b.Func.newValue(op, t, b, line) + v.AuxInt = auxint v.Args = v.argstorage[:0] - b.Values = append(b.Values, v) return v } @@ -116,158 +133,93 @@ func (b *Block) NewValue0A(line int32, op Op, t Type, aux interface{}) *Value { // 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 := &Value{ - ID: b.Func.vid.get(), - Op: op, - Type: t, - Aux: aux, - Block: b, - Line: line, - } + v := b.Func.newValue(op, t, b, line) + v.AuxInt = 0 + v.Aux = aux v.Args = v.argstorage[:0] - b.Values = append(b.Values, v) 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 := &Value{ - ID: b.Func.vid.get(), - Op: op, - Type: t, - AuxInt: auxint, - Aux: aux, - Block: b, - Line: line, - } + v := b.Func.newValue(op, t, b, line) + v.AuxInt = auxint + v.Aux = aux v.Args = v.argstorage[:0] - b.Values = append(b.Values, v) 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 := &Value{ - ID: b.Func.vid.get(), - Op: op, - Type: t, - Block: b, - Line: line, - } + v := b.Func.newValue(op, t, b, line) + v.AuxInt = 0 v.Args = v.argstorage[:1] - v.Args[0] = arg - b.Values = append(b.Values, v) + 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 := &Value{ - ID: b.Func.vid.get(), - Op: op, - Type: t, - AuxInt: auxint, - Block: b, - Line: line, - } + v := b.Func.newValue(op, t, b, line) + v.AuxInt = auxint v.Args = v.argstorage[:1] - v.Args[0] = arg - b.Values = append(b.Values, v) + 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 := &Value{ - ID: b.Func.vid.get(), - Op: op, - Type: t, - Aux: aux, - Block: b, - Line: line, - } + v := b.Func.newValue(op, t, b, line) + v.AuxInt = 0 + v.Aux = aux v.Args = v.argstorage[:1] - v.Args[0] = arg - b.Values = append(b.Values, v) + 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 := &Value{ - ID: b.Func.vid.get(), - Op: op, - Type: t, - AuxInt: auxint, - Aux: aux, - Block: b, - Line: line, - } + v := b.Func.newValue(op, t, b, line) + v.AuxInt = auxint + v.Aux = aux v.Args = v.argstorage[:1] - v.Args[0] = arg - b.Values = append(b.Values, v) + 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 := &Value{ - ID: b.Func.vid.get(), - Op: op, - Type: t, - Block: b, - Line: line, - } + v := b.Func.newValue(op, t, b, line) + v.AuxInt = 0 v.Args = v.argstorage[:2] - v.Args[0] = arg0 - v.Args[1] = arg1 - b.Values = append(b.Values, v) + 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, aux int64, arg0, arg1 *Value) *Value { - v := &Value{ - ID: b.Func.vid.get(), - Op: op, - Type: t, - AuxInt: aux, - Block: b, - Line: line, - } +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.Args[0] = arg0 - v.Args[1] = arg1 - b.Values = append(b.Values, v) + 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 := &Value{ - ID: b.Func.vid.get(), - Op: op, - Type: t, - Block: b, - Line: line, - } + v := b.Func.newValue(op, t, b, line) + v.AuxInt = 0 v.Args = []*Value{arg0, arg1, arg2} - b.Values = append(b.Values, v) 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, aux int64, arg0, arg1, arg2 *Value) *Value { - v := &Value{ - ID: b.Func.vid.get(), - Op: op, - Type: t, - AuxInt: aux, - Block: b, - Line: line, - } +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} - b.Values = append(b.Values, v) return v } @@ -310,3 +262,32 @@ func (f *Func) Fatalf(msg string, args ...interface{}) { f.Config.Fatalf(f.Entry 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/id.go b/src/cmd/compile/internal/ssa/id.go index 3f53e1a434..367e687abf 100644 --- a/src/cmd/compile/internal/ssa/id.go +++ b/src/cmd/compile/internal/ssa/id.go @@ -9,16 +9,10 @@ type ID int32 // idAlloc provides an allocator for unique integers. type idAlloc struct { last ID - free []ID } // get allocates an ID and returns it. func (a *idAlloc) get() ID { - if n := len(a.free); n > 0 { - x := a.free[n-1] - a.free = a.free[:n-1] - return x - } x := a.last x++ if x == 1<<31-1 { @@ -28,11 +22,6 @@ func (a *idAlloc) get() ID { return x } -// put deallocates an ID. -func (a *idAlloc) put(x ID) { - a.free = append(a.free, 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/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index 9238999074..2a92624319 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -964,9 +964,7 @@ func (s *regAllocState) regalloc(f *Func) { // Constants, SP, SB, ... continue } - spill.Op = OpInvalid - spill.Type = TypeInvalid - spill.resetArgs() + f.freeValue(spill) } for _, b := range f.Blocks { i := 0 -- cgit v1.3 From 4c5459da2b5d0c80d48f3bb61e194ded5d413c31 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Thu, 28 Jan 2016 16:11:56 -0800 Subject: [dev.ssa] cmd/compile: fix build Some tests make multiple Funcs per Config at once. With value & block caching, we can't do that any more. Change-Id: Ibdb60aa2fcf478f1726b3be0fcaa06b04433eb67 Reviewed-on: https://go-review.googlesource.com/19081 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 1 + src/cmd/compile/internal/ssa/func_test.go | 32 ++++++++++++++---------------- src/cmd/compile/internal/ssa/shift_test.go | 6 ++++++ 3 files changed, 22 insertions(+), 17 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index ae747324be..6bdf0c69e0 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -224,6 +224,7 @@ func buildssa(fn *Node) *ssa.Func { } if nerrors > 0 { + s.f.Free() return nil } diff --git a/src/cmd/compile/internal/ssa/func_test.go b/src/cmd/compile/internal/ssa/func_test.go index 1dc134d8a8..590804182a 100644 --- a/src/cmd/compile/internal/ssa/func_test.go +++ b/src/cmd/compile/internal/ssa/func_test.go @@ -139,8 +139,7 @@ type fun struct { // 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 := new(Func) - f.Config = c + f := c.NewFunc() blocks := make(map[string]*Block) values := make(map[string]*Value) // Create all the blocks and values. @@ -282,11 +281,10 @@ func TestArgs(t *testing.T) { } func TestEquiv(t *testing.T) { - c := testConfig(t) equivalentCases := []struct{ f, g fun }{ // simple case { - Fun(c, "entry", + Fun(testConfig(t), "entry", Bloc("entry", Valu("a", OpConst64, TypeInt64, 14, nil), Valu("b", OpConst64, TypeInt64, 26, nil), @@ -295,7 +293,7 @@ func TestEquiv(t *testing.T) { Goto("exit")), Bloc("exit", Exit("mem"))), - Fun(c, "entry", + Fun(testConfig(t), "entry", Bloc("entry", Valu("a", OpConst64, TypeInt64, 14, nil), Valu("b", OpConst64, TypeInt64, 26, nil), @@ -307,7 +305,7 @@ func TestEquiv(t *testing.T) { }, // block order changed { - Fun(c, "entry", + Fun(testConfig(t), "entry", Bloc("entry", Valu("a", OpConst64, TypeInt64, 14, nil), Valu("b", OpConst64, TypeInt64, 26, nil), @@ -316,7 +314,7 @@ func TestEquiv(t *testing.T) { Goto("exit")), Bloc("exit", Exit("mem"))), - Fun(c, "entry", + Fun(testConfig(t), "entry", Bloc("exit", Exit("mem")), Bloc("entry", @@ -338,26 +336,26 @@ func TestEquiv(t *testing.T) { differentCases := []struct{ f, g fun }{ // different shape { - Fun(c, "entry", + Fun(testConfig(t), "entry", Bloc("entry", Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Goto("exit")), Bloc("exit", Exit("mem"))), - Fun(c, "entry", + Fun(testConfig(t), "entry", Bloc("entry", Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Exit("mem"))), }, // value order changed { - Fun(c, "entry", + Fun(testConfig(t), "entry", Bloc("entry", Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Valu("b", OpConst64, TypeInt64, 26, nil), Valu("a", OpConst64, TypeInt64, 14, nil), Exit("mem"))), - Fun(c, "entry", + Fun(testConfig(t), "entry", Bloc("entry", Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Valu("a", OpConst64, TypeInt64, 14, nil), @@ -366,12 +364,12 @@ func TestEquiv(t *testing.T) { }, // value auxint different { - Fun(c, "entry", + Fun(testConfig(t), "entry", Bloc("entry", Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Valu("a", OpConst64, TypeInt64, 14, nil), Exit("mem"))), - Fun(c, "entry", + Fun(testConfig(t), "entry", Bloc("entry", Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Valu("a", OpConst64, TypeInt64, 26, nil), @@ -379,12 +377,12 @@ func TestEquiv(t *testing.T) { }, // value aux different { - Fun(c, "entry", + Fun(testConfig(t), "entry", Bloc("entry", Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Valu("a", OpConst64, TypeInt64, 0, 14), Exit("mem"))), - Fun(c, "entry", + Fun(testConfig(t), "entry", Bloc("entry", Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Valu("a", OpConst64, TypeInt64, 0, 26), @@ -392,14 +390,14 @@ func TestEquiv(t *testing.T) { }, // value args different { - Fun(c, "entry", + Fun(testConfig(t), "entry", Bloc("entry", Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Valu("a", OpConst64, TypeInt64, 14, nil), Valu("b", OpConst64, TypeInt64, 26, nil), Valu("sum", OpAdd64, TypeInt64, 0, nil, "a", "b"), Exit("mem"))), - Fun(c, "entry", + Fun(testConfig(t), "entry", Bloc("entry", Valu("mem", OpInitMem, TypeMem, 0, ".mem"), Valu("a", OpConst64, TypeInt64, 0, nil), diff --git a/src/cmd/compile/internal/ssa/shift_test.go b/src/cmd/compile/internal/ssa/shift_test.go index 9e7f0585a6..68d5f2ef70 100644 --- a/src/cmd/compile/internal/ssa/shift_test.go +++ b/src/cmd/compile/internal/ssa/shift_test.go @@ -12,16 +12,22 @@ 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 { -- cgit v1.3 From 056c09bb88008f683904e88cea582722eeac2f27 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Thu, 28 Jan 2016 15:54:45 -0800 Subject: [dev.ssa] cmd/compile: add backing store buffers for block.{Preds,Succs,Values} Speeds up compilation by 6%. Change-Id: Ibaad95710323ddbe13c1b0351843fe43a48d776e Reviewed-on: https://go-review.googlesource.com/19080 Reviewed-by: Brad Fitzpatrick --- src/cmd/compile/internal/ssa/block.go | 5 +++++ src/cmd/compile/internal/ssa/check.go | 2 +- src/cmd/compile/internal/ssa/deadcode.go | 9 +-------- src/cmd/compile/internal/ssa/func.go | 16 +++++++++++----- src/cmd/compile/internal/ssa/fuse.go | 7 ++++++- 5 files changed, 24 insertions(+), 15 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/block.go b/src/cmd/compile/internal/ssa/block.go index 02673f0650..6585528b28 100644 --- a/src/cmd/compile/internal/ssa/block.go +++ b/src/cmd/compile/internal/ssa/block.go @@ -53,6 +53,11 @@ type Block struct { // 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 diff --git a/src/cmd/compile/internal/ssa/check.go b/src/cmd/compile/internal/ssa/check.go index e6f8716d5b..1c36160f8f 100644 --- a/src/cmd/compile/internal/ssa/check.go +++ b/src/cmd/compile/internal/ssa/check.go @@ -219,7 +219,7 @@ func checkFunc(f *Func) { f.Fatalf("control value for %s is missing: %v", b, b.Control) } } - for b := f.freeBlocks; b != nil; b = b.Aux.(*Block) { + 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) } diff --git a/src/cmd/compile/internal/ssa/deadcode.go b/src/cmd/compile/internal/ssa/deadcode.go index faf16a3816..80e1490014 100644 --- a/src/cmd/compile/internal/ssa/deadcode.go +++ b/src/cmd/compile/internal/ssa/deadcode.go @@ -183,7 +183,7 @@ func deadcode(f *Func) { b.Values = b.Values[:i] } - // Remove unreachable blocks. Return dead block ids to allocator. + // Remove unreachable blocks. Return dead blocks to allocator. i = 0 for _, b := range f.Blocks { if reachable[b.ID] { @@ -193,10 +193,6 @@ func deadcode(f *Func) { if len(b.Values) > 0 { b.Fatalf("live values in unreachable block %v: %v", b, b.Values) } - b.Preds = nil - b.Succs = nil - b.Control = nil - b.Kind = BlockDead f.freeBlock(b) } } @@ -206,9 +202,6 @@ func deadcode(f *Func) { tail[j] = nil } f.Blocks = f.Blocks[:i] - - // TODO: renumber Blocks and Values densely? - // TODO: save dead Values and Blocks for reuse? Or should we just let GC handle it? } // removePred removes the predecessor p from b's predecessor list. diff --git a/src/cmd/compile/internal/ssa/func.go b/src/cmd/compile/internal/ssa/func.go index 26e4283a23..6d20a2797d 100644 --- a/src/cmd/compile/internal/ssa/func.go +++ b/src/cmd/compile/internal/ssa/func.go @@ -30,7 +30,7 @@ type Func struct { Names []LocalSlot freeValues *Value // free Values linked by argstorage[0]. All other fields except ID are 0/nil. - freeBlocks *Block // free Blocks linked by Aux.(*Block). All other fields except ID are 0/nil. + freeBlocks *Block // free Blocks linked by succstorage[0]. All other fields except ID are 0/nil. } // NumBlocks returns an integer larger than the id of any Block in the Func. @@ -68,7 +68,7 @@ func (f *Func) newValue(op Op, t Type, b *Block, line int32) *Value { // freeValue frees a value. It must no longer be referenced. func (f *Func) freeValue(v *Value) { - if v.Type == nil { + if v.Block == nil { f.Fatalf("trying to free an already freed value") } // Clear everything but ID (which we reuse). @@ -84,8 +84,8 @@ func (f *Func) NewBlock(kind BlockKind) *Block { var b *Block if f.freeBlocks != nil { b = f.freeBlocks - f.freeBlocks = b.Aux.(*Block) - b.Aux = nil + f.freeBlocks = b.succstorage[0] + b.succstorage[0] = nil } else { ID := f.bid.get() if int(ID) < len(f.Config.blocks) { @@ -96,16 +96,22 @@ func (f *Func) NewBlock(kind BlockKind) *Block { } 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.Aux = f.freeBlocks + b.succstorage[0] = f.freeBlocks f.freeBlocks = b } diff --git a/src/cmd/compile/internal/ssa/fuse.go b/src/cmd/compile/internal/ssa/fuse.go index e390fc4998..f191c7f9fd 100644 --- a/src/cmd/compile/internal/ssa/fuse.go +++ b/src/cmd/compile/internal/ssa/fuse.go @@ -22,7 +22,12 @@ func fuse(f *Func) { } // replace b->c edge with preds(b) -> c - c.Preds = b.Preds + 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 { -- cgit v1.3 From 8a961aee286cc7c891d5e0a49ed362fe500f81f4 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Thu, 28 Jan 2016 17:43:45 -0800 Subject: [dev.ssa] cmd/compile: fix -N build The OpSB hack didn't quite work. We need to really CSE these ops to make regalloc happy. Change-Id: I9f4d7bfb0929407c84ee60c9e25ff0c0fbea84af Reviewed-on: https://go-review.googlesource.com/19083 Run-TryBot: Keith Randall TryBot-Result: Gobot Gobot Reviewed-by: David Chase --- src/cmd/compile/internal/ssa/compile.go | 2 +- src/cmd/compile/internal/ssa/cse.go | 28 ++++++++++++++++++++++++++++ src/cmd/compile/internal/ssa/regalloc.go | 6 ------ 3 files changed, 29 insertions(+), 7 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/compile.go b/src/cmd/compile/internal/ssa/compile.go index 048f189ffe..121c1e1a37 100644 --- a/src/cmd/compile/internal/ssa/compile.go +++ b/src/cmd/compile/internal/ssa/compile.go @@ -92,7 +92,7 @@ var passes = [...]pass{ {"decompose", decompose, true}, {"opt", opt, true}, // TODO: split required rules and optimizing rules {"opt deadcode", deadcode, false}, // remove any blocks orphaned during opt - {"generic cse", cse, false}, + {"generic cse", cse, true}, {"nilcheckelim", nilcheckelim, false}, {"generic deadcode", deadcode, false}, {"fuse", fuse, false}, diff --git a/src/cmd/compile/internal/ssa/cse.go b/src/cmd/compile/internal/ssa/cse.go index 7603e17ecf..14cec12e92 100644 --- a/src/cmd/compile/internal/ssa/cse.go +++ b/src/cmd/compile/internal/ssa/cse.go @@ -10,6 +10,34 @@ import "sort" // Values are just relinked, nothing is deleted. A subsequent deadcode // pass is required to actually remove duplicate expressions. func cse(f *Func) { + if !f.Config.optimize { + // Don't do CSE in this case. But we need to do + // just a little bit, to combine multiple OpSB ops. + // Regalloc gets very confused otherwise. + var sb *Value + outer: + for _, b := range f.Blocks { + for _, v := range b.Values { + if v.Op == OpSB { + sb = v + break outer + } + } + } + if sb == nil { + return + } + for _, b := range f.Blocks { + for _, v := range b.Values { + for i, a := range v.Args { + if a.Op == OpSB { + v.Args[i] = sb + } + } + } + } + return + } // Two values are equivalent if they satisfy the following definition: // equivalent(v, w): // v.op == w.op diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index 2a92624319..1ab08b733c 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -316,12 +316,6 @@ func (s *regAllocState) assignReg(r register, v *Value, c *Value) { fmt.Printf("assignReg %s %s/%s\n", registers[r].Name(), v, c) } if s.regs[r].v != nil { - if v.Op == OpSB && !v.Block.Func.Config.optimize { - // Rewrite rules may introduce multiple OpSB, and with - // -N they don't get CSEd. Ignore the extra assignments. - s.f.setHome(c, ®isters[r]) - return - } 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) } -- cgit v1.3 From 9d6e605cf7c2b8b9c279e687d06bc92a8ade6fcc Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Mon, 18 Jan 2016 20:00:15 -0800 Subject: [dev.ssa] cmd/compile: simple forward-looking register allocation tweak For each value that needs to be in a fixed register at the end of the block, and try to pick that fixed register when the instruction generating that value is scheduled (or restored from a spill). Just used for end-of-block register requirements for now. Fixed-register instruction requirements (e.g. shift in ecx) can be added later. Also two-instruction constraints (input reg == output reg) might be recorded in a similar manner. Change-Id: I59916e2e7f73657bb4fc3e3b65389749d7a23fa8 Reviewed-on: https://go-review.googlesource.com/18774 Run-TryBot: Keith Randall Reviewed-by: David Chase --- src/cmd/compile/internal/ssa/regalloc.go | 111 ++++++++++++++++++++++++++----- 1 file changed, 96 insertions(+), 15 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index 1ab08b733c..61f694355e 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -205,8 +205,10 @@ type valState struct { 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() + 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 { @@ -326,21 +328,33 @@ func (s *regAllocState) assignReg(r register, v *Value, c *Value) { s.f.setHome(c, ®isters[r]) } -// allocReg picks an unused register from regmask. If there is no unused register, -// a Value will be kicked out of a register to make room. -func (s *regAllocState) allocReg(mask regMask) register { - // Pick a register to use. +// 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") } - var r register - if unused := mask & ^s.used; unused != 0 { - // Pick an unused register. - return pickReg(unused) - // TODO: use affinity graph to pick a good register + // 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? @@ -355,6 +369,7 @@ func (s *regAllocState) allocReg(mask regMask) register { // 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 { @@ -405,7 +420,7 @@ func (s *regAllocState) allocValToReg(v *Value, mask regMask, nospill bool) *Val mask &^= s.reserved() // Allocate a register. - r := s.allocReg(mask) + r := s.allocReg(v, mask) // Allocate v to the new register. var c *Value @@ -454,6 +469,7 @@ func (s *regAllocState) init(f *Func) { 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 } } @@ -757,6 +773,72 @@ func (s *regAllocState) regalloc(f *Func) { } } + // 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 { @@ -825,7 +907,6 @@ func (s *regAllocState) regalloc(f *Func) { s.freeRegs(regspec.clobbers) // Pick register for output. - var r register var mask regMask if s.values[v.ID].needReg { mask = regspec.outputs[0] &^ s.reserved() @@ -834,7 +915,7 @@ func (s *regAllocState) regalloc(f *Func) { } } if mask != 0 { - r = s.allocReg(mask) + r := s.allocReg(v, mask) s.assignReg(r, v, v) } @@ -912,7 +993,7 @@ func (s *regAllocState) regalloc(f *Func) { // 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 correct. + // 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. -- cgit v1.3 From d8a65672f8605d9d51fd90996162ab8d79a4aa32 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Mon, 25 Jan 2016 09:21:17 -0800 Subject: [dev.ssa] cmd/compile: optimization for && and || expressions Compiling && and || expressions often leads to control flow of the following form: p: If a goto b else c b: <- p ... x = phi(a, ...) If x goto t else u Note that if we take the edge p->b, then we are guaranteed to take the edge b->t also. So in this situation, we might as well go directly from p to t. Change-Id: I6974f1e6367119a2ddf2014f9741fdb490edcc12 Reviewed-on: https://go-review.googlesource.com/18910 Reviewed-by: David Chase --- src/cmd/compile/internal/ssa/compile.go | 1 + src/cmd/compile/internal/ssa/gen/genericOps.go | 31 ++--- src/cmd/compile/internal/ssa/shortcircuit.go | 144 ++++++++++++++++++++++ src/cmd/compile/internal/ssa/shortcircuit_test.go | 50 ++++++++ 4 files changed, 208 insertions(+), 18 deletions(-) create mode 100644 src/cmd/compile/internal/ssa/shortcircuit.go create mode 100644 src/cmd/compile/internal/ssa/shortcircuit_test.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/compile.go b/src/cmd/compile/internal/ssa/compile.go index 121c1e1a37..75c73eb24f 100644 --- a/src/cmd/compile/internal/ssa/compile.go +++ b/src/cmd/compile/internal/ssa/compile.go @@ -89,6 +89,7 @@ var passes = [...]pass{ {"early phielim", phielim, false}, {"early copyelim", copyelim, false}, {"early deadcode", deadcode, false}, // remove generated dead code to avoid doing pointless work during opt + {"short circuit", shortcircuit, false}, {"decompose", decompose, true}, {"opt", opt, true}, // TODO: split required rules and optimizing rules {"opt deadcode", deadcode, false}, // remove any blocks orphaned during opt diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 107c145dac..36dd58cd1d 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -245,24 +245,19 @@ var genericOps = []opData{ // arg0=ptr/int arg1=mem, output=int/ptr {name: "Convert"}, - // constants. Constant values are stored in the aux field. - // booleans have a bool aux field, strings have a string aux - // field, and so on. All integer types store their value - // in the AuxInt field as an int64 (including int, uint64, etc.). - // For integer types smaller than 64 bits, only the low-order - // bits of the AuxInt field matter. - {name: "ConstBool"}, - {name: "ConstString"}, - {name: "ConstNil", typ: "BytePtr"}, - {name: "Const8"}, - {name: "Const16"}, - {name: "Const32"}, - {name: "Const64"}, - {name: "Const32F"}, - {name: "Const64F"}, - {name: "ConstInterface"}, // nil interface - {name: "ConstSlice"}, // nil slice - // TODO: Const32F, ... + // constants. Constant values are stored in the aux or + // auxint fields. + {name: "ConstBool"}, // auxint is 0 for false and 1 for true + {name: "ConstString"}, // value is aux.(string) + {name: "ConstNil", typ: "BytePtr"}, // nil pointer + {name: "Const8"}, // value is low 8 bits of auxint + {name: "Const16"}, // value is low 16 bits of auxint + {name: "Const32"}, // value is low 32 bits of auxint + {name: "Const64"}, // value is auxint + {name: "Const32F"}, // value is math.Float64frombits(uint64(auxint)) + {name: "Const64F"}, // value is math.Float64frombits(uint64(auxint)) + {name: "ConstInterface"}, // nil interface + {name: "ConstSlice"}, // nil slice // Constant-like things {name: "InitMem"}, // memory input to the function. diff --git a/src/cmd/compile/internal/ssa/shortcircuit.go b/src/cmd/compile/internal/ssa/shortcircuit.go new file mode 100644 index 0000000000..d22a61a0af --- /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 0000000000..d518dfbabf --- /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, ".mem"), + 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) + } + } + } +} -- cgit v1.3 From 5ba31940dc2934dc76a47f0e614d441225ea3a95 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Mon, 25 Jan 2016 17:06:54 -0800 Subject: [dev.ssa] cmd/compile: fix write barriers for SSA The old write barriers used _nostore versions, which don't work for Ian's cgo checker. Instead, we adopt the same write barrier pattern as the default compiler. It's a bit trickier to code up but should be more efficient. Change-Id: I6696c3656cf179e28f800b0e096b7259bd5f3bb7 Reviewed-on: https://go-review.googlesource.com/18941 Run-TryBot: Keith Randall TryBot-Result: Gobot Gobot Reviewed-by: David Chase --- misc/cgo/errors/ptr.go | 208 ++++++++++--------- src/cmd/compile/internal/gc/builtin.go | 1 - src/cmd/compile/internal/gc/builtin/runtime.go | 1 - src/cmd/compile/internal/gc/go.go | 3 +- src/cmd/compile/internal/gc/pgen.go | 3 +- src/cmd/compile/internal/gc/ssa.go | 268 +++++++++++++++++++------ src/runtime/mbarrier.go | 8 - 7 files changed, 318 insertions(+), 174 deletions(-) (limited to 'src/cmd') diff --git a/misc/cgo/errors/ptr.go b/misc/cgo/errors/ptr.go index a0e3e066b4..0dd291f5ed 100644 --- a/misc/cgo/errors/ptr.go +++ b/misc/cgo/errors/ptr.go @@ -134,111 +134,109 @@ var ptrTests = []ptrTest{ body: `parg := [1]**C.char{&hello[0]}; C.f(&parg[0])`, fail: true, }, - /* - { - // Storing a Go pointer into C memory should fail. - name: "barrier", - c: `#include - char **f1() { return malloc(sizeof(char*)); } - void f2(char **p) {}`, - body: `p := C.f1(); *p = new(C.char); C.f2(p)`, - fail: true, - expensive: true, - }, - { - // Storing a Go pointer into C memory by assigning a - // large value should fail. - name: "barrier-struct", - c: `#include - struct s { char *a[10]; }; - struct s *f1() { return malloc(sizeof(struct s)); } - void f2(struct s *p) {}`, - body: `p := C.f1(); p.a = [10]*C.char{new(C.char)}; C.f2(p)`, - fail: true, - expensive: true, - }, - { - // Storing a Go pointer into C memory using a slice - // copy should fail. - name: "barrier-slice", - c: `#include - struct s { char *a[10]; }; - struct s *f1() { return malloc(sizeof(struct s)); } - void f2(struct s *p) {}`, - body: `p := C.f1(); copy(p.a[:], []*C.char{new(C.char)}); C.f2(p)`, - fail: true, - expensive: true, - }, - { - // A very large value uses a GC program, which is a - // different code path. - name: "barrier-gcprog-array", - c: `#include - struct s { char *a[32769]; }; - struct s *f1() { return malloc(sizeof(struct s)); } - void f2(struct s *p) {}`, - body: `p := C.f1(); p.a = [32769]*C.char{new(C.char)}; C.f2(p)`, - fail: true, - expensive: true, - }, - { - // Similar case, with a source on the heap. - name: "barrier-gcprog-array-heap", - c: `#include - struct s { char *a[32769]; }; - struct s *f1() { return malloc(sizeof(struct s)); } - void f2(struct s *p) {} - void f3(void *p) {}`, - imports: []string{"unsafe"}, - body: `p := C.f1(); n := &[32769]*C.char{new(C.char)}; p.a = *n; C.f2(p); n[0] = nil; C.f3(unsafe.Pointer(n))`, - fail: true, - expensive: true, - }, - { - // A GC program with a struct. - name: "barrier-gcprog-struct", - c: `#include - struct s { char *a[32769]; }; - struct s2 { struct s f; }; - struct s2 *f1() { return malloc(sizeof(struct s2)); } - void f2(struct s2 *p) {}`, - body: `p := C.f1(); p.f = C.struct_s{[32769]*C.char{new(C.char)}}; C.f2(p)`, - fail: true, - expensive: true, - }, - { - // Similar case, with a source on the heap. - name: "barrier-gcprog-struct-heap", - c: `#include - struct s { char *a[32769]; }; - struct s2 { struct s f; }; - struct s2 *f1() { return malloc(sizeof(struct s2)); } - void f2(struct s2 *p) {} - void f3(void *p) {}`, - imports: []string{"unsafe"}, - body: `p := C.f1(); n := &C.struct_s{[32769]*C.char{new(C.char)}}; p.f = *n; C.f2(p); n.a[0] = nil; C.f3(unsafe.Pointer(n))`, - fail: true, - expensive: true, - }, - { - // Exported functions may not return Go pointers. - name: "export1", - c: `extern unsigned char *GoFn();`, - support: `//export GoFn - func GoFn() *byte { return new(byte) }`, - body: `C.GoFn()`, - fail: true, - }, - { - // Returning a C pointer is fine. - name: "exportok", - c: `#include - extern unsigned char *GoFn();`, - support: `//export GoFn - func GoFn() *byte { return (*byte)(C.malloc(1)) }`, - body: `C.GoFn()`, - }, - */ + { + // Storing a Go pointer into C memory should fail. + name: "barrier", + c: `#include + char **f1() { return malloc(sizeof(char*)); } + void f2(char **p) {}`, + body: `p := C.f1(); *p = new(C.char); C.f2(p)`, + fail: true, + expensive: true, + }, + { + // Storing a Go pointer into C memory by assigning a + // large value should fail. + name: "barrier-struct", + c: `#include + struct s { char *a[10]; }; + struct s *f1() { return malloc(sizeof(struct s)); } + void f2(struct s *p) {}`, + body: `p := C.f1(); p.a = [10]*C.char{new(C.char)}; C.f2(p)`, + fail: true, + expensive: true, + }, + { + // Storing a Go pointer into C memory using a slice + // copy should fail. + name: "barrier-slice", + c: `#include + struct s { char *a[10]; }; + struct s *f1() { return malloc(sizeof(struct s)); } + void f2(struct s *p) {}`, + body: `p := C.f1(); copy(p.a[:], []*C.char{new(C.char)}); C.f2(p)`, + fail: true, + expensive: true, + }, + { + // A very large value uses a GC program, which is a + // different code path. + name: "barrier-gcprog-array", + c: `#include + struct s { char *a[32769]; }; + struct s *f1() { return malloc(sizeof(struct s)); } + void f2(struct s *p) {}`, + body: `p := C.f1(); p.a = [32769]*C.char{new(C.char)}; C.f2(p)`, + fail: true, + expensive: true, + }, + { + // Similar case, with a source on the heap. + name: "barrier-gcprog-array-heap", + c: `#include + struct s { char *a[32769]; }; + struct s *f1() { return malloc(sizeof(struct s)); } + void f2(struct s *p) {} + void f3(void *p) {}`, + imports: []string{"unsafe"}, + body: `p := C.f1(); n := &[32769]*C.char{new(C.char)}; p.a = *n; C.f2(p); n[0] = nil; C.f3(unsafe.Pointer(n))`, + fail: true, + expensive: true, + }, + { + // A GC program with a struct. + name: "barrier-gcprog-struct", + c: `#include + struct s { char *a[32769]; }; + struct s2 { struct s f; }; + struct s2 *f1() { return malloc(sizeof(struct s2)); } + void f2(struct s2 *p) {}`, + body: `p := C.f1(); p.f = C.struct_s{[32769]*C.char{new(C.char)}}; C.f2(p)`, + fail: true, + expensive: true, + }, + { + // Similar case, with a source on the heap. + name: "barrier-gcprog-struct-heap", + c: `#include + struct s { char *a[32769]; }; + struct s2 { struct s f; }; + struct s2 *f1() { return malloc(sizeof(struct s2)); } + void f2(struct s2 *p) {} + void f3(void *p) {}`, + imports: []string{"unsafe"}, + body: `p := C.f1(); n := &C.struct_s{[32769]*C.char{new(C.char)}}; p.f = *n; C.f2(p); n.a[0] = nil; C.f3(unsafe.Pointer(n))`, + fail: true, + expensive: true, + }, + { + // Exported functions may not return Go pointers. + name: "export1", + c: `extern unsigned char *GoFn();`, + support: `//export GoFn + func GoFn() *byte { return new(byte) }`, + body: `C.GoFn()`, + fail: true, + }, + { + // Returning a C pointer is fine. + name: "exportok", + c: `#include + extern unsigned char *GoFn();`, + support: `//export GoFn + func GoFn() *byte { return (*byte)(C.malloc(1)) }`, + body: `C.GoFn()`, + }, } func main() { diff --git a/src/cmd/compile/internal/gc/builtin.go b/src/cmd/compile/internal/gc/builtin.go index 568ffdd4fd..7f2e80b52f 100644 --- a/src/cmd/compile/internal/gc/builtin.go +++ b/src/cmd/compile/internal/gc/builtin.go @@ -117,7 +117,6 @@ const runtimeimport = "" + "func @\"\".writebarrierfat1110 (@\"\".dst·1 *any, _ uintptr, @\"\".src·3 any)\n" + "func @\"\".writebarrierfat1111 (@\"\".dst·1 *any, _ uintptr, @\"\".src·3 any)\n" + "func @\"\".typedmemmove (@\"\".typ·1 *byte, @\"\".dst·2 *any, @\"\".src·3 *any)\n" + - "func @\"\".typedmemmove_nostore (@\"\".typ·1 *byte, @\"\".dst·2 *any)\n" + "func @\"\".typedslicecopy (@\"\".typ·2 *byte, @\"\".dst·3 any, @\"\".src·4 any) (? int)\n" + "func @\"\".selectnbsend (@\"\".chanType·2 *byte, @\"\".hchan·3 chan<- any, @\"\".elem·4 *any) (? bool)\n" + "func @\"\".selectnbrecv (@\"\".chanType·2 *byte, @\"\".elem·3 *any, @\"\".hchan·4 <-chan any) (? bool)\n" + diff --git a/src/cmd/compile/internal/gc/builtin/runtime.go b/src/cmd/compile/internal/gc/builtin/runtime.go index 07a0c31650..70663eeee4 100644 --- a/src/cmd/compile/internal/gc/builtin/runtime.go +++ b/src/cmd/compile/internal/gc/builtin/runtime.go @@ -151,7 +151,6 @@ func writebarrierfat1111(dst *any, _ uintptr, src any) // *byte is really *runtime.Type func typedmemmove(typ *byte, dst *any, src *any) -func typedmemmove_nostore(typ *byte, dst *any) func typedslicecopy(typ *byte, dst any, src any) int func selectnbsend(chanType *byte, hchan chan<- any, elem *any) bool diff --git a/src/cmd/compile/internal/gc/go.go b/src/cmd/compile/internal/gc/go.go index fc7a78a87c..08442a415b 100644 --- a/src/cmd/compile/internal/gc/go.go +++ b/src/cmd/compile/internal/gc/go.go @@ -868,6 +868,7 @@ var throwreturn *Node var growslice *Node -var typedmemmove_nostore *Node +var writebarrierptr *Node +var typedmemmove *Node var panicdottype *Node diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/pgen.go index 6f5913406e..f90f89a805 100644 --- a/src/cmd/compile/internal/gc/pgen.go +++ b/src/cmd/compile/internal/gc/pgen.go @@ -353,7 +353,8 @@ func compile(fn *Node) { panicdivide = Sysfunc("panicdivide") throwreturn = Sysfunc("throwreturn") growslice = Sysfunc("growslice") - typedmemmove_nostore = Sysfunc("typedmemmove_nostore") + writebarrierptr = Sysfunc("writebarrierptr") + typedmemmove = Sysfunc("typedmemmove") panicdottype = Sysfunc("panicdottype") } diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 6bdf0c69e0..a05e33196a 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -550,8 +550,8 @@ func (s *state) stmt(n *Node) { case OAS2DOTTYPE: res, resok := s.dottype(n.Rlist.N, true) - s.assign(n.List.N, res, false, n.Lineno) - s.assign(n.List.Next.N, resok, false, n.Lineno) + s.assign(n.List.N, res, false, false, n.Lineno) + s.assign(n.List.Next.N, resok, false, false, n.Lineno) return case ODCL: @@ -572,7 +572,7 @@ func (s *state) stmt(n *Node) { prealloc[n.Left] = palloc } r := s.expr(palloc) - s.assign(n.Left.Name.Heapaddr, r, false, n.Lineno) + s.assign(n.Left.Name.Heapaddr, r, false, false, n.Lineno) case OLABEL: sym := n.Left.Sym @@ -641,30 +641,52 @@ func (s *state) stmt(n *Node) { s.f.StaticData = append(data, n) return } - var r *ssa.Value + + var t *Type if n.Right != nil { - if n.Right.Op == OSTRUCTLIT || n.Right.Op == OARRAYLIT { - // All literals with nonzero fields have already been - // rewritten during walk. Any that remain are just T{} - // or equivalents. Leave r = nil to get zeroing behavior. - if !iszero(n.Right) { - Fatalf("literal with nonzero value in SSA: %v", n.Right) - } + 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(n.Right) + r = s.expr(rhs) } } - if n.Right != nil && n.Right.Op == OAPPEND { + 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. - s.assign(n.Left, r, true, n.Lineno) - return + needwb = true } - s.assign(n.Left, r, n.Op == OASWB, n.Lineno) + + s.assign(n.Left, r, needwb, deref, n.Lineno) case OIF: bThen := s.f.NewBlock(ssa.BlockPlain) @@ -1939,7 +1961,8 @@ func (s *state) expr(n *Node) *ssa.Value { return s.newValue3(ssa.OpSliceMake, n.Type, p, l, c) case OCALLFUNC, OCALLINTER, OCALLMETH: - return s.call(n, callNormal) + 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()) @@ -2014,17 +2037,22 @@ func (s *state) expr(n *Node) *ssa.Value { 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] { - s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, et.Size(), addr, arg, s.mem()) + 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 { - s.vars[&memVar] = s.newValue3I(ssa.OpMove, ssa.TypeMem, et.Size(), addr, arg, s.mem()) - } - if haspointers(et) { - // TODO: just one write barrier call for all of these writes? - // TODO: maybe just one writeBarrier.enabled check? - s.insertWB(et, addr, n.Lineno) + 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()) + } } } @@ -2083,26 +2111,21 @@ func (s *state) condBranch(cond *Node, yes, no *ssa.Block, likely int8) { b.AddEdgeTo(no) } -func (s *state) assign(left *Node, right *ssa.Value, wb bool, line int32) { +// 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 right == nil { - // right == nil means use the zero value of the assigned type. - if !canSSA(left) { - // if we can't ssa this memory, treat it as just zeroing out the backing memory - addr := s.addr(left, false) - if left.Op == ONAME { - s.vars[&memVar] = s.newValue1A(ssa.OpVarDef, ssa.TypeMem, left, s.mem()) - } - s.vars[&memVar] = s.newValue2I(ssa.OpZero, ssa.TypeMem, t.Size(), addr, s.mem()) - return - } - right = s.zeroVal(t) - } if 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 @@ -2134,7 +2157,7 @@ func (s *state) assign(left *Node, right *ssa.Value, wb bool, line int32) { } // Recursively assign the new value we've made to the base of the dot op. - s.assign(left.Left, new, false, line) + s.assign(left.Left, new, false, false, line) // TODO: do we need to update named values here? return } @@ -2143,15 +2166,30 @@ func (s *state) assign(left *Node, right *ssa.Value, wb bool, line int32) { s.addNamedValue(left, right) return } - // not ssa-able. Treat as a store. + // 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()) } - s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, t.Size(), addr, right, 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.insertWB(left.Type, addr, line) + 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. @@ -2221,6 +2259,8 @@ const ( 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) @@ -2234,9 +2274,6 @@ func (s *state) call(n *Node, k callKind) *ssa.Value { break } closure = s.expr(fn) - if closure == nil { - return nil // TODO: remove when expr always returns non-nil - } case OCALLMETH: if fn.Op != ODOTMETH { Fatalf("OCALLMETH: n.Left not an ODOTMETH: %v", fn) @@ -2324,7 +2361,7 @@ func (s *state) call(n *Node, k callKind) *ssa.Value { b.Control = call b.AddEdgeTo(bNext) - // Read result from stack at the start of the fallthrough block + // Start exit block, find address of result. s.startBlock(bNext) var titer Iter fp := Structfirst(&titer, Getoutarg(n.Left.Type)) @@ -2332,8 +2369,7 @@ func (s *state) call(n *Node, k callKind) *ssa.Value { // call has no return value. Continue with the next statement. return nil } - a := s.entryNewValue1I(ssa.OpOffPtr, Ptrto(fp.Type), fp.Width, s.sp) - return s.newValue2(ssa.OpLoad, fp.Type, a, call) + return s.entryNewValue1I(ssa.OpOffPtr, Ptrto(fp.Type), fp.Width, s.sp) } // etypesign returns the signed-ness of e, for integer/pointer etypes. @@ -2483,6 +2519,8 @@ func (s *state) addr(n *Node, bounded bool) *ssa.Value { 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)) @@ -2682,15 +2720,17 @@ func (s *state) rtcall(fn *Node, returns bool, results []*Type, args ...*ssa.Val return res } -// insertWB inserts a write barrier. A value of type t has already -// been stored at location p. Tell the runtime about this write. -// Note: there must be no GC suspension points between the write and -// the call that this function inserts. -func (s *state) insertWB(t *Type, p *ssa.Value, line int32) { +// 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_nostore(&t, p) + // 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[TBOOL]), aux, s.sb) @@ -2701,17 +2741,131 @@ func (s *state) insertWB(t *Type, p *ssa.Value, line int32) { b.Likely = ssa.BranchUnlikely b.Control = flag b.AddEdgeTo(bThen) + b.AddEdgeTo(bElse) s.startBlock(bThen) - // TODO: writebarrierptr_nostore if just one pointer word (or a few?) taddr := s.newValue1A(ssa.OpAddr, Types[TUINTPTR], &ssa.ExternSymbol{Types[TUINTPTR], typenamesym(t)}, s.sb) - s.rtcall(typedmemmove_nostore, true, nil, taddr, p) + 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 + // } - b.AddEdgeTo(s.curBlock) + if 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) + if haspointers(ft.(*Type)) { + s.insertWBstore(ft.(*Type), addr, val, line) + } else { + s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, ft.Size(), addr, val, s.mem()) + } + } + return + } + + switch { + 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()) + default: + s.Fatalf("bad write barrier type %s", t) + } + + 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[TBOOL]), aux, s.sb) + // TODO: select the .enabled field. It is currently first, so not needed for now. + flag := s.newValue2(ssa.OpLoad, Types[TBOOL], flagaddr, s.mem()) + 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) + 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) + default: + s.Fatalf("bad write barrier type %s", t) + } + s.endBlock().AddEdgeTo(bEnd) + + // Issue regular stores for pointer writes. + s.startBlock(bElse) + 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(): + 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()) + default: + s.Fatalf("bad write barrier type %s", t) + } + s.endBlock().AddEdgeTo(bEnd) + + s.startBlock(bEnd) + + if Debug_wb > 0 { + Warnl(int(line), "write barrier") + } } // slice computes the slice v[i:j:k] and returns ptr, len, and cap of result. diff --git a/src/runtime/mbarrier.go b/src/runtime/mbarrier.go index 03011d2400..45086c43cd 100644 --- a/src/runtime/mbarrier.go +++ b/src/runtime/mbarrier.go @@ -197,14 +197,6 @@ func typedmemmove(typ *_type, dst, src unsafe.Pointer) { heapBitsBulkBarrier(uintptr(dst), typ.size) } -//go:nosplit -func typedmemmove_nostore(typ *_type, dst unsafe.Pointer) { - if typ.kind&kindNoPointers != 0 { - return - } - heapBitsBulkBarrier(uintptr(dst), typ.size) -} - //go:linkname reflect_typedmemmove reflect.typedmemmove func reflect_typedmemmove(typ *_type, dst, src unsafe.Pointer) { typedmemmove(typ, dst, src) -- cgit v1.3 From f94e0745b3dc922ca7f3d15507e33ed6d3a65ee6 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Tue, 26 Jan 2016 15:47:08 -0800 Subject: [dev.ssa] cmd/compile: prepare for some load+op combining Rename StoreConst to ValAndOff so we can use it for other ops. Make ValAndOff print nicely. Add some notes & checks related to my aborted attempt to implement combined CMP+load ops. Change-Id: I2f901d12d42bc5a82879af0334806aa184a97e27 Reviewed-on: https://go-review.googlesource.com/18947 Run-TryBot: David Chase Reviewed-by: David Chase --- src/cmd/compile/internal/gc/ssa.go | 4 +- src/cmd/compile/internal/ssa/TODO | 7 +- src/cmd/compile/internal/ssa/flagalloc.go | 7 +- src/cmd/compile/internal/ssa/gen/AMD64.rules | 68 +++---- src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 4 +- src/cmd/compile/internal/ssa/op.go | 74 ++++---- src/cmd/compile/internal/ssa/rewriteAMD64.go | 268 +++++++++++++-------------- src/cmd/compile/internal/ssa/value.go | 31 +++- 8 files changed, 245 insertions(+), 218 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index a05e33196a..89286f4356 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -4092,7 +4092,7 @@ func (s *genState) genValue(v *ssa.Value) { case ssa.OpAMD64MOVQstoreconst, ssa.OpAMD64MOVLstoreconst, ssa.OpAMD64MOVWstoreconst, ssa.OpAMD64MOVBstoreconst: p := Prog(v.Op.Asm()) p.From.Type = obj.TYPE_CONST - sc := ssa.StoreConst(v.AuxInt) + sc := ssa.ValAndOff(v.AuxInt) i := sc.Val() switch v.Op { case ssa.OpAMD64MOVBstoreconst: @@ -4372,7 +4372,7 @@ func (s *genState) genValue(v *ssa.Value) { return } case ssa.OpAMD64MOVQstoreconst, ssa.OpAMD64MOVLstoreconst, ssa.OpAMD64MOVWstoreconst, ssa.OpAMD64MOVBstoreconst: - off := ssa.StoreConst(v.AuxInt).Off() + 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") diff --git a/src/cmd/compile/internal/ssa/TODO b/src/cmd/compile/internal/ssa/TODO index 2f7973c5a3..5245753c07 100644 --- a/src/cmd/compile/internal/ssa/TODO +++ b/src/cmd/compile/internal/ssa/TODO @@ -20,7 +20,6 @@ Optimizations (better compiled code) - Expand current optimizations to all bit widths - Add a value range propagation pass (for bounds elim & bitwidth reduction) - Make dead store pass inter-block -- (x86) Combine loads into other ops - (x86) More combining address arithmetic into loads/stores - (x86) use ADDQ instead of LEAQ when we can - redundant CMP in sequences like this: @@ -38,8 +37,6 @@ Optimizations (better compiled code) Same for interfaces? - boolean logic: movb/xorb$1/testb/jeq -> movb/testb/jne - (ADDQconst (SUBQconst x)) and vice-versa -- (CMP (Load ...)) and (CMPconst (Load ...)) in one instruction - (all instructions, really) - combine LEAQs - store followed by load to same address - (CMPconst [0] (AND x y)) -> (TEST x y) @@ -50,6 +47,10 @@ Optimizations (better compiled code) - better computing of &&/|| in non-if/for contexts - 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. Optimizations (better compiler) ------------------------------- diff --git a/src/cmd/compile/internal/ssa/flagalloc.go b/src/cmd/compile/internal/ssa/flagalloc.go index f4e289e782..85e9c4fbee 100644 --- a/src/cmd/compile/internal/ssa/flagalloc.go +++ b/src/cmd/compile/internal/ssa/flagalloc.go @@ -42,11 +42,14 @@ func flagalloc(f *Func) { } } } - for _, p := range b.Preds { - end[p.ID] = flag + 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.) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 9db3abb9f0..a6ad6c1ca0 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -556,24 +556,24 @@ (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) && validStoreConst(c,off) -> - (MOVQstoreconst [makeStoreConst(c,off)] {sym} ptr mem) -(MOVLstore [off] {sym} ptr (MOVLconst [c]) mem) && validStoreConstOff(off) -> - (MOVLstoreconst [makeStoreConst(int64(int32(c)),off)] {sym} ptr mem) -(MOVWstore [off] {sym} ptr (MOVWconst [c]) mem) && validStoreConstOff(off) -> - (MOVWstoreconst [makeStoreConst(int64(int16(c)),off)] {sym} ptr mem) -(MOVBstore [off] {sym} ptr (MOVBconst [c]) mem) && validStoreConstOff(off) -> - (MOVBstoreconst [makeStoreConst(int64(int8(c)),off)] {sym} ptr mem) +(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) && StoreConst(sc).canAdd(off) -> - (MOVQstoreconst [StoreConst(sc).add(off)] {s} ptr mem) -(MOVLstoreconst [sc] {s} (ADDQconst [off] ptr) mem) && StoreConst(sc).canAdd(off) -> - (MOVLstoreconst [StoreConst(sc).add(off)] {s} ptr mem) -(MOVWstoreconst [sc] {s} (ADDQconst [off] ptr) mem) && StoreConst(sc).canAdd(off) -> - (MOVWstoreconst [StoreConst(sc).add(off)] {s} ptr mem) -(MOVBstoreconst [sc] {s} (ADDQconst [off] ptr) mem) && StoreConst(sc).canAdd(off) -> - (MOVBstoreconst [StoreConst(sc).add(off)] {s} ptr mem) +(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. @@ -607,14 +607,14 @@ (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) && StoreConst(sc).canAdd(off) -> - (MOVQstoreconst [StoreConst(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem) -(MOVLstoreconst [sc] {sym1} (LEAQ [off] {sym2} ptr) mem) && canMergeSym(sym1, sym2) && StoreConst(sc).canAdd(off) -> - (MOVLstoreconst [StoreConst(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem) -(MOVWstoreconst [sc] {sym1} (LEAQ [off] {sym2} ptr) mem) && canMergeSym(sym1, sym2) && StoreConst(sc).canAdd(off) -> - (MOVWstoreconst [StoreConst(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem) -(MOVBstoreconst [sc] {sym1} (LEAQ [off] {sym2} ptr) mem) && canMergeSym(sym1, sym2) && StoreConst(sc).canAdd(off) -> - (MOVBstoreconst [StoreConst(sc).add(off)] {mergeSym(sym1, sym2)} ptr 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) // indexed loads and stores (MOVQloadidx8 [off1] {sym} (ADDQconst [off2] ptr) idx mem) -> (MOVQloadidx8 [addOff(off1, off2)] {sym} ptr idx mem) @@ -647,16 +647,16 @@ (Zero [8] destptr mem) -> (MOVQstoreconst [0] destptr mem) (Zero [3] destptr mem) -> - (MOVBstoreconst [makeStoreConst(0,2)] destptr + (MOVBstoreconst [makeValAndOff(0,2)] destptr (MOVWstoreconst [0] destptr mem)) (Zero [5] destptr mem) -> - (MOVBstoreconst [makeStoreConst(0,4)] destptr + (MOVBstoreconst [makeValAndOff(0,4)] destptr (MOVLstoreconst [0] destptr mem)) (Zero [6] destptr mem) -> - (MOVWstoreconst [makeStoreConst(0,4)] destptr + (MOVWstoreconst [makeValAndOff(0,4)] destptr (MOVLstoreconst [0] destptr mem)) (Zero [7] destptr mem) -> - (MOVLstoreconst [makeStoreConst(0,3)] destptr + (MOVLstoreconst [makeValAndOff(0,3)] destptr (MOVLstoreconst [0] destptr mem)) // Strip off any fractional word zeroing. @@ -666,16 +666,16 @@ // Zero small numbers of words directly. (Zero [16] destptr mem) -> - (MOVQstoreconst [makeStoreConst(0,8)] destptr + (MOVQstoreconst [makeValAndOff(0,8)] destptr (MOVQstoreconst [0] destptr mem)) (Zero [24] destptr mem) -> - (MOVQstoreconst [makeStoreConst(0,16)] destptr - (MOVQstoreconst [makeStoreConst(0,8)] destptr + (MOVQstoreconst [makeValAndOff(0,16)] destptr + (MOVQstoreconst [makeValAndOff(0,8)] destptr (MOVQstoreconst [0] destptr mem))) (Zero [32] destptr mem) -> - (MOVQstoreconst [makeStoreConst(0,24)] destptr - (MOVQstoreconst [makeStoreConst(0,16)] destptr - (MOVQstoreconst [makeStoreConst(0,8)] destptr + (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. diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index dcffb49f63..9cf4a2e70b 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -382,8 +382,8 @@ func init() { // For storeconst ops, the AuxInt field encodes both // the value to store and an address offset of the store. - // Cast AuxInt to a StoreConst to extract Val and Off fields. - {name: "MOVBstoreconst", reg: gpstoreconst, asm: "MOVB", typ: "Mem"}, // store low byte of StoreConst(AuxInt).Val() to arg0+StoreConst(AuxInt).Off()+aux. arg1=mem + // Cast AuxInt to a ValAndOff to extract Val and Off fields. + {name: "MOVBstoreconst", reg: gpstoreconst, asm: "MOVB", typ: "Mem"}, // store low byte of ValAndOff(AuxInt).Val() to arg0+ValAndOff(AuxInt).Off()+aux. arg1=mem {name: "MOVWstoreconst", reg: gpstoreconst, asm: "MOVW", typ: "Mem"}, // store low 2 bytes of ... {name: "MOVLstoreconst", reg: gpstoreconst, asm: "MOVL", typ: "Mem"}, // store low 4 bytes of ... {name: "MOVQstoreconst", reg: gpstoreconst, asm: "MOVQ", typ: "Mem"}, // store 8 bytes of ... diff --git a/src/cmd/compile/internal/ssa/op.go b/src/cmd/compile/internal/ssa/op.go index 78cca9e0b8..526722f7bc 100644 --- a/src/cmd/compile/internal/ssa/op.go +++ b/src/cmd/compile/internal/ssa/op.go @@ -4,6 +4,8 @@ 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. @@ -30,57 +32,67 @@ type regInfo struct { outputs []regMask // NOTE: values can only have 1 output for now. } -// A StoreConst is used by the MOVXstoreconst opcodes. It holds -// both the value to store and an offset from the store pointer. -// A StoreConst is intended to be encoded into an AuxInt field. -// The zero StoreConst encodes a value of 0 and an offset of 0. -// The high 32 bits hold a value to be stored. +// 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 StoreConst int64 +type ValAndOff int64 -func (sc StoreConst) Val() int64 { - return int64(sc) >> 32 +func (x ValAndOff) Val() int64 { + return int64(x) >> 32 +} +func (x ValAndOff) Off() int64 { + return int64(int32(x)) } -func (sc StoreConst) Off() int64 { - return int64(int32(sc)) +func (x ValAndOff) Int64() int64 { + return int64(x) } -func (sc StoreConst) Int64() int64 { - return int64(sc) +func (x ValAndOff) String() string { + return fmt.Sprintf("val=%d,off=%d", x.Val(), x.Off()) } -// validStoreConstOff reports whether the offset can be used -// as an argument to makeStoreConst. -func validStoreConstOff(off int64) bool { +// 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)) } -// validStoreConst reports whether we can fit the value and offset into -// a StoreConst value. -func validStoreConst(val, off int64) bool { - if val != int64(int32(val)) { +// 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 !validStoreConstOff(off) { + if !validOff(off) { return false } return true } -// encode encodes a StoreConst into an int64 suitable for storing in an AuxInt field. -func makeStoreConst(val, off int64) int64 { - if !validStoreConst(val, off) { - panic("invalid makeStoreConst") +// 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 StoreConst(val<<32 + int64(uint32(off))).Int64() + return ValAndOff(val<<32 + int64(uint32(off))).Int64() } -func (sc StoreConst) canAdd(off int64) bool { - newoff := sc.Off() + off +func (x ValAndOff) canAdd(off int64) bool { + newoff := x.Off() + off return newoff == int64(int32(newoff)) } -func (sc StoreConst) add(off int64) int64 { - if !sc.canAdd(off) { - panic("invalid StoreConst.add") + +func (x ValAndOff) add(off int64) int64 { + if !x.canAdd(off) { + panic("invalid ValAndOff.add") } - return makeStoreConst(sc.Val(), sc.Off()+off) + return makeValAndOff(x.Val(), x.Off()+off) } diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 3d682f0040..ec3bbe53c2 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -6059,32 +6059,32 @@ end3a2e55db7e03920700c4875f6a55de3b: ende6347ac19d0469ee59d2e7f2e18d1070: ; // match: (MOVBstore [off] {sym} ptr (MOVBconst [c]) mem) - // cond: validStoreConstOff(off) - // result: (MOVBstoreconst [makeStoreConst(int64(int8(c)),off)] {sym} ptr mem) + // cond: validOff(off) + // result: (MOVBstoreconst [makeValAndOff(int64(int8(c)),off)] {sym} ptr mem) { off := v.AuxInt sym := v.Aux ptr := v.Args[0] if v.Args[1].Op != OpAMD64MOVBconst { - goto enda8ebda583a842dae6377b7f562040318 + goto endfdf24c49923451a076f1868988b8c9d9 } c := v.Args[1].AuxInt mem := v.Args[2] - if !(validStoreConstOff(off)) { - goto enda8ebda583a842dae6377b7f562040318 + if !(validOff(off)) { + goto endfdf24c49923451a076f1868988b8c9d9 } v.Op = OpAMD64MOVBstoreconst v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = makeStoreConst(int64(int8(c)), off) + v.AuxInt = makeValAndOff(int64(int8(c)), off) v.Aux = sym v.AddArg(ptr) v.AddArg(mem) return true } - goto enda8ebda583a842dae6377b7f562040318 -enda8ebda583a842dae6377b7f562040318: + goto endfdf24c49923451a076f1868988b8c9d9 +endfdf24c49923451a076f1868988b8c9d9: ; // match: (MOVBstore [off1] {sym1} (LEAQ [off2] {sym2} base) val mem) // cond: canMergeSym(sym1, sym2) @@ -6123,61 +6123,61 @@ func rewriteValueAMD64_OpAMD64MOVBstoreconst(v *Value, config *Config) bool { b := v.Block _ = b // match: (MOVBstoreconst [sc] {s} (ADDQconst [off] ptr) mem) - // cond: StoreConst(sc).canAdd(off) - // result: (MOVBstoreconst [StoreConst(sc).add(off)] {s} ptr mem) + // cond: ValAndOff(sc).canAdd(off) + // result: (MOVBstoreconst [ValAndOff(sc).add(off)] {s} ptr mem) { sc := v.AuxInt s := v.Aux if v.Args[0].Op != OpAMD64ADDQconst { - goto ende1cdf6d463f91ba4dd1956f8ba4cb128 + goto end8d35ca650b7c40bc43984d3f5925a052 } off := v.Args[0].AuxInt ptr := v.Args[0].Args[0] mem := v.Args[1] - if !(StoreConst(sc).canAdd(off)) { - goto ende1cdf6d463f91ba4dd1956f8ba4cb128 + if !(ValAndOff(sc).canAdd(off)) { + goto end8d35ca650b7c40bc43984d3f5925a052 } v.Op = OpAMD64MOVBstoreconst v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = StoreConst(sc).add(off) + v.AuxInt = ValAndOff(sc).add(off) v.Aux = s v.AddArg(ptr) v.AddArg(mem) return true } - goto ende1cdf6d463f91ba4dd1956f8ba4cb128 -ende1cdf6d463f91ba4dd1956f8ba4cb128: + goto end8d35ca650b7c40bc43984d3f5925a052 +end8d35ca650b7c40bc43984d3f5925a052: ; // match: (MOVBstoreconst [sc] {sym1} (LEAQ [off] {sym2} ptr) mem) - // cond: canMergeSym(sym1, sym2) && StoreConst(sc).canAdd(off) - // result: (MOVBstoreconst [StoreConst(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem) + // cond: canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off) + // result: (MOVBstoreconst [ValAndOff(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem) { sc := v.AuxInt sym1 := v.Aux if v.Args[0].Op != OpAMD64LEAQ { - goto end5feed29bca3ce7d5fccda89acf71c855 + goto end8deb839acf84818dd8fc827c0338f42c } off := v.Args[0].AuxInt sym2 := v.Args[0].Aux ptr := v.Args[0].Args[0] mem := v.Args[1] - if !(canMergeSym(sym1, sym2) && StoreConst(sc).canAdd(off)) { - goto end5feed29bca3ce7d5fccda89acf71c855 + if !(canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off)) { + goto end8deb839acf84818dd8fc827c0338f42c } v.Op = OpAMD64MOVBstoreconst v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = StoreConst(sc).add(off) + v.AuxInt = ValAndOff(sc).add(off) v.Aux = mergeSym(sym1, sym2) v.AddArg(ptr) v.AddArg(mem) return true } - goto end5feed29bca3ce7d5fccda89acf71c855 -end5feed29bca3ce7d5fccda89acf71c855: + goto end8deb839acf84818dd8fc827c0338f42c +end8deb839acf84818dd8fc827c0338f42c: ; return false } @@ -6323,32 +6323,32 @@ end199e8c23a5e7e99728a43d6a83b2c2cf: end43bffdb8d9c1fc85a95778d4911955f1: ; // match: (MOVLstore [off] {sym} ptr (MOVLconst [c]) mem) - // cond: validStoreConstOff(off) - // result: (MOVLstoreconst [makeStoreConst(int64(int32(c)),off)] {sym} ptr mem) + // cond: validOff(off) + // result: (MOVLstoreconst [makeValAndOff(int64(int32(c)),off)] {sym} ptr mem) { off := v.AuxInt sym := v.Aux ptr := v.Args[0] if v.Args[1].Op != OpAMD64MOVLconst { - goto end14bc0c027d67d279cf3ef2038b759ce2 + goto enda62a54c45bf42db801af4095d27faccd } c := v.Args[1].AuxInt mem := v.Args[2] - if !(validStoreConstOff(off)) { - goto end14bc0c027d67d279cf3ef2038b759ce2 + if !(validOff(off)) { + goto enda62a54c45bf42db801af4095d27faccd } v.Op = OpAMD64MOVLstoreconst v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = makeStoreConst(int64(int32(c)), off) + v.AuxInt = makeValAndOff(int64(int32(c)), off) v.Aux = sym v.AddArg(ptr) v.AddArg(mem) return true } - goto end14bc0c027d67d279cf3ef2038b759ce2 -end14bc0c027d67d279cf3ef2038b759ce2: + goto enda62a54c45bf42db801af4095d27faccd +enda62a54c45bf42db801af4095d27faccd: ; // match: (MOVLstore [off1] {sym1} (LEAQ [off2] {sym2} base) val mem) // cond: canMergeSym(sym1, sym2) @@ -6387,61 +6387,61 @@ func rewriteValueAMD64_OpAMD64MOVLstoreconst(v *Value, config *Config) bool { b := v.Block _ = b // match: (MOVLstoreconst [sc] {s} (ADDQconst [off] ptr) mem) - // cond: StoreConst(sc).canAdd(off) - // result: (MOVLstoreconst [StoreConst(sc).add(off)] {s} ptr mem) + // cond: ValAndOff(sc).canAdd(off) + // result: (MOVLstoreconst [ValAndOff(sc).add(off)] {s} ptr mem) { sc := v.AuxInt s := v.Aux if v.Args[0].Op != OpAMD64ADDQconst { - goto end7665f96d0aaa57009bf98632f19bf8e7 + goto end4981598152dd0763f1d735810a7d34e8 } off := v.Args[0].AuxInt ptr := v.Args[0].Args[0] mem := v.Args[1] - if !(StoreConst(sc).canAdd(off)) { - goto end7665f96d0aaa57009bf98632f19bf8e7 + if !(ValAndOff(sc).canAdd(off)) { + goto end4981598152dd0763f1d735810a7d34e8 } v.Op = OpAMD64MOVLstoreconst v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = StoreConst(sc).add(off) + v.AuxInt = ValAndOff(sc).add(off) v.Aux = s v.AddArg(ptr) v.AddArg(mem) return true } - goto end7665f96d0aaa57009bf98632f19bf8e7 -end7665f96d0aaa57009bf98632f19bf8e7: + goto end4981598152dd0763f1d735810a7d34e8 +end4981598152dd0763f1d735810a7d34e8: ; // match: (MOVLstoreconst [sc] {sym1} (LEAQ [off] {sym2} ptr) mem) - // cond: canMergeSym(sym1, sym2) && StoreConst(sc).canAdd(off) - // result: (MOVLstoreconst [StoreConst(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem) + // cond: canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off) + // result: (MOVLstoreconst [ValAndOff(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem) { sc := v.AuxInt sym1 := v.Aux if v.Args[0].Op != OpAMD64LEAQ { - goto end1664c6056a9c65fcbe30eca273e8ee64 + goto endd579250954b5df84a77518b36f739e12 } off := v.Args[0].AuxInt sym2 := v.Args[0].Aux ptr := v.Args[0].Args[0] mem := v.Args[1] - if !(canMergeSym(sym1, sym2) && StoreConst(sc).canAdd(off)) { - goto end1664c6056a9c65fcbe30eca273e8ee64 + if !(canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off)) { + goto endd579250954b5df84a77518b36f739e12 } v.Op = OpAMD64MOVLstoreconst v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = StoreConst(sc).add(off) + v.AuxInt = ValAndOff(sc).add(off) v.Aux = mergeSym(sym1, sym2) v.AddArg(ptr) v.AddArg(mem) return true } - goto end1664c6056a9c65fcbe30eca273e8ee64 -end1664c6056a9c65fcbe30eca273e8ee64: + goto endd579250954b5df84a77518b36f739e12 +endd579250954b5df84a77518b36f739e12: ; return false } @@ -6720,32 +6720,32 @@ func rewriteValueAMD64_OpAMD64MOVQstore(v *Value, config *Config) bool { end0a110b5e42a4576c32fda50590092848: ; // match: (MOVQstore [off] {sym} ptr (MOVQconst [c]) mem) - // cond: validStoreConst(c,off) - // result: (MOVQstoreconst [makeStoreConst(c,off)] {sym} ptr mem) + // cond: validValAndOff(c,off) + // result: (MOVQstoreconst [makeValAndOff(c,off)] {sym} ptr mem) { off := v.AuxInt sym := v.Aux ptr := v.Args[0] if v.Args[1].Op != OpAMD64MOVQconst { - goto end8368f37d24b6a2f59c3d00966c4d4111 + goto endda0f4b36e19753762dbd1c6ee05e4c81 } c := v.Args[1].AuxInt mem := v.Args[2] - if !(validStoreConst(c, off)) { - goto end8368f37d24b6a2f59c3d00966c4d4111 + if !(validValAndOff(c, off)) { + goto endda0f4b36e19753762dbd1c6ee05e4c81 } v.Op = OpAMD64MOVQstoreconst v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = makeStoreConst(c, off) + v.AuxInt = makeValAndOff(c, off) v.Aux = sym v.AddArg(ptr) v.AddArg(mem) return true } - goto end8368f37d24b6a2f59c3d00966c4d4111 -end8368f37d24b6a2f59c3d00966c4d4111: + goto endda0f4b36e19753762dbd1c6ee05e4c81 +endda0f4b36e19753762dbd1c6ee05e4c81: ; // match: (MOVQstore [off1] {sym1} (LEAQ [off2] {sym2} base) val mem) // cond: canMergeSym(sym1, sym2) @@ -6817,61 +6817,61 @@ func rewriteValueAMD64_OpAMD64MOVQstoreconst(v *Value, config *Config) bool { b := v.Block _ = b // match: (MOVQstoreconst [sc] {s} (ADDQconst [off] ptr) mem) - // cond: StoreConst(sc).canAdd(off) - // result: (MOVQstoreconst [StoreConst(sc).add(off)] {s} ptr mem) + // cond: ValAndOff(sc).canAdd(off) + // result: (MOVQstoreconst [ValAndOff(sc).add(off)] {s} ptr mem) { sc := v.AuxInt s := v.Aux if v.Args[0].Op != OpAMD64ADDQconst { - goto end5826e30265c68ea8c4cd595ceedf9405 + goto end3694207cd20e8e1cc719e179bdfe0c74 } off := v.Args[0].AuxInt ptr := v.Args[0].Args[0] mem := v.Args[1] - if !(StoreConst(sc).canAdd(off)) { - goto end5826e30265c68ea8c4cd595ceedf9405 + if !(ValAndOff(sc).canAdd(off)) { + goto end3694207cd20e8e1cc719e179bdfe0c74 } v.Op = OpAMD64MOVQstoreconst v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = StoreConst(sc).add(off) + v.AuxInt = ValAndOff(sc).add(off) v.Aux = s v.AddArg(ptr) v.AddArg(mem) return true } - goto end5826e30265c68ea8c4cd595ceedf9405 -end5826e30265c68ea8c4cd595ceedf9405: + goto end3694207cd20e8e1cc719e179bdfe0c74 +end3694207cd20e8e1cc719e179bdfe0c74: ; // match: (MOVQstoreconst [sc] {sym1} (LEAQ [off] {sym2} ptr) mem) - // cond: canMergeSym(sym1, sym2) && StoreConst(sc).canAdd(off) - // result: (MOVQstoreconst [StoreConst(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem) + // cond: canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off) + // result: (MOVQstoreconst [ValAndOff(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem) { sc := v.AuxInt sym1 := v.Aux if v.Args[0].Op != OpAMD64LEAQ { - goto endb9c7f7a9dbc6b885d84f851c74b018e5 + goto endf405b27b22dbf76f83abd1b5ad5e53d9 } off := v.Args[0].AuxInt sym2 := v.Args[0].Aux ptr := v.Args[0].Args[0] mem := v.Args[1] - if !(canMergeSym(sym1, sym2) && StoreConst(sc).canAdd(off)) { - goto endb9c7f7a9dbc6b885d84f851c74b018e5 + if !(canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off)) { + goto endf405b27b22dbf76f83abd1b5ad5e53d9 } v.Op = OpAMD64MOVQstoreconst v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = StoreConst(sc).add(off) + v.AuxInt = ValAndOff(sc).add(off) v.Aux = mergeSym(sym1, sym2) v.AddArg(ptr) v.AddArg(mem) return true } - goto endb9c7f7a9dbc6b885d84f851c74b018e5 -endb9c7f7a9dbc6b885d84f851c74b018e5: + goto endf405b27b22dbf76f83abd1b5ad5e53d9 +endf405b27b22dbf76f83abd1b5ad5e53d9: ; return false } @@ -7567,32 +7567,32 @@ end187fe73dfaf9cf5f4c349283b4dfd9d1: endda15fdd59aa956ded0440188f38de1aa: ; // match: (MOVWstore [off] {sym} ptr (MOVWconst [c]) mem) - // cond: validStoreConstOff(off) - // result: (MOVWstoreconst [makeStoreConst(int64(int16(c)),off)] {sym} ptr mem) + // cond: validOff(off) + // result: (MOVWstoreconst [makeValAndOff(int64(int16(c)),off)] {sym} ptr mem) { off := v.AuxInt sym := v.Aux ptr := v.Args[0] if v.Args[1].Op != OpAMD64MOVWconst { - goto end226f449215b8ea54ac24fb8d52356ffa + goto end60327daf9965d73a8c1971d098e1e31d } c := v.Args[1].AuxInt mem := v.Args[2] - if !(validStoreConstOff(off)) { - goto end226f449215b8ea54ac24fb8d52356ffa + if !(validOff(off)) { + goto end60327daf9965d73a8c1971d098e1e31d } v.Op = OpAMD64MOVWstoreconst v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = makeStoreConst(int64(int16(c)), off) + v.AuxInt = makeValAndOff(int64(int16(c)), off) v.Aux = sym v.AddArg(ptr) v.AddArg(mem) return true } - goto end226f449215b8ea54ac24fb8d52356ffa -end226f449215b8ea54ac24fb8d52356ffa: + goto end60327daf9965d73a8c1971d098e1e31d +end60327daf9965d73a8c1971d098e1e31d: ; // match: (MOVWstore [off1] {sym1} (LEAQ [off2] {sym2} base) val mem) // cond: canMergeSym(sym1, sym2) @@ -7631,61 +7631,61 @@ func rewriteValueAMD64_OpAMD64MOVWstoreconst(v *Value, config *Config) bool { b := v.Block _ = b // match: (MOVWstoreconst [sc] {s} (ADDQconst [off] ptr) mem) - // cond: StoreConst(sc).canAdd(off) - // result: (MOVWstoreconst [StoreConst(sc).add(off)] {s} ptr mem) + // cond: ValAndOff(sc).canAdd(off) + // result: (MOVWstoreconst [ValAndOff(sc).add(off)] {s} ptr mem) { sc := v.AuxInt s := v.Aux if v.Args[0].Op != OpAMD64ADDQconst { - goto end2b764f9cf1bb32af25ba4e70a6705b91 + goto end8825edac065f0e1c615ca5e6ba40e2de } off := v.Args[0].AuxInt ptr := v.Args[0].Args[0] mem := v.Args[1] - if !(StoreConst(sc).canAdd(off)) { - goto end2b764f9cf1bb32af25ba4e70a6705b91 + if !(ValAndOff(sc).canAdd(off)) { + goto end8825edac065f0e1c615ca5e6ba40e2de } v.Op = OpAMD64MOVWstoreconst v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = StoreConst(sc).add(off) + v.AuxInt = ValAndOff(sc).add(off) v.Aux = s v.AddArg(ptr) v.AddArg(mem) return true } - goto end2b764f9cf1bb32af25ba4e70a6705b91 -end2b764f9cf1bb32af25ba4e70a6705b91: + goto end8825edac065f0e1c615ca5e6ba40e2de +end8825edac065f0e1c615ca5e6ba40e2de: ; // match: (MOVWstoreconst [sc] {sym1} (LEAQ [off] {sym2} ptr) mem) - // cond: canMergeSym(sym1, sym2) && StoreConst(sc).canAdd(off) - // result: (MOVWstoreconst [StoreConst(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem) + // cond: canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off) + // result: (MOVWstoreconst [ValAndOff(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem) { sc := v.AuxInt sym1 := v.Aux if v.Args[0].Op != OpAMD64LEAQ { - goto enda15bfd8d540015b2245c65be486d2ffd + goto endba47397e07b40a64fa4cad36ac2e32ad } off := v.Args[0].AuxInt sym2 := v.Args[0].Aux ptr := v.Args[0].Args[0] mem := v.Args[1] - if !(canMergeSym(sym1, sym2) && StoreConst(sc).canAdd(off)) { - goto enda15bfd8d540015b2245c65be486d2ffd + if !(canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off)) { + goto endba47397e07b40a64fa4cad36ac2e32ad } v.Op = OpAMD64MOVWstoreconst v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = StoreConst(sc).add(off) + v.AuxInt = ValAndOff(sc).add(off) v.Aux = mergeSym(sym1, sym2) v.AddArg(ptr) v.AddArg(mem) return true } - goto enda15bfd8d540015b2245c65be486d2ffd -enda15bfd8d540015b2245c65be486d2ffd: + goto endba47397e07b40a64fa4cad36ac2e32ad +endba47397e07b40a64fa4cad36ac2e32ad: ; return false } @@ -14596,10 +14596,10 @@ end07aaaebfa15a48c52cd79b68e28d266f: ; // match: (Zero [3] destptr mem) // cond: - // result: (MOVBstoreconst [makeStoreConst(0,2)] destptr (MOVWstoreconst [0] destptr mem)) + // result: (MOVBstoreconst [makeValAndOff(0,2)] destptr (MOVWstoreconst [0] destptr mem)) { if v.AuxInt != 3 { - goto end03b2ae08f901891919e454f05273fb4e + goto end3bf4a24a87e0727b9bcfbb5fcd24aabe } destptr := v.Args[0] mem := v.Args[1] @@ -14607,7 +14607,7 @@ end07aaaebfa15a48c52cd79b68e28d266f: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = makeStoreConst(0, 2) + v.AuxInt = makeValAndOff(0, 2) v.AddArg(destptr) v0 := b.NewValue0(v.Line, OpAMD64MOVWstoreconst, TypeInvalid) v0.AuxInt = 0 @@ -14617,15 +14617,15 @@ end07aaaebfa15a48c52cd79b68e28d266f: v.AddArg(v0) return true } - goto end03b2ae08f901891919e454f05273fb4e -end03b2ae08f901891919e454f05273fb4e: + goto end3bf4a24a87e0727b9bcfbb5fcd24aabe +end3bf4a24a87e0727b9bcfbb5fcd24aabe: ; // match: (Zero [5] destptr mem) // cond: - // result: (MOVBstoreconst [makeStoreConst(0,4)] destptr (MOVLstoreconst [0] destptr mem)) + // result: (MOVBstoreconst [makeValAndOff(0,4)] destptr (MOVLstoreconst [0] destptr mem)) { if v.AuxInt != 5 { - goto endc473059deb6291d483262b08312eab48 + goto end567e4a90c6867faf1dfc2cd57daf2ce4 } destptr := v.Args[0] mem := v.Args[1] @@ -14633,7 +14633,7 @@ end03b2ae08f901891919e454f05273fb4e: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = makeStoreConst(0, 4) + v.AuxInt = makeValAndOff(0, 4) v.AddArg(destptr) v0 := b.NewValue0(v.Line, OpAMD64MOVLstoreconst, TypeInvalid) v0.AuxInt = 0 @@ -14643,15 +14643,15 @@ end03b2ae08f901891919e454f05273fb4e: v.AddArg(v0) return true } - goto endc473059deb6291d483262b08312eab48 -endc473059deb6291d483262b08312eab48: + goto end567e4a90c6867faf1dfc2cd57daf2ce4 +end567e4a90c6867faf1dfc2cd57daf2ce4: ; // match: (Zero [6] destptr mem) // cond: - // result: (MOVWstoreconst [makeStoreConst(0,4)] destptr (MOVLstoreconst [0] destptr mem)) + // result: (MOVWstoreconst [makeValAndOff(0,4)] destptr (MOVLstoreconst [0] destptr mem)) { if v.AuxInt != 6 { - goto end41b38839f25e3749384d53b5945bd56b + goto end7cddcaf215fcc2cbca9aa958147b2380 } destptr := v.Args[0] mem := v.Args[1] @@ -14659,7 +14659,7 @@ endc473059deb6291d483262b08312eab48: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = makeStoreConst(0, 4) + v.AuxInt = makeValAndOff(0, 4) v.AddArg(destptr) v0 := b.NewValue0(v.Line, OpAMD64MOVLstoreconst, TypeInvalid) v0.AuxInt = 0 @@ -14669,15 +14669,15 @@ endc473059deb6291d483262b08312eab48: v.AddArg(v0) return true } - goto end41b38839f25e3749384d53b5945bd56b -end41b38839f25e3749384d53b5945bd56b: + goto end7cddcaf215fcc2cbca9aa958147b2380 +end7cddcaf215fcc2cbca9aa958147b2380: ; // match: (Zero [7] destptr mem) // cond: - // result: (MOVLstoreconst [makeStoreConst(0,3)] destptr (MOVLstoreconst [0] destptr mem)) + // result: (MOVLstoreconst [makeValAndOff(0,3)] destptr (MOVLstoreconst [0] destptr mem)) { if v.AuxInt != 7 { - goto end06e677d4c1ac43e08783eb8117a589b6 + goto end1b58cabccbc912ea4e1cf99be8a9fbf7 } destptr := v.Args[0] mem := v.Args[1] @@ -14685,7 +14685,7 @@ end41b38839f25e3749384d53b5945bd56b: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = makeStoreConst(0, 3) + v.AuxInt = makeValAndOff(0, 3) v.AddArg(destptr) v0 := b.NewValue0(v.Line, OpAMD64MOVLstoreconst, TypeInvalid) v0.AuxInt = 0 @@ -14695,8 +14695,8 @@ end41b38839f25e3749384d53b5945bd56b: v.AddArg(v0) return true } - goto end06e677d4c1ac43e08783eb8117a589b6 -end06e677d4c1ac43e08783eb8117a589b6: + goto end1b58cabccbc912ea4e1cf99be8a9fbf7 +end1b58cabccbc912ea4e1cf99be8a9fbf7: ; // match: (Zero [size] destptr mem) // cond: size%8 != 0 && size > 8 @@ -14731,10 +14731,10 @@ endc8760f86b83b1372fce0042ab5200fc1: ; // match: (Zero [16] destptr mem) // cond: - // result: (MOVQstoreconst [makeStoreConst(0,8)] destptr (MOVQstoreconst [0] destptr mem)) + // result: (MOVQstoreconst [makeValAndOff(0,8)] destptr (MOVQstoreconst [0] destptr mem)) { if v.AuxInt != 16 { - goto endce0bdb028011236be9f04fb53462204d + goto endf1447d60cbf8025adaf1a02a2cd219c4 } destptr := v.Args[0] mem := v.Args[1] @@ -14742,7 +14742,7 @@ endc8760f86b83b1372fce0042ab5200fc1: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = makeStoreConst(0, 8) + v.AuxInt = makeValAndOff(0, 8) v.AddArg(destptr) v0 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeInvalid) v0.AuxInt = 0 @@ -14752,15 +14752,15 @@ endc8760f86b83b1372fce0042ab5200fc1: v.AddArg(v0) return true } - goto endce0bdb028011236be9f04fb53462204d -endce0bdb028011236be9f04fb53462204d: + goto endf1447d60cbf8025adaf1a02a2cd219c4 +endf1447d60cbf8025adaf1a02a2cd219c4: ; // match: (Zero [24] destptr mem) // cond: - // result: (MOVQstoreconst [makeStoreConst(0,16)] destptr (MOVQstoreconst [makeStoreConst(0,8)] destptr (MOVQstoreconst [0] destptr mem))) + // result: (MOVQstoreconst [makeValAndOff(0,16)] destptr (MOVQstoreconst [makeValAndOff(0,8)] destptr (MOVQstoreconst [0] destptr mem))) { if v.AuxInt != 24 { - goto end859fe3911b36516ea096299b2a85350e + goto end57f2984a61c64f71a528e7fa75576095 } destptr := v.Args[0] mem := v.Args[1] @@ -14768,10 +14768,10 @@ endce0bdb028011236be9f04fb53462204d: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = makeStoreConst(0, 16) + v.AuxInt = makeValAndOff(0, 16) v.AddArg(destptr) v0 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeInvalid) - v0.AuxInt = makeStoreConst(0, 8) + v0.AuxInt = makeValAndOff(0, 8) v0.AddArg(destptr) v1 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeInvalid) v1.AuxInt = 0 @@ -14783,15 +14783,15 @@ endce0bdb028011236be9f04fb53462204d: v.AddArg(v0) return true } - goto end859fe3911b36516ea096299b2a85350e -end859fe3911b36516ea096299b2a85350e: + goto end57f2984a61c64f71a528e7fa75576095 +end57f2984a61c64f71a528e7fa75576095: ; // match: (Zero [32] destptr mem) // cond: - // result: (MOVQstoreconst [makeStoreConst(0,24)] destptr (MOVQstoreconst [makeStoreConst(0,16)] destptr (MOVQstoreconst [makeStoreConst(0,8)] destptr (MOVQstoreconst [0] destptr mem)))) + // result: (MOVQstoreconst [makeValAndOff(0,24)] destptr (MOVQstoreconst [makeValAndOff(0,16)] destptr (MOVQstoreconst [makeValAndOff(0,8)] destptr (MOVQstoreconst [0] destptr mem)))) { if v.AuxInt != 32 { - goto end2c246614f6a9a07f1a683691b3f5780f + goto end418a59f9f84dd389d37ae5c24aba2760 } destptr := v.Args[0] mem := v.Args[1] @@ -14799,13 +14799,13 @@ end859fe3911b36516ea096299b2a85350e: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = makeStoreConst(0, 24) + v.AuxInt = makeValAndOff(0, 24) v.AddArg(destptr) v0 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeInvalid) - v0.AuxInt = makeStoreConst(0, 16) + v0.AuxInt = makeValAndOff(0, 16) v0.AddArg(destptr) v1 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeInvalid) - v1.AuxInt = makeStoreConst(0, 8) + v1.AuxInt = makeValAndOff(0, 8) v1.AddArg(destptr) v2 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeInvalid) v2.AuxInt = 0 @@ -14819,8 +14819,8 @@ end859fe3911b36516ea096299b2a85350e: v.AddArg(v0) return true } - goto end2c246614f6a9a07f1a683691b3f5780f -end2c246614f6a9a07f1a683691b3f5780f: + goto end418a59f9f84dd389d37ae5c24aba2760 +end418a59f9f84dd389d37ae5c24aba2760: ; // match: (Zero [size] destptr mem) // cond: size <= 1024 && size%8 == 0 && size%16 != 0 diff --git a/src/cmd/compile/internal/ssa/value.go b/src/cmd/compile/internal/ssa/value.go index 420c408e88..7e6e544e26 100644 --- a/src/cmd/compile/internal/ssa/value.go +++ b/src/cmd/compile/internal/ssa/value.go @@ -61,16 +61,22 @@ func (v *Value) String() string { func (v *Value) LongString() string { s := fmt.Sprintf("v%d = %s", v.ID, v.Op.String()) s += " <" + v.Type.String() + ">" - if v.AuxInt != 0 { - s += fmt.Sprintf(" [%d]", v.AuxInt) - - switch { - case v.Op == OpConst32F || v.Op == OpConst64F: - s += fmt.Sprintf("(%g)", math.Float64frombits(uint64(v.AuxInt))) - case v.Op == OpConstBool && v.AuxInt == 0: - s += " (false)" - case v.Op == OpConstBool && v.AuxInt == 1: - s += " (true)" + // TODO: use some operator property flags to decide + // what is encoded in the AuxInt field. + switch v.Op { + case OpConst32F, OpConst64F: + s += fmt.Sprintf(" [%g]", math.Float64frombits(uint64(v.AuxInt))) + case OpConstBool: + if v.AuxInt == 0 { + s += " [false]" + } else { + s += " [true]" + } + case OpAMD64MOVBstoreconst, OpAMD64MOVWstoreconst, OpAMD64MOVLstoreconst, OpAMD64MOVQstoreconst: + s += fmt.Sprintf(" [%s]", ValAndOff(v.AuxInt)) + default: + if v.AuxInt != 0 { + s += fmt.Sprintf(" [%d]", v.AuxInt) } } if v.Aux != nil { @@ -132,6 +138,11 @@ func (v *Value) copyInto(b *Block) *Value { 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 } -- cgit v1.3 From f3575a9561319d2398ab01dd0375e0909e2f2aa8 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Tue, 26 Jan 2016 15:55:05 -0800 Subject: [dev.ssa] cmd/compile: tweak init function prologue We used to compare the init state with == to 0 and 2, which requires 2 comparisons. Instead, compare with 1 and use <, ==. That requires only one comparison. This isn't a big deal performance-wise, as it is just init code. But there is a fair amount of init code, so this should help a bit with code size. Change-Id: I4a2765f1005776f0edce28ac143f4b7596d95a68 Reviewed-on: https://go-review.googlesource.com/18948 Reviewed-by: David Chase --- src/cmd/compile/internal/gc/init.go | 31 +++++++++++++++---------------- 1 file changed, 15 insertions(+), 16 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/init.go b/src/cmd/compile/internal/gc/init.go index 6071ab44f0..f4a4700049 100644 --- a/src/cmd/compile/internal/gc/init.go +++ b/src/cmd/compile/internal/gc/init.go @@ -33,10 +33,10 @@ func renameinit() *Sym { // 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 @@ func fninit(n *NodeList) { // (3) a := Nod(OIF, nil, nil) - - a.Left = Nod(ONE, gatevar, Nodintconst(0)) + a.Left = Nod(OGT, gatevar, Nodintconst(1)) + a.Likely = 1 r = list(r, a) + // (3a) + a.Nbody = list1(Nod(ORETURN, nil, nil)) // (4) b := Nod(OIF, nil, nil) - - b.Left = Nod(OEQ, gatevar, Nodintconst(2)) - b.Nbody = list1(Nod(ORETURN, nil, nil)) - a.Nbody = list1(b) - - // (5) - b = syslook("throwinit", 0) - - b = Nod(OCALL, b, nil) - a.Nbody = list(a.Nbody, 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 = list(r, b) + // (4a) + b.Nbody = list1(Nod(OCALL, syslook("throwinit", 0), nil)) // (6) a = Nod(OAS, gatevar, Nodintconst(1)) -- cgit v1.3 From 88b230eaa69647405e7c278044550640fc098111 Mon Sep 17 00:00:00 2001 From: David Chase Date: Fri, 29 Jan 2016 14:44:15 -0500 Subject: [dev.ssa] cmd/compile: exposed do-log boolean to reduce allocations From memory profiling, about 3% reduction in allocation count. Change-Id: I4b662d55b8a94fe724759a2b22f05a08d0bf40f8 Reviewed-on: https://go-review.googlesource.com/19103 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 5 +++++ src/cmd/compile/internal/ssa/block.go | 1 + src/cmd/compile/internal/ssa/compile.go | 16 ++++++++++++---- src/cmd/compile/internal/ssa/config.go | 7 ++++++- src/cmd/compile/internal/ssa/export_test.go | 1 + src/cmd/compile/internal/ssa/func.go | 1 + src/cmd/compile/internal/ssa/value.go | 1 + 7 files changed, 27 insertions(+), 5 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 89286f4356..c5be3496c3 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -327,6 +327,7 @@ func (s *state) label(sym *Sym) *ssaLabel { } 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...) @@ -4885,6 +4886,10 @@ func (e *ssaExport) Logf(msg string, args ...interface{}) { } } +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. diff --git a/src/cmd/compile/internal/ssa/block.go b/src/cmd/compile/internal/ssa/block.go index 6585528b28..7641811a5f 100644 --- a/src/cmd/compile/internal/ssa/block.go +++ b/src/cmd/compile/internal/ssa/block.go @@ -105,6 +105,7 @@ func (b *Block) AddEdgeTo(c *Block) { } 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...) } diff --git a/src/cmd/compile/internal/ssa/compile.go b/src/cmd/compile/internal/ssa/compile.go index 75c73eb24f..99e3c2b01e 100644 --- a/src/cmd/compile/internal/ssa/compile.go +++ b/src/cmd/compile/internal/ssa/compile.go @@ -20,7 +20,9 @@ import ( func Compile(f *Func) { // TODO: debugging - set flags to control verbosity of compiler, // which phases to dump IR before/after, etc. - f.Logf("compiling %s\n", f.Name) + if f.Log() { + f.Logf("compiling %s\n", f.Name) + } // hook to print function & phase if panic happens phaseName := "init" @@ -44,7 +46,9 @@ func Compile(f *Func) { continue } phaseName = p.name - f.Logf(" pass %s begin\n", 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 { @@ -67,9 +71,13 @@ func Compile(f *Func) { stats = fmt.Sprintf("[%d ns]", time) } - f.Logf(" pass %s end %s\n", p.name, stats) + if f.Log() { + f.Logf(" pass %s end %s\n", p.name, stats) + } printFunc(f) - f.Config.HTML.WriteFunc(fmt.Sprintf("after %s %s", phaseName, stats), f) + if f.Config.HTML != nil { + f.Config.HTML.WriteFunc(fmt.Sprintf("after %s %s", phaseName, stats), f) + } checkFunc(f) } diff --git a/src/cmd/compile/internal/ssa/config.go b/src/cmd/compile/internal/ssa/config.go index 52e772ce81..060eec2335 100644 --- a/src/cmd/compile/internal/ssa/config.go +++ b/src/cmd/compile/internal/ssa/config.go @@ -46,9 +46,13 @@ type TypeSource interface { } type Logger interface { - // Log logs a message from the compiler. + // 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{}) @@ -131,6 +135,7 @@ func (c *Config) NewFunc() *Func { } 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...) diff --git a/src/cmd/compile/internal/ssa/export_test.go b/src/cmd/compile/internal/ssa/export_test.go index 962dc52a5f..dae9ed7de0 100644 --- a/src/cmd/compile/internal/ssa/export_test.go +++ b/src/cmd/compile/internal/ssa/export_test.go @@ -36,6 +36,7 @@ func (DummyFrontend) Line(line int32) string { } 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{}) { diff --git a/src/cmd/compile/internal/ssa/func.go b/src/cmd/compile/internal/ssa/func.go index 6d20a2797d..a28484010d 100644 --- a/src/cmd/compile/internal/ssa/func.go +++ b/src/cmd/compile/internal/ssa/func.go @@ -264,6 +264,7 @@ func (f *Func) ConstFloat64(line int32, t Type, c float64) *Value { } 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...) diff --git a/src/cmd/compile/internal/ssa/value.go b/src/cmd/compile/internal/ssa/value.go index 7e6e544e26..e338c4435b 100644 --- a/src/cmd/compile/internal/ssa/value.go +++ b/src/cmd/compile/internal/ssa/value.go @@ -147,6 +147,7 @@ func (v *Value) copyInto(b *Block) *Value { } 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...) } -- cgit v1.3 From f962f33035bccd67c08fa3e0002659d6b9978bbc Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Thu, 28 Jan 2016 22:19:46 -0600 Subject: [dev.ssa] cmd/compile: reuse sparse sets across compiler passes Cache sparse sets in the function so they can be reused by subsequent compiler passes. benchmark old ns/op new ns/op delta BenchmarkDSEPass-8 206945 180022 -13.01% BenchmarkDSEPassBlock-8 5286103 2614054 -50.55% BenchmarkCSEPass-8 1790277 1790655 +0.02% BenchmarkCSEPassBlock-8 18083588 18112771 +0.16% BenchmarkDeadcodePass-8 59837 41375 -30.85% BenchmarkDeadcodePassBlock-8 1651575 511169 -69.05% BenchmarkMultiPass-8 531529 427506 -19.57% BenchmarkMultiPassBlock-8 7033496 4487814 -36.19% benchmark old allocs new allocs delta BenchmarkDSEPass-8 11 4 -63.64% BenchmarkDSEPassBlock-8 599 120 -79.97% BenchmarkCSEPass-8 18 18 +0.00% BenchmarkCSEPassBlock-8 2700 2700 +0.00% BenchmarkDeadcodePass-8 4 3 -25.00% BenchmarkDeadcodePassBlock-8 30 9 -70.00% BenchmarkMultiPass-8 24 20 -16.67% BenchmarkMultiPassBlock-8 1800 1000 -44.44% benchmark old bytes new bytes delta BenchmarkDSEPass-8 221367 142 -99.94% BenchmarkDSEPassBlock-8 3695207 3846 -99.90% BenchmarkCSEPass-8 303328 303328 +0.00% BenchmarkCSEPassBlock-8 5006400 5006400 +0.00% BenchmarkDeadcodePass-8 84232 10506 -87.53% BenchmarkDeadcodePassBlock-8 1274940 163680 -87.16% BenchmarkMultiPass-8 608674 313834 -48.44% BenchmarkMultiPassBlock-8 9906001 5003450 -49.49% Change-Id: Ib1fa58c7f494b374d1a4bb9cffbc2c48377b59d3 Reviewed-on: https://go-review.googlesource.com/19100 Reviewed-by: David Chase Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/deadcode.go | 3 +- src/cmd/compile/internal/ssa/deadstore.go | 9 ++- src/cmd/compile/internal/ssa/func.go | 25 +++++++ src/cmd/compile/internal/ssa/layout.go | 6 +- src/cmd/compile/internal/ssa/passbm_test.go | 101 ++++++++++++++++++++++++++++ src/cmd/compile/internal/ssa/regalloc.go | 3 +- src/cmd/compile/internal/ssa/sparseset.go | 4 ++ src/cmd/compile/internal/ssa/stackalloc.go | 9 ++- 8 files changed, 150 insertions(+), 10 deletions(-) create mode 100644 src/cmd/compile/internal/ssa/passbm_test.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/deadcode.go b/src/cmd/compile/internal/ssa/deadcode.go index 80e1490014..87244a6248 100644 --- a/src/cmd/compile/internal/ssa/deadcode.go +++ b/src/cmd/compile/internal/ssa/deadcode.go @@ -134,7 +134,8 @@ func deadcode(f *Func) { live := liveValues(f, reachable) // Remove dead & duplicate entries from namedValues map. - s := newSparseSet(f.NumValues()) + s := f.newSparseSet(f.NumValues()) + defer f.retSparseSet(s) i := 0 for _, name := range f.Names { j := 0 diff --git a/src/cmd/compile/internal/ssa/deadstore.go b/src/cmd/compile/internal/ssa/deadstore.go index 89f7504341..bad0e0096f 100644 --- a/src/cmd/compile/internal/ssa/deadstore.go +++ b/src/cmd/compile/internal/ssa/deadstore.go @@ -10,9 +10,12 @@ package ssa // This implementation only works within a basic block. TODO: use something more global. func dse(f *Func) { var stores []*Value - loadUse := newSparseSet(f.NumValues()) - storeUse := newSparseSet(f.NumValues()) - shadowed := newSparseSet(f.NumValues()) + 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. diff --git a/src/cmd/compile/internal/ssa/func.go b/src/cmd/compile/internal/ssa/func.go index a28484010d..9da390904d 100644 --- a/src/cmd/compile/internal/ssa/func.go +++ b/src/cmd/compile/internal/ssa/func.go @@ -31,6 +31,8 @@ type Func struct { 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. + + scrSparse []*sparseSet // sparse sets to be re-used. } // NumBlocks returns an integer larger than the id of any Block in the Func. @@ -43,6 +45,29 @@ 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.scrSparse { + if scr != nil && scr.cap() >= n { + f.scrSparse[i] = nil + scr.clear() + return scr + } + } + return newSparseSet(n) +} + +// retSparseSet returns a sparse set to the function's cache to be reused by f.newSparseSet. +func (f *Func) retSparseSet(ss *sparseSet) { + for i, scr := range f.scrSparse { + if scr == nil { + f.scrSparse[i] = ss + return + } + } + f.scrSparse = append(f.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 diff --git a/src/cmd/compile/internal/ssa/layout.go b/src/cmd/compile/internal/ssa/layout.go index 7e865f948e..8dd4b65979 100644 --- a/src/cmd/compile/internal/ssa/layout.go +++ b/src/cmd/compile/internal/ssa/layout.go @@ -12,8 +12,10 @@ func layout(f *Func) { scheduled := make([]bool, f.NumBlocks()) idToBlock := make([]*Block, f.NumBlocks()) indegree := make([]int, f.NumBlocks()) - posdegree := newSparseSet(f.NumBlocks()) // blocks with positive remaining degree - zerodegree := newSparseSet(f.NumBlocks()) // blocks with zero remaining degree + 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 { 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 0000000000..9b11ff1256 --- /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), OpArg, TypeMem, 0, ".mem"), + 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/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index 61f694355e..2d88850999 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -559,7 +559,8 @@ func (s *regAllocState) compatRegs(t Type) regMask { } func (s *regAllocState) regalloc(f *Func) { - liveSet := newSparseSet(f.NumValues()) + liveSet := f.newSparseSet(f.NumValues()) + defer f.retSparseSet(liveSet) var oldSched []*Value var phis []*Value var phiRegs []register diff --git a/src/cmd/compile/internal/ssa/sparseset.go b/src/cmd/compile/internal/ssa/sparseset.go index b79aee8497..66bebf139e 100644 --- a/src/cmd/compile/internal/ssa/sparseset.go +++ b/src/cmd/compile/internal/ssa/sparseset.go @@ -18,6 +18,10 @@ 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) } diff --git a/src/cmd/compile/internal/ssa/stackalloc.go b/src/cmd/compile/internal/ssa/stackalloc.go index 797a6b05e6..0e6cae0924 100644 --- a/src/cmd/compile/internal/ssa/stackalloc.go +++ b/src/cmd/compile/internal/ssa/stackalloc.go @@ -182,8 +182,10 @@ func (s *stackAllocState) stackalloc() { func (s *stackAllocState) computeLive(spillLive [][]ID) { s.live = make([][]ID, s.f.NumBlocks()) var phis []*Value - live := newSparseSet(s.f.NumValues()) - t := newSparseSet(s.f.NumValues()) + 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 @@ -271,7 +273,8 @@ func (f *Func) setHome(v *Value, loc Location) { func (s *stackAllocState) buildInterferenceGraph() { f := s.f s.interfere = make([][]ID, f.NumValues()) - live := newSparseSet(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. -- cgit v1.3 From 1cc5789df9eb8c88e0d7248a9a16b3d4ca854962 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Sat, 30 Jan 2016 11:25:38 -0800 Subject: [dev.ssa] cmd/compile: lots of small rewrite optimizations Small optimizations I noticed while looking at Giovanni's test cases. More shifts by constants. Indexed stores for smaller types. Fold LEA into loads/stores. More extending loads. CMP $0 of AND -> TEST Fix order of TEST ops. Giovanni's test cases at https://gist.github.com/rasky/62fba94e3a20d1b05b2a Change-Id: I7077bc0b5319bf05767eeb39f401f4bb4b39f635 Reviewed-on: https://go-review.googlesource.com/19086 Run-TryBot: Keith Randall Reviewed-by: Todd Neal Reviewed-by: David Chase --- src/cmd/compile/internal/gc/ssa.go | 35 +- src/cmd/compile/internal/ssa/TODO | 2 + src/cmd/compile/internal/ssa/gen/AMD64.rules | 120 +- src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 10 +- src/cmd/compile/internal/ssa/opGen.go | 88 ++ src/cmd/compile/internal/ssa/rewriteAMD64.go | 1953 ++++++++++++++++++++++++-- 6 files changed, 2082 insertions(+), 126 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index c5be3496c3..458bccb8dc 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -4003,13 +4003,18 @@ func (s *genState) genValue(v *ssa.Value) { // 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, - ssa.OpAMD64TESTQconst, ssa.OpAMD64TESTLconst, ssa.OpAMD64TESTWconst, ssa.OpAMD64TESTBconst: + 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.AuxInt + case ssa.OpAMD64TESTQconst, ssa.OpAMD64TESTLconst, ssa.OpAMD64TESTWconst, ssa.OpAMD64TESTBconst: + p := Prog(v.Op.Asm()) + p.From.Type = obj.TYPE_CONST + p.From.Offset = v.AuxInt + 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()) @@ -4040,7 +4045,7 @@ func (s *genState) genValue(v *ssa.Value) { 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.OpAMD64MOVOload: + 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]) @@ -4081,7 +4086,7 @@ func (s *genState) genValue(v *ssa.Value) { p.To.Scale = 8 p.To.Index = regnum(v.Args[1]) addAux(&p.To, v) - case ssa.OpAMD64MOVSSstoreidx4: + case ssa.OpAMD64MOVSSstoreidx4, ssa.OpAMD64MOVLstoreidx4: p := Prog(v.Op.Asm()) p.From.Type = obj.TYPE_REG p.From.Reg = regnum(v.Args[2]) @@ -4090,6 +4095,24 @@ func (s *genState) genValue(v *ssa.Value) { 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 @@ -4365,7 +4388,9 @@ func (s *genState) genValue(v *ssa.Value) { } switch w.Op { case ssa.OpAMD64MOVQload, ssa.OpAMD64MOVLload, ssa.OpAMD64MOVWload, ssa.OpAMD64MOVBload, - ssa.OpAMD64MOVQstore, ssa.OpAMD64MOVLstore, ssa.OpAMD64MOVWstore, ssa.OpAMD64MOVBstore: + ssa.OpAMD64MOVQstore, ssa.OpAMD64MOVLstore, ssa.OpAMD64MOVWstore, ssa.OpAMD64MOVBstore, + ssa.OpAMD64MOVBQSXload, ssa.OpAMD64MOVBQZXload, ssa.OpAMD64MOVWQSXload, + ssa.OpAMD64MOVWQZXload, ssa.OpAMD64MOVLQSXload, ssa.OpAMD64MOVLQZXload: 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") diff --git a/src/cmd/compile/internal/ssa/TODO b/src/cmd/compile/internal/ssa/TODO index 5245753c07..3191670a0e 100644 --- a/src/cmd/compile/internal/ssa/TODO +++ b/src/cmd/compile/internal/ssa/TODO @@ -51,6 +51,8 @@ Optimizations (better compiled code) Note that this is challenging for ops that generate flags because flagalloc wants to move those instructions around for flag regeneration. +- In forms like if ... { call } else { no call }, mark the call branch as unlikely. +- Non-constant rotate detection. Optimizations (better compiler) ------------------------------- diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index a6ad6c1ca0..ee21e5643b 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -464,18 +464,63 @@ (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) @@ -524,7 +569,18 @@ // multiple memory values alive simultaneously. (MOVBQSX (MOVBload [off] {sym} ptr mem)) -> @v.Args[0].Block (MOVBQSXload [off] {sym} ptr mem) (MOVBQZX (MOVBload [off] {sym} ptr mem)) -> @v.Args[0].Block (MOVBQZXload [off] {sym} ptr mem) -// TODO: more +(MOVWQSX (MOVWload [off] {sym} ptr mem)) -> @v.Args[0].Block (MOVWQSXload [off] {sym} ptr mem) +(MOVWQZX (MOVWload [off] {sym} ptr mem)) -> @v.Args[0].Block (MOVWQZXload [off] {sym} ptr mem) +(MOVLQSX (MOVLload [off] {sym} ptr mem)) -> @v.Args[0].Block (MOVLQSXload [off] {sym} ptr mem) +(MOVLQZX (MOVLload [off] {sym} ptr mem)) -> @v.Args[0].Block (MOVLQZXload [off] {sym} ptr mem) + +// 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) @@ -623,22 +679,63 @@ (MOVSSstoreidx4 [off1] {sym} (ADDQconst [off2] {sym} ptr) idx val mem) -> (MOVSSstoreidx4 [addOff(off1, off2)] {sym} ptr idx val mem) (MOVSDloadidx8 [off1] {sym} (ADDQconst [off2] {sym} ptr) idx mem) -> (MOVSDloadidx8 [addOff(off1, off2)] {sym} ptr idx mem) (MOVSDstoreidx8 [off1] {sym} (ADDQconst [off2] {sym} ptr) idx val mem) -> (MOVSDstoreidx8 [addOff(off1, off2)] {sym} ptr idx val mem) +(MOVLstoreidx4 [off1] {sym} (ADDQconst [off2] ptr) idx val mem) -> (MOVLstoreidx4 [addOff(off1, off2)] {sym} ptr idx val mem) +(MOVWstoreidx2 [off1] {sym} (ADDQconst [off2] ptr) idx val mem) -> (MOVWstoreidx2 [addOff(off1, off2)] {sym} ptr idx val mem) +(MOVBstoreidx1 [off1] {sym} (ADDQconst [off2] ptr) idx val mem) -> (MOVBstoreidx1 [addOff(off1, off2)] {sym} ptr idx val mem) (MOVQload [off1] {sym1} (LEAQ8 [off2] {sym2} ptr idx) mem) && canMergeSym(sym1, sym2) -> (MOVQloadidx8 [addOff(off1, off2)] {mergeSym(sym1,sym2)} ptr idx 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) - (MOVSSload [off1] {sym1} (LEAQ4 [off2] {sym2} ptr idx) mem) && canMergeSym(sym1, sym2) -> (MOVSSloadidx4 [addOff(off1, off2)] {mergeSym(sym1,sym2)} ptr idx 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) - (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) +(MOVBstore [off] {sym} (ADDQ ptr idx) val mem) -> (MOVBstoreidx1 [off] {sym} ptr idx val 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) @@ -963,3 +1060,12 @@ (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 index 9cf4a2e70b..10c5d2b227 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -368,14 +368,22 @@ func init() { {name: "MOVBQSXload", reg: gpload, asm: "MOVBQSX"}, // ditto, extend to int64 {name: "MOVBQZXload", reg: gpload, asm: "MOVBQZX"}, // ditto, extend to uint64 {name: "MOVWload", reg: gpload, asm: "MOVW", typ: "UInt16"}, // load 2 bytes from arg0+auxint+aux. arg1=mem + {name: "MOVWQSXload", reg: gpload, asm: "MOVWQSX"}, // ditto, extend to int64 + {name: "MOVWQZXload", reg: gpload, asm: "MOVWQZX"}, // ditto, extend to uint64 {name: "MOVLload", reg: gpload, asm: "MOVL", typ: "UInt32"}, // load 4 bytes from arg0+auxint+aux. arg1=mem + {name: "MOVLQSXload", reg: gpload, asm: "MOVLQSX"}, // ditto, extend to int64 + {name: "MOVLQZXload", reg: gpload, asm: "MOVLQZX"}, // ditto, extend to uint64 {name: "MOVQload", reg: gpload, asm: "MOVQ", typ: "UInt64"}, // load 8 bytes from arg0+auxint+aux. arg1=mem {name: "MOVQloadidx8", reg: gploadidx, asm: "MOVQ"}, // load 8 bytes from arg0+8*arg1+auxint+aux. arg2=mem {name: "MOVBstore", reg: gpstore, asm: "MOVB", typ: "Mem"}, // store byte in arg1 to arg0+auxint+aux. arg2=mem {name: "MOVWstore", reg: gpstore, asm: "MOVW", typ: "Mem"}, // store 2 bytes in arg1 to arg0+auxint+aux. arg2=mem {name: "MOVLstore", reg: gpstore, asm: "MOVL", typ: "Mem"}, // store 4 bytes in arg1 to arg0+auxint+aux. arg2=mem {name: "MOVQstore", reg: gpstore, asm: "MOVQ", typ: "Mem"}, // store 8 bytes in arg1 to arg0+auxint+aux. arg2=mem - {name: "MOVQstoreidx8", reg: gpstoreidx, asm: "MOVQ"}, // store 8 bytes in arg2 to arg0+8*arg1+auxint+aux. arg3=mem + + {name: "MOVBstoreidx1", reg: gpstoreidx, asm: "MOVB"}, // store byte in arg2 to arg0+arg1+auxint+aux. arg3=mem + {name: "MOVWstoreidx2", reg: gpstoreidx, asm: "MOVW"}, // store 2 bytes in arg2 to arg0+2*arg1+auxint+aux. arg3=mem + {name: "MOVLstoreidx4", reg: gpstoreidx, asm: "MOVL"}, // store 4 bytes in arg2 to arg0+4*arg1+auxint+aux. arg3=mem + {name: "MOVQstoreidx8", reg: gpstoreidx, asm: "MOVQ"}, // store 8 bytes in arg2 to arg0+8*arg1+auxint+aux. arg3=mem {name: "MOVOload", reg: fpload, asm: "MOVUPS", typ: "Int128"}, // load 16 bytes from arg0+auxint+aux. arg1=mem {name: "MOVOstore", reg: fpstore, asm: "MOVUPS", typ: "Mem"}, // store 16 bytes in arg1 to arg0+auxint+aux. arg2=mem diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index d391b2435e..8c6c731969 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -254,13 +254,20 @@ const ( OpAMD64MOVBQSXload OpAMD64MOVBQZXload OpAMD64MOVWload + OpAMD64MOVWQSXload + OpAMD64MOVWQZXload OpAMD64MOVLload + OpAMD64MOVLQSXload + OpAMD64MOVLQZXload OpAMD64MOVQload OpAMD64MOVQloadidx8 OpAMD64MOVBstore OpAMD64MOVWstore OpAMD64MOVLstore OpAMD64MOVQstore + OpAMD64MOVBstoreidx1 + OpAMD64MOVWstoreidx2 + OpAMD64MOVLstoreidx4 OpAMD64MOVQstoreidx8 OpAMD64MOVOload OpAMD64MOVOstore @@ -2966,6 +2973,30 @@ var opcodeTable = [...]opInfo{ }, }, }, + { + name: "MOVWQSXload", + 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", + 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", asm: x86.AMOVL, @@ -2978,6 +3009,30 @@ var opcodeTable = [...]opInfo{ }, }, }, + { + name: "MOVLQSXload", + 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", + 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", asm: x86.AMOVQ, @@ -3043,6 +3098,39 @@ var opcodeTable = [...]opInfo{ }, }, }, + { + name: "MOVBstoreidx1", + 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", + 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", + 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", asm: x86.AMOVQ, diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index ec3bbe53c2..5ff0b0fe5f 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -231,6 +231,16 @@ func rewriteValueAMD64(v *Value, config *Config) bool { 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: @@ -323,12 +333,20 @@ func rewriteValueAMD64(v *Value, config *Config) bool { return rewriteValueAMD64_OpAMD64MOVBstore(v, config) case OpAMD64MOVBstoreconst: return rewriteValueAMD64_OpAMD64MOVBstoreconst(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 OpAMD64MOVLstore: return rewriteValueAMD64_OpAMD64MOVLstore(v, config) case OpAMD64MOVLstoreconst: return rewriteValueAMD64_OpAMD64MOVLstoreconst(v, config) + case OpAMD64MOVLstoreidx4: + return rewriteValueAMD64_OpAMD64MOVLstoreidx4(v, config) case OpAMD64MOVOload: return rewriteValueAMD64_OpAMD64MOVOload(v, config) case OpAMD64MOVOstore: @@ -359,12 +377,18 @@ func rewriteValueAMD64(v *Value, config *Config) bool { 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 OpAMD64MOVWstore: return rewriteValueAMD64_OpAMD64MOVWstore(v, config) case OpAMD64MOVWstoreconst: return rewriteValueAMD64_OpAMD64MOVWstoreconst(v, config) + case OpAMD64MOVWstoreidx2: + return rewriteValueAMD64_OpAMD64MOVWstoreidx2(v, config) case OpAMD64MULB: return rewriteValueAMD64_OpAMD64MULB(v, config) case OpAMD64MULBconst: @@ -2303,6 +2327,52 @@ endac1c49c82fb6b76dd324042c4588973c: } goto end82aa9d89330cb5dc58592048bfc16ebc end82aa9d89330cb5dc58592048bfc16ebc: + ; + // match: (CMPBconst [0] (ANDB x y)) + // cond: + // result: (TESTB x y) + { + if v.AuxInt != 0 { + goto end30c06897ce79b745c782650c71157f7b + } + if v.Args[0].Op != OpAMD64ANDB { + goto end30c06897ce79b745c782650c71157f7b + } + x := v.Args[0].Args[0] + y := v.Args[0].Args[1] + v.Op = OpAMD64TESTB + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end30c06897ce79b745c782650c71157f7b +end30c06897ce79b745c782650c71157f7b: + ; + // match: (CMPBconst [0] (ANDBconst [c] x)) + // cond: + // result: (TESTBconst [c] x) + { + if v.AuxInt != 0 { + goto endfc700b49578635afa44d447c3ef97859 + } + if v.Args[0].Op != OpAMD64ANDBconst { + goto endfc700b49578635afa44d447c3ef97859 + } + c := v.Args[0].AuxInt + x := v.Args[0].Args[0] + v.Op = OpAMD64TESTBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto endfc700b49578635afa44d447c3ef97859 +endfc700b49578635afa44d447c3ef97859: ; return false } @@ -2482,6 +2552,52 @@ endc7b8e86e537d6e106e237023dc2c9a7b: } goto endf202b9830a1e45f3888f2598c762c702 endf202b9830a1e45f3888f2598c762c702: + ; + // match: (CMPLconst [0] (ANDL x y)) + // cond: + // result: (TESTL x y) + { + if v.AuxInt != 0 { + goto endb730012ce2555c10f2918eed023dd6f3 + } + if v.Args[0].Op != OpAMD64ANDL { + goto endb730012ce2555c10f2918eed023dd6f3 + } + x := v.Args[0].Args[0] + y := v.Args[0].Args[1] + v.Op = OpAMD64TESTL + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto endb730012ce2555c10f2918eed023dd6f3 +endb730012ce2555c10f2918eed023dd6f3: + ; + // match: (CMPLconst [0] (ANDLconst [c] x)) + // cond: + // result: (TESTLconst [c] x) + { + if v.AuxInt != 0 { + goto enda56a89f365433eb9e15b0c9696ce5afb + } + if v.Args[0].Op != OpAMD64ANDLconst { + goto enda56a89f365433eb9e15b0c9696ce5afb + } + c := v.Args[0].AuxInt + x := v.Args[0].Args[0] + v.Op = OpAMD64TESTLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto enda56a89f365433eb9e15b0c9696ce5afb +enda56a89f365433eb9e15b0c9696ce5afb: ; return false } @@ -2667,6 +2783,52 @@ end1248b87e4a141c78bc8eff05d3fac70e: } goto end934098fb12e383829b654938269abc12 end934098fb12e383829b654938269abc12: + ; + // match: (CMPQconst [0] (ANDQ x y)) + // cond: + // result: (TESTQ x y) + { + if v.AuxInt != 0 { + goto end9f63614ab4b6b51b299dcfacae096b23 + } + if v.Args[0].Op != OpAMD64ANDQ { + goto end9f63614ab4b6b51b299dcfacae096b23 + } + x := v.Args[0].Args[0] + y := v.Args[0].Args[1] + v.Op = OpAMD64TESTQ + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto end9f63614ab4b6b51b299dcfacae096b23 +end9f63614ab4b6b51b299dcfacae096b23: + ; + // match: (CMPQconst [0] (ANDQconst [c] x)) + // cond: + // result: (TESTQconst [c] x) + { + if v.AuxInt != 0 { + goto enda5aa8044be9d61e9e149558e9ec8ca83 + } + if v.Args[0].Op != OpAMD64ANDQconst { + goto enda5aa8044be9d61e9e149558e9ec8ca83 + } + c := v.Args[0].AuxInt + x := v.Args[0].Args[0] + v.Op = OpAMD64TESTQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto enda5aa8044be9d61e9e149558e9ec8ca83 +enda5aa8044be9d61e9e149558e9ec8ca83: ; return false } @@ -2846,6 +3008,52 @@ end4493f5af38d242ebb4bc2f64055a0854: } goto endfcea07d93ded49b0e02d5fa0059309a4 endfcea07d93ded49b0e02d5fa0059309a4: + ; + // match: (CMPWconst [0] (ANDW x y)) + // cond: + // result: (TESTW x y) + { + if v.AuxInt != 0 { + goto endd9d4754c561a7bd11697a51d800f8eca + } + if v.Args[0].Op != OpAMD64ANDW { + goto endd9d4754c561a7bd11697a51d800f8eca + } + x := v.Args[0].Args[0] + y := v.Args[0].Args[1] + v.Op = OpAMD64TESTW + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v.AddArg(y) + return true + } + goto endd9d4754c561a7bd11697a51d800f8eca +endd9d4754c561a7bd11697a51d800f8eca: + ; + // match: (CMPWconst [0] (ANDWconst [c] x)) + // cond: + // result: (TESTWconst [c] x) + { + if v.AuxInt != 0 { + goto endb532b10789c7ce4cedeb17af417ceb2b + } + if v.Args[0].Op != OpAMD64ANDWconst { + goto endb532b10789c7ce4cedeb17af417ceb2b + } + c := v.Args[0].AuxInt + x := v.Args[0].Args[0] + v.Op = OpAMD64TESTWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c + v.AddArg(x) + return true + } + goto endb532b10789c7ce4cedeb17af417ceb2b +endb532b10789c7ce4cedeb17af417ceb2b: ; return false } @@ -4582,109 +4790,422 @@ end02799ad95fe7fb5ce3c2c8ab313b737c: ; return false } -func rewriteValueAMD64_OpLeq16(v *Value, config *Config) bool { +func rewriteValueAMD64_OpAMD64LEAQ(v *Value, config *Config) bool { b := v.Block _ = b - // match: (Leq16 x y) - // cond: - // result: (SETLE (CMPW x y)) + // match: (LEAQ [off1] {sym1} (LEAQ [off2] {sym2} x)) + // cond: canMergeSym(sym1, sym2) + // result: (LEAQ [addOff(off1,off2)] {mergeSym(sym1,sym2)} x) { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETLE + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ { + goto end2e2249051d6776a92bcb0d83107e0d82 + } + off2 := v.Args[0].AuxInt + sym2 := v.Args[0].Aux + x := v.Args[0].Args[0] + if !(canMergeSym(sym1, sym2)) { + goto end2e2249051d6776a92bcb0d83107e0d82 + } + v.Op = OpAMD64LEAQ v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(x) return true } - goto end586c647ca6bb8ec725eea917c743d1ea -end586c647ca6bb8ec725eea917c743d1ea: + goto end2e2249051d6776a92bcb0d83107e0d82 +end2e2249051d6776a92bcb0d83107e0d82: ; - return false -} -func rewriteValueAMD64_OpLeq16U(v *Value, config *Config) bool { - b := v.Block - _ = b - // match: (Leq16U x y) - // cond: - // result: (SETBE (CMPW x y)) + // match: (LEAQ [off1] {sym1} (LEAQ1 [off2] {sym2} x y)) + // cond: canMergeSym(sym1, sym2) + // result: (LEAQ1 [addOff(off1,off2)] {mergeSym(sym1,sym2)} x y) { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETBE + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ1 { + goto end4e2502574680cc8e02dcc07561e96ef9 + } + 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)) { + goto end4e2502574680cc8e02dcc07561e96ef9 + } + v.Op = OpAMD64LEAQ1 v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(x) + v.AddArg(y) return true } - goto end9c24a81bc6a4a92267bd6638362dfbfc -end9c24a81bc6a4a92267bd6638362dfbfc: + goto end4e2502574680cc8e02dcc07561e96ef9 +end4e2502574680cc8e02dcc07561e96ef9: ; - return false -} -func rewriteValueAMD64_OpLeq32(v *Value, config *Config) bool { - b := v.Block - _ = b - // match: (Leq32 x y) - // cond: - // result: (SETLE (CMPL x y)) + // match: (LEAQ [off1] {sym1} (LEAQ2 [off2] {sym2} x y)) + // cond: canMergeSym(sym1, sym2) + // result: (LEAQ2 [addOff(off1,off2)] {mergeSym(sym1,sym2)} x y) { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETLE + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ2 { + goto end92e54b1fbb5ba0b17a6006fe56b4d57b + } + 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)) { + goto end92e54b1fbb5ba0b17a6006fe56b4d57b + } + v.Op = OpAMD64LEAQ2 v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) - v0.AddArg(x) - v0.AddArg(y) - v0.Type = TypeFlags - v.AddArg(v0) + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(x) + v.AddArg(y) return true } - goto end595ee99a9fc3460b2748b9129b139f88 -end595ee99a9fc3460b2748b9129b139f88: + goto end92e54b1fbb5ba0b17a6006fe56b4d57b +end92e54b1fbb5ba0b17a6006fe56b4d57b: ; - return false -} -func rewriteValueAMD64_OpLeq32F(v *Value, config *Config) bool { - b := v.Block - _ = b - // match: (Leq32F x y) - // cond: - // result: (SETGEF (UCOMISS y x)) + // match: (LEAQ [off1] {sym1} (LEAQ4 [off2] {sym2} x y)) + // cond: canMergeSym(sym1, sym2) + // result: (LEAQ4 [addOff(off1,off2)] {mergeSym(sym1,sym2)} x y) { - x := v.Args[0] - y := v.Args[1] - v.Op = OpAMD64SETGEF + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ4 { + goto end5da4c89d542d34d0d7f8848c3ea0fead + } + 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)) { + goto end5da4c89d542d34d0d7f8848c3ea0fead + } + v.Op = OpAMD64LEAQ4 v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeInvalid) - v0.AddArg(y) - v0.AddArg(x) - v0.Type = TypeFlags - v.AddArg(v0) + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(x) + v.AddArg(y) return true } - goto endfee4b989a80cc43328b24f7017e80a17 -endfee4b989a80cc43328b24f7017e80a17: + goto end5da4c89d542d34d0d7f8848c3ea0fead +end5da4c89d542d34d0d7f8848c3ea0fead: ; - return false -} -func rewriteValueAMD64_OpLeq32U(v *Value, config *Config) bool { - b := v.Block - _ = b + // match: (LEAQ [off1] {sym1} (LEAQ8 [off2] {sym2} x y)) + // cond: canMergeSym(sym1, sym2) + // result: (LEAQ8 [addOff(off1,off2)] {mergeSym(sym1,sym2)} x y) + { + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ8 { + goto endc051937df5f12598e76c0923b5a60a39 + } + 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)) { + goto endc051937df5f12598e76c0923b5a60a39 + } + v.Op = OpAMD64LEAQ8 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(x) + v.AddArg(y) + return true + } + goto endc051937df5f12598e76c0923b5a60a39 +endc051937df5f12598e76c0923b5a60a39: + ; + return false +} +func rewriteValueAMD64_OpAMD64LEAQ1(v *Value, config *Config) bool { + b := v.Block + _ = b + // 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) + { + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ { + goto end3b837b0ce1bd6a79804a28ee529fc65b + } + 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) { + goto end3b837b0ce1bd6a79804a28ee529fc65b + } + v.Op = OpAMD64LEAQ1 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(x) + v.AddArg(y) + return true + } + goto end3b837b0ce1bd6a79804a28ee529fc65b +end3b837b0ce1bd6a79804a28ee529fc65b: + ; + // 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) + { + off1 := v.AuxInt + sym1 := v.Aux + x := v.Args[0] + if v.Args[1].Op != OpAMD64LEAQ { + goto endfd9dd9448d726fc7d82274b404cddb67 + } + off2 := v.Args[1].AuxInt + sym2 := v.Args[1].Aux + y := v.Args[1].Args[0] + if !(canMergeSym(sym1, sym2) && y.Op != OpSB) { + goto endfd9dd9448d726fc7d82274b404cddb67 + } + v.Op = OpAMD64LEAQ1 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(x) + v.AddArg(y) + return true + } + goto endfd9dd9448d726fc7d82274b404cddb67 +endfd9dd9448d726fc7d82274b404cddb67: + ; + return false +} +func rewriteValueAMD64_OpAMD64LEAQ2(v *Value, config *Config) bool { + b := v.Block + _ = b + // 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) + { + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ { + goto end2bf3cb6e212c3f62ab83ce10059e672e + } + 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) { + goto end2bf3cb6e212c3f62ab83ce10059e672e + } + v.Op = OpAMD64LEAQ2 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(x) + v.AddArg(y) + return true + } + goto end2bf3cb6e212c3f62ab83ce10059e672e +end2bf3cb6e212c3f62ab83ce10059e672e: + ; + return false +} +func rewriteValueAMD64_OpAMD64LEAQ4(v *Value, config *Config) bool { + b := v.Block + _ = b + // 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) + { + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ { + goto end066907f169f09e56139e801397316c95 + } + 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) { + goto end066907f169f09e56139e801397316c95 + } + v.Op = OpAMD64LEAQ4 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(x) + v.AddArg(y) + return true + } + goto end066907f169f09e56139e801397316c95 +end066907f169f09e56139e801397316c95: + ; + return false +} +func rewriteValueAMD64_OpAMD64LEAQ8(v *Value, config *Config) bool { + b := v.Block + _ = b + // 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) + { + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ { + goto end6bde9448027690b01bbf30dee061ce23 + } + 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) { + goto end6bde9448027690b01bbf30dee061ce23 + } + v.Op = OpAMD64LEAQ8 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(x) + v.AddArg(y) + return true + } + goto end6bde9448027690b01bbf30dee061ce23 +end6bde9448027690b01bbf30dee061ce23: + ; + return false +} +func rewriteValueAMD64_OpLeq16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Leq16 x y) + // cond: + // result: (SETLE (CMPW x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETLE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto end586c647ca6bb8ec725eea917c743d1ea +end586c647ca6bb8ec725eea917c743d1ea: + ; + return false +} +func rewriteValueAMD64_OpLeq16U(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Leq16U x y) + // cond: + // result: (SETBE (CMPW x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETBE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto end9c24a81bc6a4a92267bd6638362dfbfc +end9c24a81bc6a4a92267bd6638362dfbfc: + ; + return false +} +func rewriteValueAMD64_OpLeq32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Leq32 x y) + // cond: + // result: (SETLE (CMPL x y)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETLE + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) + v0.AddArg(x) + v0.AddArg(y) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto end595ee99a9fc3460b2748b9129b139f88 +end595ee99a9fc3460b2748b9129b139f88: + ; + return false +} +func rewriteValueAMD64_OpLeq32F(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Leq32F x y) + // cond: + // result: (SETGEF (UCOMISS y x)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpAMD64SETGEF + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeInvalid) + v0.AddArg(y) + v0.AddArg(x) + v0.Type = TypeFlags + v.AddArg(v0) + return true + } + goto endfee4b989a80cc43328b24f7017e80a17 +endfee4b989a80cc43328b24f7017e80a17: + ; + return false +} +func rewriteValueAMD64_OpLeq32U(v *Value, config *Config) bool { + b := v.Block + _ = b // match: (Leq32U x y) // cond: // result: (SETBE (CMPL x y)) @@ -5883,19 +6404,42 @@ func rewriteValueAMD64_OpAMD64MOVBQSX(v *Value, config *Config) bool { goto end19c38f3a1a37dca50637c917fa26e4f7 end19c38f3a1a37dca50637c917fa26e4f7: ; - 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 [off] {sym} ptr mem) + // match: (MOVBQSX (ANDBconst [c] x)) + // cond: c & 0x80 == 0 + // result: (ANDQconst [c & 0x7f] x) { - if v.Args[0].Op != OpAMD64MOVBload { - goto end1169bcf3d56fa24321b002eaebd5a62d + if v.Args[0].Op != OpAMD64ANDBconst { + goto endf998318725c3cc6c701ebb69a2473650 } - off := v.Args[0].AuxInt + c := v.Args[0].AuxInt + x := v.Args[0].Args[0] + if !(c&0x80 == 0) { + goto endf998318725c3cc6c701ebb69a2473650 + } + v.Op = OpAMD64ANDQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 0x7f + v.AddArg(x) + return true + } + goto endf998318725c3cc6c701ebb69a2473650 +endf998318725c3cc6c701ebb69a2473650: + ; + 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 [off] {sym} ptr mem) + { + if v.Args[0].Op != OpAMD64MOVBload { + goto end1169bcf3d56fa24321b002eaebd5a62d + } + off := v.Args[0].AuxInt sym := v.Args[0].Aux ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] @@ -5914,6 +6458,26 @@ func rewriteValueAMD64_OpAMD64MOVBQZX(v *Value, config *Config) bool { } goto end1169bcf3d56fa24321b002eaebd5a62d end1169bcf3d56fa24321b002eaebd5a62d: + ; + // match: (MOVBQZX (ANDBconst [c] x)) + // cond: + // result: (ANDQconst [c & 0xff] x) + { + if v.Args[0].Op != OpAMD64ANDBconst { + goto enddca0c0e20f19210fe65677bfd758b24e + } + c := v.Args[0].AuxInt + x := v.Args[0].Args[0] + v.Op = OpAMD64ANDQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 0xff + v.AddArg(x) + return true + } + goto enddca0c0e20f19210fe65677bfd758b24e +enddca0c0e20f19210fe65677bfd758b24e: ; return false } @@ -6116,6 +6680,67 @@ endfdf24c49923451a076f1868988b8c9d9: } goto enda7086cf7f6b8cf81972e2c3d4b12f3fc enda7086cf7f6b8cf81972e2c3d4b12f3fc: + ; + // 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) + { + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ1 { + goto ende386ced77f1acdae2e8bbc379803b7cf + } + 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)) { + goto ende386ced77f1acdae2e8bbc379803b7cf + } + v.Op = OpAMD64MOVBstoreidx1 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(ptr) + v.AddArg(idx) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto ende386ced77f1acdae2e8bbc379803b7cf +ende386ced77f1acdae2e8bbc379803b7cf: + ; + // match: (MOVBstore [off] {sym} (ADDQ ptr idx) val mem) + // cond: + // result: (MOVBstoreidx1 [off] {sym} ptr idx val mem) + { + off := v.AuxInt + sym := v.Aux + if v.Args[0].Op != OpAMD64ADDQ { + goto endc7abfa0b473c622e6d5aa3b1846fb2b7 + } + ptr := v.Args[0].Args[0] + idx := v.Args[0].Args[1] + val := v.Args[1] + mem := v.Args[2] + v.Op = OpAMD64MOVBstoreidx1 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = off + v.Aux = sym + v.AddArg(ptr) + v.AddArg(idx) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto endc7abfa0b473c622e6d5aa3b1846fb2b7 +endc7abfa0b473c622e6d5aa3b1846fb2b7: ; return false } @@ -6181,6 +6806,147 @@ end8deb839acf84818dd8fc827c0338f42c: ; return false } +func rewriteValueAMD64_OpAMD64MOVBstoreidx1(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (MOVBstoreidx1 [off1] {sym} (ADDQconst [off2] ptr) idx val mem) + // cond: + // result: (MOVBstoreidx1 [addOff(off1, off2)] {sym} ptr idx val mem) + { + off1 := v.AuxInt + sym := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto endba611397b0dfd416156f29d7bd95b945 + } + off2 := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + idx := v.Args[1] + val := v.Args[2] + mem := v.Args[3] + v.Op = OpAMD64MOVBstoreidx1 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = sym + v.AddArg(ptr) + v.AddArg(idx) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto endba611397b0dfd416156f29d7bd95b945 +endba611397b0dfd416156f29d7bd95b945: + ; + 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 [off] {sym} ptr mem) + { + if v.Args[0].Op != OpAMD64MOVLload { + goto end9498ad52d5051e8e3ee9b0ed7af68d01 + } + off := v.Args[0].AuxInt + sym := v.Args[0].Aux + ptr := v.Args[0].Args[0] + mem := v.Args[0].Args[1] + v0 := v.Args[0].Block.NewValue0(v.Line, OpAMD64MOVLQSXload, TypeInvalid) + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(v0) + v0.Type = v.Type + v0.AuxInt = off + v0.Aux = sym + v0.AddArg(ptr) + v0.AddArg(mem) + return true + } + goto end9498ad52d5051e8e3ee9b0ed7af68d01 +end9498ad52d5051e8e3ee9b0ed7af68d01: + ; + // match: (MOVLQSX (ANDLconst [c] x)) + // cond: c & 0x80000000 == 0 + // result: (ANDQconst [c & 0x7fffffff] x) + { + if v.Args[0].Op != OpAMD64ANDLconst { + goto end286a5aa0d10b04039cbe6e09307b4cbe + } + c := v.Args[0].AuxInt + x := v.Args[0].Args[0] + if !(c&0x80000000 == 0) { + goto end286a5aa0d10b04039cbe6e09307b4cbe + } + v.Op = OpAMD64ANDQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 0x7fffffff + v.AddArg(x) + return true + } + goto end286a5aa0d10b04039cbe6e09307b4cbe +end286a5aa0d10b04039cbe6e09307b4cbe: + ; + 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 [off] {sym} ptr mem) + { + if v.Args[0].Op != OpAMD64MOVLload { + goto endb00602ccd4180bd749a3b01914264fbc + } + off := v.Args[0].AuxInt + sym := v.Args[0].Aux + ptr := v.Args[0].Args[0] + mem := v.Args[0].Args[1] + v0 := v.Args[0].Block.NewValue0(v.Line, OpAMD64MOVLQZXload, TypeInvalid) + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(v0) + v0.Type = v.Type + v0.AuxInt = off + v0.Aux = sym + v0.AddArg(ptr) + v0.AddArg(mem) + return true + } + goto endb00602ccd4180bd749a3b01914264fbc +endb00602ccd4180bd749a3b01914264fbc: + ; + // match: (MOVLQZX (ANDLconst [c] x)) + // cond: + // result: (ANDQconst [c & 0xffffffff] x) + { + if v.Args[0].Op != OpAMD64ANDLconst { + goto end71446f0e4f530fbbc6b25a3d07761c06 + } + c := v.Args[0].AuxInt + x := v.Args[0].Args[0] + v.Op = OpAMD64ANDQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 0xffffffff + v.AddArg(x) + return true + } + goto end71446f0e4f530fbbc6b25a3d07761c06 +end71446f0e4f530fbbc6b25a3d07761c06: + ; + return false +} func rewriteValueAMD64_OpAMD64MOVLload(v *Value, config *Config) bool { b := v.Block _ = b @@ -6380,6 +7146,39 @@ enda62a54c45bf42db801af4095d27faccd: } goto endd57b1e4313fc7a3331340a9af00ba116 endd57b1e4313fc7a3331340a9af00ba116: + ; + // 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) + { + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ4 { + goto end6d2bbe089d6de8d261fcdeef263d2f7c + } + 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)) { + goto end6d2bbe089d6de8d261fcdeef263d2f7c + } + v.Op = OpAMD64MOVLstoreidx4 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(ptr) + v.AddArg(idx) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto end6d2bbe089d6de8d261fcdeef263d2f7c +end6d2bbe089d6de8d261fcdeef263d2f7c: ; return false } @@ -6445,6 +7244,40 @@ endd579250954b5df84a77518b36f739e12: ; return false } +func rewriteValueAMD64_OpAMD64MOVLstoreidx4(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (MOVLstoreidx4 [off1] {sym} (ADDQconst [off2] ptr) idx val mem) + // cond: + // result: (MOVLstoreidx4 [addOff(off1, off2)] {sym} ptr idx val mem) + { + off1 := v.AuxInt + sym := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto endf4921486b8eca2abd4a92ffadc6cb52d + } + off2 := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + idx := v.Args[1] + val := v.Args[2] + mem := v.Args[3] + v.Op = OpAMD64MOVLstoreidx4 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = sym + v.AddArg(ptr) + v.AddArg(idx) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto endf4921486b8eca2abd4a92ffadc6cb52d +endf4921486b8eca2abd4a92ffadc6cb52d: + ; + return false +} func rewriteValueAMD64_OpAMD64MOVOload(v *Value, config *Config) bool { b := v.Block _ = b @@ -7425,27 +8258,134 @@ end66e4853026306cd46f414c22d281254f: ; return false } -func rewriteValueAMD64_OpAMD64MOVWload(v *Value, config *Config) bool { +func rewriteValueAMD64_OpAMD64MOVWQSX(v *Value, config *Config) bool { b := v.Block _ = b - // match: (MOVWload [off1] {sym} (ADDQconst [off2] ptr) mem) + // match: (MOVWQSX (MOVWload [off] {sym} ptr mem)) // cond: - // result: (MOVWload [addOff(off1, off2)] {sym} ptr mem) + // result: @v.Args[0].Block (MOVWQSXload [off] {sym} ptr mem) { - off1 := v.AuxInt - sym := v.Aux - if v.Args[0].Op != OpAMD64ADDQconst { - goto endfcb0ce76f96e8b0c2eb19a9b827c1b73 + if v.Args[0].Op != OpAMD64MOVWload { + goto endef39da125e2794cdafd008426ecc91eb } - off2 := v.Args[0].AuxInt + off := v.Args[0].AuxInt + sym := v.Args[0].Aux ptr := v.Args[0].Args[0] - mem := v.Args[1] - v.Op = OpAMD64MOVWload + mem := v.Args[0].Args[1] + v0 := v.Args[0].Block.NewValue0(v.Line, OpAMD64MOVWQSXload, TypeInvalid) + v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = addOff(off1, off2) - v.Aux = sym + v.AddArg(v0) + v0.Type = v.Type + v0.AuxInt = off + v0.Aux = sym + v0.AddArg(ptr) + v0.AddArg(mem) + return true + } + goto endef39da125e2794cdafd008426ecc91eb +endef39da125e2794cdafd008426ecc91eb: + ; + // match: (MOVWQSX (ANDWconst [c] x)) + // cond: c & 0x8000 == 0 + // result: (ANDQconst [c & 0x7fff] x) + { + if v.Args[0].Op != OpAMD64ANDWconst { + goto end8581b4c4dfd1278e97aa536308519e68 + } + c := v.Args[0].AuxInt + x := v.Args[0].Args[0] + if !(c&0x8000 == 0) { + goto end8581b4c4dfd1278e97aa536308519e68 + } + v.Op = OpAMD64ANDQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 0x7fff + v.AddArg(x) + return true + } + goto end8581b4c4dfd1278e97aa536308519e68 +end8581b4c4dfd1278e97aa536308519e68: + ; + 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 [off] {sym} ptr mem) + { + if v.Args[0].Op != OpAMD64MOVWload { + goto end348d59b382c9d0c64896811facbe4c5e + } + off := v.Args[0].AuxInt + sym := v.Args[0].Aux + ptr := v.Args[0].Args[0] + mem := v.Args[0].Args[1] + v0 := v.Args[0].Block.NewValue0(v.Line, OpAMD64MOVWQZXload, TypeInvalid) + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(v0) + v0.Type = v.Type + v0.AuxInt = off + v0.Aux = sym + v0.AddArg(ptr) + v0.AddArg(mem) + return true + } + goto end348d59b382c9d0c64896811facbe4c5e +end348d59b382c9d0c64896811facbe4c5e: + ; + // match: (MOVWQZX (ANDWconst [c] x)) + // cond: + // result: (ANDQconst [c & 0xffff] x) + { + if v.Args[0].Op != OpAMD64ANDWconst { + goto end15c2a3b0ade49892e79289e562bac52f + } + c := v.Args[0].AuxInt + x := v.Args[0].Args[0] + v.Op = OpAMD64ANDQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 0xffff + v.AddArg(x) + return true + } + goto end15c2a3b0ade49892e79289e562bac52f +end15c2a3b0ade49892e79289e562bac52f: + ; + return false +} +func rewriteValueAMD64_OpAMD64MOVWload(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (MOVWload [off1] {sym} (ADDQconst [off2] ptr) mem) + // cond: + // result: (MOVWload [addOff(off1, off2)] {sym} ptr mem) + { + off1 := v.AuxInt + sym := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto endfcb0ce76f96e8b0c2eb19a9b827c1b73 + } + off2 := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + mem := v.Args[1] + v.Op = OpAMD64MOVWload + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = sym v.AddArg(ptr) v.AddArg(mem) return true @@ -7624,6 +8564,39 @@ end60327daf9965d73a8c1971d098e1e31d: } goto end4cc466ede8e64e415c899ccac81c0f27 end4cc466ede8e64e415c899ccac81c0f27: + ; + // 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) + { + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ2 { + goto endecfc76d1ba8fcce5d4110a452cd39752 + } + 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)) { + goto endecfc76d1ba8fcce5d4110a452cd39752 + } + v.Op = OpAMD64MOVWstoreidx2 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(ptr) + v.AddArg(idx) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto endecfc76d1ba8fcce5d4110a452cd39752 +endecfc76d1ba8fcce5d4110a452cd39752: ; return false } @@ -7689,6 +8662,40 @@ endba47397e07b40a64fa4cad36ac2e32ad: ; return false } +func rewriteValueAMD64_OpAMD64MOVWstoreidx2(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (MOVWstoreidx2 [off1] {sym} (ADDQconst [off2] ptr) idx val mem) + // cond: + // result: (MOVWstoreidx2 [addOff(off1, off2)] {sym} ptr idx val mem) + { + off1 := v.AuxInt + sym := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto end7ab3a4fbfc9bac9d46ba72d40f667794 + } + off2 := v.Args[0].AuxInt + ptr := v.Args[0].Args[0] + idx := v.Args[1] + val := v.Args[2] + mem := v.Args[3] + v.Op = OpAMD64MOVWstoreidx2 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = addOff(off1, off2) + v.Aux = sym + v.AddArg(ptr) + v.AddArg(idx) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto end7ab3a4fbfc9bac9d46ba72d40f667794 +end7ab3a4fbfc9bac9d46ba72d40f667794: + ; + return false +} func rewriteValueAMD64_OpAMD64MULB(v *Value, config *Config) bool { b := v.Block _ = b @@ -11198,6 +12205,66 @@ end6453a48c573d0dc7c8b0163a266c6218: func rewriteValueAMD64_OpAMD64SARB(v *Value, config *Config) bool { b := v.Block _ = b + // match: (SARB x (MOVQconst [c])) + // cond: + // result: (SARBconst [c&31] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVQconst { + goto end03194336f801b91c1423aed6f39247f0 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SARBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 31 + v.AddArg(x) + return true + } + goto end03194336f801b91c1423aed6f39247f0 +end03194336f801b91c1423aed6f39247f0: + ; + // match: (SARB x (MOVLconst [c])) + // cond: + // result: (SARBconst [c&31] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVLconst { + goto end3f623e78dd789403b299106625e0d6df + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SARBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 31 + v.AddArg(x) + return true + } + goto end3f623e78dd789403b299106625e0d6df +end3f623e78dd789403b299106625e0d6df: + ; + // match: (SARB x (MOVWconst [c])) + // cond: + // result: (SARBconst [c&31] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVWconst { + goto end4393e26c64e39342a0634d9a5706cb10 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SARBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 31 + v.AddArg(x) + return true + } + goto end4393e26c64e39342a0634d9a5706cb10 +end4393e26c64e39342a0634d9a5706cb10: + ; // match: (SARB x (MOVBconst [c])) // cond: // result: (SARBconst [c&31] x) @@ -11247,6 +12314,26 @@ end06e0e38775f0650ed672427d19cd8fff: func rewriteValueAMD64_OpAMD64SARL(v *Value, config *Config) bool { b := v.Block _ = b + // match: (SARL x (MOVQconst [c])) + // cond: + // result: (SARLconst [c&31] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVQconst { + goto end8fb4e77be1f4d21d0f2a0facf9a60add + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SARLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 31 + v.AddArg(x) + return true + } + goto end8fb4e77be1f4d21d0f2a0facf9a60add +end8fb4e77be1f4d21d0f2a0facf9a60add: + ; // match: (SARL x (MOVLconst [c])) // cond: // result: (SARLconst [c&31] x) @@ -11266,6 +12353,46 @@ func rewriteValueAMD64_OpAMD64SARL(v *Value, config *Config) bool { } goto ende586a72c1b232ee0b63e37c71eeb8470 ende586a72c1b232ee0b63e37c71eeb8470: + ; + // match: (SARL x (MOVWconst [c])) + // cond: + // result: (SARLconst [c&31] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVWconst { + goto end37389c13b9fb94c44bd10b1143809afb + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SARLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 31 + v.AddArg(x) + return true + } + goto end37389c13b9fb94c44bd10b1143809afb +end37389c13b9fb94c44bd10b1143809afb: + ; + // match: (SARL x (MOVBconst [c])) + // cond: + // result: (SARLconst [c&31] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVBconst { + goto end72550eb8c44c45e76e40888bce753160 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SARLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 31 + v.AddArg(x) + return true + } + goto end72550eb8c44c45e76e40888bce753160 +end72550eb8c44c45e76e40888bce753160: ; return false } @@ -11316,35 +12443,135 @@ func rewriteValueAMD64_OpAMD64SARQ(v *Value, config *Config) bool { goto end25e720ab203be2745dded5550e6d8a7c end25e720ab203be2745dded5550e6d8a7c: ; - return false -} -func rewriteValueAMD64_OpAMD64SARQconst(v *Value, config *Config) bool { - b := v.Block - _ = b - // match: (SARQconst [c] (MOVQconst [d])) + // match: (SARQ x (MOVLconst [c])) // cond: - // result: (MOVQconst [d>>uint64(c)]) + // result: (SARQconst [c&63] x) { - c := v.AuxInt - if v.Args[0].Op != OpAMD64MOVQconst { - goto endd949ba69a1ff71ba62c49b39c68f269e + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVLconst { + goto endd04cf826c5db444107cf4e0bf789bcda } - d := v.Args[0].AuxInt - v.Op = OpAMD64MOVQconst + c := v.Args[1].AuxInt + v.Op = OpAMD64SARQconst v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = d >> uint64(c) + v.AuxInt = c & 63 + v.AddArg(x) return true } - goto endd949ba69a1ff71ba62c49b39c68f269e -endd949ba69a1ff71ba62c49b39c68f269e: + goto endd04cf826c5db444107cf4e0bf789bcda +endd04cf826c5db444107cf4e0bf789bcda: ; - return false -} + // match: (SARQ x (MOVWconst [c])) + // cond: + // result: (SARQconst [c&63] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVWconst { + goto end6266051b3a126922286c298594535622 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SARQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 63 + v.AddArg(x) + return true + } + goto end6266051b3a126922286c298594535622 +end6266051b3a126922286c298594535622: + ; + // match: (SARQ x (MOVBconst [c])) + // cond: + // result: (SARQconst [c&63] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVBconst { + goto endcf2a1bdfeda535fc96ae1e7f5c54d531 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SARQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 63 + v.AddArg(x) + return true + } + goto endcf2a1bdfeda535fc96ae1e7f5c54d531 +endcf2a1bdfeda535fc96ae1e7f5c54d531: + ; + 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)]) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64MOVQconst { + goto endd949ba69a1ff71ba62c49b39c68f269e + } + d := v.Args[0].AuxInt + v.Op = OpAMD64MOVQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = d >> uint64(c) + return true + } + goto endd949ba69a1ff71ba62c49b39c68f269e +endd949ba69a1ff71ba62c49b39c68f269e: + ; + 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) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVQconst { + goto endec8cafea5ff91b2a1b5cf5a169be924f + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SARWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 31 + v.AddArg(x) + return true + } + goto endec8cafea5ff91b2a1b5cf5a169be924f +endec8cafea5ff91b2a1b5cf5a169be924f: + ; + // match: (SARW x (MOVLconst [c])) + // cond: + // result: (SARWconst [c&31] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVLconst { + goto end9303d0edeebdc8a2a7e93fecf0fff61c + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SARWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 31 + v.AddArg(x) + return true + } + goto end9303d0edeebdc8a2a7e93fecf0fff61c +end9303d0edeebdc8a2a7e93fecf0fff61c: + ; // match: (SARW x (MOVWconst [c])) // cond: // result: (SARWconst [c&31] x) @@ -11364,6 +12591,26 @@ func rewriteValueAMD64_OpAMD64SARW(v *Value, config *Config) bool { } goto endc46e3f211f94238f9a0aec3c498af490 endc46e3f211f94238f9a0aec3c498af490: + ; + // match: (SARW x (MOVBconst [c])) + // cond: + // result: (SARWconst [c&31] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVBconst { + goto end0bf07ce9cd2c536c07768f8dfbe13c62 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SARWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 31 + v.AddArg(x) + return true + } + goto end0bf07ce9cd2c536c07768f8dfbe13c62 +end0bf07ce9cd2c536c07768f8dfbe13c62: ; return false } @@ -12654,6 +13901,66 @@ end9249b3ed3e1e582dd5435fb73cbc13ac: func rewriteValueAMD64_OpAMD64SHLB(v *Value, config *Config) bool { b := v.Block _ = b + // match: (SHLB x (MOVQconst [c])) + // cond: + // result: (SHLBconst [c&31] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVQconst { + goto endb1f377b81b6f4c1864893934230ecbd1 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SHLBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 31 + v.AddArg(x) + return true + } + goto endb1f377b81b6f4c1864893934230ecbd1 +endb1f377b81b6f4c1864893934230ecbd1: + ; + // match: (SHLB x (MOVLconst [c])) + // cond: + // result: (SHLBconst [c&31] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVLconst { + goto end434bc4ee26d93bf1c734be760d7a1aa6 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SHLBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 31 + v.AddArg(x) + return true + } + goto end434bc4ee26d93bf1c734be760d7a1aa6 +end434bc4ee26d93bf1c734be760d7a1aa6: + ; + // match: (SHLB x (MOVWconst [c])) + // cond: + // result: (SHLBconst [c&31] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVWconst { + goto end2c4fe4cce2ae24e0bc5c7d209d22e9d9 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SHLBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 31 + v.AddArg(x) + return true + } + goto end2c4fe4cce2ae24e0bc5c7d209d22e9d9 +end2c4fe4cce2ae24e0bc5c7d209d22e9d9: + ; // match: (SHLB x (MOVBconst [c])) // cond: // result: (SHLBconst [c&31] x) @@ -12679,6 +13986,26 @@ end2d0d0111d831d8a575b5627284a6337a: func rewriteValueAMD64_OpAMD64SHLL(v *Value, config *Config) bool { b := v.Block _ = b + // match: (SHLL x (MOVQconst [c])) + // cond: + // result: (SHLLconst [c&31] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVQconst { + goto end1b4f8b8d62445fdcb3cf9cd5036b559b + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SHLLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 31 + v.AddArg(x) + return true + } + goto end1b4f8b8d62445fdcb3cf9cd5036b559b +end1b4f8b8d62445fdcb3cf9cd5036b559b: + ; // match: (SHLL x (MOVLconst [c])) // cond: // result: (SHLLconst [c&31] x) @@ -12698,6 +14025,46 @@ func rewriteValueAMD64_OpAMD64SHLL(v *Value, config *Config) bool { } goto end633f9ddcfbb63374c895a5f78da75d25 end633f9ddcfbb63374c895a5f78da75d25: + ; + // match: (SHLL x (MOVWconst [c])) + // cond: + // result: (SHLLconst [c&31] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVWconst { + goto enda4f59495061db6cfe796b6dba8d3cad8 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SHLLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 31 + v.AddArg(x) + return true + } + goto enda4f59495061db6cfe796b6dba8d3cad8 +enda4f59495061db6cfe796b6dba8d3cad8: + ; + // match: (SHLL x (MOVBconst [c])) + // cond: + // result: (SHLLconst [c&31] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVBconst { + goto endd6f39b5f3174ca738ae1c48a96d837a6 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SHLLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 31 + v.AddArg(x) + return true + } + goto endd6f39b5f3174ca738ae1c48a96d837a6 +endd6f39b5f3174ca738ae1c48a96d837a6: ; return false } @@ -12723,12 +14090,112 @@ func rewriteValueAMD64_OpAMD64SHLQ(v *Value, config *Config) bool { } goto end4d7e3a945cacdd6b6c8c0de6f465d4ae end4d7e3a945cacdd6b6c8c0de6f465d4ae: + ; + // match: (SHLQ x (MOVLconst [c])) + // cond: + // result: (SHLQconst [c&63] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVLconst { + goto end394bae2652a3e4bc4b70a6fc193949f8 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SHLQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 63 + v.AddArg(x) + return true + } + goto end394bae2652a3e4bc4b70a6fc193949f8 +end394bae2652a3e4bc4b70a6fc193949f8: + ; + // match: (SHLQ x (MOVWconst [c])) + // cond: + // result: (SHLQconst [c&63] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVWconst { + goto end358be4078efa15ceb443ccda7ce592a0 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SHLQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 63 + v.AddArg(x) + return true + } + goto end358be4078efa15ceb443ccda7ce592a0 +end358be4078efa15ceb443ccda7ce592a0: + ; + // match: (SHLQ x (MOVBconst [c])) + // cond: + // result: (SHLQconst [c&63] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVBconst { + goto end032e0efd085f37a12322dbc63795a1b2 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SHLQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 63 + v.AddArg(x) + return true + } + goto end032e0efd085f37a12322dbc63795a1b2 +end032e0efd085f37a12322dbc63795a1b2: ; 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) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVQconst { + goto enda29aa85ce58b1fdb63d71e2632efd6db + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SHLWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 31 + v.AddArg(x) + return true + } + goto enda29aa85ce58b1fdb63d71e2632efd6db +enda29aa85ce58b1fdb63d71e2632efd6db: + ; + // match: (SHLW x (MOVLconst [c])) + // cond: + // result: (SHLWconst [c&31] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVLconst { + goto end59ce264ffde0ef9af8ea1a25db7173b6 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SHLWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 31 + v.AddArg(x) + return true + } + goto end59ce264ffde0ef9af8ea1a25db7173b6 +end59ce264ffde0ef9af8ea1a25db7173b6: + ; // match: (SHLW x (MOVWconst [c])) // cond: // result: (SHLWconst [c&31] x) @@ -12748,12 +14215,92 @@ func rewriteValueAMD64_OpAMD64SHLW(v *Value, config *Config) bool { } goto endba96a52aa58d28b3357828051e0e695c endba96a52aa58d28b3357828051e0e695c: + ; + // match: (SHLW x (MOVBconst [c])) + // cond: + // result: (SHLWconst [c&31] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVBconst { + goto endf9c2165ea24ac7bbdd46cdf0e084104f + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SHLWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 31 + v.AddArg(x) + return true + } + goto endf9c2165ea24ac7bbdd46cdf0e084104f +endf9c2165ea24ac7bbdd46cdf0e084104f: ; 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) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVQconst { + goto end2e7fb7a5406cbf51c69a0d04dc73d16a + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SHRBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 31 + v.AddArg(x) + return true + } + goto end2e7fb7a5406cbf51c69a0d04dc73d16a +end2e7fb7a5406cbf51c69a0d04dc73d16a: + ; + // match: (SHRB x (MOVLconst [c])) + // cond: + // result: (SHRBconst [c&31] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVLconst { + goto end69603cc51e4f244388f368dd188a526a + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SHRBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 31 + v.AddArg(x) + return true + } + goto end69603cc51e4f244388f368dd188a526a +end69603cc51e4f244388f368dd188a526a: + ; + // match: (SHRB x (MOVWconst [c])) + // cond: + // result: (SHRBconst [c&31] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVWconst { + goto endd96421647299a1bb1b68ad0a90fa0be3 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SHRBconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 31 + v.AddArg(x) + return true + } + goto endd96421647299a1bb1b68ad0a90fa0be3 +endd96421647299a1bb1b68ad0a90fa0be3: + ; // match: (SHRB x (MOVBconst [c])) // cond: // result: (SHRBconst [c&31] x) @@ -12779,6 +14326,26 @@ enddb1cd5aaa826d43fa4f6d1b2b8795e58: func rewriteValueAMD64_OpAMD64SHRL(v *Value, config *Config) bool { b := v.Block _ = b + // match: (SHRL x (MOVQconst [c])) + // cond: + // result: (SHRLconst [c&31] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVQconst { + goto end893880cdc59697295c1849a250163e59 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SHRLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 31 + v.AddArg(x) + return true + } + goto end893880cdc59697295c1849a250163e59 +end893880cdc59697295c1849a250163e59: + ; // match: (SHRL x (MOVLconst [c])) // cond: // result: (SHRLconst [c&31] x) @@ -12798,6 +14365,46 @@ func rewriteValueAMD64_OpAMD64SHRL(v *Value, config *Config) bool { } goto end344b8b9202e1925e8d0561f1c21412fc end344b8b9202e1925e8d0561f1c21412fc: + ; + // match: (SHRL x (MOVWconst [c])) + // cond: + // result: (SHRLconst [c&31] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVWconst { + goto end561280f746f9983f4a4b4a5119b53028 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SHRLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 31 + v.AddArg(x) + return true + } + goto end561280f746f9983f4a4b4a5119b53028 +end561280f746f9983f4a4b4a5119b53028: + ; + // match: (SHRL x (MOVBconst [c])) + // cond: + // result: (SHRLconst [c&31] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVBconst { + goto enda339271c59d274b73c04ba1f2c44c2b9 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SHRLconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 31 + v.AddArg(x) + return true + } + goto enda339271c59d274b73c04ba1f2c44c2b9 +enda339271c59d274b73c04ba1f2c44c2b9: ; return false } @@ -12823,12 +14430,112 @@ func rewriteValueAMD64_OpAMD64SHRQ(v *Value, config *Config) bool { } goto end699d35e2d5cfa08b8a3b1c8a183ddcf3 end699d35e2d5cfa08b8a3b1c8a183ddcf3: + ; + // match: (SHRQ x (MOVLconst [c])) + // cond: + // result: (SHRQconst [c&63] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVLconst { + goto end3189f4abaac8028d9191c9ba64124999 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SHRQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 63 + v.AddArg(x) + return true + } + goto end3189f4abaac8028d9191c9ba64124999 +end3189f4abaac8028d9191c9ba64124999: + ; + // match: (SHRQ x (MOVWconst [c])) + // cond: + // result: (SHRQconst [c&63] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVWconst { + goto end0cbc86ae04a355c0e2a96400242f4633 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SHRQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 63 + v.AddArg(x) + return true + } + goto end0cbc86ae04a355c0e2a96400242f4633 +end0cbc86ae04a355c0e2a96400242f4633: + ; + // match: (SHRQ x (MOVBconst [c])) + // cond: + // result: (SHRQconst [c&63] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVBconst { + goto endb9c003612674e7a1ea7c13e463c229d2 + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SHRQconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 63 + v.AddArg(x) + return true + } + goto endb9c003612674e7a1ea7c13e463c229d2 +endb9c003612674e7a1ea7c13e463c229d2: ; 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) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVQconst { + goto endc5c82eea9a6b51b1d6b76e57f21f46ff + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SHRWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 31 + v.AddArg(x) + return true + } + goto endc5c82eea9a6b51b1d6b76e57f21f46ff +endc5c82eea9a6b51b1d6b76e57f21f46ff: + ; + // match: (SHRW x (MOVLconst [c])) + // cond: + // result: (SHRWconst [c&31] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVLconst { + goto end773e94c857256ae9a31eb5b3d667e64b + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SHRWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 31 + v.AddArg(x) + return true + } + goto end773e94c857256ae9a31eb5b3d667e64b +end773e94c857256ae9a31eb5b3d667e64b: + ; // match: (SHRW x (MOVWconst [c])) // cond: // result: (SHRWconst [c&31] x) @@ -12848,6 +14555,26 @@ func rewriteValueAMD64_OpAMD64SHRW(v *Value, config *Config) bool { } goto endd75ff1f9b3e9ec9c942a39b6179da1b3 endd75ff1f9b3e9ec9c942a39b6179da1b3: + ; + // match: (SHRW x (MOVBconst [c])) + // cond: + // result: (SHRWconst [c&31] x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64MOVBconst { + goto end6761530cd742ad00057c19a6a3c38ada + } + c := v.Args[1].AuxInt + v.Op = OpAMD64SHRWconst + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c & 31 + v.AddArg(x) + return true + } + goto end6761530cd742ad00057c19a6a3c38ada +end6761530cd742ad00057c19a6a3c38ada: ; return false } -- cgit v1.3 From 25abe96214911fed68c5a66562bf524768e2a92a Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Sun, 31 Jan 2016 21:18:55 -0600 Subject: [dev.ssa] cmd/compile: regenerate code These changes were left out of the 1cc5789df9 commit. Change-Id: Id7f49973da281a567b69228dbaea31846b82b4af Reviewed-on: https://go-review.googlesource.com/19105 Reviewed-by: Brad Fitzpatrick Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/rewriteAMD64.go | 112 +++++++++++++-------------- 1 file changed, 56 insertions(+), 56 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 5ff0b0fe5f..5962794b88 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -2328,18 +2328,18 @@ endac1c49c82fb6b76dd324042c4588973c: goto end82aa9d89330cb5dc58592048bfc16ebc end82aa9d89330cb5dc58592048bfc16ebc: ; - // match: (CMPBconst [0] (ANDB x y)) + // match: (CMPBconst (ANDB x y) [0]) // cond: // result: (TESTB x y) { - if v.AuxInt != 0 { - goto end30c06897ce79b745c782650c71157f7b - } if v.Args[0].Op != OpAMD64ANDB { - goto end30c06897ce79b745c782650c71157f7b + goto endc1dd0adee6d97d0f2644600fa5247db5 } x := v.Args[0].Args[0] y := v.Args[0].Args[1] + if v.AuxInt != 0 { + goto endc1dd0adee6d97d0f2644600fa5247db5 + } v.Op = OpAMD64TESTB v.AuxInt = 0 v.Aux = nil @@ -2348,21 +2348,21 @@ end82aa9d89330cb5dc58592048bfc16ebc: v.AddArg(y) return true } - goto end30c06897ce79b745c782650c71157f7b -end30c06897ce79b745c782650c71157f7b: + goto endc1dd0adee6d97d0f2644600fa5247db5 +endc1dd0adee6d97d0f2644600fa5247db5: ; - // match: (CMPBconst [0] (ANDBconst [c] x)) + // match: (CMPBconst (ANDBconst [c] x) [0]) // cond: // result: (TESTBconst [c] x) { - if v.AuxInt != 0 { - goto endfc700b49578635afa44d447c3ef97859 - } if v.Args[0].Op != OpAMD64ANDBconst { - goto endfc700b49578635afa44d447c3ef97859 + goto end575fd7ac1086d0c37e6946db5bbc7e94 } c := v.Args[0].AuxInt x := v.Args[0].Args[0] + if v.AuxInt != 0 { + goto end575fd7ac1086d0c37e6946db5bbc7e94 + } v.Op = OpAMD64TESTBconst v.AuxInt = 0 v.Aux = nil @@ -2371,8 +2371,8 @@ end30c06897ce79b745c782650c71157f7b: v.AddArg(x) return true } - goto endfc700b49578635afa44d447c3ef97859 -endfc700b49578635afa44d447c3ef97859: + goto end575fd7ac1086d0c37e6946db5bbc7e94 +end575fd7ac1086d0c37e6946db5bbc7e94: ; return false } @@ -2553,18 +2553,18 @@ endc7b8e86e537d6e106e237023dc2c9a7b: goto endf202b9830a1e45f3888f2598c762c702 endf202b9830a1e45f3888f2598c762c702: ; - // match: (CMPLconst [0] (ANDL x y)) + // match: (CMPLconst (ANDL x y) [0]) // cond: // result: (TESTL x y) { - if v.AuxInt != 0 { - goto endb730012ce2555c10f2918eed023dd6f3 - } if v.Args[0].Op != OpAMD64ANDL { - goto endb730012ce2555c10f2918eed023dd6f3 + goto endc99c55b2fd4bbe4f6eba9675087f215d } x := v.Args[0].Args[0] y := v.Args[0].Args[1] + if v.AuxInt != 0 { + goto endc99c55b2fd4bbe4f6eba9675087f215d + } v.Op = OpAMD64TESTL v.AuxInt = 0 v.Aux = nil @@ -2573,21 +2573,21 @@ endf202b9830a1e45f3888f2598c762c702: v.AddArg(y) return true } - goto endb730012ce2555c10f2918eed023dd6f3 -endb730012ce2555c10f2918eed023dd6f3: + goto endc99c55b2fd4bbe4f6eba9675087f215d +endc99c55b2fd4bbe4f6eba9675087f215d: ; - // match: (CMPLconst [0] (ANDLconst [c] x)) + // match: (CMPLconst (ANDLconst [c] x) [0]) // cond: // result: (TESTLconst [c] x) { - if v.AuxInt != 0 { - goto enda56a89f365433eb9e15b0c9696ce5afb - } if v.Args[0].Op != OpAMD64ANDLconst { - goto enda56a89f365433eb9e15b0c9696ce5afb + goto end218077662043c7cfb0b92334ec8d691f } c := v.Args[0].AuxInt x := v.Args[0].Args[0] + if v.AuxInt != 0 { + goto end218077662043c7cfb0b92334ec8d691f + } v.Op = OpAMD64TESTLconst v.AuxInt = 0 v.Aux = nil @@ -2596,8 +2596,8 @@ endb730012ce2555c10f2918eed023dd6f3: v.AddArg(x) return true } - goto enda56a89f365433eb9e15b0c9696ce5afb -enda56a89f365433eb9e15b0c9696ce5afb: + goto end218077662043c7cfb0b92334ec8d691f +end218077662043c7cfb0b92334ec8d691f: ; return false } @@ -2784,18 +2784,18 @@ end1248b87e4a141c78bc8eff05d3fac70e: goto end934098fb12e383829b654938269abc12 end934098fb12e383829b654938269abc12: ; - // match: (CMPQconst [0] (ANDQ x y)) + // match: (CMPQconst (ANDQ x y) [0]) // cond: // result: (TESTQ x y) { - if v.AuxInt != 0 { - goto end9f63614ab4b6b51b299dcfacae096b23 - } if v.Args[0].Op != OpAMD64ANDQ { - goto end9f63614ab4b6b51b299dcfacae096b23 + goto endd253b271c624b83def50b061d8a945a1 } x := v.Args[0].Args[0] y := v.Args[0].Args[1] + if v.AuxInt != 0 { + goto endd253b271c624b83def50b061d8a945a1 + } v.Op = OpAMD64TESTQ v.AuxInt = 0 v.Aux = nil @@ -2804,21 +2804,21 @@ end934098fb12e383829b654938269abc12: v.AddArg(y) return true } - goto end9f63614ab4b6b51b299dcfacae096b23 -end9f63614ab4b6b51b299dcfacae096b23: + goto endd253b271c624b83def50b061d8a945a1 +endd253b271c624b83def50b061d8a945a1: ; - // match: (CMPQconst [0] (ANDQconst [c] x)) + // match: (CMPQconst (ANDQconst [c] x) [0]) // cond: // result: (TESTQconst [c] x) { - if v.AuxInt != 0 { - goto enda5aa8044be9d61e9e149558e9ec8ca83 - } if v.Args[0].Op != OpAMD64ANDQconst { - goto enda5aa8044be9d61e9e149558e9ec8ca83 + goto endcf00c5ad714d2152d72184b163c8d57c } c := v.Args[0].AuxInt x := v.Args[0].Args[0] + if v.AuxInt != 0 { + goto endcf00c5ad714d2152d72184b163c8d57c + } v.Op = OpAMD64TESTQconst v.AuxInt = 0 v.Aux = nil @@ -2827,8 +2827,8 @@ end9f63614ab4b6b51b299dcfacae096b23: v.AddArg(x) return true } - goto enda5aa8044be9d61e9e149558e9ec8ca83 -enda5aa8044be9d61e9e149558e9ec8ca83: + goto endcf00c5ad714d2152d72184b163c8d57c +endcf00c5ad714d2152d72184b163c8d57c: ; return false } @@ -3009,18 +3009,18 @@ end4493f5af38d242ebb4bc2f64055a0854: goto endfcea07d93ded49b0e02d5fa0059309a4 endfcea07d93ded49b0e02d5fa0059309a4: ; - // match: (CMPWconst [0] (ANDW x y)) + // match: (CMPWconst (ANDW x y) [0]) // cond: // result: (TESTW x y) { - if v.AuxInt != 0 { - goto endd9d4754c561a7bd11697a51d800f8eca - } if v.Args[0].Op != OpAMD64ANDW { - goto endd9d4754c561a7bd11697a51d800f8eca + goto end390cbc150fec59cbf63a209c485ef8b2 } x := v.Args[0].Args[0] y := v.Args[0].Args[1] + if v.AuxInt != 0 { + goto end390cbc150fec59cbf63a209c485ef8b2 + } v.Op = OpAMD64TESTW v.AuxInt = 0 v.Aux = nil @@ -3029,21 +3029,21 @@ endfcea07d93ded49b0e02d5fa0059309a4: v.AddArg(y) return true } - goto endd9d4754c561a7bd11697a51d800f8eca -endd9d4754c561a7bd11697a51d800f8eca: + goto end390cbc150fec59cbf63a209c485ef8b2 +end390cbc150fec59cbf63a209c485ef8b2: ; - // match: (CMPWconst [0] (ANDWconst [c] x)) + // match: (CMPWconst (ANDWconst [c] x) [0]) // cond: // result: (TESTWconst [c] x) { - if v.AuxInt != 0 { - goto endb532b10789c7ce4cedeb17af417ceb2b - } if v.Args[0].Op != OpAMD64ANDWconst { - goto endb532b10789c7ce4cedeb17af417ceb2b + goto end1bde0fea3dcffeb66b314bc6b4c9aae5 } c := v.Args[0].AuxInt x := v.Args[0].Args[0] + if v.AuxInt != 0 { + goto end1bde0fea3dcffeb66b314bc6b4c9aae5 + } v.Op = OpAMD64TESTWconst v.AuxInt = 0 v.Aux = nil @@ -3052,8 +3052,8 @@ endd9d4754c561a7bd11697a51d800f8eca: v.AddArg(x) return true } - goto endb532b10789c7ce4cedeb17af417ceb2b -endb532b10789c7ce4cedeb17af417ceb2b: + goto end1bde0fea3dcffeb66b314bc6b4c9aae5 +end1bde0fea3dcffeb66b314bc6b4c9aae5: ; return false } -- cgit v1.3 From c87a62f32bc5080c6656d3f80e2da8d5c63ed55b Mon Sep 17 00:00:00 2001 From: David Chase Date: Sat, 30 Jan 2016 17:37:38 -0500 Subject: [dev.ssa] cmd/compile: reducing alloc footprint of dominator calc Converted working slices of pointer into slices of pointer index. Half the size (on 64-bit machine) and no pointers to trace if GC occurs while they're live. TODO - could expose slice mapping ID->*Block; some dom clients also construct these. Minor optimization in regalloc that cuts allocation count. Minor optimization in compile.go that cuts calls to Sprintf. Change-Id: I28f0bfed422b7344af333dc52ea272441e28e463 Reviewed-on: https://go-review.googlesource.com/19104 Run-TryBot: Todd Neal TryBot-Result: Gobot Gobot Reviewed-by: Todd Neal --- src/cmd/compile/internal/ssa/compile.go | 31 +++++----- src/cmd/compile/internal/ssa/dom.go | 103 +++++++++++++++++-------------- src/cmd/compile/internal/ssa/regalloc.go | 3 + 3 files changed, 74 insertions(+), 63 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/compile.go b/src/cmd/compile/internal/ssa/compile.go index 99e3c2b01e..e602d8f5b3 100644 --- a/src/cmd/compile/internal/ssa/compile.go +++ b/src/cmd/compile/internal/ssa/compile.go @@ -57,25 +57,24 @@ func Compile(f *Func) { tStart := time.Now() p.fn(f) - tEnd := time.Now() - 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) - } + if f.Log() || f.Config.HTML != nil { + tEnd := time.Now() + + 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) + } - if f.Log() { f.Logf(" pass %s end %s\n", p.name, stats) - } - printFunc(f) - if f.Config.HTML != nil { + printFunc(f) f.Config.HTML.WriteFunc(fmt.Sprintf("after %s %s", phaseName, stats), f) } checkFunc(f) diff --git a/src/cmd/compile/internal/ssa/dom.go b/src/cmd/compile/internal/ssa/dom.go index 0d342d184e..50ff472ca3 100644 --- a/src/cmd/compile/internal/ssa/dom.go +++ b/src/cmd/compile/internal/ssa/dom.go @@ -59,21 +59,30 @@ type linkedBlocks func(*Block) []*Block // 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 dfs(entries []*Block, succFn linkedBlocks) (dfnum []int, order []*Block, parent []*Block) { +func dfs(entries []*Block, succFn linkedBlocks) (fromID []*Block, dfnum []int32, order []ID, parent []ID) { maxBlockID := entries[0].Func.NumBlocks() - dfnum = make([]int, maxBlockID) - order = make([]*Block, maxBlockID) - parent = make([]*Block, maxBlockID) + dfnum = make([]int32, maxBlockID) + order = make([]ID, maxBlockID) + parent = make([]ID, maxBlockID) + fromID = make([]*Block, maxBlockID) - n := 0 + for _, entry := range entries[0].Func.Blocks { + eid := entry.ID + if fromID[eid] != nil { + panic("Colliding entry IDs") + } + fromID[eid] = entry + } + + n := int32(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 + parent[entry.ID] = entry.ID for len(s) > 0 { node := s[len(s)-1] s = s[:len(s)-1] @@ -83,12 +92,12 @@ func dfs(entries []*Block, succFn linkedBlocks) (dfnum []int, order []*Block, pa // if it has a dfnum, we've already visited it if dfnum[w.ID] == notFound { s = append(s, w) - parent[w.ID] = node + parent[w.ID] = node.ID dfnum[w.ID] = notExplored } } dfnum[node.ID] = n - order[n] = node + order[n] = node.ID } } @@ -143,77 +152,77 @@ func dominatorsLT(entries []*Block, predFn linkedBlocks, succFn linkedBlocks) [] // 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. - dfnum, vertex, parent := dfs(entries, succFn) + fromID, dfnum, vertex, parent := dfs(entries, succFn) maxBlockID := entries[0].Func.NumBlocks() - semi := make([]*Block, maxBlockID) - samedom := make([]*Block, maxBlockID) + semi := make([]ID, maxBlockID) + samedom := make([]ID, maxBlockID) + ancestor := make([]ID, maxBlockID) + best := make([]ID, maxBlockID) + bucket := make([]ID, maxBlockID) idom := make([]*Block, maxBlockID) - ancestor := make([]*Block, maxBlockID) - best := make([]*Block, maxBlockID) - bucket := 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 == nil { + if w == 0 { continue } - if dfnum[w.ID] == notFound { + 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.ID]; v != nil; v = bucket[v.ID] { + for v := bucket[w]; v != 0; v = bucket[v] { u := eval(v, ancestor, semi, dfnum, best) - if semi[u.ID] == semi[v.ID] { - idom[v.ID] = w // true dominator + if semi[u] == semi[v] { + idom[v] = fromID[w] // true dominator } else { - samedom[v.ID] = u // v has same dominator as u + samedom[v] = u // v has same dominator as u } } - p := parent[w.ID] + p := parent[w] s := p // semidominator - var sp *Block + var sp ID // calculate the semidominator of w - for _, v := range w.Preds { + for _, v := range predFn(fromID[w]) { if dfnum[v.ID] == notFound { // skip unreachable predecessor continue } - if dfnum[v.ID] <= dfnum[w.ID] { - sp = v + if dfnum[v.ID] <= dfnum[w] { + sp = v.ID } else { - sp = semi[eval(v, ancestor, semi, dfnum, best).ID] + sp = semi[eval(v.ID, ancestor, semi, dfnum, best)] } - if dfnum[sp.ID] < dfnum[s.ID] { + if dfnum[sp] < dfnum[s] { s = sp } } // link - ancestor[w.ID] = p - best[w.ID] = w + ancestor[w] = p + best[w] = w - semi[w.ID] = s - if semi[s.ID] != parent[s.ID] { - bucket[w.ID] = bucket[s.ID] - bucket[s.ID] = 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 != nil; v = bucket[v.ID] { - idom[v.ID] = bucket[0] + for v := bucket[0]; v != 0; v = bucket[v] { + idom[v] = fromID[bucket[0]] } // Step 4. Explictly define the immediate dominator of each vertex, @@ -221,28 +230,28 @@ func dominatorsLT(entries []*Block, predFn linkedBlocks, succFn linkedBlocks) [] // number. for i := 1; i < maxBlockID-1; i++ { w := vertex[i] - if w == nil { + if w == 0 { continue } - // w has the same dominator as samedom[w.ID] - if samedom[w.ID] != nil { - idom[w.ID] = idom[samedom[w.ID].ID] + // 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 *Block, ancestor []*Block, semi []*Block, dfnum []int, best []*Block) *Block { - a := ancestor[v.ID] - if ancestor[a.ID] != nil { - b := eval(a, ancestor, semi, dfnum, best) - ancestor[v.ID] = ancestor[a.ID] - if dfnum[semi[b.ID].ID] < dfnum[semi[best[v.ID].ID].ID] { - best[v.ID] = b +func eval(v ID, ancestor []ID, semi []ID, dfnum []int32, 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.ID] + return best[v] } // dominators computes the dominator tree for f. It returns a slice diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index 2d88850999..e1f8dd1935 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -1624,6 +1624,9 @@ func (s *regAllocState) computeLive() { } // The live set has changed, update it. l := s.live[p.ID][:0] + if cap(l) == 0 { + l = make([]liveInfo, 0, len(t.contents())) + } for _, e := range t.contents() { l = append(l, liveInfo{e.key, e.val}) } -- cgit v1.3 From 16b1fce9217886797940247f6ffce57e119c3e47 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Sun, 31 Jan 2016 11:39:39 -0800 Subject: [dev.ssa] cmd/compile: add aux typing, flags to ops Add the aux type to opcodes. Add rematerializeable as a flag. Change-Id: I906e19281498f3ee51bb136299bf26e13a54b2ec Reviewed-on: https://go-review.googlesource.com/19088 Run-TryBot: Keith Randall TryBot-Result: Gobot Gobot Reviewed-by: Todd Neal --- src/cmd/compile/internal/gc/ssa.go | 8 +- src/cmd/compile/internal/ssa/check.go | 24 +- src/cmd/compile/internal/ssa/deadcode_test.go | 8 +- src/cmd/compile/internal/ssa/deadstore_test.go | 6 +- src/cmd/compile/internal/ssa/dom_test.go | 26 +- src/cmd/compile/internal/ssa/func_test.go | 34 +- src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 308 ++++++------- src/cmd/compile/internal/ssa/gen/genericOps.go | 80 ++-- src/cmd/compile/internal/ssa/gen/main.go | 21 +- src/cmd/compile/internal/ssa/nilcheck_test.go | 20 +- src/cmd/compile/internal/ssa/op.go | 26 +- src/cmd/compile/internal/ssa/opGen.go | 509 ++++++++++++++-------- src/cmd/compile/internal/ssa/passbm_test.go | 2 +- src/cmd/compile/internal/ssa/regalloc.go | 27 +- src/cmd/compile/internal/ssa/regalloc_test.go | 6 +- src/cmd/compile/internal/ssa/schedule_test.go | 2 +- src/cmd/compile/internal/ssa/shift_test.go | 2 +- src/cmd/compile/internal/ssa/shortcircuit_test.go | 2 +- src/cmd/compile/internal/ssa/value.go | 72 ++- 19 files changed, 696 insertions(+), 487 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 458bccb8dc..59993c23dd 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -4022,11 +4022,11 @@ func (s *genState) genValue(v *ssa.Value) { var i int64 switch v.Op { case ssa.OpAMD64MOVBconst: - i = int64(int8(v.AuxInt)) + i = int64(v.AuxInt8()) case ssa.OpAMD64MOVWconst: - i = int64(int16(v.AuxInt)) + i = int64(v.AuxInt16()) case ssa.OpAMD64MOVLconst: - i = int64(int32(v.AuxInt)) + i = int64(v.AuxInt32()) case ssa.OpAMD64MOVQconst: i = v.AuxInt } @@ -4116,7 +4116,7 @@ func (s *genState) genValue(v *ssa.Value) { case ssa.OpAMD64MOVQstoreconst, ssa.OpAMD64MOVLstoreconst, ssa.OpAMD64MOVWstoreconst, ssa.OpAMD64MOVBstoreconst: p := Prog(v.Op.Asm()) p.From.Type = obj.TYPE_CONST - sc := ssa.ValAndOff(v.AuxInt) + sc := v.AuxValAndOff() i := sc.Val() switch v.Op { case ssa.OpAMD64MOVBstoreconst: diff --git a/src/cmd/compile/internal/ssa/check.go b/src/cmd/compile/internal/ssa/check.go index 1c36160f8f..220877242c 100644 --- a/src/cmd/compile/internal/ssa/check.go +++ b/src/cmd/compile/internal/ssa/check.go @@ -148,9 +148,27 @@ func checkFunc(f *Func) { } for _, v := range b.Values { - switch v.Aux.(type) { - case bool, float32, float64: - f.Fatalf("value %v has an Aux value of type %T, should be AuxInt", v.LongString(), v.Aux) + + // 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 { diff --git a/src/cmd/compile/internal/ssa/deadcode_test.go b/src/cmd/compile/internal/ssa/deadcode_test.go index c59d77ea60..24934d5ac4 100644 --- a/src/cmd/compile/internal/ssa/deadcode_test.go +++ b/src/cmd/compile/internal/ssa/deadcode_test.go @@ -10,7 +10,7 @@ func TestDeadLoop(t *testing.T) { c := testConfig(t) fun := Fun(c, "entry", Bloc("entry", - Valu("mem", OpInitMem, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, nil), Goto("exit")), Bloc("exit", Exit("mem")), @@ -40,7 +40,7 @@ func TestDeadValue(t *testing.T) { c := testConfig(t) fun := Fun(c, "entry", Bloc("entry", - Valu("mem", OpInitMem, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, nil), Valu("deadval", OpConst64, TypeInt64, 37, nil), Goto("exit")), Bloc("exit", @@ -64,7 +64,7 @@ func TestNeverTaken(t *testing.T) { fun := Fun(c, "entry", Bloc("entry", Valu("cond", OpConstBool, TypeBool, 0, nil), - Valu("mem", OpInitMem, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, nil), If("cond", "then", "else")), Bloc("then", Goto("exit")), @@ -98,7 +98,7 @@ func TestNestedDeadBlocks(t *testing.T) { c := testConfig(t) fun := Fun(c, "entry", Bloc("entry", - Valu("mem", OpInitMem, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, nil), Valu("cond", OpConstBool, TypeBool, 0, nil), If("cond", "b2", "b4")), Bloc("b2", diff --git a/src/cmd/compile/internal/ssa/deadstore_test.go b/src/cmd/compile/internal/ssa/deadstore_test.go index 4514c99004..9ded8bd6e6 100644 --- a/src/cmd/compile/internal/ssa/deadstore_test.go +++ b/src/cmd/compile/internal/ssa/deadstore_test.go @@ -12,7 +12,7 @@ func TestDeadStore(t *testing.T) { ptrType := &TypeImpl{Size_: 8, Ptr: true, Name: "testptr", Elem_: elemType} // dummy for testing fun := Fun(c, "entry", Bloc("entry", - Valu("start", OpInitMem, TypeMem, 0, ".mem"), + 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"), @@ -47,7 +47,7 @@ func TestDeadStorePhi(t *testing.T) { ptrType := &TypeImpl{Size_: 8, Ptr: true, Name: "testptr"} // dummy for testing fun := Fun(c, "entry", Bloc("entry", - Valu("start", OpInitMem, TypeMem, 0, ".mem"), + 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"), @@ -74,7 +74,7 @@ func TestDeadStoreTypes(t *testing.T) { t2 := &TypeImpl{Size_: 4, Ptr: true, Name: "t2"} fun := Fun(c, "entry", Bloc("entry", - Valu("start", OpInitMem, TypeMem, 0, ".mem"), + 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"), diff --git a/src/cmd/compile/internal/ssa/dom_test.go b/src/cmd/compile/internal/ssa/dom_test.go index 7174f10e4d..0328655b6a 100644 --- a/src/cmd/compile/internal/ssa/dom_test.go +++ b/src/cmd/compile/internal/ssa/dom_test.go @@ -20,7 +20,7 @@ func genLinear(size int) []bloc { var blocs []bloc blocs = append(blocs, Bloc("entry", - Valu("mem", OpInitMem, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, nil), Goto(blockn(0)), ), ) @@ -43,7 +43,7 @@ func genFwdBack(size int) []bloc { var blocs []bloc blocs = append(blocs, Bloc("entry", - Valu("mem", OpInitMem, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, nil), Valu("p", OpConstBool, TypeBool, 1, nil), Goto(blockn(0)), ), @@ -73,7 +73,7 @@ func genManyPred(size int) []bloc { var blocs []bloc blocs = append(blocs, Bloc("entry", - Valu("mem", OpInitMem, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, nil), Valu("p", OpConstBool, TypeBool, 1, nil), Goto(blockn(0)), ), @@ -111,7 +111,7 @@ func genMaxPred(size int) []bloc { var blocs []bloc blocs = append(blocs, Bloc("entry", - Valu("mem", OpInitMem, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, nil), Valu("p", OpConstBool, TypeBool, 1, nil), Goto(blockn(0)), ), @@ -136,7 +136,7 @@ func genMaxPredValue(size int) []bloc { var blocs []bloc blocs = append(blocs, Bloc("entry", - Valu("mem", OpInitMem, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, nil), Valu("p", OpConstBool, TypeBool, 1, nil), Goto(blockn(0)), ), @@ -223,7 +223,7 @@ func TestDominatorsSingleBlock(t *testing.T) { c := testConfig(t) fun := Fun(c, "entry", Bloc("entry", - Valu("mem", OpInitMem, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, nil), Exit("mem"))) doms := map[string]string{} @@ -238,7 +238,7 @@ func TestDominatorsSimple(t *testing.T) { c := testConfig(t) fun := Fun(c, "entry", Bloc("entry", - Valu("mem", OpInitMem, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, nil), Goto("a")), Bloc("a", Goto("b")), @@ -266,7 +266,7 @@ func TestDominatorsMultPredFwd(t *testing.T) { c := testConfig(t) fun := Fun(c, "entry", Bloc("entry", - Valu("mem", OpInitMem, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, nil), Valu("p", OpConstBool, TypeBool, 1, nil), If("p", "a", "c")), Bloc("a", @@ -294,7 +294,7 @@ func TestDominatorsDeadCode(t *testing.T) { c := testConfig(t) fun := Fun(c, "entry", Bloc("entry", - Valu("mem", OpInitMem, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, nil), Valu("p", OpConstBool, TypeBool, 0, nil), If("p", "b3", "b5")), Bloc("b2", Exit("mem")), @@ -319,7 +319,7 @@ func TestDominatorsMultPredRev(t *testing.T) { Bloc("entry", Goto("first")), Bloc("first", - Valu("mem", OpInitMem, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, nil), Valu("p", OpConstBool, TypeBool, 1, nil), Goto("a")), Bloc("a", @@ -348,7 +348,7 @@ func TestDominatorsMultPred(t *testing.T) { c := testConfig(t) fun := Fun(c, "entry", Bloc("entry", - Valu("mem", OpInitMem, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, nil), Valu("p", OpConstBool, TypeBool, 1, nil), If("p", "a", "c")), Bloc("a", @@ -376,7 +376,7 @@ func TestPostDominators(t *testing.T) { c := testConfig(t) fun := Fun(c, "entry", Bloc("entry", - Valu("mem", OpInitMem, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, nil), Valu("p", OpConstBool, TypeBool, 1, nil), If("p", "a", "c")), Bloc("a", @@ -403,7 +403,7 @@ func TestInfiniteLoop(t *testing.T) { // note lack of an exit block fun := Fun(c, "entry", Bloc("entry", - Valu("mem", OpInitMem, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, nil), Valu("p", OpConstBool, TypeBool, 1, nil), Goto("a")), Bloc("a", diff --git a/src/cmd/compile/internal/ssa/func_test.go b/src/cmd/compile/internal/ssa/func_test.go index 590804182a..53213d2c11 100644 --- a/src/cmd/compile/internal/ssa/func_test.go +++ b/src/cmd/compile/internal/ssa/func_test.go @@ -6,7 +6,7 @@ // As an example, the following func // // b1: -// v1 = Arg [.mem] +// v1 = InitMem // Plain -> b2 // b2: // Exit v1 @@ -18,7 +18,7 @@ // // fun := Fun("entry", // Bloc("entry", -// Valu("mem", OpInitMem, TypeMem, 0, ".mem"), +// Valu("mem", OpInitMem, TypeMem, 0, nil), // Goto("exit")), // Bloc("exit", // Exit("mem")), @@ -267,7 +267,7 @@ func TestArgs(t *testing.T) { 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, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, nil), Goto("exit")), Bloc("exit", Exit("mem"))) @@ -289,7 +289,7 @@ func TestEquiv(t *testing.T) { 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, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, nil), Goto("exit")), Bloc("exit", Exit("mem"))), @@ -298,7 +298,7 @@ func TestEquiv(t *testing.T) { 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, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, nil), Goto("exit")), Bloc("exit", Exit("mem"))), @@ -310,7 +310,7 @@ func TestEquiv(t *testing.T) { 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, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, nil), Goto("exit")), Bloc("exit", Exit("mem"))), @@ -321,7 +321,7 @@ func TestEquiv(t *testing.T) { 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, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, nil), Goto("exit"))), }, } @@ -338,26 +338,26 @@ func TestEquiv(t *testing.T) { { Fun(testConfig(t), "entry", Bloc("entry", - Valu("mem", OpInitMem, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, nil), Goto("exit")), Bloc("exit", Exit("mem"))), Fun(testConfig(t), "entry", Bloc("entry", - Valu("mem", OpInitMem, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, nil), Exit("mem"))), }, // value order changed { Fun(testConfig(t), "entry", Bloc("entry", - Valu("mem", OpInitMem, TypeMem, 0, ".mem"), + 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, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, nil), Valu("a", OpConst64, TypeInt64, 14, nil), Valu("b", OpConst64, TypeInt64, 26, nil), Exit("mem"))), @@ -366,12 +366,12 @@ func TestEquiv(t *testing.T) { { Fun(testConfig(t), "entry", Bloc("entry", - Valu("mem", OpInitMem, TypeMem, 0, ".mem"), + 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, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, nil), Valu("a", OpConst64, TypeInt64, 26, nil), Exit("mem"))), }, @@ -379,12 +379,12 @@ func TestEquiv(t *testing.T) { { Fun(testConfig(t), "entry", Bloc("entry", - Valu("mem", OpInitMem, TypeMem, 0, ".mem"), + 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, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, nil), Valu("a", OpConst64, TypeInt64, 0, 26), Exit("mem"))), }, @@ -392,14 +392,14 @@ func TestEquiv(t *testing.T) { { Fun(testConfig(t), "entry", Bloc("entry", - Valu("mem", OpInitMem, TypeMem, 0, ".mem"), + 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, ".mem"), + 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"), diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 10c5d2b227..1cf44f148f 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -152,45 +152,45 @@ func init() { {name: "DIVSS", reg: fp21x15, asm: "DIVSS"}, // fp32 div {name: "DIVSD", reg: fp21x15, asm: "DIVSD"}, // fp64 div - {name: "MOVSSload", reg: fpload, asm: "MOVSS"}, // fp32 load - {name: "MOVSDload", reg: fpload, asm: "MOVSD"}, // fp64 load - {name: "MOVSSconst", reg: fp01, asm: "MOVSS"}, // fp32 constant - {name: "MOVSDconst", reg: fp01, asm: "MOVSD"}, // fp64 constant - {name: "MOVSSloadidx4", reg: fploadidx, asm: "MOVSS"}, // fp32 load - {name: "MOVSDloadidx8", reg: fploadidx, asm: "MOVSD"}, // fp64 load - - {name: "MOVSSstore", reg: fpstore, asm: "MOVSS"}, // fp32 store - {name: "MOVSDstore", reg: fpstore, asm: "MOVSD"}, // fp64 store - {name: "MOVSSstoreidx4", reg: fpstoreidx, asm: "MOVSS"}, // fp32 indexed by 4i store - {name: "MOVSDstoreidx8", reg: fpstoreidx, asm: "MOVSD"}, // fp64 indexed by 8i store + {name: "MOVSSload", reg: fpload, asm: "MOVSS", aux: "SymOff"}, // fp32 load + {name: "MOVSDload", 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", reg: fploadidx, asm: "MOVSS", aux: "SymOff"}, // fp32 load + {name: "MOVSDloadidx8", reg: fploadidx, asm: "MOVSD", aux: "SymOff"}, // fp64 load + + {name: "MOVSSstore", reg: fpstore, asm: "MOVSS", aux: "SymOff"}, // fp32 store + {name: "MOVSDstore", reg: fpstore, asm: "MOVSD", aux: "SymOff"}, // fp64 store + {name: "MOVSSstoreidx4", reg: fpstoreidx, asm: "MOVSS", aux: "SymOff"}, // fp32 indexed by 4i store + {name: "MOVSDstoreidx8", reg: fpstoreidx, asm: "MOVSD", aux: "SymOff"}, // fp64 indexed by 8i store // binary ops - {name: "ADDQ", reg: gp21, asm: "ADDQ"}, // arg0 + arg1 - {name: "ADDL", reg: gp21, asm: "ADDL"}, // arg0 + arg1 - {name: "ADDW", reg: gp21, asm: "ADDW"}, // arg0 + arg1 - {name: "ADDB", reg: gp21, asm: "ADDB"}, // arg0 + arg1 - {name: "ADDQconst", reg: gp11, asm: "ADDQ", typ: "UInt64"}, // arg0 + auxint - {name: "ADDLconst", reg: gp11, asm: "ADDL"}, // arg0 + auxint - {name: "ADDWconst", reg: gp11, asm: "ADDW"}, // arg0 + auxint - {name: "ADDBconst", reg: gp11, asm: "ADDB"}, // arg0 + auxint - - {name: "SUBQ", reg: gp21, asm: "SUBQ"}, // arg0 - arg1 - {name: "SUBL", reg: gp21, asm: "SUBL"}, // arg0 - arg1 - {name: "SUBW", reg: gp21, asm: "SUBW"}, // arg0 - arg1 - {name: "SUBB", reg: gp21, asm: "SUBB"}, // arg0 - arg1 - {name: "SUBQconst", reg: gp11, asm: "SUBQ"}, // arg0 - auxint - {name: "SUBLconst", reg: gp11, asm: "SUBL"}, // arg0 - auxint - {name: "SUBWconst", reg: gp11, asm: "SUBW"}, // arg0 - auxint - {name: "SUBBconst", reg: gp11, asm: "SUBB"}, // arg0 - auxint - - {name: "MULQ", reg: gp21, asm: "IMULQ"}, // arg0 * arg1 - {name: "MULL", reg: gp21, asm: "IMULL"}, // arg0 * arg1 - {name: "MULW", reg: gp21, asm: "IMULW"}, // arg0 * arg1 - {name: "MULB", reg: gp21, asm: "IMULW"}, // arg0 * arg1 - {name: "MULQconst", reg: gp11, asm: "IMULQ"}, // arg0 * auxint - {name: "MULLconst", reg: gp11, asm: "IMULL"}, // arg0 * auxint - {name: "MULWconst", reg: gp11, asm: "IMULW"}, // arg0 * auxint - {name: "MULBconst", reg: gp11, asm: "IMULW"}, // arg0 * auxint + {name: "ADDQ", reg: gp21, asm: "ADDQ"}, // arg0 + arg1 + {name: "ADDL", reg: gp21, asm: "ADDL"}, // arg0 + arg1 + {name: "ADDW", reg: gp21, asm: "ADDW"}, // arg0 + arg1 + {name: "ADDB", reg: gp21, asm: "ADDB"}, // arg0 + arg1 + {name: "ADDQconst", reg: gp11, asm: "ADDQ", aux: "Int64", typ: "UInt64"}, // arg0 + auxint + {name: "ADDLconst", reg: gp11, asm: "ADDL", aux: "Int32"}, // arg0 + auxint + {name: "ADDWconst", reg: gp11, asm: "ADDW", aux: "Int16"}, // arg0 + auxint + {name: "ADDBconst", reg: gp11, asm: "ADDB", aux: "Int8"}, // arg0 + auxint + + {name: "SUBQ", reg: gp21, asm: "SUBQ"}, // arg0 - arg1 + {name: "SUBL", reg: gp21, asm: "SUBL"}, // arg0 - arg1 + {name: "SUBW", reg: gp21, asm: "SUBW"}, // arg0 - arg1 + {name: "SUBB", reg: gp21, asm: "SUBB"}, // arg0 - arg1 + {name: "SUBQconst", reg: gp11, asm: "SUBQ", aux: "Int64"}, // arg0 - auxint + {name: "SUBLconst", reg: gp11, asm: "SUBL", aux: "Int32"}, // arg0 - auxint + {name: "SUBWconst", reg: gp11, asm: "SUBW", aux: "Int16"}, // arg0 - auxint + {name: "SUBBconst", reg: gp11, asm: "SUBB", aux: "Int8"}, // arg0 - auxint + + {name: "MULQ", reg: gp21, asm: "IMULQ"}, // arg0 * arg1 + {name: "MULL", reg: gp21, asm: "IMULL"}, // arg0 * arg1 + {name: "MULW", reg: gp21, asm: "IMULW"}, // arg0 * arg1 + {name: "MULB", reg: gp21, asm: "IMULW"}, // arg0 * arg1 + {name: "MULQconst", reg: gp11, asm: "IMULQ", aux: "Int64"}, // arg0 * auxint + {name: "MULLconst", reg: gp11, asm: "IMULL", aux: "Int32"}, // arg0 * auxint + {name: "MULWconst", reg: gp11, asm: "IMULW", aux: "Int16"}, // arg0 * auxint + {name: "MULBconst", reg: gp11, asm: "IMULW", aux: "Int8"}, // arg0 * auxint {name: "HMULL", reg: gp11hmul, asm: "IMULL"}, // (arg0 * arg1) >> width {name: "HMULW", reg: gp11hmul, asm: "IMULW"}, // (arg0 * arg1) >> width @@ -213,86 +213,86 @@ func init() { {name: "MODLU", reg: gp11mod, asm: "DIVL"}, // arg0 % arg1 {name: "MODWU", reg: gp11mod, asm: "DIVW"}, // arg0 % arg1 - {name: "ANDQ", reg: gp21, asm: "ANDQ"}, // arg0 & arg1 - {name: "ANDL", reg: gp21, asm: "ANDL"}, // arg0 & arg1 - {name: "ANDW", reg: gp21, asm: "ANDW"}, // arg0 & arg1 - {name: "ANDB", reg: gp21, asm: "ANDB"}, // arg0 & arg1 - {name: "ANDQconst", reg: gp11, asm: "ANDQ"}, // arg0 & auxint - {name: "ANDLconst", reg: gp11, asm: "ANDL"}, // arg0 & auxint - {name: "ANDWconst", reg: gp11, asm: "ANDW"}, // arg0 & auxint - {name: "ANDBconst", reg: gp11, asm: "ANDB"}, // arg0 & auxint - - {name: "ORQ", reg: gp21, asm: "ORQ"}, // arg0 | arg1 - {name: "ORL", reg: gp21, asm: "ORL"}, // arg0 | arg1 - {name: "ORW", reg: gp21, asm: "ORW"}, // arg0 | arg1 - {name: "ORB", reg: gp21, asm: "ORB"}, // arg0 | arg1 - {name: "ORQconst", reg: gp11, asm: "ORQ"}, // arg0 | auxint - {name: "ORLconst", reg: gp11, asm: "ORL"}, // arg0 | auxint - {name: "ORWconst", reg: gp11, asm: "ORW"}, // arg0 | auxint - {name: "ORBconst", reg: gp11, asm: "ORB"}, // arg0 | auxint - - {name: "XORQ", reg: gp21, asm: "XORQ"}, // arg0 ^ arg1 - {name: "XORL", reg: gp21, asm: "XORL"}, // arg0 ^ arg1 - {name: "XORW", reg: gp21, asm: "XORW"}, // arg0 ^ arg1 - {name: "XORB", reg: gp21, asm: "XORB"}, // arg0 ^ arg1 - {name: "XORQconst", reg: gp11, asm: "XORQ"}, // arg0 ^ auxint - {name: "XORLconst", reg: gp11, asm: "XORL"}, // arg0 ^ auxint - {name: "XORWconst", reg: gp11, asm: "XORW"}, // arg0 ^ auxint - {name: "XORBconst", reg: gp11, asm: "XORB"}, // arg0 ^ auxint - - {name: "CMPQ", reg: gp2flags, asm: "CMPQ", typ: "Flags"}, // arg0 compare to arg1 - {name: "CMPL", reg: gp2flags, asm: "CMPL", typ: "Flags"}, // arg0 compare to arg1 - {name: "CMPW", reg: gp2flags, asm: "CMPW", typ: "Flags"}, // arg0 compare to arg1 - {name: "CMPB", reg: gp2flags, asm: "CMPB", typ: "Flags"}, // arg0 compare to arg1 - {name: "CMPQconst", reg: gp1flags, asm: "CMPQ", typ: "Flags"}, // arg0 compare to auxint - {name: "CMPLconst", reg: gp1flags, asm: "CMPL", typ: "Flags"}, // arg0 compare to auxint - {name: "CMPWconst", reg: gp1flags, asm: "CMPW", typ: "Flags"}, // arg0 compare to auxint - {name: "CMPBconst", reg: gp1flags, asm: "CMPB", typ: "Flags"}, // arg0 compare to auxint + {name: "ANDQ", reg: gp21, asm: "ANDQ"}, // arg0 & arg1 + {name: "ANDL", reg: gp21, asm: "ANDL"}, // arg0 & arg1 + {name: "ANDW", reg: gp21, asm: "ANDW"}, // arg0 & arg1 + {name: "ANDB", reg: gp21, asm: "ANDB"}, // arg0 & arg1 + {name: "ANDQconst", reg: gp11, asm: "ANDQ", aux: "Int64"}, // arg0 & auxint + {name: "ANDLconst", reg: gp11, asm: "ANDL", aux: "Int32"}, // arg0 & auxint + {name: "ANDWconst", reg: gp11, asm: "ANDW", aux: "Int16"}, // arg0 & auxint + {name: "ANDBconst", reg: gp11, asm: "ANDB", aux: "Int8"}, // arg0 & auxint + + {name: "ORQ", reg: gp21, asm: "ORQ"}, // arg0 | arg1 + {name: "ORL", reg: gp21, asm: "ORL"}, // arg0 | arg1 + {name: "ORW", reg: gp21, asm: "ORW"}, // arg0 | arg1 + {name: "ORB", reg: gp21, asm: "ORB"}, // arg0 | arg1 + {name: "ORQconst", reg: gp11, asm: "ORQ", aux: "Int64"}, // arg0 | auxint + {name: "ORLconst", reg: gp11, asm: "ORL", aux: "Int32"}, // arg0 | auxint + {name: "ORWconst", reg: gp11, asm: "ORW", aux: "Int16"}, // arg0 | auxint + {name: "ORBconst", reg: gp11, asm: "ORB", aux: "Int8"}, // arg0 | auxint + + {name: "XORQ", reg: gp21, asm: "XORQ"}, // arg0 ^ arg1 + {name: "XORL", reg: gp21, asm: "XORL"}, // arg0 ^ arg1 + {name: "XORW", reg: gp21, asm: "XORW"}, // arg0 ^ arg1 + {name: "XORB", reg: gp21, asm: "XORB"}, // arg0 ^ arg1 + {name: "XORQconst", reg: gp11, asm: "XORQ", aux: "Int64"}, // arg0 ^ auxint + {name: "XORLconst", reg: gp11, asm: "XORL", aux: "Int32"}, // arg0 ^ auxint + {name: "XORWconst", reg: gp11, asm: "XORW", aux: "Int16"}, // arg0 ^ auxint + {name: "XORBconst", reg: gp11, asm: "XORB", aux: "Int8"}, // arg0 ^ auxint + + {name: "CMPQ", reg: gp2flags, asm: "CMPQ", typ: "Flags"}, // arg0 compare to arg1 + {name: "CMPL", reg: gp2flags, asm: "CMPL", typ: "Flags"}, // arg0 compare to arg1 + {name: "CMPW", reg: gp2flags, asm: "CMPW", typ: "Flags"}, // arg0 compare to arg1 + {name: "CMPB", reg: gp2flags, asm: "CMPB", typ: "Flags"}, // arg0 compare to arg1 + {name: "CMPQconst", reg: gp1flags, asm: "CMPQ", typ: "Flags", aux: "Int64"}, // arg0 compare to auxint + {name: "CMPLconst", reg: gp1flags, asm: "CMPL", typ: "Flags", aux: "Int32"}, // arg0 compare to auxint + {name: "CMPWconst", reg: gp1flags, asm: "CMPW", typ: "Flags", aux: "Int16"}, // arg0 compare to auxint + {name: "CMPBconst", reg: gp1flags, asm: "CMPB", typ: "Flags", aux: "Int8"}, // arg0 compare to auxint {name: "UCOMISS", reg: fp2flags, asm: "UCOMISS", typ: "Flags"}, // arg0 compare to arg1, f32 {name: "UCOMISD", reg: fp2flags, asm: "UCOMISD", typ: "Flags"}, // arg0 compare to arg1, f64 - {name: "TESTQ", reg: gp2flags, asm: "TESTQ", typ: "Flags"}, // (arg0 & arg1) compare to 0 - {name: "TESTL", reg: gp2flags, asm: "TESTL", typ: "Flags"}, // (arg0 & arg1) compare to 0 - {name: "TESTW", reg: gp2flags, asm: "TESTW", typ: "Flags"}, // (arg0 & arg1) compare to 0 - {name: "TESTB", reg: gp2flags, asm: "TESTB", typ: "Flags"}, // (arg0 & arg1) compare to 0 - {name: "TESTQconst", reg: gp1flags, asm: "TESTQ", typ: "Flags"}, // (arg0 & auxint) compare to 0 - {name: "TESTLconst", reg: gp1flags, asm: "TESTL", typ: "Flags"}, // (arg0 & auxint) compare to 0 - {name: "TESTWconst", reg: gp1flags, asm: "TESTW", typ: "Flags"}, // (arg0 & auxint) compare to 0 - {name: "TESTBconst", reg: gp1flags, asm: "TESTB", typ: "Flags"}, // (arg0 & auxint) compare to 0 - - {name: "SHLQ", reg: gp21shift, asm: "SHLQ"}, // arg0 << arg1, shift amount is mod 64 - {name: "SHLL", reg: gp21shift, asm: "SHLL"}, // arg0 << arg1, shift amount is mod 32 - {name: "SHLW", reg: gp21shift, asm: "SHLW"}, // arg0 << arg1, shift amount is mod 32 - {name: "SHLB", reg: gp21shift, asm: "SHLB"}, // arg0 << arg1, shift amount is mod 32 - {name: "SHLQconst", reg: gp11, asm: "SHLQ"}, // arg0 << auxint, shift amount 0-63 - {name: "SHLLconst", reg: gp11, asm: "SHLL"}, // arg0 << auxint, shift amount 0-31 - {name: "SHLWconst", reg: gp11, asm: "SHLW"}, // arg0 << auxint, shift amount 0-31 - {name: "SHLBconst", reg: gp11, asm: "SHLB"}, // arg0 << auxint, shift amount 0-31 + {name: "TESTQ", reg: gp2flags, asm: "TESTQ", typ: "Flags"}, // (arg0 & arg1) compare to 0 + {name: "TESTL", reg: gp2flags, asm: "TESTL", typ: "Flags"}, // (arg0 & arg1) compare to 0 + {name: "TESTW", reg: gp2flags, asm: "TESTW", typ: "Flags"}, // (arg0 & arg1) compare to 0 + {name: "TESTB", reg: gp2flags, asm: "TESTB", typ: "Flags"}, // (arg0 & arg1) compare to 0 + {name: "TESTQconst", reg: gp1flags, asm: "TESTQ", typ: "Flags", aux: "Int64"}, // (arg0 & auxint) compare to 0 + {name: "TESTLconst", reg: gp1flags, asm: "TESTL", typ: "Flags", aux: "Int32"}, // (arg0 & auxint) compare to 0 + {name: "TESTWconst", reg: gp1flags, asm: "TESTW", typ: "Flags", aux: "Int16"}, // (arg0 & auxint) compare to 0 + {name: "TESTBconst", reg: gp1flags, asm: "TESTB", typ: "Flags", aux: "Int8"}, // (arg0 & auxint) compare to 0 + + {name: "SHLQ", reg: gp21shift, asm: "SHLQ"}, // arg0 << arg1, shift amount is mod 64 + {name: "SHLL", reg: gp21shift, asm: "SHLL"}, // arg0 << arg1, shift amount is mod 32 + {name: "SHLW", reg: gp21shift, asm: "SHLW"}, // arg0 << arg1, shift amount is mod 32 + {name: "SHLB", reg: gp21shift, asm: "SHLB"}, // arg0 << arg1, shift amount is mod 32 + {name: "SHLQconst", reg: gp11, asm: "SHLQ", aux: "Int64"}, // arg0 << auxint, shift amount 0-63 + {name: "SHLLconst", reg: gp11, asm: "SHLL", aux: "Int32"}, // arg0 << auxint, shift amount 0-31 + {name: "SHLWconst", reg: gp11, asm: "SHLW", aux: "Int16"}, // arg0 << auxint, shift amount 0-31 + {name: "SHLBconst", reg: gp11, asm: "SHLB", 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", reg: gp21shift, asm: "SHRQ"}, // unsigned arg0 >> arg1, shift amount is mod 64 - {name: "SHRL", reg: gp21shift, asm: "SHRL"}, // unsigned arg0 >> arg1, shift amount is mod 32 - {name: "SHRW", reg: gp21shift, asm: "SHRW"}, // unsigned arg0 >> arg1, shift amount is mod 32 - {name: "SHRB", reg: gp21shift, asm: "SHRB"}, // unsigned arg0 >> arg1, shift amount is mod 32 - {name: "SHRQconst", reg: gp11, asm: "SHRQ"}, // unsigned arg0 >> auxint, shift amount 0-63 - {name: "SHRLconst", reg: gp11, asm: "SHRL"}, // unsigned arg0 >> auxint, shift amount 0-31 - {name: "SHRWconst", reg: gp11, asm: "SHRW"}, // unsigned arg0 >> auxint, shift amount 0-31 - {name: "SHRBconst", reg: gp11, asm: "SHRB"}, // unsigned arg0 >> auxint, shift amount 0-31 - - {name: "SARQ", reg: gp21shift, asm: "SARQ"}, // signed arg0 >> arg1, shift amount is mod 64 - {name: "SARL", reg: gp21shift, asm: "SARL"}, // signed arg0 >> arg1, shift amount is mod 32 - {name: "SARW", reg: gp21shift, asm: "SARW"}, // signed arg0 >> arg1, shift amount is mod 32 - {name: "SARB", reg: gp21shift, asm: "SARB"}, // signed arg0 >> arg1, shift amount is mod 32 - {name: "SARQconst", reg: gp11, asm: "SARQ"}, // signed arg0 >> auxint, shift amount 0-63 - {name: "SARLconst", reg: gp11, asm: "SARL"}, // signed arg0 >> auxint, shift amount 0-31 - {name: "SARWconst", reg: gp11, asm: "SARW"}, // signed arg0 >> auxint, shift amount 0-31 - {name: "SARBconst", reg: gp11, asm: "SARB"}, // signed arg0 >> auxint, shift amount 0-31 - - {name: "ROLQconst", reg: gp11, asm: "ROLQ"}, // arg0 rotate left auxint, rotate amount 0-63 - {name: "ROLLconst", reg: gp11, asm: "ROLL"}, // arg0 rotate left auxint, rotate amount 0-31 - {name: "ROLWconst", reg: gp11, asm: "ROLW"}, // arg0 rotate left auxint, rotate amount 0-15 - {name: "ROLBconst", reg: gp11, asm: "ROLB"}, // arg0 rotate left auxint, rotate amount 0-7 + {name: "SHRQ", reg: gp21shift, asm: "SHRQ"}, // unsigned arg0 >> arg1, shift amount is mod 64 + {name: "SHRL", reg: gp21shift, asm: "SHRL"}, // unsigned arg0 >> arg1, shift amount is mod 32 + {name: "SHRW", reg: gp21shift, asm: "SHRW"}, // unsigned arg0 >> arg1, shift amount is mod 32 + {name: "SHRB", reg: gp21shift, asm: "SHRB"}, // unsigned arg0 >> arg1, shift amount is mod 32 + {name: "SHRQconst", reg: gp11, asm: "SHRQ", aux: "Int64"}, // unsigned arg0 >> auxint, shift amount 0-63 + {name: "SHRLconst", reg: gp11, asm: "SHRL", aux: "Int32"}, // unsigned arg0 >> auxint, shift amount 0-31 + {name: "SHRWconst", reg: gp11, asm: "SHRW", aux: "Int16"}, // unsigned arg0 >> auxint, shift amount 0-31 + {name: "SHRBconst", reg: gp11, asm: "SHRB", aux: "Int8"}, // unsigned arg0 >> auxint, shift amount 0-31 + + {name: "SARQ", reg: gp21shift, asm: "SARQ"}, // signed arg0 >> arg1, shift amount is mod 64 + {name: "SARL", reg: gp21shift, asm: "SARL"}, // signed arg0 >> arg1, shift amount is mod 32 + {name: "SARW", reg: gp21shift, asm: "SARW"}, // signed arg0 >> arg1, shift amount is mod 32 + {name: "SARB", reg: gp21shift, asm: "SARB"}, // signed arg0 >> arg1, shift amount is mod 32 + {name: "SARQconst", reg: gp11, asm: "SARQ", aux: "Int64"}, // signed arg0 >> auxint, shift amount 0-63 + {name: "SARLconst", reg: gp11, asm: "SARL", aux: "Int32"}, // signed arg0 >> auxint, shift amount 0-31 + {name: "SARWconst", reg: gp11, asm: "SARW", aux: "Int16"}, // signed arg0 >> auxint, shift amount 0-31 + {name: "SARBconst", reg: gp11, asm: "SARB", aux: "Int8"}, // signed arg0 >> auxint, shift amount 0-31 + + {name: "ROLQconst", reg: gp11, asm: "ROLQ", aux: "Int64"}, // arg0 rotate left auxint, rotate amount 0-63 + {name: "ROLLconst", reg: gp11, asm: "ROLL", aux: "Int32"}, // arg0 rotate left auxint, rotate amount 0-31 + {name: "ROLWconst", reg: gp11, asm: "ROLW", aux: "Int16"}, // arg0 rotate left auxint, rotate amount 0-15 + {name: "ROLBconst", reg: gp11, asm: "ROLB", aux: "Int8"}, // arg0 rotate left auxint, rotate amount 0-7 // unary ops {name: "NEGQ", reg: gp11, asm: "NEGQ"}, // -arg0 @@ -339,10 +339,10 @@ func init() { {name: "MOVLQSX", reg: gp11nf, asm: "MOVLQSX"}, // sign extend arg0 from int32 to int64 {name: "MOVLQZX", reg: gp11nf, asm: "MOVLQZX"}, // zero extend arg0 from int32 to int64 - {name: "MOVBconst", reg: gp01, asm: "MOVB", typ: "UInt8"}, // 8 low bits of auxint - {name: "MOVWconst", reg: gp01, asm: "MOVW", typ: "UInt16"}, // 16 low bits of auxint - {name: "MOVLconst", reg: gp01, asm: "MOVL", typ: "UInt32"}, // 32 low bits of auxint - {name: "MOVQconst", reg: gp01, asm: "MOVQ", typ: "UInt64"}, // auxint + {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", reg: fpgp, asm: "CVTTSD2SL"}, // convert float64 to int32 {name: "CVTTSD2SQ", reg: fpgp, asm: "CVTTSD2SQ"}, // convert float64 to int64 @@ -357,44 +357,44 @@ func init() { {name: "PXOR", reg: fp21, asm: "PXOR"}, // exclusive or, applied to X regs for float negation. - {name: "LEAQ", reg: gp11sb}, // arg0 + auxint + offset encoded in aux - {name: "LEAQ1", reg: gp21sb}, // arg0 + arg1 + auxint - {name: "LEAQ2", reg: gp21sb}, // arg0 + 2*arg1 + auxint - {name: "LEAQ4", reg: gp21sb}, // arg0 + 4*arg1 + auxint - {name: "LEAQ8", reg: gp21sb}, // arg0 + 8*arg1 + auxint + {name: "LEAQ", reg: gp11sb, aux: "SymOff", rematerializeable: true}, // arg0 + auxint + offset encoded in aux + {name: "LEAQ1", reg: gp21sb, aux: "SymOff"}, // arg0 + arg1 + auxint + aux + {name: "LEAQ2", reg: gp21sb, aux: "SymOff"}, // arg0 + 2*arg1 + auxint + aux + {name: "LEAQ4", reg: gp21sb, aux: "SymOff"}, // arg0 + 4*arg1 + auxint + aux + {name: "LEAQ8", reg: gp21sb, aux: "SymOff"}, // arg0 + 8*arg1 + auxint + aux // auxint+aux == add auxint and the offset of the symbol in aux (if any) to the effective address - {name: "MOVBload", reg: gpload, asm: "MOVB", typ: "UInt8"}, // load byte from arg0+auxint+aux. arg1=mem - {name: "MOVBQSXload", reg: gpload, asm: "MOVBQSX"}, // ditto, extend to int64 - {name: "MOVBQZXload", reg: gpload, asm: "MOVBQZX"}, // ditto, extend to uint64 - {name: "MOVWload", reg: gpload, asm: "MOVW", typ: "UInt16"}, // load 2 bytes from arg0+auxint+aux. arg1=mem - {name: "MOVWQSXload", reg: gpload, asm: "MOVWQSX"}, // ditto, extend to int64 - {name: "MOVWQZXload", reg: gpload, asm: "MOVWQZX"}, // ditto, extend to uint64 - {name: "MOVLload", reg: gpload, asm: "MOVL", typ: "UInt32"}, // load 4 bytes from arg0+auxint+aux. arg1=mem - {name: "MOVLQSXload", reg: gpload, asm: "MOVLQSX"}, // ditto, extend to int64 - {name: "MOVLQZXload", reg: gpload, asm: "MOVLQZX"}, // ditto, extend to uint64 - {name: "MOVQload", reg: gpload, asm: "MOVQ", typ: "UInt64"}, // load 8 bytes from arg0+auxint+aux. arg1=mem - {name: "MOVQloadidx8", reg: gploadidx, asm: "MOVQ"}, // load 8 bytes from arg0+8*arg1+auxint+aux. arg2=mem - {name: "MOVBstore", reg: gpstore, asm: "MOVB", typ: "Mem"}, // store byte in arg1 to arg0+auxint+aux. arg2=mem - {name: "MOVWstore", reg: gpstore, asm: "MOVW", typ: "Mem"}, // store 2 bytes in arg1 to arg0+auxint+aux. arg2=mem - {name: "MOVLstore", reg: gpstore, asm: "MOVL", typ: "Mem"}, // store 4 bytes in arg1 to arg0+auxint+aux. arg2=mem - {name: "MOVQstore", reg: gpstore, asm: "MOVQ", typ: "Mem"}, // store 8 bytes in arg1 to arg0+auxint+aux. arg2=mem - - {name: "MOVBstoreidx1", reg: gpstoreidx, asm: "MOVB"}, // store byte in arg2 to arg0+arg1+auxint+aux. arg3=mem - {name: "MOVWstoreidx2", reg: gpstoreidx, asm: "MOVW"}, // store 2 bytes in arg2 to arg0+2*arg1+auxint+aux. arg3=mem - {name: "MOVLstoreidx4", reg: gpstoreidx, asm: "MOVL"}, // store 4 bytes in arg2 to arg0+4*arg1+auxint+aux. arg3=mem - {name: "MOVQstoreidx8", reg: gpstoreidx, asm: "MOVQ"}, // store 8 bytes in arg2 to arg0+8*arg1+auxint+aux. arg3=mem - - {name: "MOVOload", reg: fpload, asm: "MOVUPS", typ: "Int128"}, // load 16 bytes from arg0+auxint+aux. arg1=mem - {name: "MOVOstore", reg: fpstore, asm: "MOVUPS", typ: "Mem"}, // store 16 bytes in arg1 to arg0+auxint+aux. arg2=mem + {name: "MOVBload", reg: gpload, asm: "MOVB", aux: "SymOff", typ: "UInt8"}, // load byte from arg0+auxint+aux. arg1=mem + {name: "MOVBQSXload", reg: gpload, asm: "MOVBQSX", aux: "SymOff"}, // ditto, extend to int64 + {name: "MOVBQZXload", reg: gpload, asm: "MOVBQZX", aux: "SymOff"}, // ditto, extend to uint64 + {name: "MOVWload", reg: gpload, asm: "MOVW", aux: "SymOff", typ: "UInt16"}, // load 2 bytes from arg0+auxint+aux. arg1=mem + {name: "MOVWQSXload", reg: gpload, asm: "MOVWQSX", aux: "SymOff"}, // ditto, extend to int64 + {name: "MOVWQZXload", reg: gpload, asm: "MOVWQZX", aux: "SymOff"}, // ditto, extend to uint64 + {name: "MOVLload", reg: gpload, asm: "MOVL", aux: "SymOff", typ: "UInt32"}, // load 4 bytes from arg0+auxint+aux. arg1=mem + {name: "MOVLQSXload", reg: gpload, asm: "MOVLQSX", aux: "SymOff"}, // ditto, extend to int64 + {name: "MOVLQZXload", reg: gpload, asm: "MOVLQZX", aux: "SymOff"}, // ditto, extend to uint64 + {name: "MOVQload", reg: gpload, asm: "MOVQ", aux: "SymOff", typ: "UInt64"}, // load 8 bytes from arg0+auxint+aux. arg1=mem + {name: "MOVQloadidx8", reg: gploadidx, asm: "MOVQ", aux: "SymOff"}, // load 8 bytes from arg0+8*arg1+auxint+aux. arg2=mem + {name: "MOVBstore", reg: gpstore, asm: "MOVB", aux: "SymOff", typ: "Mem"}, // store byte in arg1 to arg0+auxint+aux. arg2=mem + {name: "MOVWstore", reg: gpstore, asm: "MOVW", aux: "SymOff", typ: "Mem"}, // store 2 bytes in arg1 to arg0+auxint+aux. arg2=mem + {name: "MOVLstore", reg: gpstore, asm: "MOVL", aux: "SymOff", typ: "Mem"}, // store 4 bytes in arg1 to arg0+auxint+aux. arg2=mem + {name: "MOVQstore", reg: gpstore, asm: "MOVQ", aux: "SymOff", typ: "Mem"}, // store 8 bytes in arg1 to arg0+auxint+aux. arg2=mem + + {name: "MOVBstoreidx1", reg: gpstoreidx, asm: "MOVB", aux: "SymOff"}, // store byte in arg2 to arg0+arg1+auxint+aux. arg3=mem + {name: "MOVWstoreidx2", reg: gpstoreidx, asm: "MOVW", aux: "SymOff"}, // store 2 bytes in arg2 to arg0+2*arg1+auxint+aux. arg3=mem + {name: "MOVLstoreidx4", reg: gpstoreidx, asm: "MOVL", aux: "SymOff"}, // store 4 bytes in arg2 to arg0+4*arg1+auxint+aux. arg3=mem + {name: "MOVQstoreidx8", reg: gpstoreidx, asm: "MOVQ", aux: "SymOff"}, // store 8 bytes in arg2 to arg0+8*arg1+auxint+aux. arg3=mem + + {name: "MOVOload", reg: fpload, asm: "MOVUPS", aux: "SymOff", typ: "Int128"}, // load 16 bytes from arg0+auxint+aux. arg1=mem + {name: "MOVOstore", reg: fpstore, asm: "MOVUPS", aux: "SymOff", typ: "Mem"}, // store 16 bytes in arg1 to arg0+auxint+aux. arg2=mem // 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", reg: gpstoreconst, asm: "MOVB", typ: "Mem"}, // store low byte of ValAndOff(AuxInt).Val() to arg0+ValAndOff(AuxInt).Off()+aux. arg1=mem - {name: "MOVWstoreconst", reg: gpstoreconst, asm: "MOVW", typ: "Mem"}, // store low 2 bytes of ... - {name: "MOVLstoreconst", reg: gpstoreconst, asm: "MOVL", typ: "Mem"}, // store low 4 bytes of ... - {name: "MOVQstoreconst", reg: gpstoreconst, asm: "MOVQ", typ: "Mem"}, // store 8 bytes of ... + {name: "MOVBstoreconst", 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", reg: gpstoreconst, asm: "MOVW", aux: "SymValAndOff", typ: "Mem"}, // store low 2 bytes of ... + {name: "MOVLstoreconst", reg: gpstoreconst, asm: "MOVL", aux: "SymValAndOff", typ: "Mem"}, // store low 4 bytes of ... + {name: "MOVQstoreconst", reg: gpstoreconst, asm: "MOVQ", aux: "SymValAndOff", typ: "Mem"}, // store 8 bytes of ... // arg0 = (duff-adjusted) pointer to start of memory to zero // arg1 = value to store (will always be zero) @@ -403,12 +403,13 @@ func init() { // returns mem { name: "DUFFZERO", + aux: "Int64", reg: regInfo{ inputs: []regMask{buildReg("DI"), buildReg("X0")}, clobbers: buildReg("DI FLAGS"), }, }, - {name: "MOVOconst", reg: regInfo{nil, 0, []regMask{fp}}, typ: "Int128"}, + {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 @@ -423,11 +424,11 @@ func init() { }, }, - {name: "CALLstatic", reg: regInfo{clobbers: callerSave}}, // call static function aux.(*gc.Sym). arg0=mem, auxint=argsize, returns mem - {name: "CALLclosure", reg: regInfo{[]regMask{gpsp, buildReg("DX"), 0}, callerSave, nil}}, // call function via closure. arg0=codeptr, arg1=closure, arg2=mem, auxint=argsize, returns mem - {name: "CALLdefer", reg: regInfo{clobbers: callerSave}}, // call deferproc. arg0=mem, auxint=argsize, returns mem - {name: "CALLgo", reg: regInfo{clobbers: callerSave}}, // call newproc. arg0=mem, auxint=argsize, returns mem - {name: "CALLinter", reg: regInfo{inputs: []regMask{gp}, clobbers: callerSave}}, // call fn by pointer. arg0=codeptr, arg1=mem, auxint=argsize, returns mem + {name: "CALLstatic", reg: regInfo{clobbers: callerSave}, aux: "SymOff"}, // call static function aux.(*gc.Sym). arg0=mem, auxint=argsize, returns mem + {name: "CALLclosure", 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", reg: regInfo{clobbers: callerSave}, aux: "Int64"}, // call deferproc. arg0=mem, auxint=argsize, returns mem + {name: "CALLgo", reg: regInfo{clobbers: callerSave}, aux: "Int64"}, // call newproc. arg0=mem, auxint=argsize, returns mem + {name: "CALLinter", 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 @@ -436,6 +437,7 @@ func init() { // returns memory { name: "DUFFCOPY", + aux: "Int64", reg: regInfo{ inputs: []regMask{buildReg("DI"), buildReg("SI")}, clobbers: buildReg("DI SI X0 FLAGS"), // uses X0 as a temporary diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 36dd58cd1d..3c7aa84ee3 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -148,10 +148,10 @@ var genericOps = []opData{ // 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"}, - {name: "Lrot16"}, - {name: "Lrot32"}, - {name: "Lrot64"}, + {name: "Lrot8", aux: "Int64"}, + {name: "Lrot16", aux: "Int64"}, + {name: "Lrot32", aux: "Int64"}, + {name: "Lrot64", aux: "Int64"}, // 2-input comparisons {name: "Eq8"}, // arg0 == arg1 @@ -247,46 +247,46 @@ var genericOps = []opData{ // constants. Constant values are stored in the aux or // auxint fields. - {name: "ConstBool"}, // auxint is 0 for false and 1 for true - {name: "ConstString"}, // value is aux.(string) - {name: "ConstNil", typ: "BytePtr"}, // nil pointer - {name: "Const8"}, // value is low 8 bits of auxint - {name: "Const16"}, // value is low 16 bits of auxint - {name: "Const32"}, // value is low 32 bits of auxint - {name: "Const64"}, // value is auxint - {name: "Const32F"}, // value is math.Float64frombits(uint64(auxint)) - {name: "Const64F"}, // value is math.Float64frombits(uint64(auxint)) - {name: "ConstInterface"}, // nil interface - {name: "ConstSlice"}, // nil slice + {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"}, // argument to the function. aux=GCNode of arg, off = offset in that arg. + {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"}, // Address of a variable. Arg0=SP or SB. Aux identifies the variable. + {name: "Addr", 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"}, // entry address of a function + {name: "Func", aux: "Sym"}, // entry address of a function // Memory operations - {name: "Load"}, // Load from arg0. arg1=memory - {name: "Store", typ: "Mem"}, // Store arg1 to arg0. arg2=memory, auxint=size. Returns memory. - {name: "Move"}, // arg0=destptr, arg1=srcptr, arg2=mem, auxint=size. Returns memory. - {name: "Zero"}, // arg0=destptr, arg1=mem, auxint=size. Returns memory. + {name: "Load"}, // Load from arg0. arg1=memory + {name: "Store", typ: "Mem", aux: "Int64"}, // Store arg1 to arg0. arg2=memory, auxint=size. Returns memory. + {name: "Move", aux: "Int64"}, // arg0=destptr, arg1=srcptr, arg2=mem, auxint=size. Returns memory. + {name: "Zero", aux: "Int64"}, // arg0=destptr, arg1=mem, auxint=size. Returns memory. // 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"}, // arg0=code pointer, arg1=context ptr, arg2=memory. auxint=arg size. Returns memory. - {name: "StaticCall"}, // call function aux.(*gc.Sym), arg0=memory. auxint=arg size. Returns memory. - {name: "DeferCall"}, // defer call. arg0=memory, auxint=arg size. Returns memory. - {name: "GoCall"}, // go call. arg0=memory, auxint=arg size. Returns memory. - {name: "InterCall"}, // interface call. arg0=code pointer, arg1=memory, auxint=arg size. Returns memory. + {name: "ClosureCall", aux: "Int64"}, // arg0=code pointer, arg1=context ptr, arg2=memory. auxint=arg size. Returns memory. + {name: "StaticCall", aux: "SymOff"}, // call function aux.(*gc.Sym), arg0=memory. auxint=arg size. Returns memory. + {name: "DeferCall", aux: "Int64"}, // defer call. arg0=memory, auxint=arg size. Returns memory. + {name: "GoCall", aux: "Int64"}, // go call. arg0=memory, auxint=arg size. Returns memory. + {name: "InterCall", aux: "Int64"}, // interface call. arg0=code pointer, arg1=memory, auxint=arg size. Returns memory. // Conversions: signed extensions, zero (unsigned) extensions, truncations {name: "SignExt8to16", typ: "Int16"}, @@ -330,9 +330,9 @@ var genericOps = []opData{ {name: "GetClosurePtr"}, // get closure pointer from dedicated register // Indexing operations - {name: "ArrayIndex"}, // arg0=array, arg1=index. Returns a[i] - {name: "PtrIndex"}, // arg0=ptr, arg1=index. Computes ptr+sizeof(*v.type)*index, where index is extended to ptrwidth type - {name: "OffPtr"}, // arg0 + auxint (arg0 and result are pointers) + {name: "ArrayIndex"}, // arg0=array, arg1=index. Returns a[i] + {name: "PtrIndex"}, // arg0=ptr, arg1=index. Computes ptr+sizeof(*v.type)*index, where index is extended to ptrwidth type + {name: "OffPtr", aux: "Int64"}, // arg0 + auxint (arg0 and result are pointers) // Slices {name: "SliceMake"}, // arg0=ptr, arg1=len, arg2=cap @@ -356,12 +356,12 @@ var genericOps = []opData{ {name: "IData"}, // arg0=interface, returns data field // Structs - {name: "StructMake0"}, // Returns struct with 0 fields. - {name: "StructMake1"}, // arg0=field0. Returns struct. - {name: "StructMake2"}, // arg0,arg1=field0,field1. Returns struct. - {name: "StructMake3"}, // arg0..2=field0..2. Returns struct. - {name: "StructMake4"}, // arg0..3=field0..3. Returns struct. - {name: "StructSelect"}, // arg0=struct, auxint=field index. Returns the auxint'th field. + {name: "StructMake0"}, // Returns struct with 0 fields. + {name: "StructMake1"}, // arg0=field0. Returns struct. + {name: "StructMake2"}, // arg0,arg1=field0,field1. Returns struct. + {name: "StructMake3"}, // arg0..2=field0..2. Returns struct. + {name: "StructMake4"}, // arg0..3=field0..3. Returns struct. + {name: "StructSelect", aux: "Int64"}, // arg0=struct, auxint=field index. Returns the auxint'th field. // Spill&restore ops for the register allocator. These are // semantically identical to OpCopy; they do not take/return @@ -376,9 +376,9 @@ var genericOps = []opData{ // Unknown value. Used for Values whose values don't matter because they are dead code. {name: "Unknown"}, - {name: "VarDef", typ: "Mem"}, // aux is a *gc.Node of a variable that is about to be initialized. arg0=mem, returns mem - {name: "VarKill"}, // aux is a *gc.Node of a variable that is known to be dead. arg0=mem, returns mem - {name: "VarLive"}, // aux is a *gc.Node of a variable that must be kept live. arg0=mem, returns mem + {name: "VarDef", aux: "Sym", typ: "Mem"}, // aux is a *gc.Node of a variable that is about to be initialized. arg0=mem, returns mem + {name: "VarKill", aux: "Sym"}, // aux is a *gc.Node of a variable that is known to be dead. arg0=mem, returns mem + {name: "VarLive", aux: "Sym"}, // aux is a *gc.Node of a variable that must be kept live. arg0=mem, returns mem } // kind control successors implicit exit diff --git a/src/cmd/compile/internal/ssa/gen/main.go b/src/cmd/compile/internal/ssa/gen/main.go index c869de82e7..f8f6c8b5f6 100644 --- a/src/cmd/compile/internal/ssa/gen/main.go +++ b/src/cmd/compile/internal/ssa/gen/main.go @@ -26,10 +26,12 @@ type arch struct { } type opData struct { - name string - reg regInfo - asm string - typ string // default result type + name string + reg regInfo + asm string + typ string // default result type + aux string + rematerializeable bool } type blockData struct { @@ -117,6 +119,17 @@ func genOp() { 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) + } + if v.rematerializeable { + if v.reg.clobbers != 0 { + log.Fatalf("%s is rematerializeable and clobbers registers", v.name) + } + fmt.Fprintln(w, "rematerializeable: true,") + } if a.name == "generic" { fmt.Fprintln(w, "generic:true,") fmt.Fprintln(w, "},") // close op diff --git a/src/cmd/compile/internal/ssa/nilcheck_test.go b/src/cmd/compile/internal/ssa/nilcheck_test.go index c4aff58d76..14955e77d8 100644 --- a/src/cmd/compile/internal/ssa/nilcheck_test.go +++ b/src/cmd/compile/internal/ssa/nilcheck_test.go @@ -21,7 +21,7 @@ func benchmarkNilCheckDeep(b *testing.B, depth int) { var blocs []bloc blocs = append(blocs, Bloc("entry", - Valu("mem", OpInitMem, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, nil), Valu("sb", OpSB, TypeInvalid, 0, nil), Goto(blockn(0)), ), @@ -67,7 +67,7 @@ func TestNilcheckSimple(t *testing.T) { c := NewConfig("amd64", DummyFrontend{t}, nil, true) fun := Fun(c, "entry", Bloc("entry", - Valu("mem", OpInitMem, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, nil), Valu("sb", OpSB, TypeInvalid, 0, nil), Goto("checkPtr")), Bloc("checkPtr", @@ -104,7 +104,7 @@ func TestNilcheckDomOrder(t *testing.T) { c := NewConfig("amd64", DummyFrontend{t}, nil, true) fun := Fun(c, "entry", Bloc("entry", - Valu("mem", OpInitMem, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, nil), Valu("sb", OpSB, TypeInvalid, 0, nil), Goto("checkPtr")), Bloc("checkPtr", @@ -140,7 +140,7 @@ func TestNilcheckAddr(t *testing.T) { c := NewConfig("amd64", DummyFrontend{t}, nil, true) fun := Fun(c, "entry", Bloc("entry", - Valu("mem", OpInitMem, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, nil), Valu("sb", OpSB, TypeInvalid, 0, nil), Goto("checkPtr")), Bloc("checkPtr", @@ -173,7 +173,7 @@ func TestNilcheckAddPtr(t *testing.T) { c := NewConfig("amd64", DummyFrontend{t}, nil, true) fun := Fun(c, "entry", Bloc("entry", - Valu("mem", OpInitMem, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, nil), Valu("sb", OpSB, TypeInvalid, 0, nil), Goto("checkPtr")), Bloc("checkPtr", @@ -207,7 +207,7 @@ func TestNilcheckPhi(t *testing.T) { c := NewConfig("amd64", DummyFrontend{t}, nil, true) fun := Fun(c, "entry", Bloc("entry", - Valu("mem", OpInitMem, TypeMem, 0, ".mem"), + 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"), @@ -251,7 +251,7 @@ func TestNilcheckKeepRemove(t *testing.T) { c := NewConfig("amd64", DummyFrontend{t}, nil, true) fun := Fun(c, "entry", Bloc("entry", - Valu("mem", OpInitMem, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, nil), Valu("sb", OpSB, TypeInvalid, 0, nil), Goto("checkPtr")), Bloc("checkPtr", @@ -299,7 +299,7 @@ func TestNilcheckInFalseBranch(t *testing.T) { c := NewConfig("amd64", DummyFrontend{t}, nil, true) fun := Fun(c, "entry", Bloc("entry", - Valu("mem", OpInitMem, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, nil), Valu("sb", OpSB, TypeInvalid, 0, nil), Goto("checkPtr")), Bloc("checkPtr", @@ -350,7 +350,7 @@ func TestNilcheckUser(t *testing.T) { c := NewConfig("amd64", DummyFrontend{t}, nil, true) fun := Fun(c, "entry", Bloc("entry", - Valu("mem", OpInitMem, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, nil), Valu("sb", OpSB, TypeInvalid, 0, nil), Goto("checkPtr")), Bloc("checkPtr", @@ -389,7 +389,7 @@ func TestNilcheckBug(t *testing.T) { c := NewConfig("amd64", DummyFrontend{t}, nil, true) fun := Fun(c, "entry", Bloc("entry", - Valu("mem", OpInitMem, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, nil), Valu("sb", OpSB, TypeInvalid, 0, nil), Goto("checkPtr")), Bloc("checkPtr", diff --git a/src/cmd/compile/internal/ssa/op.go b/src/cmd/compile/internal/ssa/op.go index 526722f7bc..a868fdbb6f 100644 --- a/src/cmd/compile/internal/ssa/op.go +++ b/src/cmd/compile/internal/ssa/op.go @@ -15,10 +15,12 @@ import "fmt" type Op int32 type opInfo struct { - name string - asm int - reg regInfo - generic bool // this is a generic (arch-independent) opcode + name string + asm int + reg regInfo + auxType auxType + generic bool // this is a generic (arch-independent) opcode + rematerializeable bool // this op is rematerializeable } type inputInfo struct { @@ -32,6 +34,22 @@ type regInfo struct { 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. diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 8c6c731969..089adfdec2 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -680,8 +680,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVSSload", - asm: x86.AMOVSS, + name: "MOVSSload", + auxType: auxSymOff, + 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 @@ -692,8 +693,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVSDload", - asm: x86.AMOVSD, + name: "MOVSDload", + auxType: auxSymOff, + 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 @@ -704,8 +706,10 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVSSconst", - asm: x86.AMOVSS, + name: "MOVSSconst", + auxType: auxFloat, + 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 @@ -713,8 +717,10 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVSDconst", - asm: x86.AMOVSD, + name: "MOVSDconst", + auxType: auxFloat, + 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 @@ -722,8 +728,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVSSloadidx4", - asm: x86.AMOVSS, + name: "MOVSSloadidx4", + auxType: auxSymOff, + 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 @@ -735,8 +742,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVSDloadidx8", - asm: x86.AMOVSD, + name: "MOVSDloadidx8", + auxType: auxSymOff, + 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 @@ -748,8 +756,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVSSstore", - asm: x86.AMOVSS, + name: "MOVSSstore", + auxType: auxSymOff, + 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 @@ -758,8 +767,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVSDstore", - asm: x86.AMOVSD, + name: "MOVSDstore", + auxType: auxSymOff, + 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 @@ -768,8 +778,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVSSstoreidx4", - asm: x86.AMOVSS, + name: "MOVSSstoreidx4", + auxType: auxSymOff, + 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 @@ -779,8 +790,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVSDstoreidx8", - asm: x86.AMOVSD, + name: "MOVSDstoreidx8", + auxType: auxSymOff, + 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 @@ -846,8 +858,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "ADDQconst", - asm: x86.AADDQ, + name: "ADDQconst", + auxType: auxInt64, + 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 @@ -859,8 +872,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "ADDLconst", - asm: x86.AADDL, + name: "ADDLconst", + auxType: auxInt32, + 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 @@ -872,8 +886,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "ADDWconst", - asm: x86.AADDW, + name: "ADDWconst", + auxType: auxInt16, + asm: x86.AADDW, reg: regInfo{ inputs: []inputInfo{ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -885,8 +900,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "ADDBconst", - asm: x86.AADDB, + name: "ADDBconst", + auxType: auxInt8, + asm: x86.AADDB, reg: regInfo{ inputs: []inputInfo{ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -954,8 +970,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SUBQconst", - asm: x86.ASUBQ, + name: "SUBQconst", + auxType: auxInt64, + 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 @@ -967,8 +984,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SUBLconst", - asm: x86.ASUBL, + name: "SUBLconst", + auxType: auxInt32, + 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 @@ -980,8 +998,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SUBWconst", - asm: x86.ASUBW, + name: "SUBWconst", + auxType: auxInt16, + asm: x86.ASUBW, reg: regInfo{ inputs: []inputInfo{ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -993,8 +1012,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SUBBconst", - asm: x86.ASUBB, + name: "SUBBconst", + auxType: auxInt8, + asm: x86.ASUBB, reg: regInfo{ inputs: []inputInfo{ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -1062,8 +1082,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MULQconst", - asm: x86.AIMULQ, + name: "MULQconst", + auxType: auxInt64, + 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 @@ -1075,8 +1096,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MULLconst", - asm: x86.AIMULL, + name: "MULLconst", + auxType: auxInt32, + 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 @@ -1088,8 +1110,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MULWconst", - asm: x86.AIMULW, + name: "MULWconst", + auxType: auxInt16, + 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 @@ -1101,8 +1124,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MULBconst", - asm: x86.AIMULW, + name: "MULBconst", + auxType: auxInt8, + 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 @@ -1422,8 +1446,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "ANDQconst", - asm: x86.AANDQ, + name: "ANDQconst", + auxType: auxInt64, + 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 @@ -1435,8 +1460,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "ANDLconst", - asm: x86.AANDL, + name: "ANDLconst", + auxType: auxInt32, + 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 @@ -1448,8 +1474,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "ANDWconst", - asm: x86.AANDW, + name: "ANDWconst", + auxType: auxInt16, + asm: x86.AANDW, reg: regInfo{ inputs: []inputInfo{ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -1461,8 +1488,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "ANDBconst", - asm: x86.AANDB, + name: "ANDBconst", + auxType: auxInt8, + asm: x86.AANDB, reg: regInfo{ inputs: []inputInfo{ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -1530,8 +1558,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "ORQconst", - asm: x86.AORQ, + name: "ORQconst", + auxType: auxInt64, + 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 @@ -1543,8 +1572,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "ORLconst", - asm: x86.AORL, + name: "ORLconst", + auxType: auxInt32, + 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 @@ -1556,8 +1586,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "ORWconst", - asm: x86.AORW, + name: "ORWconst", + auxType: auxInt16, + asm: x86.AORW, reg: regInfo{ inputs: []inputInfo{ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -1569,8 +1600,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "ORBconst", - asm: x86.AORB, + name: "ORBconst", + auxType: auxInt8, + asm: x86.AORB, reg: regInfo{ inputs: []inputInfo{ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -1638,8 +1670,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "XORQconst", - asm: x86.AXORQ, + name: "XORQconst", + auxType: auxInt64, + 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 @@ -1651,8 +1684,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "XORLconst", - asm: x86.AXORL, + name: "XORLconst", + auxType: auxInt32, + 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 @@ -1664,8 +1698,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "XORWconst", - asm: x86.AXORW, + name: "XORWconst", + auxType: auxInt16, + asm: x86.AXORW, reg: regInfo{ inputs: []inputInfo{ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -1677,8 +1712,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "XORBconst", - asm: x86.AXORB, + name: "XORBconst", + auxType: auxInt8, + asm: x86.AXORB, reg: regInfo{ inputs: []inputInfo{ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -1742,8 +1778,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "CMPQconst", - asm: x86.ACMPQ, + name: "CMPQconst", + auxType: auxInt64, + 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 @@ -1754,8 +1791,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "CMPLconst", - asm: x86.ACMPL, + name: "CMPLconst", + auxType: auxInt32, + 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 @@ -1766,8 +1804,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "CMPWconst", - asm: x86.ACMPW, + name: "CMPWconst", + auxType: auxInt16, + 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 @@ -1778,8 +1817,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "CMPBconst", - asm: x86.ACMPB, + name: "CMPBconst", + auxType: auxInt8, + 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 @@ -1868,8 +1908,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "TESTQconst", - asm: x86.ATESTQ, + name: "TESTQconst", + auxType: auxInt64, + 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 @@ -1880,8 +1921,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "TESTLconst", - asm: x86.ATESTL, + name: "TESTLconst", + auxType: auxInt32, + 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 @@ -1892,8 +1934,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "TESTWconst", - asm: x86.ATESTW, + name: "TESTWconst", + auxType: auxInt16, + 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 @@ -1904,8 +1947,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "TESTBconst", - asm: x86.ATESTB, + name: "TESTBconst", + auxType: auxInt8, + 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 @@ -1972,8 +2016,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SHLQconst", - asm: x86.ASHLQ, + name: "SHLQconst", + auxType: auxInt64, + 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 @@ -1985,8 +2030,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SHLLconst", - asm: x86.ASHLL, + name: "SHLLconst", + auxType: auxInt32, + 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 @@ -1998,8 +2044,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SHLWconst", - asm: x86.ASHLW, + name: "SHLWconst", + auxType: auxInt16, + asm: x86.ASHLW, reg: regInfo{ inputs: []inputInfo{ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -2011,8 +2058,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SHLBconst", - asm: x86.ASHLB, + name: "SHLBconst", + auxType: auxInt8, + asm: x86.ASHLB, reg: regInfo{ inputs: []inputInfo{ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -2080,8 +2128,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SHRQconst", - asm: x86.ASHRQ, + name: "SHRQconst", + auxType: auxInt64, + 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 @@ -2093,8 +2142,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SHRLconst", - asm: x86.ASHRL, + name: "SHRLconst", + auxType: auxInt32, + 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 @@ -2106,8 +2156,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SHRWconst", - asm: x86.ASHRW, + name: "SHRWconst", + auxType: auxInt16, + 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 @@ -2119,8 +2170,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SHRBconst", - asm: x86.ASHRB, + name: "SHRBconst", + auxType: auxInt8, + 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 @@ -2188,8 +2240,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SARQconst", - asm: x86.ASARQ, + name: "SARQconst", + auxType: auxInt64, + 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 @@ -2201,8 +2254,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SARLconst", - asm: x86.ASARL, + name: "SARLconst", + auxType: auxInt32, + 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 @@ -2214,8 +2268,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SARWconst", - asm: x86.ASARW, + name: "SARWconst", + auxType: auxInt16, + 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 @@ -2227,8 +2282,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SARBconst", - asm: x86.ASARB, + name: "SARBconst", + auxType: auxInt8, + 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 @@ -2240,8 +2296,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "ROLQconst", - asm: x86.AROLQ, + name: "ROLQconst", + auxType: auxInt64, + 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 @@ -2253,8 +2310,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "ROLLconst", - asm: x86.AROLL, + name: "ROLLconst", + auxType: auxInt32, + 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 @@ -2266,8 +2324,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "ROLWconst", - asm: x86.AROLW, + name: "ROLWconst", + auxType: auxInt16, + 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 @@ -2279,8 +2338,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "ROLBconst", - asm: x86.AROLB, + name: "ROLBconst", + auxType: auxInt8, + 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 @@ -2698,8 +2758,10 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVBconst", - asm: x86.AMOVB, + name: "MOVBconst", + auxType: auxInt8, + 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 @@ -2707,8 +2769,10 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVWconst", - asm: x86.AMOVW, + name: "MOVWconst", + auxType: auxInt16, + 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 @@ -2716,8 +2780,10 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVLconst", - asm: x86.AMOVL, + name: "MOVLconst", + auxType: auxInt32, + 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 @@ -2725,8 +2791,10 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVQconst", - asm: x86.AMOVQ, + name: "MOVQconst", + auxType: auxInt64, + 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 @@ -2867,7 +2935,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "LEAQ", + name: "LEAQ", + auxType: auxSymOff, + 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 @@ -2878,7 +2948,8 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "LEAQ1", + name: "LEAQ1", + auxType: auxSymOff, reg: regInfo{ inputs: []inputInfo{ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -2890,7 +2961,8 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "LEAQ2", + name: "LEAQ2", + auxType: auxSymOff, reg: regInfo{ inputs: []inputInfo{ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -2902,7 +2974,8 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "LEAQ4", + name: "LEAQ4", + auxType: auxSymOff, reg: regInfo{ inputs: []inputInfo{ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -2914,7 +2987,8 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "LEAQ8", + name: "LEAQ8", + auxType: auxSymOff, reg: regInfo{ inputs: []inputInfo{ {1, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -2926,8 +3000,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVBload", - asm: x86.AMOVB, + name: "MOVBload", + auxType: auxSymOff, + 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 @@ -2938,8 +3013,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVBQSXload", - asm: x86.AMOVBQSX, + name: "MOVBQSXload", + auxType: auxSymOff, + 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 @@ -2950,8 +3026,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVBQZXload", - asm: x86.AMOVBQZX, + name: "MOVBQZXload", + auxType: auxSymOff, + 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 @@ -2962,8 +3039,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVWload", - asm: x86.AMOVW, + name: "MOVWload", + auxType: auxSymOff, + 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 @@ -2974,8 +3052,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVWQSXload", - asm: x86.AMOVWQSX, + name: "MOVWQSXload", + auxType: auxSymOff, + 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 @@ -2986,8 +3065,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVWQZXload", - asm: x86.AMOVWQZX, + name: "MOVWQZXload", + auxType: auxSymOff, + 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 @@ -2998,8 +3078,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVLload", - asm: x86.AMOVL, + name: "MOVLload", + auxType: auxSymOff, + 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 @@ -3010,8 +3091,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVLQSXload", - asm: x86.AMOVLQSX, + name: "MOVLQSXload", + auxType: auxSymOff, + 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 @@ -3022,8 +3104,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVLQZXload", - asm: x86.AMOVLQZX, + name: "MOVLQZXload", + auxType: auxSymOff, + 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 @@ -3034,8 +3117,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVQload", - asm: x86.AMOVQ, + name: "MOVQload", + auxType: auxSymOff, + 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 @@ -3046,8 +3130,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVQloadidx8", - asm: x86.AMOVQ, + name: "MOVQloadidx8", + auxType: auxSymOff, + 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 @@ -3059,8 +3144,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVBstore", - asm: x86.AMOVB, + name: "MOVBstore", + auxType: auxSymOff, + 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 @@ -3069,8 +3155,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVWstore", - asm: x86.AMOVW, + name: "MOVWstore", + auxType: auxSymOff, + 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 @@ -3079,8 +3166,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVLstore", - asm: x86.AMOVL, + name: "MOVLstore", + auxType: auxSymOff, + 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 @@ -3089,8 +3177,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVQstore", - asm: x86.AMOVQ, + name: "MOVQstore", + auxType: auxSymOff, + 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 @@ -3099,8 +3188,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVBstoreidx1", - asm: x86.AMOVB, + name: "MOVBstoreidx1", + auxType: auxSymOff, + 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 @@ -3110,8 +3200,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVWstoreidx2", - asm: x86.AMOVW, + name: "MOVWstoreidx2", + auxType: auxSymOff, + 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 @@ -3121,8 +3212,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVLstoreidx4", - asm: x86.AMOVL, + name: "MOVLstoreidx4", + auxType: auxSymOff, + 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 @@ -3132,8 +3224,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVQstoreidx8", - asm: x86.AMOVQ, + name: "MOVQstoreidx8", + auxType: auxSymOff, + 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 @@ -3143,8 +3236,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVOload", - asm: x86.AMOVUPS, + name: "MOVOload", + auxType: auxSymOff, + 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 @@ -3155,8 +3249,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVOstore", - asm: x86.AMOVUPS, + name: "MOVOstore", + auxType: auxSymOff, + 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 @@ -3165,8 +3260,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVBstoreconst", - asm: x86.AMOVB, + name: "MOVBstoreconst", + auxType: auxSymValAndOff, + 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 @@ -3174,8 +3270,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVWstoreconst", - asm: x86.AMOVW, + name: "MOVWstoreconst", + auxType: auxSymValAndOff, + 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 @@ -3183,8 +3280,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVLstoreconst", - asm: x86.AMOVL, + name: "MOVLstoreconst", + auxType: auxSymValAndOff, + 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 @@ -3192,8 +3290,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVQstoreconst", - asm: x86.AMOVQ, + name: "MOVQstoreconst", + auxType: auxSymValAndOff, + 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 @@ -3201,7 +3300,8 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "DUFFZERO", + name: "DUFFZERO", + auxType: auxInt64, reg: regInfo{ inputs: []inputInfo{ {0, 128}, // .DI @@ -3211,7 +3311,8 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVOconst", + name: "MOVOconst", + rematerializeable: true, reg: regInfo{ outputs: []regMask{ 4294901760, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15 @@ -3230,13 +3331,15 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "CALLstatic", + name: "CALLstatic", + auxType: auxSymOff, 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", + name: "CALLclosure", + auxType: auxInt64, reg: regInfo{ inputs: []inputInfo{ {1, 4}, // .DX @@ -3246,19 +3349,22 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "CALLdefer", + name: "CALLdefer", + auxType: auxInt64, 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", + name: "CALLgo", + auxType: auxInt64, 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", + name: "CALLinter", + auxType: auxInt64, reg: regInfo{ inputs: []inputInfo{ {0, 65519}, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -3267,7 +3373,8 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "DUFFCOPY", + name: "DUFFCOPY", + auxType: auxInt64, reg: regInfo{ inputs: []inputInfo{ {0, 128}, // .DI @@ -3767,18 +3874,22 @@ var opcodeTable = [...]opInfo{ }, { name: "Lrot8", + auxType: auxInt64, generic: true, }, { name: "Lrot16", + auxType: auxInt64, generic: true, }, { name: "Lrot32", + auxType: auxInt64, generic: true, }, { name: "Lrot64", + auxType: auxInt64, generic: true, }, { @@ -4075,10 +4186,12 @@ var opcodeTable = [...]opInfo{ }, { name: "ConstBool", + auxType: auxBool, generic: true, }, { name: "ConstString", + auxType: auxString, generic: true, }, { @@ -4087,26 +4200,32 @@ var opcodeTable = [...]opInfo{ }, { name: "Const8", + auxType: auxInt8, generic: true, }, { name: "Const16", + auxType: auxInt16, generic: true, }, { name: "Const32", + auxType: auxInt32, generic: true, }, { name: "Const64", + auxType: auxInt64, generic: true, }, { name: "Const32F", + auxType: auxFloat, generic: true, }, { name: "Const64F", + auxType: auxFloat, generic: true, }, { @@ -4123,10 +4242,12 @@ var opcodeTable = [...]opInfo{ }, { name: "Arg", + auxType: auxSymOff, generic: true, }, { name: "Addr", + auxType: auxSym, generic: true, }, { @@ -4139,6 +4260,7 @@ var opcodeTable = [...]opInfo{ }, { name: "Func", + auxType: auxSym, generic: true, }, { @@ -4147,34 +4269,42 @@ var opcodeTable = [...]opInfo{ }, { name: "Store", + auxType: auxInt64, generic: true, }, { name: "Move", + auxType: auxInt64, generic: true, }, { name: "Zero", + auxType: auxInt64, generic: true, }, { name: "ClosureCall", + auxType: auxInt64, generic: true, }, { name: "StaticCall", + auxType: auxSymOff, generic: true, }, { name: "DeferCall", + auxType: auxInt64, generic: true, }, { name: "GoCall", + auxType: auxInt64, generic: true, }, { name: "InterCall", + auxType: auxInt64, generic: true, }, { @@ -4323,6 +4453,7 @@ var opcodeTable = [...]opInfo{ }, { name: "OffPtr", + auxType: auxInt64, generic: true, }, { @@ -4399,6 +4530,7 @@ var opcodeTable = [...]opInfo{ }, { name: "StructSelect", + auxType: auxInt64, generic: true, }, { @@ -4419,14 +4551,17 @@ var opcodeTable = [...]opInfo{ }, { name: "VarDef", + auxType: auxSym, generic: true, }, { name: "VarKill", + auxType: auxSym, generic: true, }, { name: "VarLive", + auxType: auxSym, generic: true, }, } diff --git a/src/cmd/compile/internal/ssa/passbm_test.go b/src/cmd/compile/internal/ssa/passbm_test.go index 9b11ff1256..8dff17a5b4 100644 --- a/src/cmd/compile/internal/ssa/passbm_test.go +++ b/src/cmd/compile/internal/ssa/passbm_test.go @@ -68,7 +68,7 @@ func genFunction(size int) []bloc { 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), OpArg, TypeMem, 0, ".mem"), + Valu(valn("store", 0, 4), OpInitMem, TypeMem, 0, nil), Valu("sb", OpSB, TypeInvalid, 0, nil), Goto(blockn(1)), ), diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index e1f8dd1935..bfb6f7da76 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -1481,31 +1481,16 @@ func (e *edgeState) findRegFor(typ Type) Location { } func (v *Value) rematerializeable() bool { - // TODO: add a flags field to opInfo for this test? - regspec := opcodeTable[v.Op].reg - - // rematerializeable ops must be able to fill any register. - outputs := regspec.outputs - if len(outputs) == 0 || countRegs(outputs[0]) <= 1 { - // Note: this case handles OpAMD64LoweredGetClosurePtr - // which can't be moved. + if !opcodeTable[v.Op].rematerializeable { return false } - - // We can't rematerialize instructions which - // clobber the flags register. - if regspec.clobbers&flagRegMask != 0 { - return false - } - - if len(v.Args) == 0 { - return true - } - if len(v.Args) == 1 && (v.Args[0].Op == OpSP || v.Args[0].Op == OpSB) { + for _, a := range v.Args { // SP and SB (generated by OpSP and OpSB) are always available. - return true + if a.Op != OpSP && a.Op != OpSB { + return false + } } - return false + return true } type liveInfo struct { diff --git a/src/cmd/compile/internal/ssa/regalloc_test.go b/src/cmd/compile/internal/ssa/regalloc_test.go index 596a920858..6f3f690f1e 100644 --- a/src/cmd/compile/internal/ssa/regalloc_test.go +++ b/src/cmd/compile/internal/ssa/regalloc_test.go @@ -10,9 +10,9 @@ func TestLiveControlOps(t *testing.T) { c := testConfig(t) f := Fun(c, "entry", Bloc("entry", - Valu("mem", OpInitMem, TypeMem, 0, ".mem"), - Valu("x", OpAMD64MOVBconst, TypeInt8, 0, 1), - Valu("y", OpAMD64MOVBconst, TypeInt8, 0, 2), + 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"), diff --git a/src/cmd/compile/internal/ssa/schedule_test.go b/src/cmd/compile/internal/ssa/schedule_test.go index 30c029ef7c..0ff57e3689 100644 --- a/src/cmd/compile/internal/ssa/schedule_test.go +++ b/src/cmd/compile/internal/ssa/schedule_test.go @@ -11,7 +11,7 @@ func TestSchedule(t *testing.T) { cases := []fun{ Fun(c, "entry", Bloc("entry", - Valu("mem0", OpInitMem, TypeMem, 0, ".mem"), + 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"), diff --git a/src/cmd/compile/internal/ssa/shift_test.go b/src/cmd/compile/internal/ssa/shift_test.go index 68d5f2ef70..8d5e62f070 100644 --- a/src/cmd/compile/internal/ssa/shift_test.go +++ b/src/cmd/compile/internal/ssa/shift_test.go @@ -34,7 +34,7 @@ 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, ".mem"), + 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"), diff --git a/src/cmd/compile/internal/ssa/shortcircuit_test.go b/src/cmd/compile/internal/ssa/shortcircuit_test.go index d518dfbabf..f208801fc1 100644 --- a/src/cmd/compile/internal/ssa/shortcircuit_test.go +++ b/src/cmd/compile/internal/ssa/shortcircuit_test.go @@ -11,7 +11,7 @@ func TestShortCircuit(t *testing.T) { fun := Fun(c, "entry", Bloc("entry", - Valu("mem", OpInitMem, TypeMem, 0, ".mem"), + Valu("mem", OpInitMem, TypeMem, 0, nil), Valu("arg1", OpArg, TypeInt64, 0, nil), Valu("arg2", OpArg, TypeInt64, 0, nil), Valu("arg3", OpArg, TypeInt64, 0, nil), diff --git a/src/cmd/compile/internal/ssa/value.go b/src/cmd/compile/internal/ssa/value.go index e338c4435b..af6bb3b97e 100644 --- a/src/cmd/compile/internal/ssa/value.go +++ b/src/cmd/compile/internal/ssa/value.go @@ -57,34 +57,72 @@ func (v *Value) String() string { 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) +} +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 [aux] args [: reg] func (v *Value) LongString() string { s := fmt.Sprintf("v%d = %s", v.ID, v.Op.String()) s += " <" + v.Type.String() + ">" - // TODO: use some operator property flags to decide - // what is encoded in the AuxInt field. - switch v.Op { - case OpConst32F, OpConst64F: - s += fmt.Sprintf(" [%g]", math.Float64frombits(uint64(v.AuxInt))) - case OpConstBool: + switch opcodeTable[v.Op].auxType { + case auxBool: if v.AuxInt == 0 { s += " [false]" } else { s += " [true]" } - case OpAMD64MOVBstoreconst, OpAMD64MOVWstoreconst, OpAMD64MOVLstoreconst, OpAMD64MOVQstoreconst: - s += fmt.Sprintf(" [%s]", ValAndOff(v.AuxInt)) - default: - if v.AuxInt != 0 { - s += fmt.Sprintf(" [%d]", v.AuxInt) + 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 auxSymOff: + if v.Aux != nil { + s += fmt.Sprintf(" {%s}", v.Aux) } - } - if v.Aux != nil { - if _, ok := v.Aux.(string); ok { - s += fmt.Sprintf(" {%q}", v.Aux) - } else { - s += fmt.Sprintf(" {%v}", v.Aux) + s += fmt.Sprintf(" [%s]", 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) -- cgit v1.3 From 3297a4f5f320ca8262ba5d222d3571020a9460bc Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Tue, 2 Feb 2016 06:35:34 -0500 Subject: [dev.ssa] cmd/compile: cache sparse sets in Config Move the cached sparse sets to the Config. I tested make.bash with pre-allocating sets of size 150 and not caching very small sets, but the difference between this implementation (no min size, no preallocation) and a min size with preallocation was fairly negligible: Number of sparse sets allocated: Cached in Config w/none preallocated no min size 3684 *this CL* Cached in Config w/three preallocated no min size 3370 Cached in Config w/three preallocated min size=150 3370 Cached in Config w/none preallocated min size=150 15947 Cached in Func, w/no min 96996 *previous code* Change-Id: I7f9de8a7cae192648a7413bfb18a6690fad34375 Reviewed-on: https://go-review.googlesource.com/19152 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/config.go | 2 ++ src/cmd/compile/internal/ssa/func.go | 14 ++++++-------- 2 files changed, 8 insertions(+), 8 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/config.go b/src/cmd/compile/internal/ssa/config.go index 060eec2335..530c480004 100644 --- a/src/cmd/compile/internal/ssa/config.go +++ b/src/cmd/compile/internal/ssa/config.go @@ -23,6 +23,8 @@ type Config struct { // Storage for low-numbered values and blocks. values [2000]Value blocks [200]Block + + scrSparse []*sparseSet // scratch sparse sets to be re-used. } type TypeSource interface { diff --git a/src/cmd/compile/internal/ssa/func.go b/src/cmd/compile/internal/ssa/func.go index 9da390904d..6e101ec1cb 100644 --- a/src/cmd/compile/internal/ssa/func.go +++ b/src/cmd/compile/internal/ssa/func.go @@ -31,8 +31,6 @@ type Func struct { 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. - - scrSparse []*sparseSet // sparse sets to be re-used. } // NumBlocks returns an integer larger than the id of any Block in the Func. @@ -47,9 +45,9 @@ func (f *Func) NumValues() int { // 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.scrSparse { + for i, scr := range f.Config.scrSparse { if scr != nil && scr.cap() >= n { - f.scrSparse[i] = nil + f.Config.scrSparse[i] = nil scr.clear() return scr } @@ -57,15 +55,15 @@ func (f *Func) newSparseSet(n int) *sparseSet { return newSparseSet(n) } -// retSparseSet returns a sparse set to the function's cache to be reused by f.newSparseSet. +// 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.scrSparse { + for i, scr := range f.Config.scrSparse { if scr == nil { - f.scrSparse[i] = ss + f.Config.scrSparse[i] = ss return } } - f.scrSparse = append(f.scrSparse, ss) + 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. -- cgit v1.3 From 955749c45f7bcff039adbe54d11c7c24782d6941 Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Wed, 3 Feb 2016 19:27:43 -0500 Subject: [dev.ssa] cmd/compile: remove dead code Change-Id: I1738e3af7de0972c54d74325d80781059d0796d8 Reviewed-on: https://go-review.googlesource.com/19186 Run-TryBot: Todd Neal TryBot-Result: Gobot Gobot Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/cse.go | 14 -------------- 1 file changed, 14 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/cse.go b/src/cmd/compile/internal/ssa/cse.go index 14cec12e92..1cf0dfd4d9 100644 --- a/src/cmd/compile/internal/ssa/cse.go +++ b/src/cmd/compile/internal/ssa/cse.go @@ -178,20 +178,6 @@ func cse(f *Func) { } } -// returns true if b dominates c. -// simple and iterative, has O(depth) complexity in tall trees. -func dom(b, c *Block, idom []*Block) bool { - // Walk up from c in the dominator tree looking for b. - for c != nil { - if c == b { - return true - } - c = idom[c.ID] - } - // Reached the entry block, never saw b. - return false -} - // An eqclass approximates an equivalence class. During the // algorithm it may represent the union of several of the // final equivalence classes. -- cgit v1.3 From c58c20f30f5b34af6b36b21b1348a5d8011612ac Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Wed, 3 Feb 2016 21:06:21 -0500 Subject: [dev.ssa] cmd/compile: use sparsetree in checkFunc Modify the simple domCheck to use the sparse tree code. This speeds up compilation of one of the generated test cases from 1m48s to 17s. Change-Id: If577410ee77b54918147a66917a8e3721297ee0a Reviewed-on: https://go-review.googlesource.com/19187 Run-TryBot: Todd Neal TryBot-Result: Gobot Gobot Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/check.go | 19 ++++++------------- 1 file changed, 6 insertions(+), 13 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/check.go b/src/cmd/compile/internal/ssa/check.go index 220877242c..796d899f7c 100644 --- a/src/cmd/compile/internal/ssa/check.go +++ b/src/cmd/compile/internal/ssa/check.go @@ -253,6 +253,7 @@ func checkFunc(f *Func) { // 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 { @@ -261,12 +262,12 @@ func checkFunc(f *Func) { if v.Op == OpPhi { y = b.Preds[i] } - if !domCheck(f, idom, x, y) { + 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, idom, b.Control.Block, b) { + if b.Control != nil && !domCheck(f, sdom, b.Control.Block, b) { f.Fatalf("control value %s for %s doesn't dominate", b.Control, b) } } @@ -274,18 +275,10 @@ func checkFunc(f *Func) { } // domCheck reports whether x dominates y (including x==y). -func domCheck(f *Func, idom []*Block, x, y *Block) bool { - if y != f.Entry && idom[y.ID] == nil { +func domCheck(f *Func, sdom sparseTree, x, y *Block) bool { + if !sdom.isAncestorEq(y, f.Entry) { // unreachable - ignore return true } - for { - if x == y { - return true - } - y = idom[y.ID] - if y == nil { - return false - } - } + return sdom.isAncestorEq(x, y) } -- cgit v1.3 From d4a95e78fa176e02a19cd94c9c273743f3a983c1 Mon Sep 17 00:00:00 2001 From: Alexandru Moșoi Date: Wed, 3 Feb 2016 19:43:46 +0100 Subject: [dev.ssa] cmd/compile/internal/ssa: simplify comparisons with constants * Simplify comparisons of form a + const1 == const2 or a + const1 != const2. * Canonicalize Eq, Neq, Add, Sub to have a constant as first argument. Needed for the above new rules and helps constant folding. Change-Id: I8078702a5daa706da57106073a3e9f640a67f486 Reviewed-on: https://go-review.googlesource.com/19192 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/testdata/cmp_ssa.go | 48 ++ src/cmd/compile/internal/ssa/gen/generic.rules | 31 ++ src/cmd/compile/internal/ssa/rewritegeneric.go | 704 ++++++++++++++++++++++++ 3 files changed, 783 insertions(+) create mode 100644 src/cmd/compile/internal/gc/testdata/cmp_ssa.go (limited to 'src/cmd') 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 0000000000..ba420f2e4e --- /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/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index 3b7209a2b2..658d78ca32 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -48,6 +48,37 @@ (Neq16 x x) -> (ConstBool [0]) (Neq8 x x) -> (ConstBool [0]) +(Eq64 (Const64 [c]) (Add64 (Const64 [d]) x)) -> (Eq64 (Const64 [c-d]) x) +(Eq32 (Const32 [c]) (Add32 (Const32 [d]) x)) -> (Eq32 (Const32 [c-d]) x) +(Eq16 (Const16 [c]) (Add16 (Const16 [d]) x)) -> (Eq16 (Const16 [c-d]) x) +(Eq8 (Const8 [c]) (Add8 (Const8 [d]) x)) -> (Eq8 (Const8 [c-d]) x) + +(Neq64 (Const64 [c]) (Add64 (Const64 [d]) x)) -> (Neq64 (Const64 [c-d]) x) +(Neq32 (Const32 [c]) (Add32 (Const32 [d]) x)) -> (Neq32 (Const32 [c-d]) x) +(Neq16 (Const16 [c]) (Add16 (Const16 [d]) x)) -> (Neq16 (Const16 [c-d]) x) +(Neq8 (Const8 [c]) (Add8 (Const8 [d]) x)) -> (Neq8 (Const8 [c-d]) x) + +// canonicalize: swap arguments for commutative opertions when one argument is a constant. +(Eq64 x (Const64 [c])) && x.Op != OpConst64 -> (Eq64 (Const64 [c]) x) +(Eq32 x (Const32 [c])) && x.Op != OpConst32 -> (Eq32 (Const32 [c]) x) +(Eq16 x (Const16 [c])) && x.Op != OpConst16 -> (Eq16 (Const16 [c]) x) +(Eq8 x (Const8 [c])) && x.Op != OpConst8 -> (Eq8 (Const8 [c]) x) + +(Neq64 x (Const64 [c])) && x.Op != OpConst64 -> (Neq64 (Const64 [c]) x) +(Neq32 x (Const32 [c])) && x.Op != OpConst32 -> (Neq32 (Const32 [c]) x) +(Neq16 x (Const16 [c])) && x.Op != OpConst16 -> (Neq16 (Const16 [c]) x) +(Neq8 x (Const8 [c])) && x.Op != OpConst8 -> (Neq8 (Const8 [c]) x) + +(Add64 x (Const64 [c])) && x.Op != OpConst64 -> (Add64 (Const64 [c]) x) +(Add32 x (Const32 [c])) && x.Op != OpConst32 -> (Add32 (Const32 [c]) x) +(Add16 x (Const16 [c])) && x.Op != OpConst16 -> (Add16 (Const16 [c]) x) +(Add8 x (Const8 [c])) && x.Op != OpConst8 -> (Add8 (Const8 [c]) x) + +(Sub64 x (Const64 [c])) && x.Op != OpConst64 -> (Add64 (Const64 [-c]) x) +(Sub32 x (Const32 [c])) && x.Op != OpConst32 -> (Add32 (Const32 [-c]) x) +(Sub16 x (Const16 [c])) && x.Op != OpConst16 -> (Add16 (Const16 [-c]) x) +(Sub8 x (Const8 [c])) && x.Op != OpConst8 -> (Add8 (Const8 [-c]) x) + // constant comparisons (Eq64 (Const64 [c]) (Const64 [d])) -> (ConstBool [b2i(int64(c) == int64(d))]) (Eq32 (Const32 [c]) (Const32 [d])) -> (ConstBool [b2i(int32(c) == int32(d))]) diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index 149553dbc2..60d9f06ae6 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -224,6 +224,33 @@ func rewriteValuegeneric_OpAdd16(v *Value, config *Config) bool { } goto end359c546ef662b7990116329cb30d6892 end359c546ef662b7990116329cb30d6892: + ; + // match: (Add16 x (Const16 [c])) + // cond: x.Op != OpConst16 + // result: (Add16 (Const16 [c]) x) + { + x := v.Args[0] + if v.Args[1].Op != OpConst16 { + goto end89b69a89778f375b0ebbc683b0c63176 + } + t := v.Args[1].Type + c := v.Args[1].AuxInt + if !(x.Op != OpConst16) { + goto end89b69a89778f375b0ebbc683b0c63176 + } + v.Op = OpAdd16 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpConst16, TypeInvalid) + v0.Type = t + v0.AuxInt = c + v.AddArg(v0) + v.AddArg(x) + return true + } + goto end89b69a89778f375b0ebbc683b0c63176 +end89b69a89778f375b0ebbc683b0c63176: ; return false } @@ -251,6 +278,33 @@ func rewriteValuegeneric_OpAdd32(v *Value, config *Config) bool { } goto enda3edaa9a512bd1d7a95f002c890bfb88 enda3edaa9a512bd1d7a95f002c890bfb88: + ; + // match: (Add32 x (Const32 [c])) + // cond: x.Op != OpConst32 + // result: (Add32 (Const32 [c]) x) + { + x := v.Args[0] + if v.Args[1].Op != OpConst32 { + goto end28a8c474bfa6968950dce0ed73b14a0b + } + t := v.Args[1].Type + c := v.Args[1].AuxInt + if !(x.Op != OpConst32) { + goto end28a8c474bfa6968950dce0ed73b14a0b + } + v.Op = OpAdd32 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpConst32, TypeInvalid) + v0.Type = t + v0.AuxInt = c + v.AddArg(v0) + v.AddArg(x) + return true + } + goto end28a8c474bfa6968950dce0ed73b14a0b +end28a8c474bfa6968950dce0ed73b14a0b: ; return false } @@ -278,6 +332,33 @@ func rewriteValuegeneric_OpAdd64(v *Value, config *Config) bool { } goto end8c46df6f85a11cb1d594076b0e467908 end8c46df6f85a11cb1d594076b0e467908: + ; + // match: (Add64 x (Const64 [c])) + // cond: x.Op != OpConst64 + // result: (Add64 (Const64 [c]) x) + { + x := v.Args[0] + if v.Args[1].Op != OpConst64 { + goto end39caa6cf1044f5c47ddbeb062d1a13bd + } + t := v.Args[1].Type + c := v.Args[1].AuxInt + if !(x.Op != OpConst64) { + goto end39caa6cf1044f5c47ddbeb062d1a13bd + } + v.Op = OpAdd64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpConst64, TypeInvalid) + v0.Type = t + v0.AuxInt = c + v.AddArg(v0) + v.AddArg(x) + return true + } + goto end39caa6cf1044f5c47ddbeb062d1a13bd +end39caa6cf1044f5c47ddbeb062d1a13bd: ; return false } @@ -305,6 +386,33 @@ func rewriteValuegeneric_OpAdd8(v *Value, config *Config) bool { } goto end60c66721511a442aade8e4da2fb326bd end60c66721511a442aade8e4da2fb326bd: + ; + // match: (Add8 x (Const8 [c])) + // cond: x.Op != OpConst8 + // result: (Add8 (Const8 [c]) x) + { + x := v.Args[0] + if v.Args[1].Op != OpConst8 { + goto end8c2901b8d12fa5c37f190783b4db8df5 + } + t := v.Args[1].Type + c := v.Args[1].AuxInt + if !(x.Op != OpConst8) { + goto end8c2901b8d12fa5c37f190783b4db8df5 + } + v.Op = OpAdd8 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpConst8, TypeInvalid) + v0.Type = t + v0.AuxInt = c + v.AddArg(v0) + v.AddArg(x) + return true + } + goto end8c2901b8d12fa5c37f190783b4db8df5 +end8c2901b8d12fa5c37f190783b4db8df5: ; return false } @@ -1141,6 +1249,67 @@ func rewriteValuegeneric_OpEq16(v *Value, config *Config) bool { } goto end0c0fe5fdfba3821add3448fd3f1fc6b7 end0c0fe5fdfba3821add3448fd3f1fc6b7: + ; + // match: (Eq16 (Const16 [c]) (Add16 (Const16 [d]) x)) + // cond: + // result: (Eq16 (Const16 [c-d]) x) + { + if v.Args[0].Op != OpConst16 { + goto end79c830afa265161fc0f0532c4c4e7f50 + } + t := v.Args[0].Type + c := v.Args[0].AuxInt + if v.Args[1].Op != OpAdd16 { + goto end79c830afa265161fc0f0532c4c4e7f50 + } + if v.Args[1].Args[0].Op != OpConst16 { + goto end79c830afa265161fc0f0532c4c4e7f50 + } + if v.Args[1].Args[0].Type != v.Args[0].Type { + goto end79c830afa265161fc0f0532c4c4e7f50 + } + d := v.Args[1].Args[0].AuxInt + x := v.Args[1].Args[1] + v.Op = OpEq16 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpConst16, TypeInvalid) + v0.Type = t + v0.AuxInt = c - d + v.AddArg(v0) + v.AddArg(x) + return true + } + goto end79c830afa265161fc0f0532c4c4e7f50 +end79c830afa265161fc0f0532c4c4e7f50: + ; + // match: (Eq16 x (Const16 [c])) + // cond: x.Op != OpConst16 + // result: (Eq16 (Const16 [c]) x) + { + x := v.Args[0] + if v.Args[1].Op != OpConst16 { + goto end5d89fe1eeb145f14e11578f41282c904 + } + t := v.Args[1].Type + c := v.Args[1].AuxInt + if !(x.Op != OpConst16) { + goto end5d89fe1eeb145f14e11578f41282c904 + } + v.Op = OpEq16 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpConst16, TypeInvalid) + v0.Type = t + v0.AuxInt = c + v.AddArg(v0) + v.AddArg(x) + return true + } + goto end5d89fe1eeb145f14e11578f41282c904 +end5d89fe1eeb145f14e11578f41282c904: ; // match: (Eq16 (Const16 [c]) (Const16 [d])) // cond: @@ -1186,6 +1355,67 @@ func rewriteValuegeneric_OpEq32(v *Value, config *Config) bool { } goto end6da547ec4ee93d787434f3bda873e4a0 end6da547ec4ee93d787434f3bda873e4a0: + ; + // match: (Eq32 (Const32 [c]) (Add32 (Const32 [d]) x)) + // cond: + // result: (Eq32 (Const32 [c-d]) x) + { + if v.Args[0].Op != OpConst32 { + goto end1a69730a32c6e432784dcdf643320ecd + } + t := v.Args[0].Type + c := v.Args[0].AuxInt + if v.Args[1].Op != OpAdd32 { + goto end1a69730a32c6e432784dcdf643320ecd + } + if v.Args[1].Args[0].Op != OpConst32 { + goto end1a69730a32c6e432784dcdf643320ecd + } + if v.Args[1].Args[0].Type != v.Args[0].Type { + goto end1a69730a32c6e432784dcdf643320ecd + } + d := v.Args[1].Args[0].AuxInt + x := v.Args[1].Args[1] + v.Op = OpEq32 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpConst32, TypeInvalid) + v0.Type = t + v0.AuxInt = c - d + v.AddArg(v0) + v.AddArg(x) + return true + } + goto end1a69730a32c6e432784dcdf643320ecd +end1a69730a32c6e432784dcdf643320ecd: + ; + // match: (Eq32 x (Const32 [c])) + // cond: x.Op != OpConst32 + // result: (Eq32 (Const32 [c]) x) + { + x := v.Args[0] + if v.Args[1].Op != OpConst32 { + goto end0ca4ef4cf416ec3083d38667e263cf45 + } + t := v.Args[1].Type + c := v.Args[1].AuxInt + if !(x.Op != OpConst32) { + goto end0ca4ef4cf416ec3083d38667e263cf45 + } + v.Op = OpEq32 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpConst32, TypeInvalid) + v0.Type = t + v0.AuxInt = c + v.AddArg(v0) + v.AddArg(x) + return true + } + goto end0ca4ef4cf416ec3083d38667e263cf45 +end0ca4ef4cf416ec3083d38667e263cf45: ; // match: (Eq32 (Const32 [c]) (Const32 [d])) // cond: @@ -1231,6 +1461,67 @@ func rewriteValuegeneric_OpEq64(v *Value, config *Config) bool { } goto endb1d471cc503ba8bb05440f01dbf33d81 endb1d471cc503ba8bb05440f01dbf33d81: + ; + // match: (Eq64 (Const64 [c]) (Add64 (Const64 [d]) x)) + // cond: + // result: (Eq64 (Const64 [c-d]) x) + { + if v.Args[0].Op != OpConst64 { + goto endffd67f3b83f6972cd459153d318f714d + } + t := v.Args[0].Type + c := v.Args[0].AuxInt + if v.Args[1].Op != OpAdd64 { + goto endffd67f3b83f6972cd459153d318f714d + } + if v.Args[1].Args[0].Op != OpConst64 { + goto endffd67f3b83f6972cd459153d318f714d + } + if v.Args[1].Args[0].Type != v.Args[0].Type { + goto endffd67f3b83f6972cd459153d318f714d + } + d := v.Args[1].Args[0].AuxInt + x := v.Args[1].Args[1] + v.Op = OpEq64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpConst64, TypeInvalid) + v0.Type = t + v0.AuxInt = c - d + v.AddArg(v0) + v.AddArg(x) + return true + } + goto endffd67f3b83f6972cd459153d318f714d +endffd67f3b83f6972cd459153d318f714d: + ; + // match: (Eq64 x (Const64 [c])) + // cond: x.Op != OpConst64 + // result: (Eq64 (Const64 [c]) x) + { + x := v.Args[0] + if v.Args[1].Op != OpConst64 { + goto endc2ecf8254dc736e97c5815362d0b477d + } + t := v.Args[1].Type + c := v.Args[1].AuxInt + if !(x.Op != OpConst64) { + goto endc2ecf8254dc736e97c5815362d0b477d + } + v.Op = OpEq64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpConst64, TypeInvalid) + v0.Type = t + v0.AuxInt = c + v.AddArg(v0) + v.AddArg(x) + return true + } + goto endc2ecf8254dc736e97c5815362d0b477d +endc2ecf8254dc736e97c5815362d0b477d: ; // match: (Eq64 (Const64 [c]) (Const64 [d])) // cond: @@ -1276,6 +1567,67 @@ func rewriteValuegeneric_OpEq8(v *Value, config *Config) bool { } goto enda66da0d3e7e51624ee46527727c48a9a enda66da0d3e7e51624ee46527727c48a9a: + ; + // match: (Eq8 (Const8 [c]) (Add8 (Const8 [d]) x)) + // cond: + // result: (Eq8 (Const8 [c-d]) x) + { + if v.Args[0].Op != OpConst8 { + goto end6912961350bb485f56ef176522aa683b + } + t := v.Args[0].Type + c := v.Args[0].AuxInt + if v.Args[1].Op != OpAdd8 { + goto end6912961350bb485f56ef176522aa683b + } + if v.Args[1].Args[0].Op != OpConst8 { + goto end6912961350bb485f56ef176522aa683b + } + if v.Args[1].Args[0].Type != v.Args[0].Type { + goto end6912961350bb485f56ef176522aa683b + } + d := v.Args[1].Args[0].AuxInt + x := v.Args[1].Args[1] + v.Op = OpEq8 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpConst8, TypeInvalid) + v0.Type = t + v0.AuxInt = c - d + v.AddArg(v0) + v.AddArg(x) + return true + } + goto end6912961350bb485f56ef176522aa683b +end6912961350bb485f56ef176522aa683b: + ; + // match: (Eq8 x (Const8 [c])) + // cond: x.Op != OpConst8 + // result: (Eq8 (Const8 [c]) x) + { + x := v.Args[0] + if v.Args[1].Op != OpConst8 { + goto end70d0b569427b24e7a912a1aa8fab3b20 + } + t := v.Args[1].Type + c := v.Args[1].AuxInt + if !(x.Op != OpConst8) { + goto end70d0b569427b24e7a912a1aa8fab3b20 + } + v.Op = OpEq8 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpConst8, TypeInvalid) + v0.Type = t + v0.AuxInt = c + v.AddArg(v0) + v.AddArg(x) + return true + } + goto end70d0b569427b24e7a912a1aa8fab3b20 +end70d0b569427b24e7a912a1aa8fab3b20: ; // match: (Eq8 (Const8 [c]) (Const8 [d])) // cond: @@ -2888,6 +3240,67 @@ func rewriteValuegeneric_OpNeq16(v *Value, config *Config) bool { } goto ende76a50b524aeb16c7aeccf5f5cc60c06 ende76a50b524aeb16c7aeccf5f5cc60c06: + ; + // match: (Neq16 (Const16 [c]) (Add16 (Const16 [d]) x)) + // cond: + // result: (Neq16 (Const16 [c-d]) x) + { + if v.Args[0].Op != OpConst16 { + goto end552011bd97e6f92ebc2672aa1843eadd + } + t := v.Args[0].Type + c := v.Args[0].AuxInt + if v.Args[1].Op != OpAdd16 { + goto end552011bd97e6f92ebc2672aa1843eadd + } + if v.Args[1].Args[0].Op != OpConst16 { + goto end552011bd97e6f92ebc2672aa1843eadd + } + if v.Args[1].Args[0].Type != v.Args[0].Type { + goto end552011bd97e6f92ebc2672aa1843eadd + } + d := v.Args[1].Args[0].AuxInt + x := v.Args[1].Args[1] + v.Op = OpNeq16 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpConst16, TypeInvalid) + v0.Type = t + v0.AuxInt = c - d + v.AddArg(v0) + v.AddArg(x) + return true + } + goto end552011bd97e6f92ebc2672aa1843eadd +end552011bd97e6f92ebc2672aa1843eadd: + ; + // match: (Neq16 x (Const16 [c])) + // cond: x.Op != OpConst16 + // result: (Neq16 (Const16 [c]) x) + { + x := v.Args[0] + if v.Args[1].Op != OpConst16 { + goto end0e45958f29e87997f632248aa9ee97e0 + } + t := v.Args[1].Type + c := v.Args[1].AuxInt + if !(x.Op != OpConst16) { + goto end0e45958f29e87997f632248aa9ee97e0 + } + v.Op = OpNeq16 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpConst16, TypeInvalid) + v0.Type = t + v0.AuxInt = c + v.AddArg(v0) + v.AddArg(x) + return true + } + goto end0e45958f29e87997f632248aa9ee97e0 +end0e45958f29e87997f632248aa9ee97e0: ; // match: (Neq16 (Const16 [c]) (Const16 [d])) // cond: @@ -2933,6 +3346,67 @@ func rewriteValuegeneric_OpNeq32(v *Value, config *Config) bool { } goto end3713a608cffd29b40ff7c3b3f2585cbb end3713a608cffd29b40ff7c3b3f2585cbb: + ; + // match: (Neq32 (Const32 [c]) (Add32 (Const32 [d]) x)) + // cond: + // result: (Neq32 (Const32 [c-d]) x) + { + if v.Args[0].Op != OpConst32 { + goto end93fc3b4a3639b965b414891111b16245 + } + t := v.Args[0].Type + c := v.Args[0].AuxInt + if v.Args[1].Op != OpAdd32 { + goto end93fc3b4a3639b965b414891111b16245 + } + if v.Args[1].Args[0].Op != OpConst32 { + goto end93fc3b4a3639b965b414891111b16245 + } + if v.Args[1].Args[0].Type != v.Args[0].Type { + goto end93fc3b4a3639b965b414891111b16245 + } + d := v.Args[1].Args[0].AuxInt + x := v.Args[1].Args[1] + v.Op = OpNeq32 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpConst32, TypeInvalid) + v0.Type = t + v0.AuxInt = c - d + v.AddArg(v0) + v.AddArg(x) + return true + } + goto end93fc3b4a3639b965b414891111b16245 +end93fc3b4a3639b965b414891111b16245: + ; + // match: (Neq32 x (Const32 [c])) + // cond: x.Op != OpConst32 + // result: (Neq32 (Const32 [c]) x) + { + x := v.Args[0] + if v.Args[1].Op != OpConst32 { + goto end5376f9ab90e282450f49011d0e0ce236 + } + t := v.Args[1].Type + c := v.Args[1].AuxInt + if !(x.Op != OpConst32) { + goto end5376f9ab90e282450f49011d0e0ce236 + } + v.Op = OpNeq32 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpConst32, TypeInvalid) + v0.Type = t + v0.AuxInt = c + v.AddArg(v0) + v.AddArg(x) + return true + } + goto end5376f9ab90e282450f49011d0e0ce236 +end5376f9ab90e282450f49011d0e0ce236: ; // match: (Neq32 (Const32 [c]) (Const32 [d])) // cond: @@ -2978,6 +3452,67 @@ func rewriteValuegeneric_OpNeq64(v *Value, config *Config) bool { } goto end3601ad382705ea12b79d2008c1e5725c end3601ad382705ea12b79d2008c1e5725c: + ; + // match: (Neq64 (Const64 [c]) (Add64 (Const64 [d]) x)) + // cond: + // result: (Neq64 (Const64 [c-d]) x) + { + if v.Args[0].Op != OpConst64 { + goto enda3d39cad13a557a2aa6d086f43596c1b + } + t := v.Args[0].Type + c := v.Args[0].AuxInt + if v.Args[1].Op != OpAdd64 { + goto enda3d39cad13a557a2aa6d086f43596c1b + } + if v.Args[1].Args[0].Op != OpConst64 { + goto enda3d39cad13a557a2aa6d086f43596c1b + } + if v.Args[1].Args[0].Type != v.Args[0].Type { + goto enda3d39cad13a557a2aa6d086f43596c1b + } + d := v.Args[1].Args[0].AuxInt + x := v.Args[1].Args[1] + v.Op = OpNeq64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpConst64, TypeInvalid) + v0.Type = t + v0.AuxInt = c - d + v.AddArg(v0) + v.AddArg(x) + return true + } + goto enda3d39cad13a557a2aa6d086f43596c1b +enda3d39cad13a557a2aa6d086f43596c1b: + ; + // match: (Neq64 x (Const64 [c])) + // cond: x.Op != OpConst64 + // result: (Neq64 (Const64 [c]) x) + { + x := v.Args[0] + if v.Args[1].Op != OpConst64 { + goto end0936a57de20373ca6cacb9506ddde708 + } + t := v.Args[1].Type + c := v.Args[1].AuxInt + if !(x.Op != OpConst64) { + goto end0936a57de20373ca6cacb9506ddde708 + } + v.Op = OpNeq64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpConst64, TypeInvalid) + v0.Type = t + v0.AuxInt = c + v.AddArg(v0) + v.AddArg(x) + return true + } + goto end0936a57de20373ca6cacb9506ddde708 +end0936a57de20373ca6cacb9506ddde708: ; // match: (Neq64 (Const64 [c]) (Const64 [d])) // cond: @@ -3023,6 +3558,67 @@ func rewriteValuegeneric_OpNeq8(v *Value, config *Config) bool { } goto end09a0deaf3c42627d0d2d3efa96e30745 end09a0deaf3c42627d0d2d3efa96e30745: + ; + // match: (Neq8 (Const8 [c]) (Add8 (Const8 [d]) x)) + // cond: + // result: (Neq8 (Const8 [c-d]) x) + { + if v.Args[0].Op != OpConst8 { + goto endc8f853c610c460c887cbfdca958e3691 + } + t := v.Args[0].Type + c := v.Args[0].AuxInt + if v.Args[1].Op != OpAdd8 { + goto endc8f853c610c460c887cbfdca958e3691 + } + if v.Args[1].Args[0].Op != OpConst8 { + goto endc8f853c610c460c887cbfdca958e3691 + } + if v.Args[1].Args[0].Type != v.Args[0].Type { + goto endc8f853c610c460c887cbfdca958e3691 + } + d := v.Args[1].Args[0].AuxInt + x := v.Args[1].Args[1] + v.Op = OpNeq8 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpConst8, TypeInvalid) + v0.Type = t + v0.AuxInt = c - d + v.AddArg(v0) + v.AddArg(x) + return true + } + goto endc8f853c610c460c887cbfdca958e3691 +endc8f853c610c460c887cbfdca958e3691: + ; + // match: (Neq8 x (Const8 [c])) + // cond: x.Op != OpConst8 + // result: (Neq8 (Const8 [c]) x) + { + x := v.Args[0] + if v.Args[1].Op != OpConst8 { + goto end04dc0ae2b08cf0447b50e5b8ef469252 + } + t := v.Args[1].Type + c := v.Args[1].AuxInt + if !(x.Op != OpConst8) { + goto end04dc0ae2b08cf0447b50e5b8ef469252 + } + v.Op = OpNeq8 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpConst8, TypeInvalid) + v0.Type = t + v0.AuxInt = c + v.AddArg(v0) + v.AddArg(x) + return true + } + goto end04dc0ae2b08cf0447b50e5b8ef469252 +end04dc0ae2b08cf0447b50e5b8ef469252: ; // match: (Neq8 (Const8 [c]) (Const8 [d])) // cond: @@ -4152,6 +4748,33 @@ func rewriteValuegeneric_OpSub16(v *Value, config *Config) bool { } goto end5c6fab95c9dbeff5973119096bfd4e78 end5c6fab95c9dbeff5973119096bfd4e78: + ; + // match: (Sub16 x (Const16 [c])) + // cond: x.Op != OpConst16 + // result: (Add16 (Const16 [-c]) x) + { + x := v.Args[0] + if v.Args[1].Op != OpConst16 { + goto end493545258a8e7e79d005b34c712ddd0c + } + t := v.Args[1].Type + c := v.Args[1].AuxInt + if !(x.Op != OpConst16) { + goto end493545258a8e7e79d005b34c712ddd0c + } + v.Op = OpAdd16 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpConst16, TypeInvalid) + v0.Type = t + v0.AuxInt = -c + v.AddArg(v0) + v.AddArg(x) + return true + } + goto end493545258a8e7e79d005b34c712ddd0c +end493545258a8e7e79d005b34c712ddd0c: ; // match: (Sub16 x x) // cond: @@ -4243,6 +4866,33 @@ func rewriteValuegeneric_OpSub32(v *Value, config *Config) bool { } goto end7623799db780e1bcc42c6ea0df9c49d3 end7623799db780e1bcc42c6ea0df9c49d3: + ; + // match: (Sub32 x (Const32 [c])) + // cond: x.Op != OpConst32 + // result: (Add32 (Const32 [-c]) x) + { + x := v.Args[0] + if v.Args[1].Op != OpConst32 { + goto end391e2f2ba8c7502b62c0153ec69c4fbd + } + t := v.Args[1].Type + c := v.Args[1].AuxInt + if !(x.Op != OpConst32) { + goto end391e2f2ba8c7502b62c0153ec69c4fbd + } + v.Op = OpAdd32 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpConst32, TypeInvalid) + v0.Type = t + v0.AuxInt = -c + v.AddArg(v0) + v.AddArg(x) + return true + } + goto end391e2f2ba8c7502b62c0153ec69c4fbd +end391e2f2ba8c7502b62c0153ec69c4fbd: ; // match: (Sub32 x x) // cond: @@ -4334,6 +4984,33 @@ func rewriteValuegeneric_OpSub64(v *Value, config *Config) bool { } goto end5a84a285ff0ff48b8ad3c64b15e3459f end5a84a285ff0ff48b8ad3c64b15e3459f: + ; + // match: (Sub64 x (Const64 [c])) + // cond: x.Op != OpConst64 + // result: (Add64 (Const64 [-c]) x) + { + x := v.Args[0] + if v.Args[1].Op != OpConst64 { + goto enda80d30f6794bcf02cd4442b238f68333 + } + t := v.Args[1].Type + c := v.Args[1].AuxInt + if !(x.Op != OpConst64) { + goto enda80d30f6794bcf02cd4442b238f68333 + } + v.Op = OpAdd64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpConst64, TypeInvalid) + v0.Type = t + v0.AuxInt = -c + v.AddArg(v0) + v.AddArg(x) + return true + } + goto enda80d30f6794bcf02cd4442b238f68333 +enda80d30f6794bcf02cd4442b238f68333: ; // match: (Sub64 x x) // cond: @@ -4425,6 +5102,33 @@ func rewriteValuegeneric_OpSub8(v *Value, config *Config) bool { } goto endc00ea11c7535529e211710574f5cff24 endc00ea11c7535529e211710574f5cff24: + ; + // match: (Sub8 x (Const8 [c])) + // cond: x.Op != OpConst8 + // result: (Add8 (Const8 [-c]) x) + { + x := v.Args[0] + if v.Args[1].Op != OpConst8 { + goto end0bfab5b6f1037e55dc049b79e2636678 + } + t := v.Args[1].Type + c := v.Args[1].AuxInt + if !(x.Op != OpConst8) { + goto end0bfab5b6f1037e55dc049b79e2636678 + } + v.Op = OpAdd8 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpConst8, TypeInvalid) + v0.Type = t + v0.AuxInt = -c + v.AddArg(v0) + v.AddArg(x) + return true + } + goto end0bfab5b6f1037e55dc049b79e2636678 +end0bfab5b6f1037e55dc049b79e2636678: ; // match: (Sub8 x x) // cond: -- cgit v1.3 From 606a11f46432f62edb759c1d1b86d536b08d0d96 Mon Sep 17 00:00:00 2001 From: Alexandru Moșoi Date: Wed, 3 Feb 2016 20:50:12 +0100 Subject: [dev.ssa] src/cmd/compile/internal/ssa/gen: detect type earlier when generating rules. Removes approx. one assignment per rule. Change-Id: Ie9f0a7082ae12c4447ff6b4d40678cd92bdbb6f2 Reviewed-on: https://go-review.googlesource.com/19194 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/gen/rulegen.go | 65 +- src/cmd/compile/internal/ssa/rewriteAMD64.go | 912 +++++++++---------------- src/cmd/compile/internal/ssa/rewritegeneric.go | 342 ++++------ 3 files changed, 463 insertions(+), 856 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/gen/rulegen.go b/src/cmd/compile/internal/ssa/gen/rulegen.go index 91fdff0784..8d6d00846d 100644 --- a/src/cmd/compile/internal/ssa/gen/rulegen.go +++ b/src/cmd/compile/internal/ssa/gen/rulegen.go @@ -446,19 +446,52 @@ func genResult0(w io.Writer, arch arch, result string, alloc *int, top bool, loc } 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 - var hasType bool if top && loc == "b" { v = "v" + if typeOverride { + fmt.Fprintf(w, "v.Type = %s\n", opType) + } fmt.Fprintf(w, "v.Op = %s\n", opName(s[0], arch)) fmt.Fprintf(w, "v.AuxInt = 0\n") fmt.Fprintf(w, "v.Aux = nil\n") fmt.Fprintf(w, "v.resetArgs()\n") - hasType = true } 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 := %s.NewValue0(v.Line, %s, TypeInvalid)\n", v, loc, opName(s[0], arch)) + fmt.Fprintf(w, "%s := %s.NewValue0(v.Line, %s, %s)\n", v, loc, opName(s[0], arch), opType) if top { // Rewrite original into a copy fmt.Fprintf(w, "v.Op = OpCopy\n") @@ -470,10 +503,7 @@ func genResult0(w io.Writer, arch arch, result string, alloc *int, top bool, loc } for _, a := range s[1:] { if a[0] == '<' { - // type restriction - t := a[1 : len(a)-1] // remove <> - fmt.Fprintf(w, "%s.Type = %s\n", v, t) - hasType = true + // type restriction, handled above } else if a[0] == '[' { // auxint restriction x := a[1 : len(a)-1] // remove [] @@ -488,26 +518,7 @@ func genResult0(w io.Writer, arch arch, result string, alloc *int, top bool, loc fmt.Fprintf(w, "%s.AddArg(%s)\n", v, x) } } - if !hasType { - // find default type, if any - for _, op := range arch.ops { - if op.name != s[0] || op.typ == "" || hasType { - continue - } - fmt.Fprintf(w, "%s.Type = %s\n", v, typeName(op.typ)) - hasType = true - } - for _, op := range genericOps { - if op.name != s[0] || op.typ == "" || hasType { - continue - } - fmt.Fprintf(w, "%s.Type = %s\n", v, typeName(op.typ)) - hasType = true - } - } - if !hasType { - log.Fatalf("sub-expression %s (op=%s) must have a type", result, s[0]) - } + return v } diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 5962794b88..ed62d3f958 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -2187,10 +2187,9 @@ end52190c0b8759133aa6c540944965c4c0: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeFlags) v0.AddArg(x) v0.AuxInt = c - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -2412,10 +2411,9 @@ end49ff4559c4bdecb2aef0c905e2d9a6cf: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeFlags) v0.AddArg(x) v0.AuxInt = c - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -2643,10 +2641,9 @@ end3bbb2c6caa57853a7561738ce3c0c630: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeFlags) v0.AddArg(x) v0.AuxInt = c - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -2868,10 +2865,9 @@ end310a9ba58ac35c97587e08c63fe8a46c: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeFlags) v0.AddArg(x) v0.AuxInt = c - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -3332,11 +3328,11 @@ func rewriteValueAMD64_OpConvert(v *Value, config *Config) bool { t := v.Type x := v.Args[0] mem := v.Args[1] + v.Type = t v.Op = OpAMD64MOVQconvert v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Type = t v.AddArg(x) v.AddArg(mem) return true @@ -3757,13 +3753,11 @@ func rewriteValueAMD64_OpDiv8(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpSignExt8to16, TypeInvalid) + v0 := b.NewValue0(v.Line, OpSignExt8to16, config.fe.TypeInt16()) v0.AddArg(x) - v0.Type = config.fe.TypeInt16() v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpSignExt8to16, TypeInvalid) + v1 := b.NewValue0(v.Line, OpSignExt8to16, config.fe.TypeInt16()) v1.AddArg(y) - v1.Type = config.fe.TypeInt16() v.AddArg(v1) return true } @@ -3785,13 +3779,11 @@ func rewriteValueAMD64_OpDiv8u(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpZeroExt8to16, TypeInvalid) + v0 := b.NewValue0(v.Line, OpZeroExt8to16, config.fe.TypeUInt16()) v0.AddArg(x) - v0.Type = config.fe.TypeUInt16() v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpZeroExt8to16, TypeInvalid) + v1 := b.NewValue0(v.Line, OpZeroExt8to16, config.fe.TypeUInt16()) v1.AddArg(y) - v1.Type = config.fe.TypeUInt16() v.AddArg(v1) return true } @@ -3813,10 +3805,9 @@ func rewriteValueAMD64_OpEq16(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -3838,10 +3829,9 @@ func rewriteValueAMD64_OpEq32(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -3863,10 +3853,9 @@ func rewriteValueAMD64_OpEq32F(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -3888,10 +3877,9 @@ func rewriteValueAMD64_OpEq64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -3913,10 +3901,9 @@ func rewriteValueAMD64_OpEq64F(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -3938,10 +3925,9 @@ func rewriteValueAMD64_OpEq8(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -3963,10 +3949,9 @@ func rewriteValueAMD64_OpEqPtr(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -3988,10 +3973,9 @@ func rewriteValueAMD64_OpGeq16(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -4013,10 +3997,9 @@ func rewriteValueAMD64_OpGeq16U(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -4038,10 +4021,9 @@ func rewriteValueAMD64_OpGeq32(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -4063,10 +4045,9 @@ func rewriteValueAMD64_OpGeq32F(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -4088,10 +4069,9 @@ func rewriteValueAMD64_OpGeq32U(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -4113,10 +4093,9 @@ func rewriteValueAMD64_OpGeq64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -4138,10 +4117,9 @@ func rewriteValueAMD64_OpGeq64F(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -4163,10 +4141,9 @@ func rewriteValueAMD64_OpGeq64U(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -4188,10 +4165,9 @@ func rewriteValueAMD64_OpGeq8(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -4213,10 +4189,9 @@ func rewriteValueAMD64_OpGeq8U(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -4298,10 +4273,9 @@ func rewriteValueAMD64_OpGreater16(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -4323,10 +4297,9 @@ func rewriteValueAMD64_OpGreater16U(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -4348,10 +4321,9 @@ func rewriteValueAMD64_OpGreater32(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -4373,10 +4345,9 @@ func rewriteValueAMD64_OpGreater32F(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -4398,10 +4369,9 @@ func rewriteValueAMD64_OpGreater32U(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -4423,10 +4393,9 @@ func rewriteValueAMD64_OpGreater64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -4448,10 +4417,9 @@ func rewriteValueAMD64_OpGreater64F(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -4473,10 +4441,9 @@ func rewriteValueAMD64_OpGreater64U(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -4498,10 +4465,9 @@ func rewriteValueAMD64_OpGreater8(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -4523,10 +4489,9 @@ func rewriteValueAMD64_OpGreater8U(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -4729,10 +4694,9 @@ func rewriteValueAMD64_OpIsInBounds(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeFlags) v0.AddArg(idx) v0.AddArg(len) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -4753,10 +4717,9 @@ func rewriteValueAMD64_OpIsNonNil(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64TESTQ, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64TESTQ, TypeFlags) v0.AddArg(p) v0.AddArg(p) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -4778,10 +4741,9 @@ func rewriteValueAMD64_OpIsSliceInBounds(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeFlags) v0.AddArg(idx) v0.AddArg(len) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -5116,10 +5078,9 @@ func rewriteValueAMD64_OpLeq16(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -5141,10 +5102,9 @@ func rewriteValueAMD64_OpLeq16U(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -5166,10 +5126,9 @@ func rewriteValueAMD64_OpLeq32(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -5191,10 +5150,9 @@ func rewriteValueAMD64_OpLeq32F(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeFlags) v0.AddArg(y) v0.AddArg(x) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -5216,10 +5174,9 @@ func rewriteValueAMD64_OpLeq32U(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -5241,10 +5198,9 @@ func rewriteValueAMD64_OpLeq64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -5266,10 +5222,9 @@ func rewriteValueAMD64_OpLeq64F(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeFlags) v0.AddArg(y) v0.AddArg(x) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -5291,10 +5246,9 @@ func rewriteValueAMD64_OpLeq64U(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -5316,10 +5270,9 @@ func rewriteValueAMD64_OpLeq8(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -5341,10 +5294,9 @@ func rewriteValueAMD64_OpLeq8U(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -5366,10 +5318,9 @@ func rewriteValueAMD64_OpLess16(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -5391,10 +5342,9 @@ func rewriteValueAMD64_OpLess16U(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -5416,10 +5366,9 @@ func rewriteValueAMD64_OpLess32(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -5441,10 +5390,9 @@ func rewriteValueAMD64_OpLess32F(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeFlags) v0.AddArg(y) v0.AddArg(x) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -5466,10 +5414,9 @@ func rewriteValueAMD64_OpLess32U(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -5491,10 +5438,9 @@ func rewriteValueAMD64_OpLess64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -5516,10 +5462,9 @@ func rewriteValueAMD64_OpLess64F(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeFlags) v0.AddArg(y) v0.AddArg(x) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -5541,10 +5486,9 @@ func rewriteValueAMD64_OpLess64U(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -5566,10 +5510,9 @@ func rewriteValueAMD64_OpLess8(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -5591,10 +5534,9 @@ func rewriteValueAMD64_OpLess8U(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -5744,11 +5686,11 @@ func rewriteValueAMD64_OpLrot16(v *Value, config *Config) bool { t := v.Type x := v.Args[0] c := v.AuxInt + v.Type = t v.Op = OpAMD64ROLWconst v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Type = t v.AuxInt = c & 15 v.AddArg(x) return true @@ -5768,11 +5710,11 @@ func rewriteValueAMD64_OpLrot32(v *Value, config *Config) bool { t := v.Type x := v.Args[0] c := v.AuxInt + v.Type = t v.Op = OpAMD64ROLLconst v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Type = t v.AuxInt = c & 31 v.AddArg(x) return true @@ -5792,11 +5734,11 @@ func rewriteValueAMD64_OpLrot64(v *Value, config *Config) bool { t := v.Type x := v.Args[0] c := v.AuxInt + v.Type = t v.Op = OpAMD64ROLQconst v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Type = t v.AuxInt = c & 63 v.AddArg(x) return true @@ -5816,11 +5758,11 @@ func rewriteValueAMD64_OpLrot8(v *Value, config *Config) bool { t := v.Type x := v.Args[0] c := v.AuxInt + v.Type = t v.Op = OpAMD64ROLBconst v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Type = t v.AuxInt = c & 7 v.AddArg(x) return true @@ -5844,17 +5786,14 @@ func rewriteValueAMD64_OpLsh16x16(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHLW, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpAMD64SHLW, t) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t) + v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeFlags) v2.AddArg(y) v2.AuxInt = 16 - v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true @@ -5878,17 +5817,14 @@ func rewriteValueAMD64_OpLsh16x32(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHLW, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpAMD64SHLW, t) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t) + v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeFlags) v2.AddArg(y) v2.AuxInt = 16 - v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true @@ -5912,17 +5848,14 @@ func rewriteValueAMD64_OpLsh16x64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHLW, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpAMD64SHLW, t) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t) + v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeFlags) v2.AddArg(y) v2.AuxInt = 16 - v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true @@ -5946,17 +5879,14 @@ func rewriteValueAMD64_OpLsh16x8(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHLW, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpAMD64SHLW, t) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t) + v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeFlags) v2.AddArg(y) v2.AuxInt = 16 - v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true @@ -5980,17 +5910,14 @@ func rewriteValueAMD64_OpLsh32x16(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHLL, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpAMD64SHLL, t) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t) + v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeFlags) v2.AddArg(y) v2.AuxInt = 32 - v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true @@ -6014,17 +5941,14 @@ func rewriteValueAMD64_OpLsh32x32(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHLL, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpAMD64SHLL, t) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t) + v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeFlags) v2.AddArg(y) v2.AuxInt = 32 - v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true @@ -6048,17 +5972,14 @@ func rewriteValueAMD64_OpLsh32x64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHLL, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpAMD64SHLL, t) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t) + v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeFlags) v2.AddArg(y) v2.AuxInt = 32 - v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true @@ -6082,17 +6003,14 @@ func rewriteValueAMD64_OpLsh32x8(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHLL, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpAMD64SHLL, t) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t) + v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeFlags) v2.AddArg(y) v2.AuxInt = 32 - v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true @@ -6116,17 +6034,14 @@ func rewriteValueAMD64_OpLsh64x16(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHLQ, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpAMD64SHLQ, t) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, t) + v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeFlags) v2.AddArg(y) v2.AuxInt = 64 - v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true @@ -6150,17 +6065,14 @@ func rewriteValueAMD64_OpLsh64x32(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHLQ, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpAMD64SHLQ, t) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, t) + v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeFlags) v2.AddArg(y) v2.AuxInt = 64 - v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true @@ -6184,17 +6096,14 @@ func rewriteValueAMD64_OpLsh64x64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHLQ, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpAMD64SHLQ, t) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, t) + v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeFlags) v2.AddArg(y) v2.AuxInt = 64 - v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true @@ -6218,17 +6127,14 @@ func rewriteValueAMD64_OpLsh64x8(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHLQ, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpAMD64SHLQ, t) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, t) + v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeFlags) v2.AddArg(y) v2.AuxInt = 64 - v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true @@ -6252,17 +6158,14 @@ func rewriteValueAMD64_OpLsh8x16(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHLB, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpAMD64SHLB, t) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t) + v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeFlags) v2.AddArg(y) v2.AuxInt = 8 - v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true @@ -6286,17 +6189,14 @@ func rewriteValueAMD64_OpLsh8x32(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHLB, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpAMD64SHLB, t) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t) + v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeFlags) v2.AddArg(y) v2.AuxInt = 8 - v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true @@ -6320,17 +6220,14 @@ func rewriteValueAMD64_OpLsh8x64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHLB, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpAMD64SHLB, t) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t) + v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeFlags) v2.AddArg(y) v2.AuxInt = 8 - v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true @@ -6354,17 +6251,14 @@ func rewriteValueAMD64_OpLsh8x8(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHLB, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpAMD64SHLB, t) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t) + v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeFlags) v2.AddArg(y) v2.AuxInt = 8 - v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true @@ -6388,13 +6282,12 @@ func rewriteValueAMD64_OpAMD64MOVBQSX(v *Value, config *Config) bool { sym := v.Args[0].Aux ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] - v0 := v.Args[0].Block.NewValue0(v.Line, OpAMD64MOVBQSXload, TypeInvalid) + v0 := v.Args[0].Block.NewValue0(v.Line, OpAMD64MOVBQSXload, v.Type) v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AddArg(v0) - v0.Type = v.Type v0.AuxInt = off v0.Aux = sym v0.AddArg(ptr) @@ -6443,13 +6336,12 @@ func rewriteValueAMD64_OpAMD64MOVBQZX(v *Value, config *Config) bool { sym := v.Args[0].Aux ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] - v0 := v.Args[0].Block.NewValue0(v.Line, OpAMD64MOVBQZXload, TypeInvalid) + v0 := v.Args[0].Block.NewValue0(v.Line, OpAMD64MOVBQZXload, v.Type) v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AddArg(v0) - v0.Type = v.Type v0.AuxInt = off v0.Aux = sym v0.AddArg(ptr) @@ -6854,13 +6746,12 @@ func rewriteValueAMD64_OpAMD64MOVLQSX(v *Value, config *Config) bool { sym := v.Args[0].Aux ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] - v0 := v.Args[0].Block.NewValue0(v.Line, OpAMD64MOVLQSXload, TypeInvalid) + v0 := v.Args[0].Block.NewValue0(v.Line, OpAMD64MOVLQSXload, v.Type) v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AddArg(v0) - v0.Type = v.Type v0.AuxInt = off v0.Aux = sym v0.AddArg(ptr) @@ -6909,13 +6800,12 @@ func rewriteValueAMD64_OpAMD64MOVLQZX(v *Value, config *Config) bool { sym := v.Args[0].Aux ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] - v0 := v.Args[0].Block.NewValue0(v.Line, OpAMD64MOVLQZXload, TypeInvalid) + v0 := v.Args[0].Block.NewValue0(v.Line, OpAMD64MOVLQZXload, v.Type) v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AddArg(v0) - v0.Type = v.Type v0.AuxInt = off v0.Aux = sym v0.AddArg(ptr) @@ -8272,13 +8162,12 @@ func rewriteValueAMD64_OpAMD64MOVWQSX(v *Value, config *Config) bool { sym := v.Args[0].Aux ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] - v0 := v.Args[0].Block.NewValue0(v.Line, OpAMD64MOVWQSXload, TypeInvalid) + v0 := v.Args[0].Block.NewValue0(v.Line, OpAMD64MOVWQSXload, v.Type) v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AddArg(v0) - v0.Type = v.Type v0.AuxInt = off v0.Aux = sym v0.AddArg(ptr) @@ -8327,13 +8216,12 @@ func rewriteValueAMD64_OpAMD64MOVWQZX(v *Value, config *Config) bool { sym := v.Args[0].Aux ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] - v0 := v.Args[0].Block.NewValue0(v.Line, OpAMD64MOVWQZXload, TypeInvalid) + v0 := v.Args[0].Block.NewValue0(v.Line, OpAMD64MOVWQZXload, v.Type) v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AddArg(v0) - v0.Type = v.Type v0.AuxInt = off v0.Aux = sym v0.AddArg(ptr) @@ -9254,13 +9142,11 @@ func rewriteValueAMD64_OpMod8(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpSignExt8to16, TypeInvalid) + v0 := b.NewValue0(v.Line, OpSignExt8to16, config.fe.TypeInt16()) v0.AddArg(x) - v0.Type = config.fe.TypeInt16() v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpSignExt8to16, TypeInvalid) + v1 := b.NewValue0(v.Line, OpSignExt8to16, config.fe.TypeInt16()) v1.AddArg(y) - v1.Type = config.fe.TypeInt16() v.AddArg(v1) return true } @@ -9282,13 +9168,11 @@ func rewriteValueAMD64_OpMod8u(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpZeroExt8to16, TypeInvalid) + v0 := b.NewValue0(v.Line, OpZeroExt8to16, config.fe.TypeUInt16()) v0.AddArg(x) - v0.Type = config.fe.TypeUInt16() v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpZeroExt8to16, TypeInvalid) + v1 := b.NewValue0(v.Line, OpZeroExt8to16, config.fe.TypeUInt16()) v1.AddArg(y) - v1.Type = config.fe.TypeUInt16() v.AddArg(v1) return true } @@ -9334,10 +9218,9 @@ end0961cbfe144a616cba75190d07d65e41: v.Aux = nil v.resetArgs() v.AddArg(dst) - v0 := b.NewValue0(v.Line, OpAMD64MOVBload, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64MOVBload, config.fe.TypeUInt8()) v0.AddArg(src) v0.AddArg(mem) - v0.Type = config.fe.TypeUInt8() v.AddArg(v0) v.AddArg(mem) return true @@ -9360,10 +9243,9 @@ end72e5dd27e999493b67ea3af4ecc60d48: v.Aux = nil v.resetArgs() v.AddArg(dst) - v0 := b.NewValue0(v.Line, OpAMD64MOVWload, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64MOVWload, config.fe.TypeUInt16()) v0.AddArg(src) v0.AddArg(mem) - v0.Type = config.fe.TypeUInt16() v.AddArg(v0) v.AddArg(mem) return true @@ -9386,10 +9268,9 @@ end017f774e406d4578b4bcefcd8db8ec1e: v.Aux = nil v.resetArgs() v.AddArg(dst) - v0 := b.NewValue0(v.Line, OpAMD64MOVLload, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64MOVLload, config.fe.TypeUInt32()) v0.AddArg(src) v0.AddArg(mem) - v0.Type = config.fe.TypeUInt32() v.AddArg(v0) v.AddArg(mem) return true @@ -9412,10 +9293,9 @@ end938ec47a2ddf8e9b4bf71ffade6e5b3f: v.Aux = nil v.resetArgs() v.AddArg(dst) - v0 := b.NewValue0(v.Line, OpAMD64MOVQload, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64MOVQload, config.fe.TypeUInt64()) v0.AddArg(src) v0.AddArg(mem) - v0.Type = config.fe.TypeUInt64() v.AddArg(v0) v.AddArg(mem) return true @@ -9438,10 +9318,9 @@ end696b3498f5fee17f49ae0f708d3dfe4b: v.Aux = nil v.resetArgs() v.AddArg(dst) - v0 := b.NewValue0(v.Line, OpAMD64MOVOload, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64MOVOload, TypeInt128) v0.AddArg(src) v0.AddArg(mem) - v0.Type = TypeInt128 v.AddArg(v0) v.AddArg(mem) return true @@ -9465,21 +9344,18 @@ end4894ace925d468c10a5b0c5b91fc4c1c: v.resetArgs() v.AuxInt = 2 v.AddArg(dst) - v0 := b.NewValue0(v.Line, OpAMD64MOVBload, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64MOVBload, config.fe.TypeUInt8()) v0.AuxInt = 2 v0.AddArg(src) v0.AddArg(mem) - v0.Type = config.fe.TypeUInt8() v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64MOVWstore, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64MOVWstore, TypeMem) v1.AddArg(dst) - v2 := b.NewValue0(v.Line, OpAMD64MOVWload, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64MOVWload, config.fe.TypeUInt16()) v2.AddArg(src) v2.AddArg(mem) - v2.Type = config.fe.TypeUInt16() v1.AddArg(v2) v1.AddArg(mem) - v1.Type = TypeMem v.AddArg(v1) return true } @@ -9502,21 +9378,18 @@ end76ce0004999139fe4608c3c5356eb364: v.resetArgs() v.AuxInt = 4 v.AddArg(dst) - v0 := b.NewValue0(v.Line, OpAMD64MOVBload, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64MOVBload, config.fe.TypeUInt8()) v0.AuxInt = 4 v0.AddArg(src) v0.AddArg(mem) - v0.Type = config.fe.TypeUInt8() v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64MOVLstore, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64MOVLstore, TypeMem) v1.AddArg(dst) - v2 := b.NewValue0(v.Line, OpAMD64MOVLload, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64MOVLload, config.fe.TypeUInt32()) v2.AddArg(src) v2.AddArg(mem) - v2.Type = config.fe.TypeUInt32() v1.AddArg(v2) v1.AddArg(mem) - v1.Type = TypeMem v.AddArg(v1) return true } @@ -9539,21 +9412,18 @@ end21378690c0f39bdd6b46566d57da34e3: v.resetArgs() v.AuxInt = 4 v.AddArg(dst) - v0 := b.NewValue0(v.Line, OpAMD64MOVWload, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64MOVWload, config.fe.TypeUInt16()) v0.AuxInt = 4 v0.AddArg(src) v0.AddArg(mem) - v0.Type = config.fe.TypeUInt16() v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64MOVLstore, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64MOVLstore, TypeMem) v1.AddArg(dst) - v2 := b.NewValue0(v.Line, OpAMD64MOVLload, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64MOVLload, config.fe.TypeUInt32()) v2.AddArg(src) v2.AddArg(mem) - v2.Type = config.fe.TypeUInt32() v1.AddArg(v2) v1.AddArg(mem) - v1.Type = TypeMem v.AddArg(v1) return true } @@ -9576,21 +9446,18 @@ endcb6e509881d8638d8cae3af4f2b19a8e: v.resetArgs() v.AuxInt = 3 v.AddArg(dst) - v0 := b.NewValue0(v.Line, OpAMD64MOVLload, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64MOVLload, config.fe.TypeUInt32()) v0.AuxInt = 3 v0.AddArg(src) v0.AddArg(mem) - v0.Type = config.fe.TypeUInt32() v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64MOVLstore, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64MOVLstore, TypeMem) v1.AddArg(dst) - v2 := b.NewValue0(v.Line, OpAMD64MOVLload, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64MOVLload, config.fe.TypeUInt32()) v2.AddArg(src) v2.AddArg(mem) - v2.Type = config.fe.TypeUInt32() v1.AddArg(v2) v1.AddArg(mem) - v1.Type = TypeMem v.AddArg(v1) return true } @@ -9614,21 +9481,18 @@ end3429ae54bc071c0856ad366c79b7ab97: v.resetArgs() v.AuxInt = size - 8 v.AddArg(dst) - v0 := b.NewValue0(v.Line, OpAMD64MOVQload, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64MOVQload, config.fe.TypeUInt64()) v0.AuxInt = size - 8 v0.AddArg(src) v0.AddArg(mem) - v0.Type = config.fe.TypeUInt64() v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64MOVQstore, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64MOVQstore, TypeMem) v1.AddArg(dst) - v2 := b.NewValue0(v.Line, OpAMD64MOVQload, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64MOVQload, config.fe.TypeUInt64()) v2.AddArg(src) v2.AddArg(mem) - v2.Type = config.fe.TypeUInt64() v1.AddArg(v2) v1.AddArg(mem) - v1.Type = TypeMem v.AddArg(v1) return true } @@ -9651,25 +9515,21 @@ endc90f121709d5411d389649dea89a2251: v.Aux = nil v.resetArgs() v.AuxInt = size - size%16 - v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) - v0.Type = dst.Type + v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, dst.Type) v0.AddArg(dst) v0.AuxInt = size % 16 v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) - v1.Type = src.Type + v1 := b.NewValue0(v.Line, OpAMD64ADDQconst, src.Type) v1.AddArg(src) v1.AuxInt = size % 16 v.AddArg(v1) - v2 := b.NewValue0(v.Line, OpAMD64MOVQstore, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64MOVQstore, TypeMem) v2.AddArg(dst) - v3 := b.NewValue0(v.Line, OpAMD64MOVQload, TypeInvalid) + v3 := b.NewValue0(v.Line, OpAMD64MOVQload, config.fe.TypeUInt64()) v3.AddArg(src) v3.AddArg(mem) - v3.Type = config.fe.TypeUInt64() v2.AddArg(v3) v2.AddArg(mem) - v2.Type = TypeMem v.AddArg(v2) return true } @@ -9692,25 +9552,21 @@ end376c57db23b866866f23677c6cde43ba: v.Aux = nil v.resetArgs() v.AuxInt = size - size%16 - v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) - v0.Type = dst.Type + v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, dst.Type) v0.AddArg(dst) v0.AuxInt = size % 16 v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) - v1.Type = src.Type + v1 := b.NewValue0(v.Line, OpAMD64ADDQconst, src.Type) v1.AddArg(src) v1.AuxInt = size % 16 v.AddArg(v1) - v2 := b.NewValue0(v.Line, OpAMD64MOVOstore, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64MOVOstore, TypeMem) v2.AddArg(dst) - v3 := b.NewValue0(v.Line, OpAMD64MOVOload, TypeInvalid) + v3 := b.NewValue0(v.Line, OpAMD64MOVOload, TypeInt128) v3.AddArg(src) v3.AddArg(mem) - v3.Type = TypeInt128 v2.AddArg(v3) v2.AddArg(mem) - v2.Type = TypeMem v.AddArg(v2) return true } @@ -9758,9 +9614,8 @@ endcb66da6685f0079ee1f84d10fa561f22: v.resetArgs() v.AddArg(dst) v.AddArg(src) - v0 := b.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64MOVQconst, config.fe.TypeUInt64()) v0.AuxInt = size / 8 - v0.Type = config.fe.TypeUInt64() v.AddArg(v0) v.AddArg(mem) return true @@ -10139,8 +9994,7 @@ func rewriteValueAMD64_OpNeg32F(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) - v0 := b.NewValue0(v.Line, OpAMD64MOVSSconst, TypeInvalid) - v0.Type = config.Frontend().TypeFloat32() + v0 := b.NewValue0(v.Line, OpAMD64MOVSSconst, config.Frontend().TypeFloat32()) v0.AuxInt = f2i(math.Copysign(0, -1)) v.AddArg(v0) return true @@ -10183,8 +10037,7 @@ func rewriteValueAMD64_OpNeg64F(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(x) - v0 := b.NewValue0(v.Line, OpAMD64MOVSDconst, TypeInvalid) - v0.Type = config.Frontend().TypeFloat64() + v0 := b.NewValue0(v.Line, OpAMD64MOVSDconst, config.Frontend().TypeFloat64()) v0.AuxInt = f2i(math.Copysign(0, -1)) v.AddArg(v0) return true @@ -10227,10 +10080,9 @@ func rewriteValueAMD64_OpNeq16(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -10252,10 +10104,9 @@ func rewriteValueAMD64_OpNeq32(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -10277,10 +10128,9 @@ func rewriteValueAMD64_OpNeq32F(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -10302,10 +10152,9 @@ func rewriteValueAMD64_OpNeq64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -10327,10 +10176,9 @@ func rewriteValueAMD64_OpNeq64F(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -10352,10 +10200,9 @@ func rewriteValueAMD64_OpNeq8(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -10377,10 +10224,9 @@ func rewriteValueAMD64_OpNeqPtr(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeFlags) v0.AddArg(x) v0.AddArg(y) - v0.Type = TypeFlags v.AddArg(v0) return true } @@ -11064,17 +10910,14 @@ func rewriteValueAMD64_OpRsh16Ux16(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHRW, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpAMD64SHRW, t) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t) + v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeFlags) v2.AddArg(y) v2.AuxInt = 16 - v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true @@ -11098,17 +10941,14 @@ func rewriteValueAMD64_OpRsh16Ux32(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHRW, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpAMD64SHRW, t) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t) + v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeFlags) v2.AddArg(y) v2.AuxInt = 16 - v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true @@ -11132,17 +10972,14 @@ func rewriteValueAMD64_OpRsh16Ux64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHRW, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpAMD64SHRW, t) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t) + v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeFlags) v2.AddArg(y) v2.AuxInt = 16 - v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true @@ -11166,17 +11003,14 @@ func rewriteValueAMD64_OpRsh16Ux8(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHRW, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpAMD64SHRW, t) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t) + v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeFlags) v2.AddArg(y) v2.AuxInt = 16 - v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true @@ -11196,23 +11030,19 @@ func rewriteValueAMD64_OpRsh16x16(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] + v.Type = t v.Op = OpAMD64SARW v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Type = t v.AddArg(x) - v0 := b.NewValue0(v.Line, OpAMD64ORW, TypeInvalid) - v0.Type = y.Type + v0 := b.NewValue0(v.Line, OpAMD64ORW, y.Type) v0.AddArg(y) - v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) - v1.Type = y.Type - v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v2.Type = y.Type - v3 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + 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 - v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) v0.AddArg(v1) @@ -11234,23 +11064,19 @@ func rewriteValueAMD64_OpRsh16x32(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] + v.Type = t v.Op = OpAMD64SARW v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Type = t v.AddArg(x) - v0 := b.NewValue0(v.Line, OpAMD64ORL, TypeInvalid) - v0.Type = y.Type + v0 := b.NewValue0(v.Line, OpAMD64ORL, y.Type) v0.AddArg(y) - v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) - v1.Type = y.Type - v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v2.Type = y.Type - v3 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + 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 - v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) v0.AddArg(v1) @@ -11272,23 +11098,19 @@ func rewriteValueAMD64_OpRsh16x64(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] + v.Type = t v.Op = OpAMD64SARW v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Type = t v.AddArg(x) - v0 := b.NewValue0(v.Line, OpAMD64ORQ, TypeInvalid) - v0.Type = y.Type + v0 := b.NewValue0(v.Line, OpAMD64ORQ, y.Type) v0.AddArg(y) - v1 := b.NewValue0(v.Line, OpAMD64NOTQ, TypeInvalid) - v1.Type = y.Type - v2 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) - v2.Type = y.Type - v3 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + 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 - v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) v0.AddArg(v1) @@ -11310,23 +11132,19 @@ func rewriteValueAMD64_OpRsh16x8(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] + v.Type = t v.Op = OpAMD64SARW v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Type = t v.AddArg(x) - v0 := b.NewValue0(v.Line, OpAMD64ORB, TypeInvalid) - v0.Type = y.Type + v0 := b.NewValue0(v.Line, OpAMD64ORB, y.Type) v0.AddArg(y) - v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) - v1.Type = y.Type - v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v2.Type = y.Type - v3 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + 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 - v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) v0.AddArg(v1) @@ -11352,17 +11170,14 @@ func rewriteValueAMD64_OpRsh32Ux16(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHRL, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpAMD64SHRL, t) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t) + v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeFlags) v2.AddArg(y) v2.AuxInt = 32 - v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true @@ -11386,17 +11201,14 @@ func rewriteValueAMD64_OpRsh32Ux32(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHRL, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpAMD64SHRL, t) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t) + v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeFlags) v2.AddArg(y) v2.AuxInt = 32 - v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true @@ -11420,17 +11232,14 @@ func rewriteValueAMD64_OpRsh32Ux64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHRL, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpAMD64SHRL, t) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t) + v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeFlags) v2.AddArg(y) v2.AuxInt = 32 - v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true @@ -11454,17 +11263,14 @@ func rewriteValueAMD64_OpRsh32Ux8(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHRL, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpAMD64SHRL, t) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t) + v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeFlags) v2.AddArg(y) v2.AuxInt = 32 - v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true @@ -11484,23 +11290,19 @@ func rewriteValueAMD64_OpRsh32x16(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] + v.Type = t v.Op = OpAMD64SARL v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Type = t v.AddArg(x) - v0 := b.NewValue0(v.Line, OpAMD64ORW, TypeInvalid) - v0.Type = y.Type + v0 := b.NewValue0(v.Line, OpAMD64ORW, y.Type) v0.AddArg(y) - v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) - v1.Type = y.Type - v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v2.Type = y.Type - v3 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + 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 - v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) v0.AddArg(v1) @@ -11522,23 +11324,19 @@ func rewriteValueAMD64_OpRsh32x32(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] + v.Type = t v.Op = OpAMD64SARL v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Type = t v.AddArg(x) - v0 := b.NewValue0(v.Line, OpAMD64ORL, TypeInvalid) - v0.Type = y.Type + v0 := b.NewValue0(v.Line, OpAMD64ORL, y.Type) v0.AddArg(y) - v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) - v1.Type = y.Type - v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v2.Type = y.Type - v3 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + 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 - v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) v0.AddArg(v1) @@ -11560,23 +11358,19 @@ func rewriteValueAMD64_OpRsh32x64(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] + v.Type = t v.Op = OpAMD64SARL v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Type = t v.AddArg(x) - v0 := b.NewValue0(v.Line, OpAMD64ORQ, TypeInvalid) - v0.Type = y.Type + v0 := b.NewValue0(v.Line, OpAMD64ORQ, y.Type) v0.AddArg(y) - v1 := b.NewValue0(v.Line, OpAMD64NOTQ, TypeInvalid) - v1.Type = y.Type - v2 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) - v2.Type = y.Type - v3 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + 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 - v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) v0.AddArg(v1) @@ -11598,23 +11392,19 @@ func rewriteValueAMD64_OpRsh32x8(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] + v.Type = t v.Op = OpAMD64SARL v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Type = t v.AddArg(x) - v0 := b.NewValue0(v.Line, OpAMD64ORB, TypeInvalid) - v0.Type = y.Type + v0 := b.NewValue0(v.Line, OpAMD64ORB, y.Type) v0.AddArg(y) - v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) - v1.Type = y.Type - v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v2.Type = y.Type - v3 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + 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 - v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) v0.AddArg(v1) @@ -11640,17 +11430,14 @@ func rewriteValueAMD64_OpRsh64Ux16(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHRQ, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpAMD64SHRQ, t) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, t) + v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeFlags) v2.AddArg(y) v2.AuxInt = 64 - v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true @@ -11674,17 +11461,14 @@ func rewriteValueAMD64_OpRsh64Ux32(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHRQ, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpAMD64SHRQ, t) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, t) + v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeFlags) v2.AddArg(y) v2.AuxInt = 64 - v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true @@ -11708,17 +11492,14 @@ func rewriteValueAMD64_OpRsh64Ux64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHRQ, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpAMD64SHRQ, t) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, t) + v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeFlags) v2.AddArg(y) v2.AuxInt = 64 - v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true @@ -11742,17 +11523,14 @@ func rewriteValueAMD64_OpRsh64Ux8(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHRQ, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpAMD64SHRQ, t) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, t) + v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeFlags) v2.AddArg(y) v2.AuxInt = 64 - v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true @@ -11772,23 +11550,19 @@ func rewriteValueAMD64_OpRsh64x16(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] + v.Type = t v.Op = OpAMD64SARQ v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Type = t v.AddArg(x) - v0 := b.NewValue0(v.Line, OpAMD64ORW, TypeInvalid) - v0.Type = y.Type + v0 := b.NewValue0(v.Line, OpAMD64ORW, y.Type) v0.AddArg(y) - v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) - v1.Type = y.Type - v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v2.Type = y.Type - v3 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + 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 - v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) v0.AddArg(v1) @@ -11810,23 +11584,19 @@ func rewriteValueAMD64_OpRsh64x32(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] + v.Type = t v.Op = OpAMD64SARQ v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Type = t v.AddArg(x) - v0 := b.NewValue0(v.Line, OpAMD64ORL, TypeInvalid) - v0.Type = y.Type + v0 := b.NewValue0(v.Line, OpAMD64ORL, y.Type) v0.AddArg(y) - v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) - v1.Type = y.Type - v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v2.Type = y.Type - v3 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + 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 - v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) v0.AddArg(v1) @@ -11848,23 +11618,19 @@ func rewriteValueAMD64_OpRsh64x64(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] + v.Type = t v.Op = OpAMD64SARQ v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Type = t v.AddArg(x) - v0 := b.NewValue0(v.Line, OpAMD64ORQ, TypeInvalid) - v0.Type = y.Type + v0 := b.NewValue0(v.Line, OpAMD64ORQ, y.Type) v0.AddArg(y) - v1 := b.NewValue0(v.Line, OpAMD64NOTQ, TypeInvalid) - v1.Type = y.Type - v2 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) - v2.Type = y.Type - v3 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + 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 - v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) v0.AddArg(v1) @@ -11886,23 +11652,19 @@ func rewriteValueAMD64_OpRsh64x8(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] + v.Type = t v.Op = OpAMD64SARQ v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Type = t v.AddArg(x) - v0 := b.NewValue0(v.Line, OpAMD64ORB, TypeInvalid) - v0.Type = y.Type + v0 := b.NewValue0(v.Line, OpAMD64ORB, y.Type) v0.AddArg(y) - v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) - v1.Type = y.Type - v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v2.Type = y.Type - v3 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + 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 - v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) v0.AddArg(v1) @@ -11928,17 +11690,14 @@ func rewriteValueAMD64_OpRsh8Ux16(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHRB, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpAMD64SHRB, t) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t) + v2 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeFlags) v2.AddArg(y) v2.AuxInt = 8 - v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true @@ -11962,17 +11721,14 @@ func rewriteValueAMD64_OpRsh8Ux32(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHRB, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpAMD64SHRB, t) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t) + v2 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeFlags) v2.AddArg(y) v2.AuxInt = 8 - v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true @@ -11996,17 +11752,14 @@ func rewriteValueAMD64_OpRsh8Ux64(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHRB, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpAMD64SHRB, t) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t) + v2 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeFlags) v2.AddArg(y) v2.AuxInt = 8 - v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true @@ -12030,17 +11783,14 @@ func rewriteValueAMD64_OpRsh8Ux8(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SHRB, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpAMD64SHRB, t) v0.AddArg(x) v0.AddArg(y) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v1.Type = t - v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, t) + v2 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeFlags) v2.AddArg(y) v2.AuxInt = 8 - v2.Type = TypeFlags v1.AddArg(v2) v.AddArg(v1) return true @@ -12060,23 +11810,19 @@ func rewriteValueAMD64_OpRsh8x16(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] + v.Type = t v.Op = OpAMD64SARB v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Type = t v.AddArg(x) - v0 := b.NewValue0(v.Line, OpAMD64ORW, TypeInvalid) - v0.Type = y.Type + v0 := b.NewValue0(v.Line, OpAMD64ORW, y.Type) v0.AddArg(y) - v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) - v1.Type = y.Type - v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v2.Type = y.Type - v3 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeInvalid) + 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 - v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) v0.AddArg(v1) @@ -12098,23 +11844,19 @@ func rewriteValueAMD64_OpRsh8x32(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] + v.Type = t v.Op = OpAMD64SARB v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Type = t v.AddArg(x) - v0 := b.NewValue0(v.Line, OpAMD64ORL, TypeInvalid) - v0.Type = y.Type + v0 := b.NewValue0(v.Line, OpAMD64ORL, y.Type) v0.AddArg(y) - v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) - v1.Type = y.Type - v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v2.Type = y.Type - v3 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeInvalid) + 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 - v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) v0.AddArg(v1) @@ -12136,23 +11878,19 @@ func rewriteValueAMD64_OpRsh8x64(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] + v.Type = t v.Op = OpAMD64SARB v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Type = t v.AddArg(x) - v0 := b.NewValue0(v.Line, OpAMD64ORQ, TypeInvalid) - v0.Type = y.Type + v0 := b.NewValue0(v.Line, OpAMD64ORQ, y.Type) v0.AddArg(y) - v1 := b.NewValue0(v.Line, OpAMD64NOTQ, TypeInvalid) - v1.Type = y.Type - v2 := b.NewValue0(v.Line, OpAMD64SBBQcarrymask, TypeInvalid) - v2.Type = y.Type - v3 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeInvalid) + 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 - v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) v0.AddArg(v1) @@ -12174,23 +11912,19 @@ func rewriteValueAMD64_OpRsh8x8(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] + v.Type = t v.Op = OpAMD64SARB v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Type = t v.AddArg(x) - v0 := b.NewValue0(v.Line, OpAMD64ORB, TypeInvalid) - v0.Type = y.Type + v0 := b.NewValue0(v.Line, OpAMD64ORB, y.Type) v0.AddArg(y) - v1 := b.NewValue0(v.Line, OpAMD64NOTL, TypeInvalid) - v1.Type = y.Type - v2 := b.NewValue0(v.Line, OpAMD64SBBLcarrymask, TypeInvalid) - v2.Type = y.Type - v3 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeInvalid) + 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 - v3.Type = TypeFlags v2.AddArg(v3) v1.AddArg(v2) v0.AddArg(v1) @@ -14614,8 +14348,7 @@ end9ca5d2a70e2df1a5a3ed6786bce1f7b2: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SUBBconst, TypeInvalid) - v0.Type = v.Type + v0 := b.NewValue0(v.Line, OpAMD64SUBBconst, v.Type) v0.AddArg(x) v0.AuxInt = c v.AddArg(v0) @@ -14745,8 +14478,7 @@ end178c1d6c86f9c16f6497586c2f7d8625: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SUBLconst, TypeInvalid) - v0.Type = v.Type + v0 := b.NewValue0(v.Line, OpAMD64SUBLconst, v.Type) v0.AddArg(x) v0.AuxInt = c v.AddArg(v0) @@ -14882,8 +14614,7 @@ end9bbb7b20824a498752c605942fad89c2: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SUBQconst, TypeInvalid) - v0.Type = v.Type + v0 := b.NewValue0(v.Line, OpAMD64SUBQconst, v.Type) v0.AddArg(x) v0.AuxInt = c v.AddArg(v0) @@ -15012,8 +14743,7 @@ end135aa9100b2f61d58b37cede37b63731: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAMD64SUBWconst, TypeInvalid) - v0.Type = v.Type + v0 := b.NewValue0(v.Line, OpAMD64SUBWconst, v.Type) v0.AddArg(x) v0.AuxInt = c v.AddArg(v0) @@ -16336,11 +16066,10 @@ end07aaaebfa15a48c52cd79b68e28d266f: v.resetArgs() v.AuxInt = makeValAndOff(0, 2) v.AddArg(destptr) - v0 := b.NewValue0(v.Line, OpAMD64MOVWstoreconst, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64MOVWstoreconst, TypeMem) v0.AuxInt = 0 v0.AddArg(destptr) v0.AddArg(mem) - v0.Type = TypeMem v.AddArg(v0) return true } @@ -16362,11 +16091,10 @@ end3bf4a24a87e0727b9bcfbb5fcd24aabe: v.resetArgs() v.AuxInt = makeValAndOff(0, 4) v.AddArg(destptr) - v0 := b.NewValue0(v.Line, OpAMD64MOVLstoreconst, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64MOVLstoreconst, TypeMem) v0.AuxInt = 0 v0.AddArg(destptr) v0.AddArg(mem) - v0.Type = TypeMem v.AddArg(v0) return true } @@ -16388,11 +16116,10 @@ end567e4a90c6867faf1dfc2cd57daf2ce4: v.resetArgs() v.AuxInt = makeValAndOff(0, 4) v.AddArg(destptr) - v0 := b.NewValue0(v.Line, OpAMD64MOVLstoreconst, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64MOVLstoreconst, TypeMem) v0.AuxInt = 0 v0.AddArg(destptr) v0.AddArg(mem) - v0.Type = TypeMem v.AddArg(v0) return true } @@ -16414,11 +16141,10 @@ end7cddcaf215fcc2cbca9aa958147b2380: v.resetArgs() v.AuxInt = makeValAndOff(0, 3) v.AddArg(destptr) - v0 := b.NewValue0(v.Line, OpAMD64MOVLstoreconst, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64MOVLstoreconst, TypeMem) v0.AuxInt = 0 v0.AddArg(destptr) v0.AddArg(mem) - v0.Type = TypeMem v.AddArg(v0) return true } @@ -16440,16 +16166,14 @@ end1b58cabccbc912ea4e1cf99be8a9fbf7: v.Aux = nil v.resetArgs() v.AuxInt = size - size%8 - v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, config.fe.TypeUInt64()) v0.AddArg(destptr) v0.AuxInt = size % 8 - v0.Type = config.fe.TypeUInt64() v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeMem) v1.AuxInt = 0 v1.AddArg(destptr) v1.AddArg(mem) - v1.Type = TypeMem v.AddArg(v1) return true } @@ -16471,11 +16195,10 @@ endc8760f86b83b1372fce0042ab5200fc1: v.resetArgs() v.AuxInt = makeValAndOff(0, 8) v.AddArg(destptr) - v0 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeMem) v0.AuxInt = 0 v0.AddArg(destptr) v0.AddArg(mem) - v0.Type = TypeMem v.AddArg(v0) return true } @@ -16497,16 +16220,14 @@ endf1447d60cbf8025adaf1a02a2cd219c4: v.resetArgs() v.AuxInt = makeValAndOff(0, 16) v.AddArg(destptr) - v0 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeMem) v0.AuxInt = makeValAndOff(0, 8) v0.AddArg(destptr) - v1 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeMem) v1.AuxInt = 0 v1.AddArg(destptr) v1.AddArg(mem) - v1.Type = TypeMem v0.AddArg(v1) - v0.Type = TypeMem v.AddArg(v0) return true } @@ -16528,21 +16249,18 @@ end57f2984a61c64f71a528e7fa75576095: v.resetArgs() v.AuxInt = makeValAndOff(0, 24) v.AddArg(destptr) - v0 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeMem) v0.AuxInt = makeValAndOff(0, 16) v0.AddArg(destptr) - v1 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeMem) v1.AuxInt = makeValAndOff(0, 8) v1.AddArg(destptr) - v2 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeMem) v2.AuxInt = 0 v2.AddArg(destptr) v2.AddArg(mem) - v2.Type = TypeMem v1.AddArg(v2) - v1.Type = TypeMem v0.AddArg(v1) - v0.Type = TypeMem v.AddArg(v0) return true } @@ -16564,19 +16282,16 @@ end418a59f9f84dd389d37ae5c24aba2760: v.Aux = nil v.resetArgs() v.AuxInt = size - 8 - v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, config.fe.TypeUInt64()) v0.AuxInt = 8 v0.AddArg(destptr) - v0.Type = config.fe.TypeUInt64() v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64MOVQstore, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64MOVQstore, TypeMem) v1.AddArg(destptr) - v2 := b.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) + v2 := b.NewValue0(v.Line, OpAMD64MOVQconst, config.fe.TypeUInt64()) v2.AuxInt = 0 - v2.Type = config.fe.TypeUInt64() v1.AddArg(v2) v1.AddArg(mem) - v1.Type = TypeMem v.AddArg(v1) return true } @@ -16598,14 +16313,12 @@ end240266449c3e493db1c3b38a78682ff0: v.Aux = nil v.resetArgs() v.AuxInt = duffStart(size) - v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, config.fe.TypeUInt64()) v0.AuxInt = duffAdj(size) v0.AddArg(destptr) - v0.Type = config.fe.TypeUInt64() v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64MOVOconst, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64MOVOconst, TypeInt128) v1.AuxInt = 0 - v1.Type = TypeInt128 v.AddArg(v1) v.AddArg(mem) return true @@ -16628,13 +16341,11 @@ endf508bb887eee9119069b22c23dbca138: v.Aux = nil v.resetArgs() v.AddArg(destptr) - v0 := b.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64MOVQconst, config.fe.TypeUInt64()) v0.AuxInt = size / 8 - v0.Type = config.fe.TypeUInt64() v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpAMD64MOVQconst, TypeInvalid) + v1 := b.NewValue0(v.Line, OpAMD64MOVQconst, config.fe.TypeUInt64()) v1.AuxInt = 0 - v1.Type = config.fe.TypeUInt64() v.AddArg(v1) v.AddArg(mem) return true @@ -17413,10 +17124,9 @@ func rewriteBlockAMD64(b *Block) bool { yes := b.Succs[0] no := b.Succs[1] b.Kind = BlockAMD64NE - v0 := b.NewValue0(v.Line, OpAMD64TESTB, TypeInvalid) + v0 := b.NewValue0(v.Line, OpAMD64TESTB, TypeFlags) v0.AddArg(cond) v0.AddArg(cond) - v0.Type = TypeFlags b.Control = v0 b.Succs[0] = yes b.Succs[1] = no diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index 60d9f06ae6..b9e4d186e9 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -528,13 +528,11 @@ func rewriteValuegeneric_OpArg(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpArg, TypeInvalid) - v0.Type = config.fe.TypeBytePtr() + v0 := b.NewValue0(v.Line, OpArg, config.fe.TypeBytePtr()) v0.Aux = n v0.AuxInt = off v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpArg, TypeInvalid) - v1.Type = config.fe.TypeInt() + v1 := b.NewValue0(v.Line, OpArg, config.fe.TypeInt()) v1.Aux = n v1.AuxInt = off + config.PtrSize v.AddArg(v1) @@ -556,18 +554,15 @@ end939d3f946bf61eb85b46b374e7afa9e9: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpArg, TypeInvalid) - v0.Type = config.fe.TypeBytePtr() + v0 := b.NewValue0(v.Line, OpArg, config.fe.TypeBytePtr()) v0.Aux = n v0.AuxInt = off v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpArg, TypeInvalid) - v1.Type = config.fe.TypeInt() + 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, TypeInvalid) - v2.Type = config.fe.TypeInt() + v2 := b.NewValue0(v.Line, OpArg, config.fe.TypeInt()) v2.Aux = n v2.AuxInt = off + 2*config.PtrSize v.AddArg(v2) @@ -589,13 +584,11 @@ endab4b93ad3b1cf55e5bf25d1fd9cd498e: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpArg, TypeInvalid) - v0.Type = config.fe.TypeBytePtr() + v0 := b.NewValue0(v.Line, OpArg, config.fe.TypeBytePtr()) v0.Aux = n v0.AuxInt = off v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpArg, TypeInvalid) - v1.Type = config.fe.TypeBytePtr() + v1 := b.NewValue0(v.Line, OpArg, config.fe.TypeBytePtr()) v1.Aux = n v1.AuxInt = off + config.PtrSize v.AddArg(v1) @@ -617,13 +610,11 @@ end851de8e588a39e81b4e2aef06566bf3e: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpArg, TypeInvalid) - v0.Type = config.fe.TypeFloat64() + v0 := b.NewValue0(v.Line, OpArg, config.fe.TypeFloat64()) v0.Aux = n v0.AuxInt = off v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpArg, TypeInvalid) - v1.Type = config.fe.TypeFloat64() + v1 := b.NewValue0(v.Line, OpArg, config.fe.TypeFloat64()) v1.Aux = n v1.AuxInt = off + 8 v.AddArg(v1) @@ -645,13 +636,11 @@ end0988fc6a62c810b2f4976cb6cf44387f: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpArg, TypeInvalid) - v0.Type = config.fe.TypeFloat32() + v0 := b.NewValue0(v.Line, OpArg, config.fe.TypeFloat32()) v0.Aux = n v0.AuxInt = off v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpArg, TypeInvalid) - v1.Type = config.fe.TypeFloat32() + v1 := b.NewValue0(v.Line, OpArg, config.fe.TypeFloat32()) v1.Aux = n v1.AuxInt = off + 4 v.AddArg(v1) @@ -691,8 +680,7 @@ ende233eeefa826638b0e541bcca531d701: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpArg, TypeInvalid) - v0.Type = t.FieldType(0) + v0 := b.NewValue0(v.Line, OpArg, t.FieldType(0)) v0.Aux = n v0.AuxInt = off + t.FieldOff(0) v.AddArg(v0) @@ -715,13 +703,11 @@ ende953e77a0617051dd3f7ad4d58c9ab37: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpArg, TypeInvalid) - v0.Type = t.FieldType(0) + 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, TypeInvalid) - v1.Type = t.FieldType(1) + v1 := b.NewValue0(v.Line, OpArg, t.FieldType(1)) v1.Aux = n v1.AuxInt = off + t.FieldOff(1) v.AddArg(v1) @@ -744,18 +730,15 @@ end9a008048978aabad9de0723212e60631: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpArg, TypeInvalid) - v0.Type = t.FieldType(0) + 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, TypeInvalid) - v1.Type = t.FieldType(1) + 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, TypeInvalid) - v2.Type = t.FieldType(2) + v2 := b.NewValue0(v.Line, OpArg, t.FieldType(2)) v2.Aux = n v2.AuxInt = off + t.FieldOff(2) v.AddArg(v2) @@ -778,23 +761,19 @@ end0196e61dbeebc6402f3aa1e9a182210b: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpArg, TypeInvalid) - v0.Type = t.FieldType(0) + 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, TypeInvalid) - v1.Type = t.FieldType(1) + 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, TypeInvalid) - v2.Type = t.FieldType(2) + 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, TypeInvalid) - v3.Type = t.FieldType(3) + v3 := b.NewValue0(v.Line, OpArg, t.FieldType(3)) v3.Aux = n v3.AuxInt = off + t.FieldOff(3) v.AddArg(v3) @@ -825,8 +804,7 @@ func rewriteValuegeneric_OpArrayIndex(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpPtrIndex, TypeInvalid) - v0.Type = v.Type.PtrTo() + v0 := b.NewValue0(v.Line, OpPtrIndex, v.Type.PtrTo()) v0.AddArg(ptr) v0.AddArg(idx) v.AddArg(v0) @@ -993,11 +971,9 @@ func rewriteValuegeneric_OpConstInterface(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpConstNil, TypeInvalid) - v0.Type = config.fe.TypeBytePtr() + v0 := b.NewValue0(v.Line, OpConstNil, config.fe.TypeBytePtr()) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpConstNil, TypeInvalid) - v1.Type = config.fe.TypeBytePtr() + v1 := b.NewValue0(v.Line, OpConstNil, config.fe.TypeBytePtr()) v.AddArg(v1) return true } @@ -1020,15 +996,12 @@ func rewriteValuegeneric_OpConstSlice(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpConstNil, TypeInvalid) - v0.Type = config.fe.TypeBytePtr() + v0 := b.NewValue0(v.Line, OpConstNil, config.fe.TypeBytePtr()) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpConst32, TypeInvalid) - v1.Type = config.fe.TypeInt() + v1 := b.NewValue0(v.Line, OpConst32, config.fe.TypeInt()) v1.AuxInt = 0 v.AddArg(v1) - v2 := b.NewValue0(v.Line, OpConst32, TypeInvalid) - v2.Type = config.fe.TypeInt() + v2 := b.NewValue0(v.Line, OpConst32, config.fe.TypeInt()) v2.AuxInt = 0 v.AddArg(v2) return true @@ -1047,15 +1020,12 @@ end9ba6baf9c7247b1f5ba4099c0c3910ce: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpConstNil, TypeInvalid) - v0.Type = config.fe.TypeBytePtr() + v0 := b.NewValue0(v.Line, OpConstNil, config.fe.TypeBytePtr()) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpConst64, TypeInvalid) - v1.Type = config.fe.TypeInt() + v1 := b.NewValue0(v.Line, OpConst64, config.fe.TypeInt()) v1.AuxInt = 0 v.AddArg(v1) - v2 := b.NewValue0(v.Line, OpConst64, TypeInvalid) - v2.Type = config.fe.TypeInt() + v2 := b.NewValue0(v.Line, OpConst64, config.fe.TypeInt()) v2.AuxInt = 0 v.AddArg(v2) return true @@ -1080,11 +1050,9 @@ func rewriteValuegeneric_OpConstString(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpConstNil, TypeInvalid) - v0.Type = config.fe.TypeBytePtr() + v0 := b.NewValue0(v.Line, OpConstNil, config.fe.TypeBytePtr()) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpConst32, TypeInvalid) - v1.Type = config.fe.TypeInt() + v1 := b.NewValue0(v.Line, OpConst32, config.fe.TypeInt()) v1.AuxInt = 0 v.AddArg(v1) return true @@ -1104,11 +1072,9 @@ end85d5f388ba947643af63cdc68c1155a5: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpConstNil, TypeInvalid) - v0.Type = config.fe.TypeBytePtr() + v0 := b.NewValue0(v.Line, OpConstNil, config.fe.TypeBytePtr()) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpConst64, TypeInvalid) - v1.Type = config.fe.TypeInt() + v1 := b.NewValue0(v.Line, OpConst64, config.fe.TypeInt()) v1.AuxInt = 0 v.AddArg(v1) return true @@ -1128,15 +1094,12 @@ endc807259a5ed2760fbbd3dc7386641343: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAddr, TypeInvalid) - v0.Type = config.fe.TypeBytePtr() + v0 := b.NewValue0(v.Line, OpAddr, config.fe.TypeBytePtr()) v0.Aux = config.fe.StringData(s.(string)) - v1 := b.NewValue0(v.Line, OpSB, TypeInvalid) - v1.Type = config.fe.TypeUintptr() + v1 := b.NewValue0(v.Line, OpSB, config.fe.TypeUintptr()) v0.AddArg(v1) v.AddArg(v0) - v2 := b.NewValue0(v.Line, OpConst32, TypeInvalid) - v2.Type = config.fe.TypeInt() + v2 := b.NewValue0(v.Line, OpConst32, config.fe.TypeInt()) v2.AuxInt = int64(len(s.(string))) v.AddArg(v2) return true @@ -1156,15 +1119,12 @@ end107a700a4519d18f418602421444ddb6: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpAddr, TypeInvalid) - v0.Type = config.fe.TypeBytePtr() + v0 := b.NewValue0(v.Line, OpAddr, config.fe.TypeBytePtr()) v0.Aux = config.fe.StringData(s.(string)) - v1 := b.NewValue0(v.Line, OpSB, TypeInvalid) - v1.Type = config.fe.TypeUintptr() + v1 := b.NewValue0(v.Line, OpSB, config.fe.TypeUintptr()) v0.AddArg(v1) v.AddArg(v0) - v2 := b.NewValue0(v.Line, OpConst64, TypeInvalid) - v2.Type = config.fe.TypeInt() + v2 := b.NewValue0(v.Line, OpConst64, config.fe.TypeInt()) v2.AuxInt = int64(len(s.(string))) v.AddArg(v2) return true @@ -1666,13 +1626,11 @@ func rewriteValuegeneric_OpEqInter(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpITab, TypeInvalid) + v0 := b.NewValue0(v.Line, OpITab, config.fe.TypeBytePtr()) v0.AddArg(x) - v0.Type = config.fe.TypeBytePtr() v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpITab, TypeInvalid) + v1 := b.NewValue0(v.Line, OpITab, config.fe.TypeBytePtr()) v1.AddArg(y) - v1.Type = config.fe.TypeBytePtr() v.AddArg(v1) return true } @@ -1696,9 +1654,8 @@ func rewriteValuegeneric_OpEqPtr(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpIsNonNil, TypeInvalid) + v0 := b.NewValue0(v.Line, OpIsNonNil, config.fe.TypeBool()) v0.AddArg(p) - v0.Type = config.fe.TypeBool() v.AddArg(v0) return true } @@ -1717,9 +1674,8 @@ ende701cdb6a2c1fff4d4b283b7f8f6178b: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpIsNonNil, TypeInvalid) + v0 := b.NewValue0(v.Line, OpIsNonNil, config.fe.TypeBool()) v0.AddArg(p) - v0.Type = config.fe.TypeBool() v.AddArg(v0) return true } @@ -1741,13 +1697,11 @@ func rewriteValuegeneric_OpEqSlice(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpSlicePtr, TypeInvalid) + v0 := b.NewValue0(v.Line, OpSlicePtr, config.fe.TypeBytePtr()) v0.AddArg(x) - v0.Type = config.fe.TypeBytePtr() v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpSlicePtr, TypeInvalid) + v1 := b.NewValue0(v.Line, OpSlicePtr, config.fe.TypeBytePtr()) v1.AddArg(y) - v1.Type = config.fe.TypeBytePtr() v.AddArg(v1) return true } @@ -2800,8 +2754,7 @@ end8d25f5c949948132921b6be29ede6bde: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpLoad, TypeInvalid) - v0.Type = t.FieldType(0) + v0 := b.NewValue0(v.Line, OpLoad, t.FieldType(0)) v0.AddArg(ptr) v0.AddArg(mem) v.AddArg(v0) @@ -2824,15 +2777,12 @@ endfe908e5a8617dd39df2f9b2b92e93ae5: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpLoad, TypeInvalid) - v0.Type = t.FieldType(0) + v0 := b.NewValue0(v.Line, OpLoad, t.FieldType(0)) v0.AddArg(ptr) v0.AddArg(mem) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpLoad, TypeInvalid) - v1.Type = t.FieldType(1) - v2 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v2.Type = t.FieldType(1).PtrTo() + 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) @@ -2857,24 +2807,19 @@ end20e20e64004b765012cfb80c575ef27b: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpLoad, TypeInvalid) - v0.Type = t.FieldType(0) + v0 := b.NewValue0(v.Line, OpLoad, t.FieldType(0)) v0.AddArg(ptr) v0.AddArg(mem) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpLoad, TypeInvalid) - v1.Type = t.FieldType(1) - v2 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v2.Type = t.FieldType(1).PtrTo() + 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, TypeInvalid) - v3.Type = t.FieldType(2) - v4 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v4.Type = t.FieldType(2).PtrTo() + 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) @@ -2899,33 +2844,26 @@ ende612bf71067ed67541735cdc8b5a3288: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpLoad, TypeInvalid) - v0.Type = t.FieldType(0) + v0 := b.NewValue0(v.Line, OpLoad, t.FieldType(0)) v0.AddArg(ptr) v0.AddArg(mem) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpLoad, TypeInvalid) - v1.Type = t.FieldType(1) - v2 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v2.Type = t.FieldType(1).PtrTo() + 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, TypeInvalid) - v3.Type = t.FieldType(2) - v4 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v4.Type = t.FieldType(2).PtrTo() + 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, TypeInvalid) - v5.Type = t.FieldType(3) - v6 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v6.Type = t.FieldType(3).PtrTo() + 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) @@ -2950,15 +2888,12 @@ end46c66c64d9030f2cc9a7a767f67953d1: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpLoad, TypeInvalid) - v0.Type = config.fe.TypeFloat32() + v0 := b.NewValue0(v.Line, OpLoad, config.fe.TypeFloat32()) v0.AddArg(ptr) v0.AddArg(mem) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpLoad, TypeInvalid) - v1.Type = config.fe.TypeFloat32() - v2 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v2.Type = config.fe.TypeFloat32().PtrTo() + 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) @@ -2983,15 +2918,12 @@ end665854b31b828893d90b36bb462ff381: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpLoad, TypeInvalid) - v0.Type = config.fe.TypeFloat64() + v0 := b.NewValue0(v.Line, OpLoad, config.fe.TypeFloat64()) v0.AddArg(ptr) v0.AddArg(mem) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpLoad, TypeInvalid) - v1.Type = config.fe.TypeFloat64() - v2 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v2.Type = config.fe.TypeFloat64().PtrTo() + 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) @@ -3016,15 +2948,12 @@ end1b106f89e0e3e26c613b957a7c98d8ad: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpLoad, TypeInvalid) - v0.Type = config.fe.TypeBytePtr() + v0 := b.NewValue0(v.Line, OpLoad, config.fe.TypeBytePtr()) v0.AddArg(ptr) v0.AddArg(mem) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpLoad, TypeInvalid) - v1.Type = config.fe.TypeInt() - v2 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v2.Type = config.fe.TypeInt().PtrTo() + 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) @@ -3049,24 +2978,19 @@ enddd15a6f3d53a6ce7a19d4e181dd1c13a: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpLoad, TypeInvalid) - v0.Type = config.fe.TypeBytePtr() + v0 := b.NewValue0(v.Line, OpLoad, config.fe.TypeBytePtr()) v0.AddArg(ptr) v0.AddArg(mem) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpLoad, TypeInvalid) - v1.Type = config.fe.TypeInt() - v2 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v2.Type = config.fe.TypeInt().PtrTo() + 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, TypeInvalid) - v3.Type = config.fe.TypeInt() - v4 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v4.Type = config.fe.TypeInt().PtrTo() + 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) @@ -3091,15 +3015,12 @@ end65e8b0055aa7491b9b6066d9fe1b2c13: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpLoad, TypeInvalid) - v0.Type = config.fe.TypeBytePtr() + v0 := b.NewValue0(v.Line, OpLoad, config.fe.TypeBytePtr()) v0.AddArg(ptr) v0.AddArg(mem) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpLoad, TypeInvalid) - v1.Type = config.fe.TypeBytePtr() - v2 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v2.Type = config.fe.TypeBytePtr().PtrTo() + 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) @@ -3657,13 +3578,11 @@ func rewriteValuegeneric_OpNeqInter(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpITab, TypeInvalid) + v0 := b.NewValue0(v.Line, OpITab, config.fe.TypeBytePtr()) v0.AddArg(x) - v0.Type = config.fe.TypeBytePtr() v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpITab, TypeInvalid) + v1 := b.NewValue0(v.Line, OpITab, config.fe.TypeBytePtr()) v1.AddArg(y) - v1.Type = config.fe.TypeBytePtr() v.AddArg(v1) return true } @@ -3726,13 +3645,11 @@ func rewriteValuegeneric_OpNeqSlice(v *Value, config *Config) bool { v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpSlicePtr, TypeInvalid) + v0 := b.NewValue0(v.Line, OpSlicePtr, config.fe.TypeBytePtr()) v0.AddArg(x) - v0.Type = config.fe.TypeBytePtr() v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpSlicePtr, TypeInvalid) + v1 := b.NewValue0(v.Line, OpSlicePtr, config.fe.TypeBytePtr()) v1.AddArg(y) - v1.Type = config.fe.TypeBytePtr() v.AddArg(v1) return true } @@ -3855,11 +3772,9 @@ func rewriteValuegeneric_OpPtrIndex(v *Value, config *Config) bool { v.Aux = nil v.resetArgs() v.AddArg(ptr) - v0 := b.NewValue0(v.Line, OpMul32, TypeInvalid) - v0.Type = config.fe.TypeInt() + v0 := b.NewValue0(v.Line, OpMul32, config.fe.TypeInt()) v0.AddArg(idx) - v1 := b.NewValue0(v.Line, OpConst32, TypeInvalid) - v1.Type = config.fe.TypeInt() + v1 := b.NewValue0(v.Line, OpConst32, config.fe.TypeInt()) v1.AuxInt = t.Elem().Size() v0.AddArg(v1) v.AddArg(v0) @@ -3883,11 +3798,9 @@ endd902622aaa1e7545b5a2a0c08b47d287: v.Aux = nil v.resetArgs() v.AddArg(ptr) - v0 := b.NewValue0(v.Line, OpMul64, TypeInvalid) - v0.Type = config.fe.TypeInt() + v0 := b.NewValue0(v.Line, OpMul64, config.fe.TypeInt()) v0.AddArg(idx) - v1 := b.NewValue0(v.Line, OpConst64, TypeInvalid) - v1.Type = config.fe.TypeInt() + v1 := b.NewValue0(v.Line, OpConst64, config.fe.TypeInt()) v1.AuxInt = t.Elem().Size() v0.AddArg(v1) v.AddArg(v0) @@ -4033,18 +3946,16 @@ end2cff6d06f4440132f48ca374b6b1e9d8: v.Aux = nil v.resetArgs() v.AuxInt = t.FieldType(1).Size() - v0 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v0.Type = t.FieldType(1).PtrTo() + 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, TypeInvalid) + v1 := b.NewValue0(v.Line, OpStore, TypeMem) v1.AuxInt = t.FieldType(0).Size() v1.AddArg(dst) v1.AddArg(f0) v1.AddArg(mem) - v1.Type = TypeMem v.AddArg(v1) return true } @@ -4069,28 +3980,24 @@ end4e8ede6cc575a287795971da6b637973: v.Aux = nil v.resetArgs() v.AuxInt = t.FieldType(2).Size() - v0 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v0.Type = t.FieldType(2).PtrTo() + 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, TypeInvalid) + v1 := b.NewValue0(v.Line, OpStore, TypeMem) v1.AuxInt = t.FieldType(1).Size() - v2 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v2.Type = t.FieldType(1).PtrTo() + 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, TypeInvalid) + v3 := b.NewValue0(v.Line, OpStore, TypeMem) v3.AuxInt = t.FieldType(0).Size() v3.AddArg(dst) v3.AddArg(f0) v3.AddArg(mem) - v3.Type = TypeMem v1.AddArg(v3) - v1.Type = TypeMem v.AddArg(v1) return true } @@ -4116,38 +4023,32 @@ end6ad675267724a87c8f852dd1e185e911: v.Aux = nil v.resetArgs() v.AuxInt = t.FieldType(3).Size() - v0 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v0.Type = t.FieldType(3).PtrTo() + 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, TypeInvalid) + v1 := b.NewValue0(v.Line, OpStore, TypeMem) v1.AuxInt = t.FieldType(2).Size() - v2 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v2.Type = t.FieldType(2).PtrTo() + 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, TypeInvalid) + v3 := b.NewValue0(v.Line, OpStore, TypeMem) v3.AuxInt = t.FieldType(1).Size() - v4 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v4.Type = t.FieldType(1).PtrTo() + 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, TypeInvalid) + v5 := b.NewValue0(v.Line, OpStore, TypeMem) v5.AuxInt = t.FieldType(0).Size() v5.AddArg(dst) v5.AddArg(f0) v5.AddArg(mem) - v5.Type = TypeMem v3.AddArg(v5) - v3.Type = TypeMem v1.AddArg(v3) - v1.Type = TypeMem v.AddArg(v1) return true } @@ -4173,18 +4074,16 @@ end7ea91abd44794f7653374502a5a405ea: v.Aux = nil v.resetArgs() v.AuxInt = 4 - v0 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v0.Type = config.fe.TypeFloat32().PtrTo() + 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, TypeInvalid) + v1 := b.NewValue0(v.Line, OpStore, TypeMem) v1.AuxInt = 4 v1.AddArg(dst) v1.AddArg(real) v1.AddArg(mem) - v1.Type = TypeMem v.AddArg(v1) return true } @@ -4210,18 +4109,16 @@ endced898cb0a165662afe48ea44ad3318a: v.Aux = nil v.resetArgs() v.AuxInt = 8 - v0 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v0.Type = config.fe.TypeFloat64().PtrTo() + 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, TypeInvalid) + v1 := b.NewValue0(v.Line, OpStore, TypeMem) v1.AuxInt = 8 v1.AddArg(dst) v1.AddArg(real) v1.AddArg(mem) - v1.Type = TypeMem v.AddArg(v1) return true } @@ -4247,18 +4144,16 @@ end3851a482d7bd37a93c4d81581e85b3ab: v.Aux = nil v.resetArgs() v.AuxInt = config.PtrSize - v0 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v0.Type = config.fe.TypeInt().PtrTo() + 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, TypeInvalid) + v1 := b.NewValue0(v.Line, OpStore, TypeMem) v1.AuxInt = config.PtrSize v1.AddArg(dst) v1.AddArg(ptr) v1.AddArg(mem) - v1.Type = TypeMem v.AddArg(v1) return true } @@ -4285,28 +4180,24 @@ endd3a6ecebdad5899570a79fe5c62f34f1: v.Aux = nil v.resetArgs() v.AuxInt = config.PtrSize - v0 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v0.Type = config.fe.TypeInt().PtrTo() + 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, TypeInvalid) + v1 := b.NewValue0(v.Line, OpStore, TypeMem) v1.AuxInt = config.PtrSize - v2 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v2.Type = config.fe.TypeInt().PtrTo() + 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, TypeInvalid) + v3 := b.NewValue0(v.Line, OpStore, TypeMem) v3.AuxInt = config.PtrSize v3.AddArg(dst) v3.AddArg(ptr) v3.AddArg(mem) - v3.Type = TypeMem v1.AddArg(v3) - v1.Type = TypeMem v.AddArg(v1) return true } @@ -4332,18 +4223,16 @@ endd5cc8c3dad7d24c845b0b88fc51487ae: v.Aux = nil v.resetArgs() v.AuxInt = config.PtrSize - v0 := b.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v0.Type = config.fe.TypeBytePtr().PtrTo() + 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, TypeInvalid) + v1 := b.NewValue0(v.Line, OpStore, TypeMem) v1.AuxInt = config.PtrSize v1.AddArg(dst) v1.AddArg(itab) v1.AddArg(mem) - v1.Type = TypeMem v.AddArg(v1) return true } @@ -4410,10 +4299,9 @@ end45295326269ba18413dceb7b608a0b9d: v.AuxInt = size v.AddArg(dst) v.AddArg(src) - v0 := b.NewValue0(v.Line, OpVarDef, TypeInvalid) + v0 := b.NewValue0(v.Line, OpVarDef, TypeMem) v0.Aux = x v0.AddArg(mem) - v0.Type = TypeMem v.AddArg(v0) return true } @@ -4704,15 +4592,13 @@ end56a7c7781fee35eeff0a3652dc206012: if !(!config.fe.CanSSA(t)) { goto end2afd47b4fcaaab7a73325bd8a75e3e8e } - v0 := v.Args[0].Block.NewValue0(v.Line, OpLoad, TypeInvalid) + v0 := v.Args[0].Block.NewValue0(v.Line, OpLoad, v.Type) v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AddArg(v0) - v0.Type = v.Type - v1 := v.Args[0].Block.NewValue0(v.Line, OpOffPtr, TypeInvalid) - v1.Type = v.Type.PtrTo() + v1 := v.Args[0].Block.NewValue0(v.Line, OpOffPtr, v.Type.PtrTo()) v1.AuxInt = t.FieldOff(i) v1.AddArg(ptr) v0.AddArg(v1) -- cgit v1.3 From 93a0b0f315a1b37e59449740dc5e5bb692b0d9f5 Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Wed, 3 Feb 2016 06:21:24 -0500 Subject: [dev.ssa] cmd/compile: rewrites for constant shifts Add rewrite rules to optimize constant shifts. Fixes #10637 Change-Id: I74b724d3e81aeb7098c696d02c050f7fdfd5b523 Reviewed-on: https://go-review.googlesource.com/19106 Reviewed-by: Keith Randall Run-TryBot: Todd Neal TryBot-Result: Gobot Gobot --- .../compile/internal/gc/testdata/arithConst_ssa.go | 11758 ++++++++++++++++--- src/cmd/compile/internal/gc/testdata/arith_ssa.go | 99 + .../internal/gc/testdata/gen/arithConstGen.go | 294 + src/cmd/compile/internal/ssa/gen/generic.rules | 96 + src/cmd/compile/internal/ssa/rewrite.go | 5 + src/cmd/compile/internal/ssa/rewritegeneric.go | 3096 ++++- 6 files changed, 13383 insertions(+), 1965 deletions(-) create mode 100644 src/cmd/compile/internal/gc/testdata/gen/arithConstGen.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/testdata/arithConst_ssa.go b/src/cmd/compile/internal/gc/testdata/arithConst_ssa.go index 93420aee66..782d2df8c8 100644 --- a/src/cmd/compile/internal/gc/testdata/arithConst_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/arithConst_ssa.go @@ -2,1811 +2,1903 @@ package main import "fmt" +//go:noinline func add_uint64_0_ssa(a uint64) uint64 { - switch { - } return a + 0 } + +//go:noinline func add_0_uint64_ssa(a uint64) uint64 { - switch { - } return 0 + a } +//go:noinline func add_uint64_1_ssa(a uint64) uint64 { - switch { - } return a + 1 } + +//go:noinline func add_1_uint64_ssa(a uint64) uint64 { - switch { - } return 1 + a } +//go:noinline func add_uint64_4294967296_ssa(a uint64) uint64 { - switch { - } return a + 4294967296 } + +//go:noinline func add_4294967296_uint64_ssa(a uint64) uint64 { - switch { - } return 4294967296 + a } +//go:noinline func add_uint64_18446744073709551615_ssa(a uint64) uint64 { - switch { - } return a + 18446744073709551615 } + +//go:noinline func add_18446744073709551615_uint64_ssa(a uint64) uint64 { - switch { - } return 18446744073709551615 + a } +//go:noinline func sub_uint64_0_ssa(a uint64) uint64 { - switch { - } return a - 0 } + +//go:noinline func sub_0_uint64_ssa(a uint64) uint64 { - switch { - } return 0 - a } +//go:noinline func sub_uint64_1_ssa(a uint64) uint64 { - switch { - } return a - 1 } + +//go:noinline func sub_1_uint64_ssa(a uint64) uint64 { - switch { - } return 1 - a } +//go:noinline func sub_uint64_4294967296_ssa(a uint64) uint64 { - switch { - } return a - 4294967296 } + +//go:noinline func sub_4294967296_uint64_ssa(a uint64) uint64 { - switch { - } return 4294967296 - a } +//go:noinline func sub_uint64_18446744073709551615_ssa(a uint64) uint64 { - switch { - } return a - 18446744073709551615 } + +//go:noinline func sub_18446744073709551615_uint64_ssa(a uint64) uint64 { - switch { - } return 18446744073709551615 - a } +//go:noinline func div_0_uint64_ssa(a uint64) uint64 { - switch { - } return 0 / a } +//go:noinline func div_uint64_1_ssa(a uint64) uint64 { - switch { - } return a / 1 } + +//go:noinline func div_1_uint64_ssa(a uint64) uint64 { - switch { - } return 1 / a } +//go:noinline func div_uint64_4294967296_ssa(a uint64) uint64 { - switch { - } return a / 4294967296 } + +//go:noinline func div_4294967296_uint64_ssa(a uint64) uint64 { - switch { - } return 4294967296 / a } +//go:noinline func div_uint64_18446744073709551615_ssa(a uint64) uint64 { - switch { - } return a / 18446744073709551615 } + +//go:noinline func div_18446744073709551615_uint64_ssa(a uint64) uint64 { - switch { - } return 18446744073709551615 / a } +//go:noinline func mul_uint64_0_ssa(a uint64) uint64 { - switch { - } return a * 0 } + +//go:noinline func mul_0_uint64_ssa(a uint64) uint64 { - switch { - } return 0 * a } +//go:noinline func mul_uint64_1_ssa(a uint64) uint64 { - switch { - } return a * 1 } + +//go:noinline func mul_1_uint64_ssa(a uint64) uint64 { - switch { - } return 1 * a } +//go:noinline func mul_uint64_4294967296_ssa(a uint64) uint64 { - switch { - } return a * 4294967296 } + +//go:noinline func mul_4294967296_uint64_ssa(a uint64) uint64 { - switch { - } return 4294967296 * a } +//go:noinline func mul_uint64_18446744073709551615_ssa(a uint64) uint64 { - switch { - } return a * 18446744073709551615 } + +//go:noinline func mul_18446744073709551615_uint64_ssa(a uint64) uint64 { - switch { - } 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 { - switch { - } return a + -9223372036854775808 } + +//go:noinline func add_Neg9223372036854775808_int64_ssa(a int64) int64 { - switch { - } return -9223372036854775808 + a } +//go:noinline func add_int64_Neg9223372036854775807_ssa(a int64) int64 { - switch { - } return a + -9223372036854775807 } + +//go:noinline func add_Neg9223372036854775807_int64_ssa(a int64) int64 { - switch { - } return -9223372036854775807 + a } +//go:noinline func add_int64_Neg4294967296_ssa(a int64) int64 { - switch { - } return a + -4294967296 } + +//go:noinline func add_Neg4294967296_int64_ssa(a int64) int64 { - switch { - } return -4294967296 + a } +//go:noinline func add_int64_Neg1_ssa(a int64) int64 { - switch { - } return a + -1 } + +//go:noinline func add_Neg1_int64_ssa(a int64) int64 { - switch { - } return -1 + a } +//go:noinline func add_int64_0_ssa(a int64) int64 { - switch { - } return a + 0 } + +//go:noinline func add_0_int64_ssa(a int64) int64 { - switch { - } return 0 + a } +//go:noinline func add_int64_1_ssa(a int64) int64 { - switch { - } return a + 1 } + +//go:noinline func add_1_int64_ssa(a int64) int64 { - switch { - } return 1 + a } +//go:noinline func add_int64_4294967296_ssa(a int64) int64 { - switch { - } return a + 4294967296 } + +//go:noinline func add_4294967296_int64_ssa(a int64) int64 { - switch { - } return 4294967296 + a } +//go:noinline func add_int64_9223372036854775806_ssa(a int64) int64 { - switch { - } return a + 9223372036854775806 } + +//go:noinline func add_9223372036854775806_int64_ssa(a int64) int64 { - switch { - } return 9223372036854775806 + a } +//go:noinline func add_int64_9223372036854775807_ssa(a int64) int64 { - switch { - } return a + 9223372036854775807 } + +//go:noinline func add_9223372036854775807_int64_ssa(a int64) int64 { - switch { - } return 9223372036854775807 + a } +//go:noinline func sub_int64_Neg9223372036854775808_ssa(a int64) int64 { - switch { - } return a - -9223372036854775808 } + +//go:noinline func sub_Neg9223372036854775808_int64_ssa(a int64) int64 { - switch { - } return -9223372036854775808 - a } +//go:noinline func sub_int64_Neg9223372036854775807_ssa(a int64) int64 { - switch { - } return a - -9223372036854775807 } + +//go:noinline func sub_Neg9223372036854775807_int64_ssa(a int64) int64 { - switch { - } return -9223372036854775807 - a } +//go:noinline func sub_int64_Neg4294967296_ssa(a int64) int64 { - switch { - } return a - -4294967296 } + +//go:noinline func sub_Neg4294967296_int64_ssa(a int64) int64 { - switch { - } return -4294967296 - a } +//go:noinline func sub_int64_Neg1_ssa(a int64) int64 { - switch { - } return a - -1 } + +//go:noinline func sub_Neg1_int64_ssa(a int64) int64 { - switch { - } return -1 - a } +//go:noinline func sub_int64_0_ssa(a int64) int64 { - switch { - } return a - 0 } + +//go:noinline func sub_0_int64_ssa(a int64) int64 { - switch { - } return 0 - a } +//go:noinline func sub_int64_1_ssa(a int64) int64 { - switch { - } return a - 1 } + +//go:noinline func sub_1_int64_ssa(a int64) int64 { - switch { - } return 1 - a } +//go:noinline func sub_int64_4294967296_ssa(a int64) int64 { - switch { - } return a - 4294967296 } + +//go:noinline func sub_4294967296_int64_ssa(a int64) int64 { - switch { - } return 4294967296 - a } +//go:noinline func sub_int64_9223372036854775806_ssa(a int64) int64 { - switch { - } return a - 9223372036854775806 } + +//go:noinline func sub_9223372036854775806_int64_ssa(a int64) int64 { - switch { - } return 9223372036854775806 - a } +//go:noinline func sub_int64_9223372036854775807_ssa(a int64) int64 { - switch { - } return a - 9223372036854775807 } + +//go:noinline func sub_9223372036854775807_int64_ssa(a int64) int64 { - switch { - } return 9223372036854775807 - a } +//go:noinline func div_int64_Neg9223372036854775808_ssa(a int64) int64 { - switch { - } return a / -9223372036854775808 } + +//go:noinline func div_Neg9223372036854775808_int64_ssa(a int64) int64 { - switch { - } return -9223372036854775808 / a } +//go:noinline func div_int64_Neg9223372036854775807_ssa(a int64) int64 { - switch { - } return a / -9223372036854775807 } + +//go:noinline func div_Neg9223372036854775807_int64_ssa(a int64) int64 { - switch { - } return -9223372036854775807 / a } +//go:noinline func div_int64_Neg4294967296_ssa(a int64) int64 { - switch { - } return a / -4294967296 } + +//go:noinline func div_Neg4294967296_int64_ssa(a int64) int64 { - switch { - } return -4294967296 / a } +//go:noinline func div_int64_Neg1_ssa(a int64) int64 { - switch { - } return a / -1 } + +//go:noinline func div_Neg1_int64_ssa(a int64) int64 { - switch { - } return -1 / a } +//go:noinline func div_0_int64_ssa(a int64) int64 { - switch { - } return 0 / a } +//go:noinline func div_int64_1_ssa(a int64) int64 { - switch { - } return a / 1 } + +//go:noinline func div_1_int64_ssa(a int64) int64 { - switch { - } return 1 / a } +//go:noinline func div_int64_4294967296_ssa(a int64) int64 { - switch { - } return a / 4294967296 } + +//go:noinline func div_4294967296_int64_ssa(a int64) int64 { - switch { - } return 4294967296 / a } +//go:noinline func div_int64_9223372036854775806_ssa(a int64) int64 { - switch { - } return a / 9223372036854775806 } + +//go:noinline func div_9223372036854775806_int64_ssa(a int64) int64 { - switch { - } return 9223372036854775806 / a } +//go:noinline func div_int64_9223372036854775807_ssa(a int64) int64 { - switch { - } return a / 9223372036854775807 } + +//go:noinline func div_9223372036854775807_int64_ssa(a int64) int64 { - switch { - } return 9223372036854775807 / a } +//go:noinline func mul_int64_Neg9223372036854775808_ssa(a int64) int64 { - switch { - } return a * -9223372036854775808 } + +//go:noinline func mul_Neg9223372036854775808_int64_ssa(a int64) int64 { - switch { - } return -9223372036854775808 * a } +//go:noinline func mul_int64_Neg9223372036854775807_ssa(a int64) int64 { - switch { - } return a * -9223372036854775807 } + +//go:noinline func mul_Neg9223372036854775807_int64_ssa(a int64) int64 { - switch { - } return -9223372036854775807 * a } +//go:noinline func mul_int64_Neg4294967296_ssa(a int64) int64 { - switch { - } return a * -4294967296 } + +//go:noinline func mul_Neg4294967296_int64_ssa(a int64) int64 { - switch { - } return -4294967296 * a } +//go:noinline func mul_int64_Neg1_ssa(a int64) int64 { - switch { - } return a * -1 } + +//go:noinline func mul_Neg1_int64_ssa(a int64) int64 { - switch { - } return -1 * a } +//go:noinline func mul_int64_0_ssa(a int64) int64 { - switch { - } return a * 0 } + +//go:noinline func mul_0_int64_ssa(a int64) int64 { - switch { - } return 0 * a } +//go:noinline func mul_int64_1_ssa(a int64) int64 { - switch { - } return a * 1 } + +//go:noinline func mul_1_int64_ssa(a int64) int64 { - switch { - } return 1 * a } +//go:noinline func mul_int64_4294967296_ssa(a int64) int64 { - switch { - } return a * 4294967296 } + +//go:noinline func mul_4294967296_int64_ssa(a int64) int64 { - switch { - } return 4294967296 * a } +//go:noinline func mul_int64_9223372036854775806_ssa(a int64) int64 { - switch { - } return a * 9223372036854775806 } + +//go:noinline func mul_9223372036854775806_int64_ssa(a int64) int64 { - switch { - } return 9223372036854775806 * a } +//go:noinline func mul_int64_9223372036854775807_ssa(a int64) int64 { - switch { - } return a * 9223372036854775807 } + +//go:noinline func mul_9223372036854775807_int64_ssa(a int64) int64 { - switch { - } return 9223372036854775807 * a } +//go:noinline func add_uint32_0_ssa(a uint32) uint32 { - switch { - } return a + 0 } + +//go:noinline func add_0_uint32_ssa(a uint32) uint32 { - switch { - } return 0 + a } +//go:noinline func add_uint32_1_ssa(a uint32) uint32 { - switch { - } return a + 1 } + +//go:noinline func add_1_uint32_ssa(a uint32) uint32 { - switch { - } return 1 + a } +//go:noinline func add_uint32_4294967295_ssa(a uint32) uint32 { - switch { - } return a + 4294967295 } + +//go:noinline func add_4294967295_uint32_ssa(a uint32) uint32 { - switch { - } return 4294967295 + a } +//go:noinline func sub_uint32_0_ssa(a uint32) uint32 { - switch { - } return a - 0 } + +//go:noinline func sub_0_uint32_ssa(a uint32) uint32 { - switch { - } return 0 - a } +//go:noinline func sub_uint32_1_ssa(a uint32) uint32 { - switch { - } return a - 1 } + +//go:noinline func sub_1_uint32_ssa(a uint32) uint32 { - switch { - } return 1 - a } +//go:noinline func sub_uint32_4294967295_ssa(a uint32) uint32 { - switch { - } return a - 4294967295 } + +//go:noinline func sub_4294967295_uint32_ssa(a uint32) uint32 { - switch { - } return 4294967295 - a } +//go:noinline func div_0_uint32_ssa(a uint32) uint32 { - switch { - } return 0 / a } +//go:noinline func div_uint32_1_ssa(a uint32) uint32 { - switch { - } return a / 1 } + +//go:noinline func div_1_uint32_ssa(a uint32) uint32 { - switch { - } return 1 / a } +//go:noinline func div_uint32_4294967295_ssa(a uint32) uint32 { - switch { - } return a / 4294967295 } + +//go:noinline func div_4294967295_uint32_ssa(a uint32) uint32 { - switch { - } return 4294967295 / a } +//go:noinline func mul_uint32_0_ssa(a uint32) uint32 { - switch { - } return a * 0 } + +//go:noinline func mul_0_uint32_ssa(a uint32) uint32 { - switch { - } return 0 * a } +//go:noinline func mul_uint32_1_ssa(a uint32) uint32 { - switch { - } return a * 1 } + +//go:noinline func mul_1_uint32_ssa(a uint32) uint32 { - switch { - } return 1 * a } +//go:noinline func mul_uint32_4294967295_ssa(a uint32) uint32 { - switch { - } return a * 4294967295 } + +//go:noinline func mul_4294967295_uint32_ssa(a uint32) uint32 { - switch { - } 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 { - switch { - } return a + -2147483648 } + +//go:noinline func add_Neg2147483648_int32_ssa(a int32) int32 { - switch { - } return -2147483648 + a } +//go:noinline func add_int32_Neg2147483647_ssa(a int32) int32 { - switch { - } return a + -2147483647 } + +//go:noinline func add_Neg2147483647_int32_ssa(a int32) int32 { - switch { - } return -2147483647 + a } +//go:noinline func add_int32_Neg1_ssa(a int32) int32 { - switch { - } return a + -1 } + +//go:noinline func add_Neg1_int32_ssa(a int32) int32 { - switch { - } return -1 + a } +//go:noinline func add_int32_0_ssa(a int32) int32 { - switch { - } return a + 0 } + +//go:noinline func add_0_int32_ssa(a int32) int32 { - switch { - } return 0 + a } +//go:noinline func add_int32_1_ssa(a int32) int32 { - switch { - } return a + 1 } + +//go:noinline func add_1_int32_ssa(a int32) int32 { - switch { - } return 1 + a } +//go:noinline func add_int32_2147483647_ssa(a int32) int32 { - switch { - } return a + 2147483647 } + +//go:noinline func add_2147483647_int32_ssa(a int32) int32 { - switch { - } return 2147483647 + a } +//go:noinline func sub_int32_Neg2147483648_ssa(a int32) int32 { - switch { - } return a - -2147483648 } + +//go:noinline func sub_Neg2147483648_int32_ssa(a int32) int32 { - switch { - } return -2147483648 - a } +//go:noinline func sub_int32_Neg2147483647_ssa(a int32) int32 { - switch { - } return a - -2147483647 } + +//go:noinline func sub_Neg2147483647_int32_ssa(a int32) int32 { - switch { - } return -2147483647 - a } +//go:noinline func sub_int32_Neg1_ssa(a int32) int32 { - switch { - } return a - -1 } + +//go:noinline func sub_Neg1_int32_ssa(a int32) int32 { - switch { - } return -1 - a } +//go:noinline func sub_int32_0_ssa(a int32) int32 { - switch { - } return a - 0 } + +//go:noinline func sub_0_int32_ssa(a int32) int32 { - switch { - } return 0 - a } +//go:noinline func sub_int32_1_ssa(a int32) int32 { - switch { - } return a - 1 } + +//go:noinline func sub_1_int32_ssa(a int32) int32 { - switch { - } return 1 - a } +//go:noinline func sub_int32_2147483647_ssa(a int32) int32 { - switch { - } return a - 2147483647 } + +//go:noinline func sub_2147483647_int32_ssa(a int32) int32 { - switch { - } return 2147483647 - a } +//go:noinline func div_int32_Neg2147483648_ssa(a int32) int32 { - switch { - } return a / -2147483648 } + +//go:noinline func div_Neg2147483648_int32_ssa(a int32) int32 { - switch { - } return -2147483648 / a } +//go:noinline func div_int32_Neg2147483647_ssa(a int32) int32 { - switch { - } return a / -2147483647 } + +//go:noinline func div_Neg2147483647_int32_ssa(a int32) int32 { - switch { - } return -2147483647 / a } +//go:noinline func div_int32_Neg1_ssa(a int32) int32 { - switch { - } return a / -1 } + +//go:noinline func div_Neg1_int32_ssa(a int32) int32 { - switch { - } return -1 / a } +//go:noinline func div_0_int32_ssa(a int32) int32 { - switch { - } return 0 / a } +//go:noinline func div_int32_1_ssa(a int32) int32 { - switch { - } return a / 1 } + +//go:noinline func div_1_int32_ssa(a int32) int32 { - switch { - } return 1 / a } +//go:noinline func div_int32_2147483647_ssa(a int32) int32 { - switch { - } return a / 2147483647 } + +//go:noinline func div_2147483647_int32_ssa(a int32) int32 { - switch { - } return 2147483647 / a } +//go:noinline func mul_int32_Neg2147483648_ssa(a int32) int32 { - switch { - } return a * -2147483648 } + +//go:noinline func mul_Neg2147483648_int32_ssa(a int32) int32 { - switch { - } return -2147483648 * a } +//go:noinline func mul_int32_Neg2147483647_ssa(a int32) int32 { - switch { - } return a * -2147483647 } + +//go:noinline func mul_Neg2147483647_int32_ssa(a int32) int32 { - switch { - } return -2147483647 * a } +//go:noinline func mul_int32_Neg1_ssa(a int32) int32 { - switch { - } return a * -1 } + +//go:noinline func mul_Neg1_int32_ssa(a int32) int32 { - switch { - } return -1 * a } +//go:noinline func mul_int32_0_ssa(a int32) int32 { - switch { - } return a * 0 } + +//go:noinline func mul_0_int32_ssa(a int32) int32 { - switch { - } return 0 * a } +//go:noinline func mul_int32_1_ssa(a int32) int32 { - switch { - } return a * 1 } + +//go:noinline func mul_1_int32_ssa(a int32) int32 { - switch { - } return 1 * a } +//go:noinline func mul_int32_2147483647_ssa(a int32) int32 { - switch { - } return a * 2147483647 } + +//go:noinline func mul_2147483647_int32_ssa(a int32) int32 { - switch { - } return 2147483647 * a } +//go:noinline func add_uint16_0_ssa(a uint16) uint16 { - switch { - } return a + 0 } + +//go:noinline func add_0_uint16_ssa(a uint16) uint16 { - switch { - } return 0 + a } +//go:noinline func add_uint16_1_ssa(a uint16) uint16 { - switch { - } return a + 1 } + +//go:noinline func add_1_uint16_ssa(a uint16) uint16 { - switch { - } return 1 + a } +//go:noinline func add_uint16_65535_ssa(a uint16) uint16 { - switch { - } return a + 65535 } + +//go:noinline func add_65535_uint16_ssa(a uint16) uint16 { - switch { - } return 65535 + a } +//go:noinline func sub_uint16_0_ssa(a uint16) uint16 { - switch { - } return a - 0 } + +//go:noinline func sub_0_uint16_ssa(a uint16) uint16 { - switch { - } return 0 - a } +//go:noinline func sub_uint16_1_ssa(a uint16) uint16 { - switch { - } return a - 1 } + +//go:noinline func sub_1_uint16_ssa(a uint16) uint16 { - switch { - } return 1 - a } +//go:noinline func sub_uint16_65535_ssa(a uint16) uint16 { - switch { - } return a - 65535 } + +//go:noinline func sub_65535_uint16_ssa(a uint16) uint16 { - switch { - } return 65535 - a } +//go:noinline func div_0_uint16_ssa(a uint16) uint16 { - switch { - } return 0 / a } +//go:noinline func div_uint16_1_ssa(a uint16) uint16 { - switch { - } return a / 1 } + +//go:noinline func div_1_uint16_ssa(a uint16) uint16 { - switch { - } return 1 / a } +//go:noinline func div_uint16_65535_ssa(a uint16) uint16 { - switch { - } return a / 65535 } + +//go:noinline func div_65535_uint16_ssa(a uint16) uint16 { - switch { - } return 65535 / a } +//go:noinline func mul_uint16_0_ssa(a uint16) uint16 { - switch { - } return a * 0 } + +//go:noinline func mul_0_uint16_ssa(a uint16) uint16 { - switch { - } return 0 * a } +//go:noinline func mul_uint16_1_ssa(a uint16) uint16 { - switch { - } return a * 1 } + +//go:noinline func mul_1_uint16_ssa(a uint16) uint16 { - switch { - } return 1 * a } +//go:noinline func mul_uint16_65535_ssa(a uint16) uint16 { - switch { - } return a * 65535 } + +//go:noinline func mul_65535_uint16_ssa(a uint16) uint16 { - switch { - } 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 { - switch { - } return a + -32768 } + +//go:noinline func add_Neg32768_int16_ssa(a int16) int16 { - switch { - } return -32768 + a } +//go:noinline func add_int16_Neg32767_ssa(a int16) int16 { - switch { - } return a + -32767 } + +//go:noinline func add_Neg32767_int16_ssa(a int16) int16 { - switch { - } return -32767 + a } +//go:noinline func add_int16_Neg1_ssa(a int16) int16 { - switch { - } return a + -1 } + +//go:noinline func add_Neg1_int16_ssa(a int16) int16 { - switch { - } return -1 + a } +//go:noinline func add_int16_0_ssa(a int16) int16 { - switch { - } return a + 0 } + +//go:noinline func add_0_int16_ssa(a int16) int16 { - switch { - } return 0 + a } +//go:noinline func add_int16_1_ssa(a int16) int16 { - switch { - } return a + 1 } + +//go:noinline func add_1_int16_ssa(a int16) int16 { - switch { - } return 1 + a } +//go:noinline func add_int16_32766_ssa(a int16) int16 { - switch { - } return a + 32766 } + +//go:noinline func add_32766_int16_ssa(a int16) int16 { - switch { - } return 32766 + a } +//go:noinline func add_int16_32767_ssa(a int16) int16 { - switch { - } return a + 32767 } + +//go:noinline func add_32767_int16_ssa(a int16) int16 { - switch { - } return 32767 + a } +//go:noinline func sub_int16_Neg32768_ssa(a int16) int16 { - switch { - } return a - -32768 } + +//go:noinline func sub_Neg32768_int16_ssa(a int16) int16 { - switch { - } return -32768 - a } +//go:noinline func sub_int16_Neg32767_ssa(a int16) int16 { - switch { - } return a - -32767 } + +//go:noinline func sub_Neg32767_int16_ssa(a int16) int16 { - switch { - } return -32767 - a } +//go:noinline func sub_int16_Neg1_ssa(a int16) int16 { - switch { - } return a - -1 } + +//go:noinline func sub_Neg1_int16_ssa(a int16) int16 { - switch { - } return -1 - a } +//go:noinline func sub_int16_0_ssa(a int16) int16 { - switch { - } return a - 0 } + +//go:noinline func sub_0_int16_ssa(a int16) int16 { - switch { - } return 0 - a } +//go:noinline func sub_int16_1_ssa(a int16) int16 { - switch { - } return a - 1 } + +//go:noinline func sub_1_int16_ssa(a int16) int16 { - switch { - } return 1 - a } +//go:noinline func sub_int16_32766_ssa(a int16) int16 { - switch { - } return a - 32766 } + +//go:noinline func sub_32766_int16_ssa(a int16) int16 { - switch { - } return 32766 - a } +//go:noinline func sub_int16_32767_ssa(a int16) int16 { - switch { - } return a - 32767 } + +//go:noinline func sub_32767_int16_ssa(a int16) int16 { - switch { - } return 32767 - a } +//go:noinline func div_int16_Neg32768_ssa(a int16) int16 { - switch { - } return a / -32768 } + +//go:noinline func div_Neg32768_int16_ssa(a int16) int16 { - switch { - } return -32768 / a } +//go:noinline func div_int16_Neg32767_ssa(a int16) int16 { - switch { - } return a / -32767 } + +//go:noinline func div_Neg32767_int16_ssa(a int16) int16 { - switch { - } return -32767 / a } +//go:noinline func div_int16_Neg1_ssa(a int16) int16 { - switch { - } return a / -1 } + +//go:noinline func div_Neg1_int16_ssa(a int16) int16 { - switch { - } return -1 / a } +//go:noinline func div_0_int16_ssa(a int16) int16 { - switch { - } return 0 / a } +//go:noinline func div_int16_1_ssa(a int16) int16 { - switch { - } return a / 1 } + +//go:noinline func div_1_int16_ssa(a int16) int16 { - switch { - } return 1 / a } +//go:noinline func div_int16_32766_ssa(a int16) int16 { - switch { - } return a / 32766 } + +//go:noinline func div_32766_int16_ssa(a int16) int16 { - switch { - } return 32766 / a } +//go:noinline func div_int16_32767_ssa(a int16) int16 { - switch { - } return a / 32767 } + +//go:noinline func div_32767_int16_ssa(a int16) int16 { - switch { - } return 32767 / a } +//go:noinline func mul_int16_Neg32768_ssa(a int16) int16 { - switch { - } return a * -32768 } + +//go:noinline func mul_Neg32768_int16_ssa(a int16) int16 { - switch { - } return -32768 * a } +//go:noinline func mul_int16_Neg32767_ssa(a int16) int16 { - switch { - } return a * -32767 } + +//go:noinline func mul_Neg32767_int16_ssa(a int16) int16 { - switch { - } return -32767 * a } +//go:noinline func mul_int16_Neg1_ssa(a int16) int16 { - switch { - } return a * -1 } + +//go:noinline func mul_Neg1_int16_ssa(a int16) int16 { - switch { - } return -1 * a } +//go:noinline func mul_int16_0_ssa(a int16) int16 { - switch { - } return a * 0 } + +//go:noinline func mul_0_int16_ssa(a int16) int16 { - switch { - } return 0 * a } +//go:noinline func mul_int16_1_ssa(a int16) int16 { - switch { - } return a * 1 } + +//go:noinline func mul_1_int16_ssa(a int16) int16 { - switch { - } return 1 * a } +//go:noinline func mul_int16_32766_ssa(a int16) int16 { - switch { - } return a * 32766 } + +//go:noinline func mul_32766_int16_ssa(a int16) int16 { - switch { - } return 32766 * a } +//go:noinline func mul_int16_32767_ssa(a int16) int16 { - switch { - } return a * 32767 } + +//go:noinline func mul_32767_int16_ssa(a int16) int16 { - switch { - } return 32767 * a } +//go:noinline func add_uint8_0_ssa(a uint8) uint8 { - switch { - } return a + 0 } + +//go:noinline func add_0_uint8_ssa(a uint8) uint8 { - switch { - } return 0 + a } +//go:noinline func add_uint8_1_ssa(a uint8) uint8 { - switch { - } return a + 1 } + +//go:noinline func add_1_uint8_ssa(a uint8) uint8 { - switch { - } return 1 + a } +//go:noinline func add_uint8_255_ssa(a uint8) uint8 { - switch { - } return a + 255 } + +//go:noinline func add_255_uint8_ssa(a uint8) uint8 { - switch { - } return 255 + a } +//go:noinline func sub_uint8_0_ssa(a uint8) uint8 { - switch { - } return a - 0 } + +//go:noinline func sub_0_uint8_ssa(a uint8) uint8 { - switch { - } return 0 - a } +//go:noinline func sub_uint8_1_ssa(a uint8) uint8 { - switch { - } return a - 1 } + +//go:noinline func sub_1_uint8_ssa(a uint8) uint8 { - switch { - } return 1 - a } +//go:noinline func sub_uint8_255_ssa(a uint8) uint8 { - switch { - } return a - 255 } + +//go:noinline func sub_255_uint8_ssa(a uint8) uint8 { - switch { - } return 255 - a } +//go:noinline func div_0_uint8_ssa(a uint8) uint8 { - switch { - } return 0 / a } +//go:noinline func div_uint8_1_ssa(a uint8) uint8 { - switch { - } return a / 1 } + +//go:noinline func div_1_uint8_ssa(a uint8) uint8 { - switch { - } return 1 / a } +//go:noinline func div_uint8_255_ssa(a uint8) uint8 { - switch { - } return a / 255 } + +//go:noinline func div_255_uint8_ssa(a uint8) uint8 { - switch { - } return 255 / a } +//go:noinline func mul_uint8_0_ssa(a uint8) uint8 { - switch { - } return a * 0 } + +//go:noinline func mul_0_uint8_ssa(a uint8) uint8 { - switch { - } return 0 * a } +//go:noinline func mul_uint8_1_ssa(a uint8) uint8 { - switch { - } return a * 1 } + +//go:noinline func mul_1_uint8_ssa(a uint8) uint8 { - switch { - } return 1 * a } +//go:noinline func mul_uint8_255_ssa(a uint8) uint8 { - switch { - } return a * 255 } + +//go:noinline func mul_255_uint8_ssa(a uint8) uint8 { - switch { - } return 255 * a } -func add_int8_Neg128_ssa(a int8) int8 { - switch { - } - return a + -128 +//go:noinline +func lsh_uint8_0_ssa(a uint8) uint8 { + return a << 0 } -func add_Neg128_int8_ssa(a int8) int8 { - switch { - } - return -128 + a + +//go:noinline +func lsh_0_uint8_ssa(a uint8) uint8 { + return 0 << a } -func add_int8_Neg127_ssa(a int8) int8 { - switch { - } - return a + -127 +//go:noinline +func lsh_uint8_1_ssa(a uint8) uint8 { + return a << 1 } -func add_Neg127_int8_ssa(a int8) int8 { - switch { - } - return -127 + a + +//go:noinline +func lsh_1_uint8_ssa(a uint8) uint8 { + return 1 << a } -func add_int8_Neg1_ssa(a int8) int8 { - switch { - } - return a + -1 +//go:noinline +func lsh_uint8_255_ssa(a uint8) uint8 { + return a << 255 } -func add_Neg1_int8_ssa(a int8) int8 { - switch { - } - return -1 + a + +//go:noinline +func lsh_255_uint8_ssa(a uint8) uint8 { + return 255 << a } -func add_int8_0_ssa(a int8) int8 { - switch { - } - return a + 0 +//go:noinline +func rsh_uint8_0_ssa(a uint8) uint8 { + return a >> 0 } -func add_0_int8_ssa(a int8) int8 { - switch { - } + +//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 { - switch { - } return a + 1 } + +//go:noinline func add_1_int8_ssa(a int8) int8 { - switch { - } return 1 + a } +//go:noinline func add_int8_126_ssa(a int8) int8 { - switch { - } return a + 126 } + +//go:noinline func add_126_int8_ssa(a int8) int8 { - switch { - } return 126 + a } +//go:noinline func add_int8_127_ssa(a int8) int8 { - switch { - } return a + 127 } + +//go:noinline func add_127_int8_ssa(a int8) int8 { - switch { - } return 127 + a } +//go:noinline func sub_int8_Neg128_ssa(a int8) int8 { - switch { - } return a - -128 } + +//go:noinline func sub_Neg128_int8_ssa(a int8) int8 { - switch { - } return -128 - a } +//go:noinline func sub_int8_Neg127_ssa(a int8) int8 { - switch { - } return a - -127 } + +//go:noinline func sub_Neg127_int8_ssa(a int8) int8 { - switch { - } return -127 - a } +//go:noinline func sub_int8_Neg1_ssa(a int8) int8 { - switch { - } return a - -1 } + +//go:noinline func sub_Neg1_int8_ssa(a int8) int8 { - switch { - } return -1 - a } +//go:noinline func sub_int8_0_ssa(a int8) int8 { - switch { - } return a - 0 } + +//go:noinline func sub_0_int8_ssa(a int8) int8 { - switch { - } return 0 - a } +//go:noinline func sub_int8_1_ssa(a int8) int8 { - switch { - } return a - 1 } + +//go:noinline func sub_1_int8_ssa(a int8) int8 { - switch { - } return 1 - a } +//go:noinline func sub_int8_126_ssa(a int8) int8 { - switch { - } return a - 126 } + +//go:noinline func sub_126_int8_ssa(a int8) int8 { - switch { - } return 126 - a } +//go:noinline func sub_int8_127_ssa(a int8) int8 { - switch { - } return a - 127 } + +//go:noinline func sub_127_int8_ssa(a int8) int8 { - switch { - } return 127 - a } +//go:noinline func div_int8_Neg128_ssa(a int8) int8 { - switch { - } return a / -128 } + +//go:noinline func div_Neg128_int8_ssa(a int8) int8 { - switch { - } return -128 / a } +//go:noinline func div_int8_Neg127_ssa(a int8) int8 { - switch { - } return a / -127 } + +//go:noinline func div_Neg127_int8_ssa(a int8) int8 { - switch { - } return -127 / a } +//go:noinline func div_int8_Neg1_ssa(a int8) int8 { - switch { - } return a / -1 } + +//go:noinline func div_Neg1_int8_ssa(a int8) int8 { - switch { - } return -1 / a } +//go:noinline func div_0_int8_ssa(a int8) int8 { - switch { - } return 0 / a } +//go:noinline func div_int8_1_ssa(a int8) int8 { - switch { - } return a / 1 } + +//go:noinline func div_1_int8_ssa(a int8) int8 { - switch { - } return 1 / a } +//go:noinline func div_int8_126_ssa(a int8) int8 { - switch { - } return a / 126 } + +//go:noinline func div_126_int8_ssa(a int8) int8 { - switch { - } return 126 / a } +//go:noinline func div_int8_127_ssa(a int8) int8 { - switch { - } return a / 127 } + +//go:noinline func div_127_int8_ssa(a int8) int8 { - switch { - } return 127 / a } +//go:noinline func mul_int8_Neg128_ssa(a int8) int8 { - switch { - } return a * -128 } + +//go:noinline func mul_Neg128_int8_ssa(a int8) int8 { - switch { - } return -128 * a } +//go:noinline func mul_int8_Neg127_ssa(a int8) int8 { - switch { - } return a * -127 } + +//go:noinline func mul_Neg127_int8_ssa(a int8) int8 { - switch { - } return -127 * a } +//go:noinline func mul_int8_Neg1_ssa(a int8) int8 { - switch { - } return a * -1 } + +//go:noinline func mul_Neg1_int8_ssa(a int8) int8 { - switch { - } return -1 * a } +//go:noinline func mul_int8_0_ssa(a int8) int8 { - switch { - } return a * 0 } + +//go:noinline func mul_0_int8_ssa(a int8) int8 { - switch { - } return 0 * a } +//go:noinline func mul_int8_1_ssa(a int8) int8 { - switch { - } return a * 1 } + +//go:noinline func mul_1_int8_ssa(a int8) int8 { - switch { - } return 1 * a } +//go:noinline func mul_int8_126_ssa(a int8) int8 { - switch { - } return a * 126 } + +//go:noinline func mul_126_int8_ssa(a int8) int8 { - switch { - } return 126 * a } +//go:noinline func mul_int8_127_ssa(a int8) int8 { - switch { - } return a * 127 } + +//go:noinline func mul_127_int8_ssa(a int8) int8 { - switch { - } return 127 * a } @@ -1814,1528 +1906,7718 @@ var failed bool func main() { - if got := div_0_uint64_ssa(1); got != 0 { - fmt.Printf("div_uint64 0/1 = %d, wanted 0\n", got) + if got := add_0_uint64_ssa(0); got != 0 { + fmt.Printf("add_uint64 0+0 = %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) + if got := add_uint64_0_ssa(0); got != 0 { + fmt.Printf("add_uint64 0+0 = %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) + if got := add_0_uint64_ssa(1); got != 1 { + fmt.Printf("add_uint64 0+1 = %d, wanted 1\n", got) failed = true } - if got := div_uint64_1_ssa(0); got != 0 { - fmt.Printf("div_uint64 0/1 = %d, wanted 0\n", got) + if got := add_uint64_0_ssa(1); got != 1 { + fmt.Printf("add_uint64 1+0 = %d, wanted 1\n", got) failed = true } - if got := div_1_uint64_ssa(1); got != 1 { - fmt.Printf("div_uint64 1/1 = %d, wanted 1\n", got) + if got := add_0_uint64_ssa(4294967296); got != 4294967296 { + fmt.Printf("add_uint64 0+4294967296 = %d, wanted 4294967296\n", got) failed = true } - if got := div_uint64_1_ssa(1); got != 1 { - fmt.Printf("div_uint64 1/1 = %d, wanted 1\n", got) + if got := add_uint64_0_ssa(4294967296); got != 4294967296 { + fmt.Printf("add_uint64 4294967296+0 = %d, wanted 4294967296\n", got) failed = true } - if got := div_1_uint64_ssa(4294967296); got != 0 { - fmt.Printf("div_uint64 1/4294967296 = %d, wanted 0\n", got) + if got := add_0_uint64_ssa(18446744073709551615); got != 18446744073709551615 { + fmt.Printf("add_uint64 0+18446744073709551615 = %d, wanted 18446744073709551615\n", got) failed = true } - if got := div_uint64_1_ssa(4294967296); got != 4294967296 { - fmt.Printf("div_uint64 4294967296/1 = %d, wanted 4294967296\n", got) + if got := add_uint64_0_ssa(18446744073709551615); got != 18446744073709551615 { + fmt.Printf("add_uint64 18446744073709551615+0 = %d, wanted 18446744073709551615\n", got) failed = true } - if got := div_1_uint64_ssa(18446744073709551615); got != 0 { - fmt.Printf("div_uint64 1/18446744073709551615 = %d, wanted 0\n", got) + if got := add_1_uint64_ssa(0); got != 1 { + fmt.Printf("add_uint64 1+0 = %d, wanted 1\n", got) failed = true } - if got := div_uint64_1_ssa(18446744073709551615); got != 18446744073709551615 { - fmt.Printf("div_uint64 18446744073709551615/1 = %d, wanted 18446744073709551615\n", got) + if got := add_uint64_1_ssa(0); got != 1 { + fmt.Printf("add_uint64 0+1 = %d, wanted 1\n", got) failed = true } - if got := div_uint64_4294967296_ssa(0); got != 0 { - fmt.Printf("div_uint64 0/4294967296 = %d, wanted 0\n", got) + if got := add_1_uint64_ssa(1); got != 2 { + fmt.Printf("add_uint64 1+1 = %d, wanted 2\n", got) failed = true } - if got := div_4294967296_uint64_ssa(1); got != 4294967296 { - fmt.Printf("div_uint64 4294967296/1 = %d, wanted 4294967296\n", got) + if got := add_uint64_1_ssa(1); got != 2 { + fmt.Printf("add_uint64 1+1 = %d, wanted 2\n", got) failed = true } - if got := div_uint64_4294967296_ssa(1); got != 0 { - fmt.Printf("div_uint64 1/4294967296 = %d, wanted 0\n", got) + if got := add_1_uint64_ssa(4294967296); got != 4294967297 { + fmt.Printf("add_uint64 1+4294967296 = %d, wanted 4294967297\n", got) failed = true } - if got := div_4294967296_uint64_ssa(4294967296); got != 1 { - fmt.Printf("div_uint64 4294967296/4294967296 = %d, wanted 1\n", got) + if got := add_uint64_1_ssa(4294967296); got != 4294967297 { + fmt.Printf("add_uint64 4294967296+1 = %d, wanted 4294967297\n", got) failed = true } - if got := div_uint64_4294967296_ssa(4294967296); got != 1 { - fmt.Printf("div_uint64 4294967296/4294967296 = %d, wanted 1\n", got) + if got := add_1_uint64_ssa(18446744073709551615); got != 0 { + fmt.Printf("add_uint64 1+18446744073709551615 = %d, wanted 0\n", got) failed = true } - if got := div_4294967296_uint64_ssa(18446744073709551615); got != 0 { - fmt.Printf("div_uint64 4294967296/18446744073709551615 = %d, wanted 0\n", got) + if got := add_uint64_1_ssa(18446744073709551615); got != 0 { + fmt.Printf("add_uint64 18446744073709551615+1 = %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) + if got := add_4294967296_uint64_ssa(0); got != 4294967296 { + fmt.Printf("add_uint64 4294967296+0 = %d, wanted 4294967296\n", got) failed = true } - if got := div_uint64_18446744073709551615_ssa(0); got != 0 { - fmt.Printf("div_uint64 0/18446744073709551615 = %d, wanted 0\n", got) + if got := add_uint64_4294967296_ssa(0); got != 4294967296 { + fmt.Printf("add_uint64 0+4294967296 = %d, wanted 4294967296\n", got) failed = true } - if got := div_18446744073709551615_uint64_ssa(1); got != 18446744073709551615 { - fmt.Printf("div_uint64 18446744073709551615/1 = %d, wanted 18446744073709551615\n", got) + if got := add_4294967296_uint64_ssa(1); got != 4294967297 { + fmt.Printf("add_uint64 4294967296+1 = %d, wanted 4294967297\n", got) failed = true } - if got := div_uint64_18446744073709551615_ssa(1); got != 0 { - fmt.Printf("div_uint64 1/18446744073709551615 = %d, wanted 0\n", got) + if got := add_uint64_4294967296_ssa(1); got != 4294967297 { + fmt.Printf("add_uint64 1+4294967296 = %d, wanted 4294967297\n", got) failed = true } - if got := div_18446744073709551615_uint64_ssa(4294967296); got != 4294967295 { - fmt.Printf("div_uint64 18446744073709551615/4294967296 = %d, wanted 4294967295\n", got) + if got := add_4294967296_uint64_ssa(4294967296); got != 8589934592 { + fmt.Printf("add_uint64 4294967296+4294967296 = %d, wanted 8589934592\n", got) failed = true } - if got := div_uint64_18446744073709551615_ssa(4294967296); got != 0 { - fmt.Printf("div_uint64 4294967296/18446744073709551615 = %d, wanted 0\n", got) + if got := add_uint64_4294967296_ssa(4294967296); got != 8589934592 { + fmt.Printf("add_uint64 4294967296+4294967296 = %d, wanted 8589934592\n", got) failed = true } - if got := div_18446744073709551615_uint64_ssa(18446744073709551615); got != 1 { - fmt.Printf("div_uint64 18446744073709551615/18446744073709551615 = %d, wanted 1\n", got) + if got := add_4294967296_uint64_ssa(18446744073709551615); got != 4294967295 { + fmt.Printf("add_uint64 4294967296+18446744073709551615 = %d, wanted 4294967295\n", got) failed = true } - if got := div_uint64_18446744073709551615_ssa(18446744073709551615); got != 1 { - fmt.Printf("div_uint64 18446744073709551615/18446744073709551615 = %d, wanted 1\n", got) + if got := add_uint64_4294967296_ssa(18446744073709551615); got != 4294967295 { + fmt.Printf("add_uint64 18446744073709551615+4294967296 = %d, wanted 4294967295\n", got) failed = true } - if got := div_Neg9223372036854775808_int64_ssa(-9223372036854775808); got != 1 { - fmt.Printf("div_int64 -9223372036854775808/-9223372036854775808 = %d, wanted 1\n", got) + if got := add_18446744073709551615_uint64_ssa(0); got != 18446744073709551615 { + fmt.Printf("add_uint64 18446744073709551615+0 = %d, wanted 18446744073709551615\n", got) failed = true } - if got := div_int64_Neg9223372036854775808_ssa(-9223372036854775808); got != 1 { - fmt.Printf("div_int64 -9223372036854775808/-9223372036854775808 = %d, wanted 1\n", got) + if got := add_uint64_18446744073709551615_ssa(0); got != 18446744073709551615 { + fmt.Printf("add_uint64 0+18446744073709551615 = %d, wanted 18446744073709551615\n", got) failed = true } - if got := div_Neg9223372036854775808_int64_ssa(-9223372036854775807); got != 1 { - fmt.Printf("div_int64 -9223372036854775808/-9223372036854775807 = %d, wanted 1\n", got) + if got := add_18446744073709551615_uint64_ssa(1); got != 0 { + fmt.Printf("add_uint64 18446744073709551615+1 = %d, wanted 0\n", got) failed = true } - if got := div_int64_Neg9223372036854775808_ssa(-9223372036854775807); got != 0 { - fmt.Printf("div_int64 -9223372036854775807/-9223372036854775808 = %d, wanted 0\n", got) + if got := add_uint64_18446744073709551615_ssa(1); got != 0 { + fmt.Printf("add_uint64 1+18446744073709551615 = %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) + if got := add_18446744073709551615_uint64_ssa(4294967296); got != 4294967295 { + fmt.Printf("add_uint64 18446744073709551615+4294967296 = %d, wanted 4294967295\n", got) failed = true } - if got := div_int64_Neg9223372036854775808_ssa(-4294967296); got != 0 { - fmt.Printf("div_int64 -4294967296/-9223372036854775808 = %d, wanted 0\n", got) + if got := add_uint64_18446744073709551615_ssa(4294967296); got != 4294967295 { + fmt.Printf("add_uint64 4294967296+18446744073709551615 = %d, wanted 4294967295\n", got) failed = true } - if got := div_Neg9223372036854775808_int64_ssa(-1); got != -9223372036854775808 { - fmt.Printf("div_int64 -9223372036854775808/-1 = %d, wanted -9223372036854775808\n", got) + if got := add_18446744073709551615_uint64_ssa(18446744073709551615); got != 18446744073709551614 { + fmt.Printf("add_uint64 18446744073709551615+18446744073709551615 = %d, wanted 18446744073709551614\n", got) failed = true } - if got := div_int64_Neg9223372036854775808_ssa(-1); got != 0 { - fmt.Printf("div_int64 -1/-9223372036854775808 = %d, wanted 0\n", got) + if got := add_uint64_18446744073709551615_ssa(18446744073709551615); got != 18446744073709551614 { + fmt.Printf("add_uint64 18446744073709551615+18446744073709551615 = %d, wanted 18446744073709551614\n", got) failed = true } - if got := div_int64_Neg9223372036854775808_ssa(0); got != 0 { - fmt.Printf("div_int64 0/-9223372036854775808 = %d, wanted 0\n", got) + if got := sub_0_uint64_ssa(0); got != 0 { + fmt.Printf("sub_uint64 0-0 = %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) + if got := sub_uint64_0_ssa(0); got != 0 { + fmt.Printf("sub_uint64 0-0 = %d, wanted 0\n", got) failed = true } - if got := div_int64_Neg9223372036854775808_ssa(1); got != 0 { - fmt.Printf("div_int64 1/-9223372036854775808 = %d, wanted 0\n", got) + if got := sub_0_uint64_ssa(1); got != 18446744073709551615 { + fmt.Printf("sub_uint64 0-1 = %d, wanted 18446744073709551615\n", got) failed = true } - if got := div_Neg9223372036854775808_int64_ssa(4294967296); got != -2147483648 { - fmt.Printf("div_int64 -9223372036854775808/4294967296 = %d, wanted -2147483648\n", got) + if got := sub_uint64_0_ssa(1); got != 1 { + fmt.Printf("sub_uint64 1-0 = %d, wanted 1\n", got) failed = true } - if got := div_int64_Neg9223372036854775808_ssa(4294967296); got != 0 { - fmt.Printf("div_int64 4294967296/-9223372036854775808 = %d, wanted 0\n", got) + if got := sub_0_uint64_ssa(4294967296); got != 18446744069414584320 { + fmt.Printf("sub_uint64 0-4294967296 = %d, wanted 18446744069414584320\n", got) failed = true } - if got := div_Neg9223372036854775808_int64_ssa(9223372036854775806); got != -1 { - fmt.Printf("div_int64 -9223372036854775808/9223372036854775806 = %d, wanted -1\n", got) + if got := sub_uint64_0_ssa(4294967296); got != 4294967296 { + fmt.Printf("sub_uint64 4294967296-0 = %d, wanted 4294967296\n", got) failed = true } - if got := div_int64_Neg9223372036854775808_ssa(9223372036854775806); got != 0 { - fmt.Printf("div_int64 9223372036854775806/-9223372036854775808 = %d, wanted 0\n", got) + if got := sub_0_uint64_ssa(18446744073709551615); got != 1 { + fmt.Printf("sub_uint64 0-18446744073709551615 = %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) + if got := sub_uint64_0_ssa(18446744073709551615); got != 18446744073709551615 { + fmt.Printf("sub_uint64 18446744073709551615-0 = %d, wanted 18446744073709551615\n", got) failed = true } - if got := div_int64_Neg9223372036854775808_ssa(9223372036854775807); got != 0 { - fmt.Printf("div_int64 9223372036854775807/-9223372036854775808 = %d, wanted 0\n", got) + if got := sub_1_uint64_ssa(0); got != 1 { + fmt.Printf("sub_uint64 1-0 = %d, wanted 1\n", got) failed = true } - if got := div_Neg9223372036854775807_int64_ssa(-9223372036854775808); got != 0 { - fmt.Printf("div_int64 -9223372036854775807/-9223372036854775808 = %d, wanted 0\n", got) + if got := sub_uint64_1_ssa(0); got != 18446744073709551615 { + fmt.Printf("sub_uint64 0-1 = %d, wanted 18446744073709551615\n", got) failed = true } - if got := div_int64_Neg9223372036854775807_ssa(-9223372036854775808); got != 1 { - fmt.Printf("div_int64 -9223372036854775808/-9223372036854775807 = %d, wanted 1\n", got) + if got := sub_1_uint64_ssa(1); got != 0 { + fmt.Printf("sub_uint64 1-1 = %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) + if got := sub_uint64_1_ssa(1); got != 0 { + fmt.Printf("sub_uint64 1-1 = %d, wanted 0\n", got) failed = true } - if got := div_int64_Neg9223372036854775807_ssa(-9223372036854775807); got != 1 { - fmt.Printf("div_int64 -9223372036854775807/-9223372036854775807 = %d, wanted 1\n", got) + if got := sub_1_uint64_ssa(4294967296); got != 18446744069414584321 { + fmt.Printf("sub_uint64 1-4294967296 = %d, wanted 18446744069414584321\n", got) failed = true } - if got := div_Neg9223372036854775807_int64_ssa(-4294967296); got != 2147483647 { - fmt.Printf("div_int64 -9223372036854775807/-4294967296 = %d, wanted 2147483647\n", got) + if got := sub_uint64_1_ssa(4294967296); got != 4294967295 { + fmt.Printf("sub_uint64 4294967296-1 = %d, wanted 4294967295\n", got) failed = true } - if got := div_int64_Neg9223372036854775807_ssa(-4294967296); got != 0 { - fmt.Printf("div_int64 -4294967296/-9223372036854775807 = %d, wanted 0\n", got) + if got := sub_1_uint64_ssa(18446744073709551615); got != 2 { + fmt.Printf("sub_uint64 1-18446744073709551615 = %d, wanted 2\n", got) failed = true } - if got := div_Neg9223372036854775807_int64_ssa(-1); got != 9223372036854775807 { - fmt.Printf("div_int64 -9223372036854775807/-1 = %d, wanted 9223372036854775807\n", got) + if got := sub_uint64_1_ssa(18446744073709551615); got != 18446744073709551614 { + fmt.Printf("sub_uint64 18446744073709551615-1 = %d, wanted 18446744073709551614\n", got) failed = true } - if got := div_int64_Neg9223372036854775807_ssa(-1); got != 0 { - fmt.Printf("div_int64 -1/-9223372036854775807 = %d, wanted 0\n", got) + if got := sub_4294967296_uint64_ssa(0); got != 4294967296 { + fmt.Printf("sub_uint64 4294967296-0 = %d, wanted 4294967296\n", got) failed = true } - if got := div_int64_Neg9223372036854775807_ssa(0); got != 0 { - fmt.Printf("div_int64 0/-9223372036854775807 = %d, wanted 0\n", got) + if got := sub_uint64_4294967296_ssa(0); got != 18446744069414584320 { + fmt.Printf("sub_uint64 0-4294967296 = %d, wanted 18446744069414584320\n", got) failed = true } - if got := div_Neg9223372036854775807_int64_ssa(1); got != -9223372036854775807 { - fmt.Printf("div_int64 -9223372036854775807/1 = %d, wanted -9223372036854775807\n", got) + if got := sub_4294967296_uint64_ssa(1); got != 4294967295 { + fmt.Printf("sub_uint64 4294967296-1 = %d, wanted 4294967295\n", got) failed = true } - if got := div_int64_Neg9223372036854775807_ssa(1); got != 0 { - fmt.Printf("div_int64 1/-9223372036854775807 = %d, wanted 0\n", got) + if got := sub_uint64_4294967296_ssa(1); got != 18446744069414584321 { + fmt.Printf("sub_uint64 1-4294967296 = %d, wanted 18446744069414584321\n", got) failed = true } - if got := div_Neg9223372036854775807_int64_ssa(4294967296); got != -2147483647 { - fmt.Printf("div_int64 -9223372036854775807/4294967296 = %d, wanted -2147483647\n", got) + if got := sub_4294967296_uint64_ssa(4294967296); got != 0 { + fmt.Printf("sub_uint64 4294967296-4294967296 = %d, wanted 0\n", got) failed = true } - if got := div_int64_Neg9223372036854775807_ssa(4294967296); got != 0 { - fmt.Printf("div_int64 4294967296/-9223372036854775807 = %d, wanted 0\n", got) + if got := sub_uint64_4294967296_ssa(4294967296); got != 0 { + fmt.Printf("sub_uint64 4294967296-4294967296 = %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) + if got := sub_4294967296_uint64_ssa(18446744073709551615); got != 4294967297 { + fmt.Printf("sub_uint64 4294967296-18446744073709551615 = %d, wanted 4294967297\n", got) failed = true } - if got := div_int64_Neg9223372036854775807_ssa(9223372036854775806); got != 0 { - fmt.Printf("div_int64 9223372036854775806/-9223372036854775807 = %d, wanted 0\n", got) + if got := sub_uint64_4294967296_ssa(18446744073709551615); got != 18446744069414584319 { + fmt.Printf("sub_uint64 18446744073709551615-4294967296 = %d, wanted 18446744069414584319\n", got) failed = true } - if got := div_Neg9223372036854775807_int64_ssa(9223372036854775807); got != -1 { - fmt.Printf("div_int64 -9223372036854775807/9223372036854775807 = %d, wanted -1\n", got) + if got := sub_18446744073709551615_uint64_ssa(0); got != 18446744073709551615 { + fmt.Printf("sub_uint64 18446744073709551615-0 = %d, wanted 18446744073709551615\n", got) failed = true } - if got := div_int64_Neg9223372036854775807_ssa(9223372036854775807); got != -1 { - fmt.Printf("div_int64 9223372036854775807/-9223372036854775807 = %d, wanted -1\n", got) + if got := sub_uint64_18446744073709551615_ssa(0); got != 1 { + fmt.Printf("sub_uint64 0-18446744073709551615 = %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) + if got := sub_18446744073709551615_uint64_ssa(1); got != 18446744073709551614 { + fmt.Printf("sub_uint64 18446744073709551615-1 = %d, wanted 18446744073709551614\n", got) failed = true } - if got := div_int64_Neg4294967296_ssa(-9223372036854775808); got != 2147483648 { - fmt.Printf("div_int64 -9223372036854775808/-4294967296 = %d, wanted 2147483648\n", got) + if got := sub_uint64_18446744073709551615_ssa(1); got != 2 { + fmt.Printf("sub_uint64 1-18446744073709551615 = %d, wanted 2\n", got) failed = true } - if got := div_Neg4294967296_int64_ssa(-9223372036854775807); got != 0 { - fmt.Printf("div_int64 -4294967296/-9223372036854775807 = %d, wanted 0\n", got) + if got := sub_18446744073709551615_uint64_ssa(4294967296); got != 18446744069414584319 { + fmt.Printf("sub_uint64 18446744073709551615-4294967296 = %d, wanted 18446744069414584319\n", got) failed = true } - if got := div_int64_Neg4294967296_ssa(-9223372036854775807); got != 2147483647 { - fmt.Printf("div_int64 -9223372036854775807/-4294967296 = %d, wanted 2147483647\n", got) + if got := sub_uint64_18446744073709551615_ssa(4294967296); got != 4294967297 { + fmt.Printf("sub_uint64 4294967296-18446744073709551615 = %d, wanted 4294967297\n", got) failed = true } - if got := div_Neg4294967296_int64_ssa(-4294967296); got != 1 { - fmt.Printf("div_int64 -4294967296/-4294967296 = %d, wanted 1\n", got) + if got := sub_18446744073709551615_uint64_ssa(18446744073709551615); got != 0 { + fmt.Printf("sub_uint64 18446744073709551615-18446744073709551615 = %d, wanted 0\n", got) failed = true } - if got := div_int64_Neg4294967296_ssa(-4294967296); got != 1 { - fmt.Printf("div_int64 -4294967296/-4294967296 = %d, wanted 1\n", got) + 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_Neg4294967296_int64_ssa(-1); got != 4294967296 { - fmt.Printf("div_int64 -4294967296/-1 = %d, wanted 4294967296\n", got) + 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_int64_Neg4294967296_ssa(-1); got != 0 { - fmt.Printf("div_int64 -1/-4294967296 = %d, wanted 0\n", got) + 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_int64_Neg4294967296_ssa(0); got != 0 { - fmt.Printf("div_int64 0/-4294967296 = %d, wanted 0\n", got) + 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_Neg4294967296_int64_ssa(1); got != -4294967296 { - fmt.Printf("div_int64 -4294967296/1 = %d, wanted -4294967296\n", got) + 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_int64_Neg4294967296_ssa(1); got != 0 { - fmt.Printf("div_int64 1/-4294967296 = %d, wanted 0\n", got) + 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_Neg4294967296_int64_ssa(4294967296); got != -1 { - fmt.Printf("div_int64 -4294967296/4294967296 = %d, wanted -1\n", got) + 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_int64_Neg4294967296_ssa(4294967296); got != -1 { - fmt.Printf("div_int64 4294967296/-4294967296 = %d, wanted -1\n", got) + 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_Neg4294967296_int64_ssa(9223372036854775806); got != 0 { - fmt.Printf("div_int64 -4294967296/9223372036854775806 = %d, wanted 0\n", got) + 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_int64_Neg4294967296_ssa(9223372036854775806); got != -2147483647 { - fmt.Printf("div_int64 9223372036854775806/-4294967296 = %d, wanted -2147483647\n", got) + 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_Neg4294967296_int64_ssa(9223372036854775807); got != 0 { - fmt.Printf("div_int64 -4294967296/9223372036854775807 = %d, wanted 0\n", got) + 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_int64_Neg4294967296_ssa(9223372036854775807); got != -2147483647 { - fmt.Printf("div_int64 9223372036854775807/-4294967296 = %d, wanted -2147483647\n", got) + 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_Neg1_int64_ssa(-9223372036854775808); got != 0 { - fmt.Printf("div_int64 -1/-9223372036854775808 = %d, wanted 0\n", got) + 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_int64_Neg1_ssa(-9223372036854775808); got != -9223372036854775808 { - fmt.Printf("div_int64 -9223372036854775808/-1 = %d, wanted -9223372036854775808\n", got) + 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_Neg1_int64_ssa(-9223372036854775807); got != 0 { - fmt.Printf("div_int64 -1/-9223372036854775807 = %d, wanted 0\n", got) + 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_int64_Neg1_ssa(-9223372036854775807); got != 9223372036854775807 { - fmt.Printf("div_int64 -9223372036854775807/-1 = %d, wanted 9223372036854775807\n", got) + 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_Neg1_int64_ssa(-4294967296); got != 0 { - fmt.Printf("div_int64 -1/-4294967296 = %d, wanted 0\n", got) + 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_int64_Neg1_ssa(-4294967296); got != 4294967296 { - fmt.Printf("div_int64 -4294967296/-1 = %d, wanted 4294967296\n", got) + 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_Neg1_int64_ssa(-1); got != 1 { - fmt.Printf("div_int64 -1/-1 = %d, wanted 1\n", got) + 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_int64_Neg1_ssa(-1); got != 1 { - fmt.Printf("div_int64 -1/-1 = %d, wanted 1\n", got) + 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_int64_Neg1_ssa(0); got != 0 { - fmt.Printf("div_int64 0/-1 = %d, wanted 0\n", got) + 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_Neg1_int64_ssa(1); got != -1 { - fmt.Printf("div_int64 -1/1 = %d, wanted -1\n", got) + 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_int64_Neg1_ssa(1); got != -1 { - fmt.Printf("div_int64 1/-1 = %d, wanted -1\n", got) + 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_Neg1_int64_ssa(4294967296); got != 0 { - fmt.Printf("div_int64 -1/4294967296 = %d, wanted 0\n", got) + 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_int64_Neg1_ssa(4294967296); got != -4294967296 { - fmt.Printf("div_int64 4294967296/-1 = %d, wanted -4294967296\n", got) + if got := div_uint64_18446744073709551615_ssa(18446744073709551615); got != 1 { + fmt.Printf("div_uint64 18446744073709551615/18446744073709551615 = %d, wanted 1\n", got) failed = true } - if got := div_Neg1_int64_ssa(9223372036854775806); got != 0 { - fmt.Printf("div_int64 -1/9223372036854775806 = %d, wanted 0\n", got) + if got := mul_0_uint64_ssa(0); got != 0 { + fmt.Printf("mul_uint64 0*0 = %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) + if got := mul_uint64_0_ssa(0); got != 0 { + fmt.Printf("mul_uint64 0*0 = %d, wanted 0\n", got) failed = true } - if got := div_Neg1_int64_ssa(9223372036854775807); got != 0 { - fmt.Printf("div_int64 -1/9223372036854775807 = %d, wanted 0\n", got) + if got := mul_0_uint64_ssa(1); got != 0 { + fmt.Printf("mul_uint64 0*1 = %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) + if got := mul_uint64_0_ssa(1); got != 0 { + fmt.Printf("mul_uint64 1*0 = %d, wanted 0\n", got) failed = true } - if got := div_0_int64_ssa(-9223372036854775808); got != 0 { - fmt.Printf("div_int64 0/-9223372036854775808 = %d, wanted 0\n", got) + if got := mul_0_uint64_ssa(4294967296); got != 0 { + fmt.Printf("mul_uint64 0*4294967296 = %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) + if got := mul_uint64_0_ssa(4294967296); got != 0 { + fmt.Printf("mul_uint64 4294967296*0 = %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) + if got := mul_0_uint64_ssa(18446744073709551615); got != 0 { + fmt.Printf("mul_uint64 0*18446744073709551615 = %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) + if got := mul_uint64_0_ssa(18446744073709551615); got != 0 { + fmt.Printf("mul_uint64 18446744073709551615*0 = %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) + if got := mul_1_uint64_ssa(0); got != 0 { + fmt.Printf("mul_uint64 1*0 = %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) + if got := mul_uint64_1_ssa(0); got != 0 { + fmt.Printf("mul_uint64 0*1 = %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) + if got := mul_1_uint64_ssa(1); got != 1 { + fmt.Printf("mul_uint64 1*1 = %d, wanted 1\n", got) failed = true } - if got := div_0_int64_ssa(9223372036854775807); got != 0 { - fmt.Printf("div_int64 0/9223372036854775807 = %d, wanted 0\n", got) + if got := mul_uint64_1_ssa(1); got != 1 { + fmt.Printf("mul_uint64 1*1 = %d, wanted 1\n", got) failed = true } - if got := div_1_int64_ssa(-9223372036854775808); got != 0 { - fmt.Printf("div_int64 1/-9223372036854775808 = %d, wanted 0\n", got) + if got := mul_1_uint64_ssa(4294967296); got != 4294967296 { + fmt.Printf("mul_uint64 1*4294967296 = %d, wanted 4294967296\n", got) failed = true } - if got := div_int64_1_ssa(-9223372036854775808); got != -9223372036854775808 { - fmt.Printf("div_int64 -9223372036854775808/1 = %d, wanted -9223372036854775808\n", got) + if got := mul_uint64_1_ssa(4294967296); got != 4294967296 { + fmt.Printf("mul_uint64 4294967296*1 = %d, wanted 4294967296\n", got) failed = true } - if got := div_1_int64_ssa(-9223372036854775807); got != 0 { - fmt.Printf("div_int64 1/-9223372036854775807 = %d, wanted 0\n", got) + if got := mul_1_uint64_ssa(18446744073709551615); got != 18446744073709551615 { + fmt.Printf("mul_uint64 1*18446744073709551615 = %d, wanted 18446744073709551615\n", got) failed = true } - if got := div_int64_1_ssa(-9223372036854775807); got != -9223372036854775807 { - fmt.Printf("div_int64 -9223372036854775807/1 = %d, wanted -9223372036854775807\n", got) + if got := mul_uint64_1_ssa(18446744073709551615); got != 18446744073709551615 { + fmt.Printf("mul_uint64 18446744073709551615*1 = %d, wanted 18446744073709551615\n", got) failed = true } - if got := div_1_int64_ssa(-4294967296); got != 0 { - fmt.Printf("div_int64 1/-4294967296 = %d, wanted 0\n", got) + if got := mul_4294967296_uint64_ssa(0); got != 0 { + fmt.Printf("mul_uint64 4294967296*0 = %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) + if got := mul_uint64_4294967296_ssa(0); got != 0 { + fmt.Printf("mul_uint64 0*4294967296 = %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) + if got := mul_4294967296_uint64_ssa(1); got != 4294967296 { + fmt.Printf("mul_uint64 4294967296*1 = %d, wanted 4294967296\n", got) failed = true } - if got := div_int64_1_ssa(-1); got != -1 { - fmt.Printf("div_int64 -1/1 = %d, wanted -1\n", got) + if got := mul_uint64_4294967296_ssa(1); got != 4294967296 { + fmt.Printf("mul_uint64 1*4294967296 = %d, wanted 4294967296\n", got) failed = true } - if got := div_int64_1_ssa(0); got != 0 { - fmt.Printf("div_int64 0/1 = %d, wanted 0\n", got) + if got := mul_4294967296_uint64_ssa(4294967296); got != 0 { + fmt.Printf("mul_uint64 4294967296*4294967296 = %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) + if got := mul_uint64_4294967296_ssa(4294967296); got != 0 { + fmt.Printf("mul_uint64 4294967296*4294967296 = %d, wanted 0\n", got) failed = true } - if got := div_int64_1_ssa(1); got != 1 { - fmt.Printf("div_int64 1/1 = %d, wanted 1\n", got) + if got := mul_4294967296_uint64_ssa(18446744073709551615); got != 18446744069414584320 { + fmt.Printf("mul_uint64 4294967296*18446744073709551615 = %d, wanted 18446744069414584320\n", got) failed = true } - if got := div_1_int64_ssa(4294967296); got != 0 { - fmt.Printf("div_int64 1/4294967296 = %d, wanted 0\n", got) + if got := mul_uint64_4294967296_ssa(18446744073709551615); got != 18446744069414584320 { + fmt.Printf("mul_uint64 18446744073709551615*4294967296 = %d, wanted 18446744069414584320\n", got) failed = true } - if got := div_int64_1_ssa(4294967296); got != 4294967296 { - fmt.Printf("div_int64 4294967296/1 = %d, wanted 4294967296\n", got) + if got := mul_18446744073709551615_uint64_ssa(0); got != 0 { + fmt.Printf("mul_uint64 18446744073709551615*0 = %d, wanted 0\n", got) failed = true } - if got := div_1_int64_ssa(9223372036854775806); got != 0 { - fmt.Printf("div_int64 1/9223372036854775806 = %d, wanted 0\n", got) + if got := mul_uint64_18446744073709551615_ssa(0); got != 0 { + fmt.Printf("mul_uint64 0*18446744073709551615 = %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) + if got := mul_18446744073709551615_uint64_ssa(1); got != 18446744073709551615 { + fmt.Printf("mul_uint64 18446744073709551615*1 = %d, wanted 18446744073709551615\n", got) failed = true } - if got := div_1_int64_ssa(9223372036854775807); got != 0 { - fmt.Printf("div_int64 1/9223372036854775807 = %d, wanted 0\n", got) + if got := mul_uint64_18446744073709551615_ssa(1); got != 18446744073709551615 { + fmt.Printf("mul_uint64 1*18446744073709551615 = %d, wanted 18446744073709551615\n", got) failed = true } - if got := div_int64_1_ssa(9223372036854775807); got != 9223372036854775807 { - fmt.Printf("div_int64 9223372036854775807/1 = %d, wanted 9223372036854775807\n", got) + if got := mul_18446744073709551615_uint64_ssa(4294967296); got != 18446744069414584320 { + fmt.Printf("mul_uint64 18446744073709551615*4294967296 = %d, wanted 18446744069414584320\n", got) failed = true } - if got := div_4294967296_int64_ssa(-9223372036854775808); got != 0 { - fmt.Printf("div_int64 4294967296/-9223372036854775808 = %d, wanted 0\n", got) + if got := mul_uint64_18446744073709551615_ssa(4294967296); got != 18446744069414584320 { + fmt.Printf("mul_uint64 4294967296*18446744073709551615 = %d, wanted 18446744069414584320\n", got) failed = true } - if got := div_int64_4294967296_ssa(-9223372036854775808); got != -2147483648 { - fmt.Printf("div_int64 -9223372036854775808/4294967296 = %d, wanted -2147483648\n", got) + if got := mul_18446744073709551615_uint64_ssa(18446744073709551615); got != 1 { + fmt.Printf("mul_uint64 18446744073709551615*18446744073709551615 = %d, wanted 1\n", got) failed = true } - if got := div_4294967296_int64_ssa(-9223372036854775807); got != 0 { - fmt.Printf("div_int64 4294967296/-9223372036854775807 = %d, wanted 0\n", got) + if got := mul_uint64_18446744073709551615_ssa(18446744073709551615); got != 1 { + fmt.Printf("mul_uint64 18446744073709551615*18446744073709551615 = %d, wanted 1\n", got) failed = true } - if got := div_int64_4294967296_ssa(-9223372036854775807); got != -2147483647 { - fmt.Printf("div_int64 -9223372036854775807/4294967296 = %d, wanted -2147483647\n", got) + if got := lsh_0_uint64_ssa(0); got != 0 { + fmt.Printf("lsh_uint64 0<<0 = %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) + if got := lsh_uint64_0_ssa(0); got != 0 { + fmt.Printf("lsh_uint64 0<<0 = %d, wanted 0\n", got) failed = true } - if got := div_int64_4294967296_ssa(-4294967296); got != -1 { - fmt.Printf("div_int64 -4294967296/4294967296 = %d, wanted -1\n", got) + if got := lsh_0_uint64_ssa(1); got != 0 { + fmt.Printf("lsh_uint64 0<<1 = %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) + if got := lsh_uint64_0_ssa(1); got != 1 { + fmt.Printf("lsh_uint64 1<<0 = %d, wanted 1\n", got) failed = true } - if got := div_int64_4294967296_ssa(-1); got != 0 { - fmt.Printf("div_int64 -1/4294967296 = %d, wanted 0\n", got) + if got := lsh_0_uint64_ssa(4294967296); got != 0 { + fmt.Printf("lsh_uint64 0<<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) + if got := lsh_uint64_0_ssa(4294967296); got != 4294967296 { + fmt.Printf("lsh_uint64 4294967296<<0 = %d, wanted 4294967296\n", got) failed = true } - if got := div_4294967296_int64_ssa(1); got != 4294967296 { - fmt.Printf("div_int64 4294967296/1 = %d, wanted 4294967296\n", got) + if got := lsh_0_uint64_ssa(18446744073709551615); got != 0 { + fmt.Printf("lsh_uint64 0<<18446744073709551615 = %d, wanted 0\n", got) failed = true } - if got := div_int64_4294967296_ssa(1); got != 0 { - fmt.Printf("div_int64 1/4294967296 = %d, wanted 0\n", got) + if got := lsh_uint64_0_ssa(18446744073709551615); got != 18446744073709551615 { + fmt.Printf("lsh_uint64 18446744073709551615<<0 = %d, wanted 18446744073709551615\n", got) failed = true } - if got := div_4294967296_int64_ssa(4294967296); got != 1 { - fmt.Printf("div_int64 4294967296/4294967296 = %d, wanted 1\n", got) + if got := lsh_1_uint64_ssa(0); got != 1 { + fmt.Printf("lsh_uint64 1<<0 = %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) + if got := lsh_uint64_1_ssa(0); got != 0 { + fmt.Printf("lsh_uint64 0<<1 = %d, wanted 0\n", got) failed = true } - if got := div_4294967296_int64_ssa(9223372036854775806); got != 0 { - fmt.Printf("div_int64 4294967296/9223372036854775806 = %d, wanted 0\n", got) + if got := lsh_1_uint64_ssa(1); got != 2 { + fmt.Printf("lsh_uint64 1<<1 = %d, wanted 2\n", got) failed = true } - if got := div_int64_4294967296_ssa(9223372036854775806); got != 2147483647 { - fmt.Printf("div_int64 9223372036854775806/4294967296 = %d, wanted 2147483647\n", got) + if got := lsh_uint64_1_ssa(1); got != 2 { + fmt.Printf("lsh_uint64 1<<1 = %d, wanted 2\n", got) failed = true } - if got := div_4294967296_int64_ssa(9223372036854775807); got != 0 { - fmt.Printf("div_int64 4294967296/9223372036854775807 = %d, wanted 0\n", got) + if got := lsh_1_uint64_ssa(4294967296); got != 0 { + fmt.Printf("lsh_uint64 1<<4294967296 = %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) + if got := lsh_uint64_1_ssa(4294967296); got != 8589934592 { + fmt.Printf("lsh_uint64 4294967296<<1 = %d, wanted 8589934592\n", got) failed = true } - if got := div_9223372036854775806_int64_ssa(-9223372036854775808); got != 0 { - fmt.Printf("div_int64 9223372036854775806/-9223372036854775808 = %d, wanted 0\n", got) + if got := lsh_1_uint64_ssa(18446744073709551615); got != 0 { + fmt.Printf("lsh_uint64 1<<18446744073709551615 = %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) + if got := lsh_uint64_1_ssa(18446744073709551615); got != 18446744073709551614 { + fmt.Printf("lsh_uint64 18446744073709551615<<1 = %d, wanted 18446744073709551614\n", got) failed = true } - if got := div_9223372036854775806_int64_ssa(-9223372036854775807); got != 0 { - fmt.Printf("div_int64 9223372036854775806/-9223372036854775807 = %d, wanted 0\n", got) + if got := lsh_4294967296_uint64_ssa(0); got != 4294967296 { + fmt.Printf("lsh_uint64 4294967296<<0 = %d, wanted 4294967296\n", got) failed = true } - if got := div_int64_9223372036854775806_ssa(-9223372036854775807); got != -1 { - fmt.Printf("div_int64 -9223372036854775807/9223372036854775806 = %d, wanted -1\n", got) + if got := lsh_uint64_4294967296_ssa(0); got != 0 { + fmt.Printf("lsh_uint64 0<<4294967296 = %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) + if got := lsh_4294967296_uint64_ssa(1); got != 8589934592 { + fmt.Printf("lsh_uint64 4294967296<<1 = %d, wanted 8589934592\n", got) failed = true } - if got := div_int64_9223372036854775806_ssa(-4294967296); got != 0 { - fmt.Printf("div_int64 -4294967296/9223372036854775806 = %d, wanted 0\n", got) + if got := lsh_uint64_4294967296_ssa(1); got != 0 { + fmt.Printf("lsh_uint64 1<<4294967296 = %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) + if got := lsh_4294967296_uint64_ssa(4294967296); got != 0 { + fmt.Printf("lsh_uint64 4294967296<<4294967296 = %d, wanted 0\n", got) failed = true } - if got := div_int64_9223372036854775806_ssa(-1); got != 0 { - fmt.Printf("div_int64 -1/9223372036854775806 = %d, wanted 0\n", got) + if got := lsh_uint64_4294967296_ssa(4294967296); got != 0 { + fmt.Printf("lsh_uint64 4294967296<<4294967296 = %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) + if got := lsh_4294967296_uint64_ssa(18446744073709551615); got != 0 { + fmt.Printf("lsh_uint64 4294967296<<18446744073709551615 = %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) + if got := lsh_uint64_4294967296_ssa(18446744073709551615); got != 0 { + fmt.Printf("lsh_uint64 18446744073709551615<<4294967296 = %d, wanted 0\n", got) failed = true } - if got := div_int64_9223372036854775806_ssa(1); got != 0 { - fmt.Printf("div_int64 1/9223372036854775806 = %d, wanted 0\n", got) + if got := lsh_18446744073709551615_uint64_ssa(0); got != 18446744073709551615 { + fmt.Printf("lsh_uint64 18446744073709551615<<0 = %d, wanted 18446744073709551615\n", got) failed = true } - if got := div_9223372036854775806_int64_ssa(4294967296); got != 2147483647 { - fmt.Printf("div_int64 9223372036854775806/4294967296 = %d, wanted 2147483647\n", got) + if got := lsh_uint64_18446744073709551615_ssa(0); got != 0 { + fmt.Printf("lsh_uint64 0<<18446744073709551615 = %d, wanted 0\n", got) failed = true } - if got := div_int64_9223372036854775806_ssa(4294967296); got != 0 { - fmt.Printf("div_int64 4294967296/9223372036854775806 = %d, wanted 0\n", got) + if got := lsh_18446744073709551615_uint64_ssa(1); got != 18446744073709551614 { + fmt.Printf("lsh_uint64 18446744073709551615<<1 = %d, wanted 18446744073709551614\n", got) failed = true } - if got := div_9223372036854775806_int64_ssa(9223372036854775806); got != 1 { - fmt.Printf("div_int64 9223372036854775806/9223372036854775806 = %d, wanted 1\n", got) + if got := lsh_uint64_18446744073709551615_ssa(1); got != 0 { + fmt.Printf("lsh_uint64 1<<18446744073709551615 = %d, wanted 0\n", got) failed = true } - if got := div_int64_9223372036854775806_ssa(9223372036854775806); got != 1 { - fmt.Printf("div_int64 9223372036854775806/9223372036854775806 = %d, wanted 1\n", got) + if got := lsh_18446744073709551615_uint64_ssa(4294967296); got != 0 { + fmt.Printf("lsh_uint64 18446744073709551615<<4294967296 = %d, wanted 0\n", got) failed = true } - if got := div_9223372036854775806_int64_ssa(9223372036854775807); got != 0 { - fmt.Printf("div_int64 9223372036854775806/9223372036854775807 = %d, wanted 0\n", got) + if got := lsh_uint64_18446744073709551615_ssa(4294967296); got != 0 { + fmt.Printf("lsh_uint64 4294967296<<18446744073709551615 = %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) + if got := lsh_18446744073709551615_uint64_ssa(18446744073709551615); got != 0 { + fmt.Printf("lsh_uint64 18446744073709551615<<18446744073709551615 = %d, wanted 0\n", got) failed = true } - if got := div_9223372036854775807_int64_ssa(-9223372036854775808); got != 0 { - fmt.Printf("div_int64 9223372036854775807/-9223372036854775808 = %d, wanted 0\n", got) + if got := lsh_uint64_18446744073709551615_ssa(18446744073709551615); got != 0 { + fmt.Printf("lsh_uint64 18446744073709551615<<18446744073709551615 = %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) + if got := rsh_0_uint64_ssa(0); got != 0 { + fmt.Printf("rsh_uint64 0>>0 = %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) + if got := rsh_uint64_0_ssa(0); got != 0 { + fmt.Printf("rsh_uint64 0>>0 = %d, wanted 0\n", got) failed = true } - if got := div_int64_9223372036854775807_ssa(-9223372036854775807); got != -1 { - fmt.Printf("div_int64 -9223372036854775807/9223372036854775807 = %d, wanted -1\n", got) + if got := rsh_0_uint64_ssa(1); got != 0 { + fmt.Printf("rsh_uint64 0>>1 = %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) + if got := rsh_uint64_0_ssa(1); got != 1 { + fmt.Printf("rsh_uint64 1>>0 = %d, wanted 1\n", got) failed = true } - if got := div_int64_9223372036854775807_ssa(-4294967296); got != 0 { - fmt.Printf("div_int64 -4294967296/9223372036854775807 = %d, wanted 0\n", got) + if got := rsh_0_uint64_ssa(4294967296); got != 0 { + fmt.Printf("rsh_uint64 0>>4294967296 = %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) + if got := rsh_uint64_0_ssa(4294967296); got != 4294967296 { + fmt.Printf("rsh_uint64 4294967296>>0 = %d, wanted 4294967296\n", got) failed = true } - if got := div_int64_9223372036854775807_ssa(-1); got != 0 { - fmt.Printf("div_int64 -1/9223372036854775807 = %d, wanted 0\n", got) + if got := rsh_0_uint64_ssa(18446744073709551615); got != 0 { + fmt.Printf("rsh_uint64 0>>18446744073709551615 = %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) + if got := rsh_uint64_0_ssa(18446744073709551615); got != 18446744073709551615 { + fmt.Printf("rsh_uint64 18446744073709551615>>0 = %d, wanted 18446744073709551615\n", got) failed = true } - if got := div_9223372036854775807_int64_ssa(1); got != 9223372036854775807 { - fmt.Printf("div_int64 9223372036854775807/1 = %d, wanted 9223372036854775807\n", got) + if got := rsh_1_uint64_ssa(0); got != 1 { + fmt.Printf("rsh_uint64 1>>0 = %d, wanted 1\n", got) failed = true } - if got := div_int64_9223372036854775807_ssa(1); got != 0 { - fmt.Printf("div_int64 1/9223372036854775807 = %d, wanted 0\n", got) + if got := rsh_uint64_1_ssa(0); got != 0 { + fmt.Printf("rsh_uint64 0>>1 = %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) + if got := rsh_1_uint64_ssa(1); got != 0 { + fmt.Printf("rsh_uint64 1>>1 = %d, wanted 0\n", got) failed = true } - if got := div_int64_9223372036854775807_ssa(4294967296); got != 0 { - fmt.Printf("div_int64 4294967296/9223372036854775807 = %d, wanted 0\n", got) + if got := rsh_uint64_1_ssa(1); got != 0 { + fmt.Printf("rsh_uint64 1>>1 = %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) + if got := rsh_1_uint64_ssa(4294967296); got != 0 { + fmt.Printf("rsh_uint64 1>>4294967296 = %d, wanted 0\n", got) failed = true } - if got := div_int64_9223372036854775807_ssa(9223372036854775806); got != 0 { - fmt.Printf("div_int64 9223372036854775806/9223372036854775807 = %d, wanted 0\n", got) + if got := rsh_uint64_1_ssa(4294967296); got != 2147483648 { + fmt.Printf("rsh_uint64 4294967296>>1 = %d, wanted 2147483648\n", got) failed = true } - if got := div_9223372036854775807_int64_ssa(9223372036854775807); got != 1 { - fmt.Printf("div_int64 9223372036854775807/9223372036854775807 = %d, wanted 1\n", got) + if got := rsh_1_uint64_ssa(18446744073709551615); got != 0 { + fmt.Printf("rsh_uint64 1>>18446744073709551615 = %d, wanted 0\n", got) failed = true } - if got := div_int64_9223372036854775807_ssa(9223372036854775807); got != 1 { - fmt.Printf("div_int64 9223372036854775807/9223372036854775807 = %d, wanted 1\n", got) + if got := rsh_uint64_1_ssa(18446744073709551615); got != 9223372036854775807 { + fmt.Printf("rsh_uint64 18446744073709551615>>1 = %d, wanted 9223372036854775807\n", got) failed = true } - if got := div_0_uint32_ssa(1); got != 0 { - fmt.Printf("div_uint32 0/1 = %d, wanted 0\n", got) + if got := rsh_4294967296_uint64_ssa(0); got != 4294967296 { + fmt.Printf("rsh_uint64 4294967296>>0 = %d, wanted 4294967296\n", got) failed = true } - if got := div_0_uint32_ssa(4294967295); got != 0 { - fmt.Printf("div_uint32 0/4294967295 = %d, wanted 0\n", got) + if got := rsh_uint64_4294967296_ssa(0); got != 0 { + fmt.Printf("rsh_uint64 0>>4294967296 = %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) + if got := rsh_4294967296_uint64_ssa(1); got != 2147483648 { + fmt.Printf("rsh_uint64 4294967296>>1 = %d, wanted 2147483648\n", got) failed = true } - if got := div_1_uint32_ssa(1); got != 1 { - fmt.Printf("div_uint32 1/1 = %d, wanted 1\n", got) + if got := rsh_uint64_4294967296_ssa(1); got != 0 { + fmt.Printf("rsh_uint64 1>>4294967296 = %d, wanted 0\n", got) failed = true } - if got := div_uint32_1_ssa(1); got != 1 { - fmt.Printf("div_uint32 1/1 = %d, wanted 1\n", got) + if got := rsh_4294967296_uint64_ssa(4294967296); got != 0 { + fmt.Printf("rsh_uint64 4294967296>>4294967296 = %d, wanted 0\n", got) failed = true } - if got := div_1_uint32_ssa(4294967295); got != 0 { - fmt.Printf("div_uint32 1/4294967295 = %d, wanted 0\n", got) + if got := rsh_uint64_4294967296_ssa(4294967296); got != 0 { + fmt.Printf("rsh_uint64 4294967296>>4294967296 = %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) + if got := rsh_4294967296_uint64_ssa(18446744073709551615); got != 0 { + fmt.Printf("rsh_uint64 4294967296>>18446744073709551615 = %d, wanted 0\n", got) failed = true } - if got := div_uint32_4294967295_ssa(0); got != 0 { - fmt.Printf("div_uint32 0/4294967295 = %d, wanted 0\n", got) + if got := rsh_uint64_4294967296_ssa(18446744073709551615); got != 0 { + fmt.Printf("rsh_uint64 18446744073709551615>>4294967296 = %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) + if got := rsh_18446744073709551615_uint64_ssa(0); got != 18446744073709551615 { + fmt.Printf("rsh_uint64 18446744073709551615>>0 = %d, wanted 18446744073709551615\n", got) failed = true } - if got := div_uint32_4294967295_ssa(1); got != 0 { - fmt.Printf("div_uint32 1/4294967295 = %d, wanted 0\n", got) + if got := rsh_uint64_18446744073709551615_ssa(0); got != 0 { + fmt.Printf("rsh_uint64 0>>18446744073709551615 = %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) + if got := rsh_18446744073709551615_uint64_ssa(1); got != 9223372036854775807 { + fmt.Printf("rsh_uint64 18446744073709551615>>1 = %d, wanted 9223372036854775807\n", got) failed = true } - if got := div_uint32_4294967295_ssa(4294967295); got != 1 { - fmt.Printf("div_uint32 4294967295/4294967295 = %d, wanted 1\n", got) + if got := rsh_uint64_18446744073709551615_ssa(1); got != 0 { + fmt.Printf("rsh_uint64 1>>18446744073709551615 = %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) + if got := rsh_18446744073709551615_uint64_ssa(4294967296); got != 0 { + fmt.Printf("rsh_uint64 18446744073709551615>>4294967296 = %d, wanted 0\n", got) failed = true } - if got := div_int32_Neg2147483648_ssa(-2147483648); got != 1 { - fmt.Printf("div_int32 -2147483648/-2147483648 = %d, wanted 1\n", got) + if got := rsh_uint64_18446744073709551615_ssa(4294967296); got != 0 { + fmt.Printf("rsh_uint64 4294967296>>18446744073709551615 = %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) + if got := rsh_18446744073709551615_uint64_ssa(18446744073709551615); got != 0 { + fmt.Printf("rsh_uint64 18446744073709551615>>18446744073709551615 = %d, wanted 0\n", got) failed = true } - if got := div_int32_Neg2147483648_ssa(-2147483647); got != 0 { - fmt.Printf("div_int32 -2147483647/-2147483648 = %d, wanted 0\n", got) + if got := rsh_uint64_18446744073709551615_ssa(18446744073709551615); got != 0 { + fmt.Printf("rsh_uint64 18446744073709551615>>18446744073709551615 = %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) + if got := add_Neg9223372036854775808_int64_ssa(-9223372036854775808); got != 0 { + fmt.Printf("add_int64 -9223372036854775808+-9223372036854775808 = %d, wanted 0\n", got) failed = true } - if got := div_int32_Neg2147483648_ssa(-1); got != 0 { - fmt.Printf("div_int32 -1/-2147483648 = %d, wanted 0\n", got) + if got := add_int64_Neg9223372036854775808_ssa(-9223372036854775808); got != 0 { + fmt.Printf("add_int64 -9223372036854775808+-9223372036854775808 = %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) + if got := add_Neg9223372036854775808_int64_ssa(-9223372036854775807); got != 1 { + fmt.Printf("add_int64 -9223372036854775808+-9223372036854775807 = %d, wanted 1\n", got) failed = true } - if got := div_Neg2147483648_int32_ssa(1); got != -2147483648 { - fmt.Printf("div_int32 -2147483648/1 = %d, wanted -2147483648\n", got) + if got := add_int64_Neg9223372036854775808_ssa(-9223372036854775807); got != 1 { + fmt.Printf("add_int64 -9223372036854775807+-9223372036854775808 = %d, wanted 1\n", got) failed = true } - if got := div_int32_Neg2147483648_ssa(1); got != 0 { - fmt.Printf("div_int32 1/-2147483648 = %d, wanted 0\n", got) + if got := add_Neg9223372036854775808_int64_ssa(-4294967296); got != 9223372032559808512 { + fmt.Printf("add_int64 -9223372036854775808+-4294967296 = %d, wanted 9223372032559808512\n", got) failed = true } - if got := div_Neg2147483648_int32_ssa(2147483647); got != -1 { - fmt.Printf("div_int32 -2147483648/2147483647 = %d, wanted -1\n", got) + if got := add_int64_Neg9223372036854775808_ssa(-4294967296); got != 9223372032559808512 { + fmt.Printf("add_int64 -4294967296+-9223372036854775808 = %d, wanted 9223372032559808512\n", got) failed = true } - if got := div_int32_Neg2147483648_ssa(2147483647); got != 0 { - fmt.Printf("div_int32 2147483647/-2147483648 = %d, wanted 0\n", got) + if got := add_Neg9223372036854775808_int64_ssa(-1); got != 9223372036854775807 { + fmt.Printf("add_int64 -9223372036854775808+-1 = %d, wanted 9223372036854775807\n", got) failed = true } - if got := div_Neg2147483647_int32_ssa(-2147483648); got != 0 { - fmt.Printf("div_int32 -2147483647/-2147483648 = %d, wanted 0\n", got) + if got := add_int64_Neg9223372036854775808_ssa(-1); got != 9223372036854775807 { + fmt.Printf("add_int64 -1+-9223372036854775808 = %d, wanted 9223372036854775807\n", got) failed = true } - if got := div_int32_Neg2147483647_ssa(-2147483648); got != 1 { - fmt.Printf("div_int32 -2147483648/-2147483647 = %d, wanted 1\n", got) + if got := add_Neg9223372036854775808_int64_ssa(0); got != -9223372036854775808 { + fmt.Printf("add_int64 -9223372036854775808+0 = %d, wanted -9223372036854775808\n", got) failed = true } - if got := div_Neg2147483647_int32_ssa(-2147483647); got != 1 { - fmt.Printf("div_int32 -2147483647/-2147483647 = %d, wanted 1\n", got) + if got := add_int64_Neg9223372036854775808_ssa(0); got != -9223372036854775808 { + fmt.Printf("add_int64 0+-9223372036854775808 = %d, wanted -9223372036854775808\n", got) failed = true } - if got := div_int32_Neg2147483647_ssa(-2147483647); got != 1 { - fmt.Printf("div_int32 -2147483647/-2147483647 = %d, wanted 1\n", got) + if got := add_Neg9223372036854775808_int64_ssa(1); got != -9223372036854775807 { + fmt.Printf("add_int64 -9223372036854775808+1 = %d, wanted -9223372036854775807\n", got) failed = true } - if got := div_Neg2147483647_int32_ssa(-1); got != 2147483647 { - fmt.Printf("div_int32 -2147483647/-1 = %d, wanted 2147483647\n", got) + if got := add_int64_Neg9223372036854775808_ssa(1); got != -9223372036854775807 { + fmt.Printf("add_int64 1+-9223372036854775808 = %d, wanted -9223372036854775807\n", got) failed = true } - if got := div_int32_Neg2147483647_ssa(-1); got != 0 { - fmt.Printf("div_int32 -1/-2147483647 = %d, wanted 0\n", got) + if got := add_Neg9223372036854775808_int64_ssa(4294967296); got != -9223372032559808512 { + fmt.Printf("add_int64 -9223372036854775808+4294967296 = %d, wanted -9223372032559808512\n", got) failed = true } - if got := div_int32_Neg2147483647_ssa(0); got != 0 { - fmt.Printf("div_int32 0/-2147483647 = %d, wanted 0\n", got) + if got := add_int64_Neg9223372036854775808_ssa(4294967296); got != -9223372032559808512 { + fmt.Printf("add_int64 4294967296+-9223372036854775808 = %d, wanted -9223372032559808512\n", got) failed = true } - if got := div_Neg2147483647_int32_ssa(1); got != -2147483647 { - fmt.Printf("div_int32 -2147483647/1 = %d, wanted -2147483647\n", got) + if got := add_Neg9223372036854775808_int64_ssa(9223372036854775806); got != -2 { + fmt.Printf("add_int64 -9223372036854775808+9223372036854775806 = %d, wanted -2\n", got) failed = true } - if got := div_int32_Neg2147483647_ssa(1); got != 0 { - fmt.Printf("div_int32 1/-2147483647 = %d, wanted 0\n", got) + if got := add_int64_Neg9223372036854775808_ssa(9223372036854775806); got != -2 { + fmt.Printf("add_int64 9223372036854775806+-9223372036854775808 = %d, wanted -2\n", got) failed = true } - if got := div_Neg2147483647_int32_ssa(2147483647); got != -1 { - fmt.Printf("div_int32 -2147483647/2147483647 = %d, wanted -1\n", got) + if got := add_Neg9223372036854775808_int64_ssa(9223372036854775807); got != -1 { + fmt.Printf("add_int64 -9223372036854775808+9223372036854775807 = %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) + if got := add_int64_Neg9223372036854775808_ssa(9223372036854775807); got != -1 { + fmt.Printf("add_int64 9223372036854775807+-9223372036854775808 = %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) + if got := add_Neg9223372036854775807_int64_ssa(-9223372036854775808); got != 1 { + fmt.Printf("add_int64 -9223372036854775807+-9223372036854775808 = %d, wanted 1\n", got) failed = true } - if got := div_int32_Neg1_ssa(-2147483648); got != -2147483648 { - fmt.Printf("div_int32 -2147483648/-1 = %d, wanted -2147483648\n", got) + if got := add_int64_Neg9223372036854775807_ssa(-9223372036854775808); got != 1 { + fmt.Printf("add_int64 -9223372036854775808+-9223372036854775807 = %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) + if got := add_Neg9223372036854775807_int64_ssa(-9223372036854775807); got != 2 { + fmt.Printf("add_int64 -9223372036854775807+-9223372036854775807 = %d, wanted 2\n", got) failed = true } - if got := div_int32_Neg1_ssa(-2147483647); got != 2147483647 { - fmt.Printf("div_int32 -2147483647/-1 = %d, wanted 2147483647\n", got) + if got := add_int64_Neg9223372036854775807_ssa(-9223372036854775807); got != 2 { + fmt.Printf("add_int64 -9223372036854775807+-9223372036854775807 = %d, wanted 2\n", got) failed = true } - if got := div_Neg1_int32_ssa(-1); got != 1 { - fmt.Printf("div_int32 -1/-1 = %d, wanted 1\n", got) + if got := add_Neg9223372036854775807_int64_ssa(-4294967296); got != 9223372032559808513 { + fmt.Printf("add_int64 -9223372036854775807+-4294967296 = %d, wanted 9223372032559808513\n", got) failed = true } - if got := div_int32_Neg1_ssa(-1); got != 1 { - fmt.Printf("div_int32 -1/-1 = %d, wanted 1\n", got) + if got := add_int64_Neg9223372036854775807_ssa(-4294967296); got != 9223372032559808513 { + fmt.Printf("add_int64 -4294967296+-9223372036854775807 = %d, wanted 9223372032559808513\n", got) failed = true } - if got := div_int32_Neg1_ssa(0); got != 0 { - fmt.Printf("div_int32 0/-1 = %d, wanted 0\n", got) + if got := add_Neg9223372036854775807_int64_ssa(-1); got != -9223372036854775808 { + fmt.Printf("add_int64 -9223372036854775807+-1 = %d, wanted -9223372036854775808\n", got) failed = true } - if got := div_Neg1_int32_ssa(1); got != -1 { - fmt.Printf("div_int32 -1/1 = %d, wanted -1\n", got) + if got := add_int64_Neg9223372036854775807_ssa(-1); got != -9223372036854775808 { + fmt.Printf("add_int64 -1+-9223372036854775807 = %d, wanted -9223372036854775808\n", got) failed = true } - if got := div_int32_Neg1_ssa(1); got != -1 { - fmt.Printf("div_int32 1/-1 = %d, wanted -1\n", got) + if got := add_Neg9223372036854775807_int64_ssa(0); got != -9223372036854775807 { + fmt.Printf("add_int64 -9223372036854775807+0 = %d, wanted -9223372036854775807\n", got) failed = true } - if got := div_Neg1_int32_ssa(2147483647); got != 0 { - fmt.Printf("div_int32 -1/2147483647 = %d, wanted 0\n", got) + if got := add_int64_Neg9223372036854775807_ssa(0); got != -9223372036854775807 { + fmt.Printf("add_int64 0+-9223372036854775807 = %d, wanted -9223372036854775807\n", got) failed = true } - if got := div_int32_Neg1_ssa(2147483647); got != -2147483647 { - fmt.Printf("div_int32 2147483647/-1 = %d, wanted -2147483647\n", got) + if got := add_Neg9223372036854775807_int64_ssa(1); got != -9223372036854775806 { + fmt.Printf("add_int64 -9223372036854775807+1 = %d, wanted -9223372036854775806\n", got) failed = true } - if got := div_0_int32_ssa(-2147483648); got != 0 { - fmt.Printf("div_int32 0/-2147483648 = %d, wanted 0\n", got) + if got := add_int64_Neg9223372036854775807_ssa(1); got != -9223372036854775806 { + fmt.Printf("add_int64 1+-9223372036854775807 = %d, wanted -9223372036854775806\n", got) failed = true } - if got := div_0_int32_ssa(-2147483647); got != 0 { - fmt.Printf("div_int32 0/-2147483647 = %d, wanted 0\n", got) + if got := add_Neg9223372036854775807_int64_ssa(4294967296); got != -9223372032559808511 { + fmt.Printf("add_int64 -9223372036854775807+4294967296 = %d, wanted -9223372032559808511\n", got) failed = true } - if got := div_0_int32_ssa(-1); got != 0 { - fmt.Printf("div_int32 0/-1 = %d, wanted 0\n", got) + if got := add_int64_Neg9223372036854775807_ssa(4294967296); got != -9223372032559808511 { + fmt.Printf("add_int64 4294967296+-9223372036854775807 = %d, wanted -9223372032559808511\n", got) failed = true } - if got := div_0_int32_ssa(1); got != 0 { - fmt.Printf("div_int32 0/1 = %d, wanted 0\n", got) + if got := add_Neg9223372036854775807_int64_ssa(9223372036854775806); got != -1 { + fmt.Printf("add_int64 -9223372036854775807+9223372036854775806 = %d, wanted -1\n", got) failed = true } - if got := div_0_int32_ssa(2147483647); got != 0 { - fmt.Printf("div_int32 0/2147483647 = %d, wanted 0\n", got) + if got := add_int64_Neg9223372036854775807_ssa(9223372036854775806); got != -1 { + fmt.Printf("add_int64 9223372036854775806+-9223372036854775807 = %d, wanted -1\n", got) failed = true } - if got := div_1_int32_ssa(-2147483648); got != 0 { - fmt.Printf("div_int32 1/-2147483648 = %d, wanted 0\n", got) + if got := add_Neg9223372036854775807_int64_ssa(9223372036854775807); got != 0 { + fmt.Printf("add_int64 -9223372036854775807+9223372036854775807 = %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) + if got := add_int64_Neg9223372036854775807_ssa(9223372036854775807); got != 0 { + fmt.Printf("add_int64 9223372036854775807+-9223372036854775807 = %d, wanted 0\n", got) failed = true } - if got := div_1_int32_ssa(-2147483647); got != 0 { - fmt.Printf("div_int32 1/-2147483647 = %d, wanted 0\n", got) + if got := add_Neg4294967296_int64_ssa(-9223372036854775808); got != 9223372032559808512 { + fmt.Printf("add_int64 -4294967296+-9223372036854775808 = %d, wanted 9223372032559808512\n", got) failed = true } - if got := div_int32_1_ssa(-2147483647); got != -2147483647 { - fmt.Printf("div_int32 -2147483647/1 = %d, wanted -2147483647\n", got) + if got := add_int64_Neg4294967296_ssa(-9223372036854775808); got != 9223372032559808512 { + fmt.Printf("add_int64 -9223372036854775808+-4294967296 = %d, wanted 9223372032559808512\n", got) failed = true } - if got := div_1_int32_ssa(-1); got != -1 { - fmt.Printf("div_int32 1/-1 = %d, wanted -1\n", got) + if got := add_Neg4294967296_int64_ssa(-9223372036854775807); got != 9223372032559808513 { + fmt.Printf("add_int64 -4294967296+-9223372036854775807 = %d, wanted 9223372032559808513\n", got) failed = true } - if got := div_int32_1_ssa(-1); got != -1 { - fmt.Printf("div_int32 -1/1 = %d, wanted -1\n", got) + if got := add_int64_Neg4294967296_ssa(-9223372036854775807); got != 9223372032559808513 { + fmt.Printf("add_int64 -9223372036854775807+-4294967296 = %d, wanted 9223372032559808513\n", got) failed = true } - if got := div_int32_1_ssa(0); got != 0 { - fmt.Printf("div_int32 0/1 = %d, wanted 0\n", got) + if got := add_Neg4294967296_int64_ssa(-4294967296); got != -8589934592 { + fmt.Printf("add_int64 -4294967296+-4294967296 = %d, wanted -8589934592\n", got) failed = true } - if got := div_1_int32_ssa(1); got != 1 { - fmt.Printf("div_int32 1/1 = %d, wanted 1\n", got) + if got := add_int64_Neg4294967296_ssa(-4294967296); got != -8589934592 { + fmt.Printf("add_int64 -4294967296+-4294967296 = %d, wanted -8589934592\n", got) failed = true } - if got := div_int32_1_ssa(1); got != 1 { - fmt.Printf("div_int32 1/1 = %d, wanted 1\n", got) + if got := add_Neg4294967296_int64_ssa(-1); got != -4294967297 { + fmt.Printf("add_int64 -4294967296+-1 = %d, wanted -4294967297\n", got) failed = true } - if got := div_1_int32_ssa(2147483647); got != 0 { - fmt.Printf("div_int32 1/2147483647 = %d, wanted 0\n", got) + if got := add_int64_Neg4294967296_ssa(-1); got != -4294967297 { + fmt.Printf("add_int64 -1+-4294967296 = %d, wanted -4294967297\n", got) failed = true } - if got := div_int32_1_ssa(2147483647); got != 2147483647 { - fmt.Printf("div_int32 2147483647/1 = %d, wanted 2147483647\n", got) + if got := add_Neg4294967296_int64_ssa(0); got != -4294967296 { + fmt.Printf("add_int64 -4294967296+0 = %d, wanted -4294967296\n", got) failed = true } - if got := div_2147483647_int32_ssa(-2147483648); got != 0 { - fmt.Printf("div_int32 2147483647/-2147483648 = %d, wanted 0\n", got) + if got := add_int64_Neg4294967296_ssa(0); got != -4294967296 { + fmt.Printf("add_int64 0+-4294967296 = %d, wanted -4294967296\n", got) failed = true } - if got := div_int32_2147483647_ssa(-2147483648); got != -1 { - fmt.Printf("div_int32 -2147483648/2147483647 = %d, wanted -1\n", got) + if got := add_Neg4294967296_int64_ssa(1); got != -4294967295 { + fmt.Printf("add_int64 -4294967296+1 = %d, wanted -4294967295\n", got) failed = true } - if got := div_2147483647_int32_ssa(-2147483647); got != -1 { - fmt.Printf("div_int32 2147483647/-2147483647 = %d, wanted -1\n", got) + if got := add_int64_Neg4294967296_ssa(1); got != -4294967295 { + fmt.Printf("add_int64 1+-4294967296 = %d, wanted -4294967295\n", got) failed = true } - if got := div_int32_2147483647_ssa(-2147483647); got != -1 { - fmt.Printf("div_int32 -2147483647/2147483647 = %d, wanted -1\n", got) + if got := add_Neg4294967296_int64_ssa(4294967296); got != 0 { + fmt.Printf("add_int64 -4294967296+4294967296 = %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) + if got := add_int64_Neg4294967296_ssa(4294967296); got != 0 { + fmt.Printf("add_int64 4294967296+-4294967296 = %d, wanted 0\n", got) failed = true } - if got := div_int32_2147483647_ssa(-1); got != 0 { - fmt.Printf("div_int32 -1/2147483647 = %d, wanted 0\n", got) + if got := add_Neg4294967296_int64_ssa(9223372036854775806); got != 9223372032559808510 { + fmt.Printf("add_int64 -4294967296+9223372036854775806 = %d, wanted 9223372032559808510\n", got) failed = true } - if got := div_int32_2147483647_ssa(0); got != 0 { - fmt.Printf("div_int32 0/2147483647 = %d, wanted 0\n", got) + if got := add_int64_Neg4294967296_ssa(9223372036854775806); got != 9223372032559808510 { + fmt.Printf("add_int64 9223372036854775806+-4294967296 = %d, wanted 9223372032559808510\n", got) failed = true } - if got := div_2147483647_int32_ssa(1); got != 2147483647 { - fmt.Printf("div_int32 2147483647/1 = %d, wanted 2147483647\n", got) + if got := add_Neg4294967296_int64_ssa(9223372036854775807); got != 9223372032559808511 { + fmt.Printf("add_int64 -4294967296+9223372036854775807 = %d, wanted 9223372032559808511\n", got) failed = true } - if got := div_int32_2147483647_ssa(1); got != 0 { - fmt.Printf("div_int32 1/2147483647 = %d, wanted 0\n", got) + if got := add_int64_Neg4294967296_ssa(9223372036854775807); got != 9223372032559808511 { + fmt.Printf("add_int64 9223372036854775807+-4294967296 = %d, wanted 9223372032559808511\n", got) failed = true } - if got := div_2147483647_int32_ssa(2147483647); got != 1 { - fmt.Printf("div_int32 2147483647/2147483647 = %d, wanted 1\n", got) + if got := add_Neg1_int64_ssa(-9223372036854775808); got != 9223372036854775807 { + fmt.Printf("add_int64 -1+-9223372036854775808 = %d, wanted 9223372036854775807\n", got) failed = true } - if got := div_int32_2147483647_ssa(2147483647); got != 1 { - fmt.Printf("div_int32 2147483647/2147483647 = %d, wanted 1\n", got) + if got := add_int64_Neg1_ssa(-9223372036854775808); got != 9223372036854775807 { + fmt.Printf("add_int64 -9223372036854775808+-1 = %d, wanted 9223372036854775807\n", got) failed = true } - if got := div_0_uint16_ssa(1); got != 0 { - fmt.Printf("div_uint16 0/1 = %d, wanted 0\n", got) + if got := add_Neg1_int64_ssa(-9223372036854775807); got != -9223372036854775808 { + fmt.Printf("add_int64 -1+-9223372036854775807 = %d, wanted -9223372036854775808\n", got) failed = true } - if got := div_0_uint16_ssa(65535); got != 0 { - fmt.Printf("div_uint16 0/65535 = %d, wanted 0\n", got) + if got := add_int64_Neg1_ssa(-9223372036854775807); got != -9223372036854775808 { + fmt.Printf("add_int64 -9223372036854775807+-1 = %d, wanted -9223372036854775808\n", got) failed = true } - if got := div_uint16_1_ssa(0); got != 0 { - fmt.Printf("div_uint16 0/1 = %d, wanted 0\n", got) + if got := add_Neg1_int64_ssa(-4294967296); got != -4294967297 { + fmt.Printf("add_int64 -1+-4294967296 = %d, wanted -4294967297\n", got) failed = true } - if got := div_1_uint16_ssa(1); got != 1 { - fmt.Printf("div_uint16 1/1 = %d, wanted 1\n", got) + if got := add_int64_Neg1_ssa(-4294967296); got != -4294967297 { + fmt.Printf("add_int64 -4294967296+-1 = %d, wanted -4294967297\n", got) failed = true } - if got := div_uint16_1_ssa(1); got != 1 { - fmt.Printf("div_uint16 1/1 = %d, wanted 1\n", got) + if got := add_Neg1_int64_ssa(-1); got != -2 { + fmt.Printf("add_int64 -1+-1 = %d, wanted -2\n", got) failed = true } - if got := div_1_uint16_ssa(65535); got != 0 { - fmt.Printf("div_uint16 1/65535 = %d, wanted 0\n", got) + if got := add_int64_Neg1_ssa(-1); got != -2 { + fmt.Printf("add_int64 -1+-1 = %d, wanted -2\n", got) failed = true } - if got := div_uint16_1_ssa(65535); got != 65535 { - fmt.Printf("div_uint16 65535/1 = %d, wanted 65535\n", got) + if got := add_Neg1_int64_ssa(0); got != -1 { + fmt.Printf("add_int64 -1+0 = %d, wanted -1\n", got) failed = true } - if got := div_uint16_65535_ssa(0); got != 0 { - fmt.Printf("div_uint16 0/65535 = %d, wanted 0\n", got) + if got := add_int64_Neg1_ssa(0); got != -1 { + fmt.Printf("add_int64 0+-1 = %d, wanted -1\n", got) failed = true } - if got := div_65535_uint16_ssa(1); got != 65535 { - fmt.Printf("div_uint16 65535/1 = %d, wanted 65535\n", got) + if got := add_Neg1_int64_ssa(1); got != 0 { + fmt.Printf("add_int64 -1+1 = %d, wanted 0\n", got) failed = true } - if got := div_uint16_65535_ssa(1); got != 0 { - fmt.Printf("div_uint16 1/65535 = %d, wanted 0\n", got) + if got := add_int64_Neg1_ssa(1); got != 0 { + fmt.Printf("add_int64 1+-1 = %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) + if got := add_Neg1_int64_ssa(4294967296); got != 4294967295 { + fmt.Printf("add_int64 -1+4294967296 = %d, wanted 4294967295\n", got) failed = true } - if got := div_uint16_65535_ssa(65535); got != 1 { - fmt.Printf("div_uint16 65535/65535 = %d, wanted 1\n", got) + if got := add_int64_Neg1_ssa(4294967296); got != 4294967295 { + fmt.Printf("add_int64 4294967296+-1 = %d, wanted 4294967295\n", got) failed = true } - if got := div_Neg32768_int16_ssa(-32768); got != 1 { - fmt.Printf("div_int16 -32768/-32768 = %d, wanted 1\n", got) + if got := add_Neg1_int64_ssa(9223372036854775806); got != 9223372036854775805 { + fmt.Printf("add_int64 -1+9223372036854775806 = %d, wanted 9223372036854775805\n", got) failed = true } - if got := div_int16_Neg32768_ssa(-32768); got != 1 { - fmt.Printf("div_int16 -32768/-32768 = %d, wanted 1\n", got) + if got := add_int64_Neg1_ssa(9223372036854775806); got != 9223372036854775805 { + fmt.Printf("add_int64 9223372036854775806+-1 = %d, wanted 9223372036854775805\n", got) failed = true } - if got := div_Neg32768_int16_ssa(-32767); got != 1 { - fmt.Printf("div_int16 -32768/-32767 = %d, wanted 1\n", got) + if got := add_Neg1_int64_ssa(9223372036854775807); got != 9223372036854775806 { + fmt.Printf("add_int64 -1+9223372036854775807 = %d, wanted 9223372036854775806\n", got) failed = true } - if got := div_int16_Neg32768_ssa(-32767); got != 0 { - fmt.Printf("div_int16 -32767/-32768 = %d, wanted 0\n", got) + if got := add_int64_Neg1_ssa(9223372036854775807); got != 9223372036854775806 { + fmt.Printf("add_int64 9223372036854775807+-1 = %d, wanted 9223372036854775806\n", got) failed = true } - if got := div_Neg32768_int16_ssa(-1); got != -32768 { - fmt.Printf("div_int16 -32768/-1 = %d, wanted -32768\n", got) + if got := add_0_int64_ssa(-9223372036854775808); got != -9223372036854775808 { + fmt.Printf("add_int64 0+-9223372036854775808 = %d, wanted -9223372036854775808\n", got) failed = true } - if got := div_int16_Neg32768_ssa(-1); got != 0 { - fmt.Printf("div_int16 -1/-32768 = %d, wanted 0\n", got) + if got := add_int64_0_ssa(-9223372036854775808); got != -9223372036854775808 { + fmt.Printf("add_int64 -9223372036854775808+0 = %d, wanted -9223372036854775808\n", got) failed = true } - if got := div_int16_Neg32768_ssa(0); got != 0 { - fmt.Printf("div_int16 0/-32768 = %d, wanted 0\n", got) + if got := add_0_int64_ssa(-9223372036854775807); got != -9223372036854775807 { + fmt.Printf("add_int64 0+-9223372036854775807 = %d, wanted -9223372036854775807\n", got) failed = true } - if got := div_Neg32768_int16_ssa(1); got != -32768 { - fmt.Printf("div_int16 -32768/1 = %d, wanted -32768\n", got) + if got := add_int64_0_ssa(-9223372036854775807); got != -9223372036854775807 { + fmt.Printf("add_int64 -9223372036854775807+0 = %d, wanted -9223372036854775807\n", got) failed = true } - if got := div_int16_Neg32768_ssa(1); got != 0 { - fmt.Printf("div_int16 1/-32768 = %d, wanted 0\n", got) + if got := add_0_int64_ssa(-4294967296); got != -4294967296 { + fmt.Printf("add_int64 0+-4294967296 = %d, wanted -4294967296\n", got) failed = true } - if got := div_Neg32768_int16_ssa(32766); got != -1 { - fmt.Printf("div_int16 -32768/32766 = %d, wanted -1\n", got) + if got := add_int64_0_ssa(-4294967296); got != -4294967296 { + fmt.Printf("add_int64 -4294967296+0 = %d, wanted -4294967296\n", got) failed = true } - if got := div_int16_Neg32768_ssa(32766); got != 0 { - fmt.Printf("div_int16 32766/-32768 = %d, wanted 0\n", got) + if got := add_0_int64_ssa(-1); got != -1 { + fmt.Printf("add_int64 0+-1 = %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) + if got := add_int64_0_ssa(-1); got != -1 { + fmt.Printf("add_int64 -1+0 = %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) + if got := add_0_int64_ssa(0); got != 0 { + fmt.Printf("add_int64 0+0 = %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) + if got := add_int64_0_ssa(0); got != 0 { + fmt.Printf("add_int64 0+0 = %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) + if got := add_0_int64_ssa(1); got != 1 { + fmt.Printf("add_int64 0+1 = %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) + if got := add_int64_0_ssa(1); got != 1 { + fmt.Printf("add_int64 1+0 = %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) + if got := add_0_int64_ssa(4294967296); got != 4294967296 { + fmt.Printf("add_int64 0+4294967296 = %d, wanted 4294967296\n", got) failed = true } - if got := div_Neg32767_int16_ssa(-1); got != 32767 { - fmt.Printf("div_int16 -32767/-1 = %d, wanted 32767\n", got) + if got := add_int64_0_ssa(4294967296); got != 4294967296 { + fmt.Printf("add_int64 4294967296+0 = %d, wanted 4294967296\n", got) failed = true } - if got := div_int16_Neg32767_ssa(-1); got != 0 { - fmt.Printf("div_int16 -1/-32767 = %d, wanted 0\n", got) + if got := add_0_int64_ssa(9223372036854775806); got != 9223372036854775806 { + fmt.Printf("add_int64 0+9223372036854775806 = %d, wanted 9223372036854775806\n", got) failed = true } - if got := div_int16_Neg32767_ssa(0); got != 0 { - fmt.Printf("div_int16 0/-32767 = %d, wanted 0\n", got) + if got := add_int64_0_ssa(9223372036854775806); got != 9223372036854775806 { + fmt.Printf("add_int64 9223372036854775806+0 = %d, wanted 9223372036854775806\n", got) failed = true } - if got := div_Neg32767_int16_ssa(1); got != -32767 { - fmt.Printf("div_int16 -32767/1 = %d, wanted -32767\n", got) + if got := add_0_int64_ssa(9223372036854775807); got != 9223372036854775807 { + fmt.Printf("add_int64 0+9223372036854775807 = %d, wanted 9223372036854775807\n", got) failed = true } - if got := div_int16_Neg32767_ssa(1); got != 0 { - fmt.Printf("div_int16 1/-32767 = %d, wanted 0\n", got) + if got := add_int64_0_ssa(9223372036854775807); got != 9223372036854775807 { + fmt.Printf("add_int64 9223372036854775807+0 = %d, wanted 9223372036854775807\n", got) failed = true } - if got := div_Neg32767_int16_ssa(32766); got != -1 { - fmt.Printf("div_int16 -32767/32766 = %d, wanted -1\n", got) + if got := add_1_int64_ssa(-9223372036854775808); got != -9223372036854775807 { + fmt.Printf("add_int64 1+-9223372036854775808 = %d, wanted -9223372036854775807\n", got) failed = true } - if got := div_int16_Neg32767_ssa(32766); got != 0 { - fmt.Printf("div_int16 32766/-32767 = %d, wanted 0\n", got) + if got := add_int64_1_ssa(-9223372036854775808); got != -9223372036854775807 { + fmt.Printf("add_int64 -9223372036854775808+1 = %d, wanted -9223372036854775807\n", got) failed = true } - if got := div_Neg32767_int16_ssa(32767); got != -1 { - fmt.Printf("div_int16 -32767/32767 = %d, wanted -1\n", got) + if got := add_1_int64_ssa(-9223372036854775807); got != -9223372036854775806 { + fmt.Printf("add_int64 1+-9223372036854775807 = %d, wanted -9223372036854775806\n", got) failed = true } - if got := div_int16_Neg32767_ssa(32767); got != -1 { - fmt.Printf("div_int16 32767/-32767 = %d, wanted -1\n", got) + if got := add_int64_1_ssa(-9223372036854775807); got != -9223372036854775806 { + fmt.Printf("add_int64 -9223372036854775807+1 = %d, wanted -9223372036854775806\n", got) failed = true } - if got := div_Neg1_int16_ssa(-32768); got != 0 { - fmt.Printf("div_int16 -1/-32768 = %d, wanted 0\n", got) + if got := add_1_int64_ssa(-4294967296); got != -4294967295 { + fmt.Printf("add_int64 1+-4294967296 = %d, wanted -4294967295\n", got) failed = true } - if got := div_int16_Neg1_ssa(-32768); got != -32768 { - fmt.Printf("div_int16 -32768/-1 = %d, wanted -32768\n", got) + if got := add_int64_1_ssa(-4294967296); got != -4294967295 { + fmt.Printf("add_int64 -4294967296+1 = %d, wanted -4294967295\n", got) failed = true } - if got := div_Neg1_int16_ssa(-32767); got != 0 { - fmt.Printf("div_int16 -1/-32767 = %d, wanted 0\n", got) + if got := add_1_int64_ssa(-1); got != 0 { + fmt.Printf("add_int64 1+-1 = %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) + if got := add_int64_1_ssa(-1); got != 0 { + fmt.Printf("add_int64 -1+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) + if got := add_1_int64_ssa(0); got != 1 { + fmt.Printf("add_int64 1+0 = %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) + if got := add_int64_1_ssa(0); got != 1 { + fmt.Printf("add_int64 0+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) + if got := add_1_int64_ssa(1); got != 2 { + fmt.Printf("add_int64 1+1 = %d, wanted 2\n", got) failed = true } - if got := div_Neg1_int16_ssa(1); got != -1 { - fmt.Printf("div_int16 -1/1 = %d, wanted -1\n", got) + if got := add_int64_1_ssa(1); got != 2 { + fmt.Printf("add_int64 1+1 = %d, wanted 2\n", got) failed = true } - if got := div_int16_Neg1_ssa(1); got != -1 { - fmt.Printf("div_int16 1/-1 = %d, wanted -1\n", got) + if got := add_1_int64_ssa(4294967296); got != 4294967297 { + fmt.Printf("add_int64 1+4294967296 = %d, wanted 4294967297\n", got) failed = true } - if got := div_Neg1_int16_ssa(32766); got != 0 { - fmt.Printf("div_int16 -1/32766 = %d, wanted 0\n", got) + if got := add_int64_1_ssa(4294967296); got != 4294967297 { + fmt.Printf("add_int64 4294967296+1 = %d, wanted 4294967297\n", got) failed = true } - if got := div_int16_Neg1_ssa(32766); got != -32766 { - fmt.Printf("div_int16 32766/-1 = %d, wanted -32766\n", got) + if got := add_1_int64_ssa(9223372036854775806); got != 9223372036854775807 { + fmt.Printf("add_int64 1+9223372036854775806 = %d, wanted 9223372036854775807\n", got) failed = true } - if got := div_Neg1_int16_ssa(32767); got != 0 { - fmt.Printf("div_int16 -1/32767 = %d, wanted 0\n", got) + if got := add_int64_1_ssa(9223372036854775806); got != 9223372036854775807 { + fmt.Printf("add_int64 9223372036854775806+1 = %d, wanted 9223372036854775807\n", got) failed = true } - if got := div_int16_Neg1_ssa(32767); got != -32767 { - fmt.Printf("div_int16 32767/-1 = %d, wanted -32767\n", got) + if got := add_1_int64_ssa(9223372036854775807); got != -9223372036854775808 { + fmt.Printf("add_int64 1+9223372036854775807 = %d, wanted -9223372036854775808\n", got) failed = true } - if got := div_0_int16_ssa(-32768); got != 0 { - fmt.Printf("div_int16 0/-32768 = %d, wanted 0\n", got) + if got := add_int64_1_ssa(9223372036854775807); got != -9223372036854775808 { + fmt.Printf("add_int64 9223372036854775807+1 = %d, wanted -9223372036854775808\n", got) failed = true } - if got := div_0_int16_ssa(-32767); got != 0 { - fmt.Printf("div_int16 0/-32767 = %d, wanted 0\n", got) + if got := add_4294967296_int64_ssa(-9223372036854775808); got != -9223372032559808512 { + fmt.Printf("add_int64 4294967296+-9223372036854775808 = %d, wanted -9223372032559808512\n", got) failed = true } - if got := div_0_int16_ssa(-1); got != 0 { - fmt.Printf("div_int16 0/-1 = %d, wanted 0\n", got) + if got := add_int64_4294967296_ssa(-9223372036854775808); got != -9223372032559808512 { + fmt.Printf("add_int64 -9223372036854775808+4294967296 = %d, wanted -9223372032559808512\n", got) failed = true } - if got := div_0_int16_ssa(1); got != 0 { - fmt.Printf("div_int16 0/1 = %d, wanted 0\n", got) + if got := add_4294967296_int64_ssa(-9223372036854775807); got != -9223372032559808511 { + fmt.Printf("add_int64 4294967296+-9223372036854775807 = %d, wanted -9223372032559808511\n", got) failed = true } - if got := div_0_int16_ssa(32766); got != 0 { - fmt.Printf("div_int16 0/32766 = %d, wanted 0\n", got) + if got := add_int64_4294967296_ssa(-9223372036854775807); got != -9223372032559808511 { + fmt.Printf("add_int64 -9223372036854775807+4294967296 = %d, wanted -9223372032559808511\n", got) failed = true } - if got := div_0_int16_ssa(32767); got != 0 { - fmt.Printf("div_int16 0/32767 = %d, wanted 0\n", got) + if got := add_4294967296_int64_ssa(-4294967296); got != 0 { + fmt.Printf("add_int64 4294967296+-4294967296 = %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) + if got := add_int64_4294967296_ssa(-4294967296); got != 0 { + fmt.Printf("add_int64 -4294967296+4294967296 = %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) + if got := add_4294967296_int64_ssa(-1); got != 4294967295 { + fmt.Printf("add_int64 4294967296+-1 = %d, wanted 4294967295\n", got) failed = true } - if got := div_1_int16_ssa(-32767); got != 0 { - fmt.Printf("div_int16 1/-32767 = %d, wanted 0\n", got) + if got := add_int64_4294967296_ssa(-1); got != 4294967295 { + fmt.Printf("add_int64 -1+4294967296 = %d, wanted 4294967295\n", got) failed = true } - if got := div_int16_1_ssa(-32767); got != -32767 { - fmt.Printf("div_int16 -32767/1 = %d, wanted -32767\n", got) + if got := add_4294967296_int64_ssa(0); got != 4294967296 { + fmt.Printf("add_int64 4294967296+0 = %d, wanted 4294967296\n", got) failed = true } - if got := div_1_int16_ssa(-1); got != -1 { - fmt.Printf("div_int16 1/-1 = %d, wanted -1\n", got) + if got := add_int64_4294967296_ssa(0); got != 4294967296 { + fmt.Printf("add_int64 0+4294967296 = %d, wanted 4294967296\n", got) failed = true } - if got := div_int16_1_ssa(-1); got != -1 { - fmt.Printf("div_int16 -1/1 = %d, wanted -1\n", got) + if got := add_4294967296_int64_ssa(1); got != 4294967297 { + fmt.Printf("add_int64 4294967296+1 = %d, wanted 4294967297\n", got) failed = true } - if got := div_int16_1_ssa(0); got != 0 { - fmt.Printf("div_int16 0/1 = %d, wanted 0\n", got) + if got := add_int64_4294967296_ssa(1); got != 4294967297 { + fmt.Printf("add_int64 1+4294967296 = %d, wanted 4294967297\n", got) failed = true } - if got := div_1_int16_ssa(1); got != 1 { - fmt.Printf("div_int16 1/1 = %d, wanted 1\n", got) + 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 } @@ -3344,633 +9626,3043 @@ func main() { failed = true } - if got := div_1_int16_ssa(32766); got != 0 { - fmt.Printf("div_int16 1/32766 = %d, wanted 0\n", got) + 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_int16_1_ssa(32766); got != 32766 { - fmt.Printf("div_int16 32766/1 = %d, wanted 32766\n", got) + 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_1_int16_ssa(32767); got != 0 { - fmt.Printf("div_int16 1/32767 = %d, wanted 0\n", got) + 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_int16_1_ssa(32767); got != 32767 { - fmt.Printf("div_int16 32767/1 = %d, wanted 32767\n", got) + 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_32766_int16_ssa(-32768); got != 0 { - fmt.Printf("div_int16 32766/-32768 = %d, wanted 0\n", got) + 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_int16_32766_ssa(-32768); got != -1 { - fmt.Printf("div_int16 -32768/32766 = %d, wanted -1\n", got) + 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_32766_int16_ssa(-32767); got != 0 { - fmt.Printf("div_int16 32766/-32767 = %d, wanted 0\n", got) + 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_int16_32766_ssa(-32767); got != -1 { - fmt.Printf("div_int16 -32767/32766 = %d, wanted -1\n", got) + 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_32766_int16_ssa(-1); got != -32766 { - fmt.Printf("div_int16 32766/-1 = %d, wanted -32766\n", got) + 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_int16_32766_ssa(-1); got != 0 { - fmt.Printf("div_int16 -1/32766 = %d, wanted 0\n", got) + 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_int16_32766_ssa(0); got != 0 { - fmt.Printf("div_int16 0/32766 = %d, wanted 0\n", got) + 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_32766_int16_ssa(1); got != 32766 { - fmt.Printf("div_int16 32766/1 = %d, wanted 32766\n", got) + 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_int16_32766_ssa(1); got != 0 { - fmt.Printf("div_int16 1/32766 = %d, wanted 0\n", got) + 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_32766_int16_ssa(32766); got != 1 { - fmt.Printf("div_int16 32766/32766 = %d, wanted 1\n", got) + 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_int16_32766_ssa(32766); got != 1 { - fmt.Printf("div_int16 32766/32766 = %d, wanted 1\n", got) + 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_32766_int16_ssa(32767); got != 0 { - fmt.Printf("div_int16 32766/32767 = %d, wanted 0\n", got) + 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_int16_32766_ssa(32767); got != 1 { - fmt.Printf("div_int16 32767/32766 = %d, wanted 1\n", got) + 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_32767_int16_ssa(-32768); got != 0 { - fmt.Printf("div_int16 32767/-32768 = %d, wanted 0\n", got) + 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_int16_32767_ssa(-32768); got != -1 { - fmt.Printf("div_int16 -32768/32767 = %d, wanted -1\n", got) + 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_32767_int16_ssa(-32767); got != -1 { - fmt.Printf("div_int16 32767/-32767 = %d, wanted -1\n", got) + 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_int16_32767_ssa(-32767); got != -1 { - fmt.Printf("div_int16 -32767/32767 = %d, wanted -1\n", got) + 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_32767_int16_ssa(-1); got != -32767 { - fmt.Printf("div_int16 32767/-1 = %d, wanted -32767\n", got) + 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_int16_32767_ssa(-1); got != 0 { - fmt.Printf("div_int16 -1/32767 = %d, wanted 0\n", got) + 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_int16_32767_ssa(0); got != 0 { - fmt.Printf("div_int16 0/32767 = %d, wanted 0\n", got) + 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_32767_int16_ssa(1); got != 32767 { - fmt.Printf("div_int16 32767/1 = %d, wanted 32767\n", got) + 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_int16_32767_ssa(1); got != 0 { - fmt.Printf("div_int16 1/32767 = %d, wanted 0\n", got) + 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_32767_int16_ssa(32766); got != 1 { - fmt.Printf("div_int16 32767/32766 = %d, wanted 1\n", got) + 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_int16_32767_ssa(32766); got != 0 { - fmt.Printf("div_int16 32766/32767 = %d, wanted 0\n", got) + 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_32767_int16_ssa(32767); got != 1 { - fmt.Printf("div_int16 32767/32767 = %d, wanted 1\n", got) + if got := mul_Neg128_int8_ssa(-128); got != 0 { + fmt.Printf("mul_int8 -128*-128 = %d, wanted 0\n", got) failed = true } - if got := div_int16_32767_ssa(32767); got != 1 { - fmt.Printf("div_int16 32767/32767 = %d, wanted 1\n", got) + if got := mul_int8_Neg128_ssa(-128); got != 0 { + fmt.Printf("mul_int8 -128*-128 = %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) + if got := mul_Neg128_int8_ssa(-127); got != -128 { + fmt.Printf("mul_int8 -128*-127 = %d, wanted -128\n", got) failed = true } - if got := div_0_uint8_ssa(255); got != 0 { - fmt.Printf("div_uint8 0/255 = %d, wanted 0\n", got) + if got := mul_int8_Neg128_ssa(-127); got != -128 { + fmt.Printf("mul_int8 -127*-128 = %d, wanted -128\n", got) failed = true } - if got := div_uint8_1_ssa(0); got != 0 { - fmt.Printf("div_uint8 0/1 = %d, wanted 0\n", got) + if got := mul_Neg128_int8_ssa(-1); got != -128 { + fmt.Printf("mul_int8 -128*-1 = %d, wanted -128\n", got) failed = true } - if got := div_1_uint8_ssa(1); got != 1 { - fmt.Printf("div_uint8 1/1 = %d, wanted 1\n", got) + if got := mul_int8_Neg128_ssa(-1); got != -128 { + fmt.Printf("mul_int8 -1*-128 = %d, wanted -128\n", got) failed = true } - if got := div_uint8_1_ssa(1); got != 1 { - fmt.Printf("div_uint8 1/1 = %d, wanted 1\n", got) + if got := mul_Neg128_int8_ssa(0); got != 0 { + fmt.Printf("mul_int8 -128*0 = %d, wanted 0\n", got) failed = true } - if got := div_1_uint8_ssa(255); got != 0 { - fmt.Printf("adiv_uint8 1/255 = %d, wanted 0\n", got) + if got := mul_int8_Neg128_ssa(0); got != 0 { + fmt.Printf("mul_int8 0*-128 = %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) + if got := mul_Neg128_int8_ssa(1); got != -128 { + fmt.Printf("mul_int8 -128*1 = %d, wanted -128\n", got) failed = true } - if got := div_uint8_255_ssa(0); got != 0 { - fmt.Printf("div_uint8 0/255 = %d, wanted 0\n", got) + if got := mul_int8_Neg128_ssa(1); got != -128 { + fmt.Printf("mul_int8 1*-128 = %d, wanted -128\n", got) failed = true } - if got := div_255_uint8_ssa(1); got != 255 { - fmt.Printf("div_uint8 255/1 = %d, wanted 255\n", got) + if got := mul_Neg128_int8_ssa(126); got != 0 { + fmt.Printf("mul_int8 -128*126 = %d, wanted 0\n", got) failed = true } - if got := div_uint8_255_ssa(1); got != 0 { - fmt.Printf("bdiv_uint8 1/255 = %d, wanted 0\n", got) + if got := mul_int8_Neg128_ssa(126); got != 0 { + fmt.Printf("mul_int8 126*-128 = %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) + if got := mul_Neg128_int8_ssa(127); got != -128 { + fmt.Printf("mul_int8 -128*127 = %d, wanted -128\n", got) failed = true } - if got := div_uint8_255_ssa(255); got != 1 { - fmt.Printf("div_uint8 255/255 = %d, wanted 1\n", got) + if got := mul_int8_Neg128_ssa(127); got != -128 { + fmt.Printf("mul_int8 127*-128 = %d, wanted -128\n", got) failed = true } - if got := div_Neg128_int8_ssa(-128); got != 1 { - fmt.Printf("div_int8 -128/-128 = %d, wanted 1\n", got) + if got := mul_Neg127_int8_ssa(-128); got != -128 { + fmt.Printf("mul_int8 -127*-128 = %d, wanted -128\n", got) failed = true } - if got := div_int8_Neg128_ssa(-128); got != 1 { - fmt.Printf("div_int8 -128/-128 = %d, wanted 1\n", got) + if got := mul_int8_Neg127_ssa(-128); got != -128 { + fmt.Printf("mul_int8 -128*-127 = %d, wanted -128\n", got) failed = true } - if got := div_Neg128_int8_ssa(-127); got != 1 { - fmt.Printf("div_int8 -128/-127 = %d, wanted 1\n", got) + if got := mul_Neg127_int8_ssa(-127); got != 1 { + fmt.Printf("mul_int8 -127*-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) + if got := mul_int8_Neg127_ssa(-127); got != 1 { + fmt.Printf("mul_int8 -127*-127 = %d, wanted 1\n", got) failed = true } - if got := div_Neg128_int8_ssa(-1); got != -128 { - fmt.Printf("div_int8 -128/-1 = %d, wanted -128\n", got) + if got := mul_Neg127_int8_ssa(-1); got != 127 { + fmt.Printf("mul_int8 -127*-1 = %d, wanted 127\n", got) failed = true } - if got := div_int8_Neg128_ssa(-1); got != 0 { - fmt.Printf("div_int8 -1/-128 = %d, wanted 0\n", got) + if got := mul_int8_Neg127_ssa(-1); got != 127 { + fmt.Printf("mul_int8 -1*-127 = %d, wanted 127\n", got) failed = true } - if got := div_int8_Neg128_ssa(0); got != 0 { - fmt.Printf("div_int8 0/-128 = %d, wanted 0\n", got) + if got := mul_Neg127_int8_ssa(0); got != 0 { + fmt.Printf("mul_int8 -127*0 = %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) + if got := mul_int8_Neg127_ssa(0); got != 0 { + fmt.Printf("mul_int8 0*-127 = %d, wanted 0\n", got) failed = true } - if got := div_int8_Neg128_ssa(1); got != 0 { - fmt.Printf("div_int8 1/-128 = %d, wanted 0\n", got) + if got := mul_Neg127_int8_ssa(1); got != -127 { + fmt.Printf("mul_int8 -127*1 = %d, wanted -127\n", got) failed = true } - if got := div_Neg128_int8_ssa(126); got != -1 { - fmt.Printf("div_int8 -128/126 = %d, wanted -1\n", got) + if got := mul_int8_Neg127_ssa(1); got != -127 { + fmt.Printf("mul_int8 1*-127 = %d, wanted -127\n", got) failed = true } - if got := div_int8_Neg128_ssa(126); got != 0 { - fmt.Printf("div_int8 126/-128 = %d, wanted 0\n", got) + if got := mul_Neg127_int8_ssa(126); got != 126 { + fmt.Printf("mul_int8 -127*126 = %d, wanted 126\n", got) failed = true } - if got := div_Neg128_int8_ssa(127); got != -1 { - fmt.Printf("div_int8 -128/127 = %d, wanted -1\n", got) + if got := mul_int8_Neg127_ssa(126); got != 126 { + fmt.Printf("mul_int8 126*-127 = %d, wanted 126\n", got) failed = true } - if got := div_int8_Neg128_ssa(127); got != 0 { - fmt.Printf("div_int8 127/-128 = %d, wanted 0\n", got) + if got := mul_Neg127_int8_ssa(127); got != -1 { + fmt.Printf("mul_int8 -127*127 = %d, wanted -1\n", got) failed = true } - if got := div_Neg127_int8_ssa(-128); got != 0 { - fmt.Printf("div_int8 -127/-128 = %d, wanted 0\n", got) + if got := mul_int8_Neg127_ssa(127); got != -1 { + fmt.Printf("mul_int8 127*-127 = %d, wanted -1\n", got) failed = true } - if got := div_int8_Neg127_ssa(-128); got != 1 { - fmt.Printf("div_int8 -128/-127 = %d, wanted 1\n", got) + if got := mul_Neg1_int8_ssa(-128); got != -128 { + fmt.Printf("mul_int8 -1*-128 = %d, wanted -128\n", got) failed = true } - if got := div_Neg127_int8_ssa(-127); got != 1 { - fmt.Printf("div_int8 -127/-127 = %d, wanted 1\n", got) + if got := mul_int8_Neg1_ssa(-128); got != -128 { + fmt.Printf("mul_int8 -128*-1 = %d, wanted -128\n", got) failed = true } - if got := div_int8_Neg127_ssa(-127); got != 1 { - fmt.Printf("div_int8 -127/-127 = %d, wanted 1\n", got) + if got := mul_Neg1_int8_ssa(-127); got != 127 { + fmt.Printf("mul_int8 -1*-127 = %d, wanted 127\n", got) failed = true } - if got := div_Neg127_int8_ssa(-1); got != 127 { - fmt.Printf("div_int8 -127/-1 = %d, wanted 127\n", got) + if got := mul_int8_Neg1_ssa(-127); got != 127 { + fmt.Printf("mul_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) + if got := mul_Neg1_int8_ssa(-1); got != 1 { + fmt.Printf("mul_int8 -1*-1 = %d, wanted 1\n", got) failed = true } - if got := div_int8_Neg127_ssa(0); got != 0 { - fmt.Printf("div_int8 0/-127 = %d, wanted 0\n", got) + if got := mul_int8_Neg1_ssa(-1); got != 1 { + fmt.Printf("mul_int8 -1*-1 = %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) + if got := mul_Neg1_int8_ssa(0); got != 0 { + fmt.Printf("mul_int8 -1*0 = %d, wanted 0\n", got) failed = true } - if got := div_int8_Neg127_ssa(1); got != 0 { - fmt.Printf("div_int8 1/-127 = %d, wanted 0\n", got) + if got := mul_int8_Neg1_ssa(0); got != 0 { + fmt.Printf("mul_int8 0*-1 = %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) + if got := mul_Neg1_int8_ssa(1); got != -1 { + fmt.Printf("mul_int8 -1*1 = %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) + if got := mul_int8_Neg1_ssa(1); got != -1 { + fmt.Printf("mul_int8 1*-1 = %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) + if got := mul_Neg1_int8_ssa(126); got != -126 { + fmt.Printf("mul_int8 -1*126 = %d, wanted -126\n", got) failed = true } - if got := div_int8_Neg127_ssa(127); got != -1 { - fmt.Printf("div_int8 127/-127 = %d, wanted -1\n", got) + if got := mul_int8_Neg1_ssa(126); got != -126 { + fmt.Printf("mul_int8 126*-1 = %d, wanted -126\n", got) failed = true } - if got := div_Neg1_int8_ssa(-128); got != 0 { - fmt.Printf("div_int8 -1/-128 = %d, wanted 0\n", got) + if got := mul_Neg1_int8_ssa(127); got != -127 { + fmt.Printf("mul_int8 -1*127 = %d, wanted -127\n", got) failed = true } - if got := div_int8_Neg1_ssa(-128); got != -128 { - fmt.Printf("div_int8 -128/-1 = %d, wanted -128\n", got) + if got := mul_int8_Neg1_ssa(127); got != -127 { + fmt.Printf("mul_int8 127*-1 = %d, wanted -127\n", got) failed = true } - if got := div_Neg1_int8_ssa(-127); got != 0 { - fmt.Printf("div_int8 -1/-127 = %d, wanted 0\n", got) + if got := mul_0_int8_ssa(-128); got != 0 { + fmt.Printf("mul_int8 0*-128 = %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) + if got := mul_int8_0_ssa(-128); got != 0 { + fmt.Printf("mul_int8 -128*0 = %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) + if got := mul_0_int8_ssa(-127); got != 0 { + fmt.Printf("mul_int8 0*-127 = %d, wanted 0\n", got) failed = true } - if got := div_int8_Neg1_ssa(-1); got != 1 { - fmt.Printf("div_int8 -1/-1 = %d, wanted 1\n", got) + if got := mul_int8_0_ssa(-127); got != 0 { + fmt.Printf("mul_int8 -127*0 = %d, wanted 0\n", got) failed = true } - if got := div_int8_Neg1_ssa(0); got != 0 { - fmt.Printf("div_int8 0/-1 = %d, wanted 0\n", got) + if got := mul_0_int8_ssa(-1); got != 0 { + fmt.Printf("mul_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) + if got := mul_int8_0_ssa(-1); got != 0 { + fmt.Printf("mul_int8 -1*0 = %d, wanted 0\n", got) failed = true } - if got := div_int8_Neg1_ssa(1); got != -1 { - fmt.Printf("div_int8 1/-1 = %d, wanted -1\n", got) + if got := mul_0_int8_ssa(0); got != 0 { + fmt.Printf("mul_int8 0*0 = %d, wanted 0\n", got) failed = true } - if got := div_Neg1_int8_ssa(126); got != 0 { - fmt.Printf("div_int8 -1/126 = %d, wanted 0\n", got) + if got := mul_int8_0_ssa(0); got != 0 { + fmt.Printf("mul_int8 0*0 = %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) + if got := mul_0_int8_ssa(1); got != 0 { + fmt.Printf("mul_int8 0*1 = %d, wanted 0\n", got) failed = true } - if got := div_Neg1_int8_ssa(127); got != 0 { - fmt.Printf("div_int8 -1/127 = %d, wanted 0\n", got) + if got := mul_int8_0_ssa(1); got != 0 { + fmt.Printf("mul_int8 1*0 = %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) + if got := mul_0_int8_ssa(126); got != 0 { + fmt.Printf("mul_int8 0*126 = %d, wanted 0\n", got) failed = true } - if got := div_0_int8_ssa(-128); got != 0 { - fmt.Printf("div_int8 0/-128 = %d, wanted 0\n", got) + if got := mul_int8_0_ssa(126); got != 0 { + fmt.Printf("mul_int8 126*0 = %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) + if got := mul_0_int8_ssa(127); got != 0 { + fmt.Printf("mul_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) + if got := mul_int8_0_ssa(127); got != 0 { + fmt.Printf("mul_int8 127*0 = %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) + if got := mul_1_int8_ssa(-128); got != -128 { + fmt.Printf("mul_int8 1*-128 = %d, wanted -128\n", got) failed = true } - if got := div_0_int8_ssa(126); got != 0 { - fmt.Printf("div_int8 0/126 = %d, wanted 0\n", got) + if got := mul_int8_1_ssa(-128); got != -128 { + fmt.Printf("mul_int8 -128*1 = %d, wanted -128\n", got) failed = true } - if got := div_0_int8_ssa(127); got != 0 { - fmt.Printf("div_int8 0/127 = %d, wanted 0\n", got) + if got := mul_1_int8_ssa(-127); got != -127 { + fmt.Printf("mul_int8 1*-127 = %d, wanted -127\n", got) failed = true } - if got := div_1_int8_ssa(-128); got != 0 { - fmt.Printf("div_int8 1/-128 = %d, wanted 0\n", got) + if got := mul_int8_1_ssa(-127); got != -127 { + fmt.Printf("mul_int8 -127*1 = %d, wanted -127\n", got) failed = true } - if got := div_int8_1_ssa(-128); got != -128 { - fmt.Printf("div_int8 -128/1 = %d, wanted -128\n", got) + if got := mul_1_int8_ssa(-1); got != -1 { + fmt.Printf("mul_int8 1*-1 = %d, wanted -1\n", got) failed = true } - if got := div_1_int8_ssa(-127); got != 0 { - fmt.Printf("div_int8 1/-127 = %d, wanted 0\n", got) + if got := mul_int8_1_ssa(-1); got != -1 { + fmt.Printf("mul_int8 -1*1 = %d, wanted -1\n", got) failed = true } - if got := div_int8_1_ssa(-127); got != -127 { - fmt.Printf("div_int8 -127/1 = %d, wanted -127\n", got) + if got := mul_1_int8_ssa(0); got != 0 { + fmt.Printf("mul_int8 1*0 = %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) + if got := mul_int8_1_ssa(0); got != 0 { + fmt.Printf("mul_int8 0*1 = %d, wanted 0\n", got) failed = true } - if got := div_int8_1_ssa(-1); got != -1 { - fmt.Printf("div_int8 -1/1 = %d, wanted -1\n", got) + if got := mul_1_int8_ssa(1); got != 1 { + fmt.Printf("mul_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) + if got := mul_int8_1_ssa(1); got != 1 { + fmt.Printf("mul_int8 1*1 = %d, wanted 1\n", got) failed = true } - if got := div_1_int8_ssa(1); got != 1 { - fmt.Printf("div_int8 1/1 = %d, wanted 1\n", got) + if got := mul_1_int8_ssa(126); got != 126 { + fmt.Printf("mul_int8 1*126 = %d, wanted 126\n", got) failed = true } - if got := div_int8_1_ssa(1); got != 1 { - fmt.Printf("div_int8 1/1 = %d, wanted 1\n", got) + if got := mul_int8_1_ssa(126); got != 126 { + fmt.Printf("mul_int8 126*1 = %d, wanted 126\n", got) failed = true } - if got := div_1_int8_ssa(126); got != 0 { - fmt.Printf("div_int8 1/126 = %d, wanted 0\n", got) + if got := mul_1_int8_ssa(127); got != 127 { + fmt.Printf("mul_int8 1*127 = %d, wanted 127\n", got) failed = true } - if got := div_int8_1_ssa(126); got != 126 { - fmt.Printf("div_int8 126/1 = %d, wanted 126\n", got) + if got := mul_int8_1_ssa(127); got != 127 { + fmt.Printf("mul_int8 127*1 = %d, wanted 127\n", got) failed = true } - if got := div_1_int8_ssa(127); got != 0 { - fmt.Printf("div_int8 1/127 = %d, wanted 0\n", got) + if got := mul_126_int8_ssa(-128); got != 0 { + fmt.Printf("mul_int8 126*-128 = %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) + if got := mul_int8_126_ssa(-128); got != 0 { + fmt.Printf("mul_int8 -128*126 = %d, wanted 0\n", got) failed = true } - if got := div_126_int8_ssa(-128); got != 0 { - fmt.Printf("div_int8 126/-128 = %d, wanted 0\n", got) + if got := mul_126_int8_ssa(-127); got != 126 { + fmt.Printf("mul_int8 126*-127 = %d, wanted 126\n", got) failed = true } - if got := div_int8_126_ssa(-128); got != -1 { - fmt.Printf("div_int8 -128/126 = %d, wanted -1\n", got) + if got := mul_int8_126_ssa(-127); got != 126 { + fmt.Printf("mul_int8 -127*126 = %d, wanted 126\n", got) failed = true } - if got := div_126_int8_ssa(-127); got != 0 { - fmt.Printf("div_int8 126/-127 = %d, wanted 0\n", got) + if got := mul_126_int8_ssa(-1); got != -126 { + fmt.Printf("mul_int8 126*-1 = %d, wanted -126\n", got) failed = true } - if got := div_int8_126_ssa(-127); got != -1 { - fmt.Printf("div_int8 -127/126 = %d, wanted -1\n", got) + if got := mul_int8_126_ssa(-1); got != -126 { + fmt.Printf("mul_int8 -1*126 = %d, wanted -126\n", got) failed = true } - if got := div_126_int8_ssa(-1); got != -126 { - fmt.Printf("div_int8 126/-1 = %d, wanted -126\n", got) + if got := mul_126_int8_ssa(0); got != 0 { + fmt.Printf("mul_int8 126*0 = %d, wanted 0\n", got) failed = true } - if got := div_int8_126_ssa(-1); got != 0 { - fmt.Printf("div_int8 -1/126 = %d, wanted 0\n", got) + if got := mul_int8_126_ssa(0); got != 0 { + fmt.Printf("mul_int8 0*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) + if got := mul_126_int8_ssa(1); got != 126 { + fmt.Printf("mul_int8 126*1 = %d, wanted 126\n", got) failed = true } - if got := div_126_int8_ssa(1); got != 126 { - fmt.Printf("div_int8 126/1 = %d, wanted 126\n", got) + if got := mul_int8_126_ssa(1); got != 126 { + fmt.Printf("mul_int8 1*126 = %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) + if got := mul_126_int8_ssa(126); got != 4 { + fmt.Printf("mul_int8 126*126 = %d, wanted 4\n", got) failed = true } - if got := div_126_int8_ssa(126); got != 1 { - fmt.Printf("div_int8 126/126 = %d, wanted 1\n", got) + if got := mul_int8_126_ssa(126); got != 4 { + fmt.Printf("mul_int8 126*126 = %d, wanted 4\n", got) failed = true } - if got := div_int8_126_ssa(126); got != 1 { - fmt.Printf("div_int8 126/126 = %d, wanted 1\n", got) + if got := mul_126_int8_ssa(127); got != -126 { + fmt.Printf("mul_int8 126*127 = %d, wanted -126\n", got) failed = true } - if got := div_126_int8_ssa(127); got != 0 { - fmt.Printf("div_int8 126/127 = %d, wanted 0\n", got) + if got := mul_int8_126_ssa(127); got != -126 { + fmt.Printf("mul_int8 127*126 = %d, wanted -126\n", got) failed = true } - if got := div_int8_126_ssa(127); got != 1 { - fmt.Printf("div_int8 127/126 = %d, wanted 1\n", got) + if got := mul_127_int8_ssa(-128); got != -128 { + fmt.Printf("mul_int8 127*-128 = %d, wanted -128\n", got) failed = true } - if got := div_127_int8_ssa(-128); got != 0 { - fmt.Printf("div_int8 127/-128 = %d, wanted 0\n", got) + if got := mul_int8_127_ssa(-128); got != -128 { + fmt.Printf("mul_int8 -128*127 = %d, wanted -128\n", got) failed = true } - if got := div_int8_127_ssa(-128); got != -1 { - fmt.Printf("div_int8 -128/127 = %d, wanted -1\n", got) + if got := mul_127_int8_ssa(-127); got != -1 { + fmt.Printf("mul_int8 127*-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) + if got := mul_int8_127_ssa(-127); got != -1 { + fmt.Printf("mul_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) + if got := mul_127_int8_ssa(-1); got != -127 { + fmt.Printf("mul_int8 127*-1 = %d, wanted -127\n", got) failed = true } - if got := div_127_int8_ssa(-1); got != -127 { - fmt.Printf("div_int8 127/-1 = %d, wanted -127\n", got) + if got := mul_int8_127_ssa(-1); got != -127 { + fmt.Printf("mul_int8 -1*127 = %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) + if got := mul_127_int8_ssa(0); got != 0 { + fmt.Printf("mul_int8 127*0 = %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) + if got := mul_int8_127_ssa(0); got != 0 { + fmt.Printf("mul_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) + if got := mul_127_int8_ssa(1); got != 127 { + fmt.Printf("mul_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) + if got := mul_int8_127_ssa(1); got != 127 { + fmt.Printf("mul_int8 1*127 = %d, wanted 127\n", got) failed = true } - if got := div_127_int8_ssa(126); got != 1 { - fmt.Printf("div_int8 127/126 = %d, wanted 1\n", got) + if got := mul_127_int8_ssa(126); got != -126 { + fmt.Printf("mul_int8 127*126 = %d, wanted -126\n", got) failed = true } - if got := div_int8_127_ssa(126); got != 0 { - fmt.Printf("div_int8 126/127 = %d, wanted 0\n", got) + if got := mul_int8_127_ssa(126); got != -126 { + fmt.Printf("mul_int8 126*127 = %d, wanted -126\n", got) failed = true } - if got := div_127_int8_ssa(127); got != 1 { - fmt.Printf("div_int8 127/127 = %d, wanted 1\n", got) + if got := mul_127_int8_ssa(127); got != 1 { + fmt.Printf("mul_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) + if got := mul_int8_127_ssa(127); got != 1 { + fmt.Printf("mul_int8 127*127 = %d, wanted 1\n", got) failed = true } if failed { diff --git a/src/cmd/compile/internal/gc/testdata/arith_ssa.go b/src/cmd/compile/internal/gc/testdata/arith_ssa.go index af31245505..22a78105e0 100644 --- a/src/cmd/compile/internal/gc/testdata/arith_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/arith_ssa.go @@ -8,6 +8,102 @@ package main +import "fmt" + +// 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() { @@ -275,6 +371,9 @@ func main() { testLrot() testShiftCX() testSubConst() + testOverflowConstShift() + testArithConstShift() + testArithRshConst() if failed { panic("failed") 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 0000000000..34e54ad08a --- /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/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index 658d78ca32..28fe9ff878 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -35,6 +35,19 @@ (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))]) + (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))]) @@ -79,6 +92,89 @@ (Sub16 x (Const16 [c])) && x.Op != OpConst16 -> (Add16 (Const16 [-c]) x) (Sub8 x (Const8 [c])) && x.Op != OpConst8 -> (Add8 (Const8 [-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 x (Const32 [c])) -> (Lsh64x64 x (Const64 [int64(uint32(c))])) +(Lsh64x16 x (Const16 [c])) -> (Lsh64x64 x (Const64 [int64(uint16(c))])) +(Lsh64x8 x (Const8 [c])) -> (Lsh64x64 x (Const64 [int64(uint8(c))])) +(Rsh64x32 x (Const32 [c])) -> (Rsh64x64 x (Const64 [int64(uint32(c))])) +(Rsh64x16 x (Const16 [c])) -> (Rsh64x64 x (Const64 [int64(uint16(c))])) +(Rsh64x8 x (Const8 [c])) -> (Rsh64x64 x (Const64 [int64(uint8(c))])) +(Rsh64Ux32 x (Const32 [c])) -> (Rsh64Ux64 x (Const64 [int64(uint32(c))])) +(Rsh64Ux16 x (Const16 [c])) -> (Rsh64Ux64 x (Const64 [int64(uint16(c))])) +(Rsh64Ux8 x (Const8 [c])) -> (Rsh64Ux64 x (Const64 [int64(uint8(c))])) + +(Lsh32x32 x (Const32 [c])) -> (Lsh32x64 x (Const64 [int64(uint32(c))])) +(Lsh32x16 x (Const16 [c])) -> (Lsh32x64 x (Const64 [int64(uint16(c))])) +(Lsh32x8 x (Const8 [c])) -> (Lsh32x64 x (Const64 [int64(uint8(c))])) +(Rsh32x32 x (Const32 [c])) -> (Rsh32x64 x (Const64 [int64(uint32(c))])) +(Rsh32x16 x (Const16 [c])) -> (Rsh32x64 x (Const64 [int64(uint16(c))])) +(Rsh32x8 x (Const8 [c])) -> (Rsh32x64 x (Const64 [int64(uint8(c))])) +(Rsh32Ux32 x (Const32 [c])) -> (Rsh32Ux64 x (Const64 [int64(uint32(c))])) +(Rsh32Ux16 x (Const16 [c])) -> (Rsh32Ux64 x (Const64 [int64(uint16(c))])) +(Rsh32Ux8 x (Const8 [c])) -> (Rsh32Ux64 x (Const64 [int64(uint8(c))])) + +(Lsh16x32 x (Const32 [c])) -> (Lsh16x64 x (Const64 [int64(uint32(c))])) +(Lsh16x16 x (Const16 [c])) -> (Lsh16x64 x (Const64 [int64(uint16(c))])) +(Lsh16x8 x (Const8 [c])) -> (Lsh16x64 x (Const64 [int64(uint8(c))])) +(Rsh16x32 x (Const32 [c])) -> (Rsh16x64 x (Const64 [int64(uint32(c))])) +(Rsh16x16 x (Const16 [c])) -> (Rsh16x64 x (Const64 [int64(uint16(c))])) +(Rsh16x8 x (Const8 [c])) -> (Rsh16x64 x (Const64 [int64(uint8(c))])) +(Rsh16Ux32 x (Const32 [c])) -> (Rsh16Ux64 x (Const64 [int64(uint32(c))])) +(Rsh16Ux16 x (Const16 [c])) -> (Rsh16Ux64 x (Const64 [int64(uint16(c))])) +(Rsh16Ux8 x (Const8 [c])) -> (Rsh16Ux64 x (Const64 [int64(uint8(c))])) + +(Lsh8x32 x (Const32 [c])) -> (Lsh8x64 x (Const64 [int64(uint32(c))])) +(Lsh8x16 x (Const16 [c])) -> (Lsh8x64 x (Const64 [int64(uint16(c))])) +(Lsh8x8 x (Const8 [c])) -> (Lsh8x64 x (Const64 [int64(uint8(c))])) +(Rsh8x32 x (Const32 [c])) -> (Rsh8x64 x (Const64 [int64(uint32(c))])) +(Rsh8x16 x (Const16 [c])) -> (Rsh8x64 x (Const64 [int64(uint16(c))])) +(Rsh8x8 x (Const8 [c])) -> (Rsh8x64 x (Const64 [int64(uint8(c))])) +(Rsh8Ux32 x (Const32 [c])) -> (Rsh8Ux64 x (Const64 [int64(uint32(c))])) +(Rsh8Ux16 x (Const16 [c])) -> (Rsh8Ux64 x (Const64 [int64(uint16(c))])) +(Rsh8Ux8 x (Const8 [c])) -> (Rsh8Ux64 x (Const64 [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 + +// 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 -> (Const64 [0]) +(Rsh32Ux64 _ (Const64 [c])) && uint64(c) >= 32 -> (Const64 [0]) +(Lsh16x64 _ (Const64 [c])) && uint64(c) >= 16 -> (Const64 [0]) +(Rsh16Ux64 _ (Const64 [c])) && uint64(c) >= 16 -> (Const64 [0]) +(Lsh8x64 _ (Const64 [c])) && uint64(c) >= 8 -> (Const64 [0]) +(Rsh8Ux64 _ (Const64 [c])) && uint64(c) >= 8 -> (Const64 [0]) + + +// combine const shifts +(Lsh64x64 (Lsh64x64 x (Const64 [c])) (Const64 [d])) && !uaddOvf(c,d) -> (Lsh64x64 x (Const64 [c+d])) +(Lsh32x64 (Lsh32x64 x (Const64 [c])) (Const64 [d])) && !uaddOvf(c,d) -> (Lsh32x64 x (Const64 [c+d])) +(Lsh16x64 (Lsh16x64 x (Const64 [c])) (Const64 [d])) && !uaddOvf(c,d) -> (Lsh16x64 x (Const64 [c+d])) +(Lsh8x64 (Lsh8x64 x (Const64 [c])) (Const64 [d])) && !uaddOvf(c,d) -> (Lsh8x64 x (Const64 [c+d])) + +(Rsh64x64 (Rsh64x64 x (Const64 [c])) (Const64 [d])) && !uaddOvf(c,d) -> (Rsh64x64 x (Const64 [c+d])) +(Rsh32x64 (Rsh32x64 x (Const64 [c])) (Const64 [d])) && !uaddOvf(c,d) -> (Rsh32x64 x (Const64 [c+d])) +(Rsh16x64 (Rsh16x64 x (Const64 [c])) (Const64 [d])) && !uaddOvf(c,d) -> (Rsh16x64 x (Const64 [c+d])) +(Rsh8x64 (Rsh8x64 x (Const64 [c])) (Const64 [d])) && !uaddOvf(c,d) -> (Rsh8x64 x (Const64 [c+d])) + +(Rsh64Ux64 (Rsh64Ux64 x (Const64 [c])) (Const64 [d])) && !uaddOvf(c,d) -> (Rsh64Ux64 x (Const64 [c+d])) +(Rsh32Ux64 (Rsh32Ux64 x (Const64 [c])) (Const64 [d])) && !uaddOvf(c,d) -> (Rsh32Ux64 x (Const64 [c+d])) +(Rsh16Ux64 (Rsh16Ux64 x (Const64 [c])) (Const64 [d])) && !uaddOvf(c,d) -> (Rsh16Ux64 x (Const64 [c+d])) +(Rsh8Ux64 (Rsh8Ux64 x (Const64 [c])) (Const64 [d])) && !uaddOvf(c,d) -> (Rsh8Ux64 x (Const64 [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))]) diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go index f7da347263..7dd0d2e5d5 100644 --- a/src/cmd/compile/internal/ssa/rewrite.go +++ b/src/cmd/compile/internal/ssa/rewrite.go @@ -181,6 +181,11 @@ 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) +} + // DUFFZERO consists of repeated blocks of 4 MOVUPSs + ADD, // See runtime/mkduff.go. const ( diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index b9e4d186e9..67f07e65dc 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -135,6 +135,38 @@ func rewriteValuegeneric(v *Value, config *Config) bool { 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 OpMul16: return rewriteValuegeneric_OpMul16(v, config) case OpMul32: @@ -167,6 +199,70 @@ func rewriteValuegeneric(v *Value, config *Config) bool { return rewriteValuegeneric_OpOr8(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: @@ -242,8 +338,7 @@ end359c546ef662b7990116329cb30d6892: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpConst16, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpConst16, t) v0.AuxInt = c v.AddArg(v0) v.AddArg(x) @@ -296,8 +391,7 @@ enda3edaa9a512bd1d7a95f002c890bfb88: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpConst32, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpConst32, t) v0.AuxInt = c v.AddArg(v0) v.AddArg(x) @@ -350,8 +444,7 @@ end8c46df6f85a11cb1d594076b0e467908: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpConst64, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = c v.AddArg(v0) v.AddArg(x) @@ -404,8 +497,7 @@ end60c66721511a442aade8e4da2fb326bd: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpConst8, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpConst8, t) v0.AuxInt = c v.AddArg(v0) v.AddArg(x) @@ -1234,8 +1326,7 @@ end0c0fe5fdfba3821add3448fd3f1fc6b7: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpConst16, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpConst16, t) v0.AuxInt = c - d v.AddArg(v0) v.AddArg(x) @@ -1261,8 +1352,7 @@ end79c830afa265161fc0f0532c4c4e7f50: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpConst16, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpConst16, t) v0.AuxInt = c v.AddArg(v0) v.AddArg(x) @@ -1340,8 +1430,7 @@ end6da547ec4ee93d787434f3bda873e4a0: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpConst32, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpConst32, t) v0.AuxInt = c - d v.AddArg(v0) v.AddArg(x) @@ -1367,8 +1456,7 @@ end1a69730a32c6e432784dcdf643320ecd: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpConst32, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpConst32, t) v0.AuxInt = c v.AddArg(v0) v.AddArg(x) @@ -1446,8 +1534,7 @@ endb1d471cc503ba8bb05440f01dbf33d81: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpConst64, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = c - d v.AddArg(v0) v.AddArg(x) @@ -1473,8 +1560,7 @@ endffd67f3b83f6972cd459153d318f714d: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpConst64, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = c v.AddArg(v0) v.AddArg(x) @@ -1552,8 +1638,7 @@ enda66da0d3e7e51624ee46527727c48a9a: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpConst8, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpConst8, t) v0.AuxInt = c - d v.AddArg(v0) v.AddArg(x) @@ -1579,8 +1664,7 @@ end6912961350bb485f56ef176522aa683b: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpConst8, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpConst8, t) v0.AuxInt = c v.AddArg(v0) v.AddArg(x) @@ -3033,713 +3117,2861 @@ end12671c83ebe3ccbc8e53383765ee7675: ; return false } -func rewriteValuegeneric_OpMul16(v *Value, config *Config) bool { +func rewriteValuegeneric_OpLsh16x16(v *Value, config *Config) bool { b := v.Block _ = b - // match: (Mul16 (Const16 [c]) (Const16 [d])) + // match: (Lsh16x16 x (Const16 [c])) // cond: - // result: (Const16 [c*d]) + // result: (Lsh16x64 x (Const64 [int64(uint16(c))])) { - if v.Args[0].Op != OpConst16 { - goto ende8dd468add3015aea24531cf3c89ccb7 - } - c := v.Args[0].AuxInt + t := v.Type + x := v.Args[0] if v.Args[1].Op != OpConst16 { - goto ende8dd468add3015aea24531cf3c89ccb7 + goto end2f5aa78b30ebd2471e8d03a307923b06 } - d := v.Args[1].AuxInt - v.Op = OpConst16 + c := v.Args[1].AuxInt + v.Op = OpLsh16x64 v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = c * d + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = int64(uint16(c)) + v.AddArg(v0) return true } - goto ende8dd468add3015aea24531cf3c89ccb7 -ende8dd468add3015aea24531cf3c89ccb7: + goto end2f5aa78b30ebd2471e8d03a307923b06 +end2f5aa78b30ebd2471e8d03a307923b06: ; return false } -func rewriteValuegeneric_OpMul32(v *Value, config *Config) bool { +func rewriteValuegeneric_OpLsh16x32(v *Value, config *Config) bool { b := v.Block _ = b - // match: (Mul32 (Const32 [c]) (Const32 [d])) + // match: (Lsh16x32 x (Const32 [c])) // cond: - // result: (Const32 [c*d]) + // result: (Lsh16x64 x (Const64 [int64(uint32(c))])) { - if v.Args[0].Op != OpConst32 { - goto end60b4523099fa7b55e2e872e05bd497a7 - } - c := v.Args[0].AuxInt + t := v.Type + x := v.Args[0] if v.Args[1].Op != OpConst32 { - goto end60b4523099fa7b55e2e872e05bd497a7 + goto endedeb000c8c97090261a47f08a2ff17e4 } - d := v.Args[1].AuxInt - v.Op = OpConst32 + c := v.Args[1].AuxInt + v.Op = OpLsh16x64 v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = c * d + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = int64(uint32(c)) + v.AddArg(v0) return true } - goto end60b4523099fa7b55e2e872e05bd497a7 -end60b4523099fa7b55e2e872e05bd497a7: + goto endedeb000c8c97090261a47f08a2ff17e4 +endedeb000c8c97090261a47f08a2ff17e4: ; return false } -func rewriteValuegeneric_OpMul64(v *Value, config *Config) bool { +func rewriteValuegeneric_OpLsh16x64(v *Value, config *Config) bool { b := v.Block _ = b - // match: (Mul64 (Const64 [c]) (Const64 [d])) + // match: (Lsh16x64 (Const16 [c]) (Const64 [d])) // cond: - // result: (Const64 [c*d]) + // result: (Const16 [int64(int16(c) << uint64(d))]) { - if v.Args[0].Op != OpConst64 { - goto end7aea1048b5d1230974b97f17238380ae + if v.Args[0].Op != OpConst16 { + goto endc9f0d91f3da4bdd46a634a62549810e0 } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst64 { - goto end7aea1048b5d1230974b97f17238380ae + goto endc9f0d91f3da4bdd46a634a62549810e0 } d := v.Args[1].AuxInt - v.Op = OpConst64 + v.Op = OpConst16 v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = c * d + v.AuxInt = int64(int16(c) << uint64(d)) return true } - goto end7aea1048b5d1230974b97f17238380ae -end7aea1048b5d1230974b97f17238380ae: + goto endc9f0d91f3da4bdd46a634a62549810e0 +endc9f0d91f3da4bdd46a634a62549810e0: ; - return false -} -func rewriteValuegeneric_OpMul8(v *Value, config *Config) bool { - b := v.Block - _ = b - // match: (Mul8 (Const8 [c]) (Const8 [d])) + // match: (Lsh16x64 x (Const64 [0])) // cond: - // result: (Const8 [c*d]) + // result: x { - if v.Args[0].Op != OpConst8 { - goto end2f1952fd654c4a62ff00511041728809 + x := v.Args[0] + if v.Args[1].Op != OpConst64 { + goto end7ecc343739fab9b50a0bdff6e9d121e6 } - c := v.Args[0].AuxInt - if v.Args[1].Op != OpConst8 { - goto end2f1952fd654c4a62ff00511041728809 + if v.Args[1].AuxInt != 0 { + goto end7ecc343739fab9b50a0bdff6e9d121e6 } - d := v.Args[1].AuxInt - v.Op = OpConst8 + v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = c * d + v.Type = x.Type + v.AddArg(x) return true } - goto end2f1952fd654c4a62ff00511041728809 -end2f1952fd654c4a62ff00511041728809: + goto end7ecc343739fab9b50a0bdff6e9d121e6 +end7ecc343739fab9b50a0bdff6e9d121e6: ; - return false -} -func rewriteValuegeneric_OpNeq16(v *Value, config *Config) bool { - b := v.Block - _ = b - // match: (Neq16 x x) - // cond: - // result: (ConstBool [0]) + // match: (Lsh16x64 _ (Const64 [c])) + // cond: uint64(c) >= 16 + // result: (Const64 [0]) { - x := v.Args[0] - if v.Args[1] != x { - goto ende76a50b524aeb16c7aeccf5f5cc60c06 + if v.Args[1].Op != OpConst64 { + goto end1d2c74d359df9d89b16c4f658a231dfe } - v.Op = OpConstBool + c := v.Args[1].AuxInt + if !(uint64(c) >= 16) { + goto end1d2c74d359df9d89b16c4f658a231dfe + } + v.Op = OpConst64 v.AuxInt = 0 v.Aux = nil v.resetArgs() v.AuxInt = 0 return true } - goto ende76a50b524aeb16c7aeccf5f5cc60c06 -ende76a50b524aeb16c7aeccf5f5cc60c06: + goto end1d2c74d359df9d89b16c4f658a231dfe +end1d2c74d359df9d89b16c4f658a231dfe: ; - // match: (Neq16 (Const16 [c]) (Add16 (Const16 [d]) x)) - // cond: - // result: (Neq16 (Const16 [c-d]) x) + // match: (Lsh16x64 (Lsh16x64 x (Const64 [c])) (Const64 [d])) + // cond: !uaddOvf(c,d) + // result: (Lsh16x64 x (Const64 [c+d])) { - if v.Args[0].Op != OpConst16 { - goto end552011bd97e6f92ebc2672aa1843eadd + t := v.Type + if v.Args[0].Op != OpLsh16x64 { + goto end26a91e42735a02a30e94a998f54372dd } - t := v.Args[0].Type - c := v.Args[0].AuxInt - if v.Args[1].Op != OpAdd16 { - goto end552011bd97e6f92ebc2672aa1843eadd + x := v.Args[0].Args[0] + if v.Args[0].Args[1].Op != OpConst64 { + goto end26a91e42735a02a30e94a998f54372dd } - if v.Args[1].Args[0].Op != OpConst16 { - goto end552011bd97e6f92ebc2672aa1843eadd + c := v.Args[0].Args[1].AuxInt + if v.Args[1].Op != OpConst64 { + goto end26a91e42735a02a30e94a998f54372dd } - if v.Args[1].Args[0].Type != v.Args[0].Type { - goto end552011bd97e6f92ebc2672aa1843eadd + d := v.Args[1].AuxInt + if !(!uaddOvf(c, d)) { + goto end26a91e42735a02a30e94a998f54372dd } - d := v.Args[1].Args[0].AuxInt - x := v.Args[1].Args[1] - v.Op = OpNeq16 + v.Op = OpLsh16x64 v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpConst16, TypeInvalid) - v0.Type = t - v0.AuxInt = c - d - v.AddArg(v0) v.AddArg(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = c + d + v.AddArg(v0) return true } - goto end552011bd97e6f92ebc2672aa1843eadd -end552011bd97e6f92ebc2672aa1843eadd: + goto end26a91e42735a02a30e94a998f54372dd +end26a91e42735a02a30e94a998f54372dd: ; - // match: (Neq16 x (Const16 [c])) - // cond: x.Op != OpConst16 - // result: (Neq16 (Const16 [c]) x) + return false +} +func rewriteValuegeneric_OpLsh16x8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Lsh16x8 x (Const8 [c])) + // cond: + // result: (Lsh16x64 x (Const64 [int64(uint8(c))])) { + t := v.Type x := v.Args[0] - if v.Args[1].Op != OpConst16 { - goto end0e45958f29e87997f632248aa9ee97e0 + if v.Args[1].Op != OpConst8 { + goto endce2401b8a6c6190fe81d77e2d562a10c } - t := v.Args[1].Type c := v.Args[1].AuxInt - if !(x.Op != OpConst16) { - goto end0e45958f29e87997f632248aa9ee97e0 - } - v.Op = OpNeq16 + v.Op = OpLsh16x64 v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpConst16, TypeInvalid) - v0.Type = t - v0.AuxInt = c - v.AddArg(v0) v.AddArg(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = int64(uint8(c)) + v.AddArg(v0) return true } - goto end0e45958f29e87997f632248aa9ee97e0 -end0e45958f29e87997f632248aa9ee97e0: + goto endce2401b8a6c6190fe81d77e2d562a10c +endce2401b8a6c6190fe81d77e2d562a10c: ; - // match: (Neq16 (Const16 [c]) (Const16 [d])) + return false +} +func rewriteValuegeneric_OpLsh32x16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Lsh32x16 x (Const16 [c])) // cond: - // result: (ConstBool [b2i(int16(c) != int16(d))]) + // result: (Lsh32x64 x (Const64 [int64(uint16(c))])) { - if v.Args[0].Op != OpConst16 { - goto end6302c9b645bb191982d28c2f846904d6 - } - c := v.Args[0].AuxInt + t := v.Type + x := v.Args[0] if v.Args[1].Op != OpConst16 { - goto end6302c9b645bb191982d28c2f846904d6 + goto end7205eb3e315971143ac5584d07045570 } - d := v.Args[1].AuxInt - v.Op = OpConstBool + c := v.Args[1].AuxInt + v.Op = OpLsh32x64 v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = b2i(int16(c) != int16(d)) + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = int64(uint16(c)) + v.AddArg(v0) return true } - goto end6302c9b645bb191982d28c2f846904d6 -end6302c9b645bb191982d28c2f846904d6: + goto end7205eb3e315971143ac5584d07045570 +end7205eb3e315971143ac5584d07045570: ; return false } -func rewriteValuegeneric_OpNeq32(v *Value, config *Config) bool { +func rewriteValuegeneric_OpLsh32x32(v *Value, config *Config) bool { b := v.Block _ = b - // match: (Neq32 x x) + // match: (Lsh32x32 x (Const32 [c])) // cond: - // result: (ConstBool [0]) + // result: (Lsh32x64 x (Const64 [int64(uint32(c))])) { + t := v.Type x := v.Args[0] - if v.Args[1] != x { - goto end3713a608cffd29b40ff7c3b3f2585cbb + if v.Args[1].Op != OpConst32 { + goto endc1a330b287199c80228e665a53881298 } - v.Op = OpConstBool + c := v.Args[1].AuxInt + v.Op = OpLsh32x64 v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = 0 + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = int64(uint32(c)) + v.AddArg(v0) return true } - goto end3713a608cffd29b40ff7c3b3f2585cbb -end3713a608cffd29b40ff7c3b3f2585cbb: + goto endc1a330b287199c80228e665a53881298 +endc1a330b287199c80228e665a53881298: ; - // match: (Neq32 (Const32 [c]) (Add32 (Const32 [d]) x)) + return false +} +func rewriteValuegeneric_OpLsh32x64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Lsh32x64 (Const32 [c]) (Const64 [d])) // cond: - // result: (Neq32 (Const32 [c-d]) x) + // result: (Const32 [int64(int32(c) << uint64(d))]) { if v.Args[0].Op != OpConst32 { - goto end93fc3b4a3639b965b414891111b16245 + goto end5896bd9a3fe78f1e1712563642d33254 } - t := v.Args[0].Type c := v.Args[0].AuxInt - if v.Args[1].Op != OpAdd32 { - goto end93fc3b4a3639b965b414891111b16245 + if v.Args[1].Op != OpConst64 { + goto end5896bd9a3fe78f1e1712563642d33254 } - if v.Args[1].Args[0].Op != OpConst32 { - goto end93fc3b4a3639b965b414891111b16245 + d := v.Args[1].AuxInt + v.Op = OpConst32 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = int64(int32(c) << uint64(d)) + return true + } + goto end5896bd9a3fe78f1e1712563642d33254 +end5896bd9a3fe78f1e1712563642d33254: + ; + // match: (Lsh32x64 x (Const64 [0])) + // cond: + // result: x + { + x := v.Args[0] + if v.Args[1].Op != OpConst64 { + goto endd9ce9639a91b11e601823be3d4d6c209 } - if v.Args[1].Args[0].Type != v.Args[0].Type { - goto end93fc3b4a3639b965b414891111b16245 + if v.Args[1].AuxInt != 0 { + goto endd9ce9639a91b11e601823be3d4d6c209 } - d := v.Args[1].Args[0].AuxInt - x := v.Args[1].Args[1] - v.Op = OpNeq32 + v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpConst32, TypeInvalid) - v0.Type = t - v0.AuxInt = c - d - v.AddArg(v0) + v.Type = x.Type v.AddArg(x) return true } - goto end93fc3b4a3639b965b414891111b16245 -end93fc3b4a3639b965b414891111b16245: + goto endd9ce9639a91b11e601823be3d4d6c209 +endd9ce9639a91b11e601823be3d4d6c209: ; - // match: (Neq32 x (Const32 [c])) - // cond: x.Op != OpConst32 - // result: (Neq32 (Const32 [c]) x) + // match: (Lsh32x64 _ (Const64 [c])) + // cond: uint64(c) >= 32 + // result: (Const64 [0]) { - x := v.Args[0] - if v.Args[1].Op != OpConst32 { - goto end5376f9ab90e282450f49011d0e0ce236 + if v.Args[1].Op != OpConst64 { + goto end81247a2423f489be15859d3930738fdf } - t := v.Args[1].Type c := v.Args[1].AuxInt - if !(x.Op != OpConst32) { - goto end5376f9ab90e282450f49011d0e0ce236 + if !(uint64(c) >= 32) { + goto end81247a2423f489be15859d3930738fdf } - v.Op = OpNeq32 + v.Op = OpConst64 v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpConst32, TypeInvalid) - v0.Type = t - v0.AuxInt = c - v.AddArg(v0) - v.AddArg(x) + v.AuxInt = 0 return true } - goto end5376f9ab90e282450f49011d0e0ce236 -end5376f9ab90e282450f49011d0e0ce236: + goto end81247a2423f489be15859d3930738fdf +end81247a2423f489be15859d3930738fdf: ; - // match: (Neq32 (Const32 [c]) (Const32 [d])) - // cond: - // result: (ConstBool [b2i(int32(c) != int32(d))]) + // match: (Lsh32x64 (Lsh32x64 x (Const64 [c])) (Const64 [d])) + // cond: !uaddOvf(c,d) + // result: (Lsh32x64 x (Const64 [c+d])) { - if v.Args[0].Op != OpConst32 { - goto endf9f3d0814854d2d0879d331e9bdfcae2 + t := v.Type + if v.Args[0].Op != OpLsh32x64 { + goto endf96a7c9571797fe61a5b63a4923d7e6e } - c := v.Args[0].AuxInt - if v.Args[1].Op != OpConst32 { - goto endf9f3d0814854d2d0879d331e9bdfcae2 + x := v.Args[0].Args[0] + if v.Args[0].Args[1].Op != OpConst64 { + goto endf96a7c9571797fe61a5b63a4923d7e6e + } + c := v.Args[0].Args[1].AuxInt + if v.Args[1].Op != OpConst64 { + goto endf96a7c9571797fe61a5b63a4923d7e6e } d := v.Args[1].AuxInt - v.Op = OpConstBool + if !(!uaddOvf(c, d)) { + goto endf96a7c9571797fe61a5b63a4923d7e6e + } + v.Op = OpLsh32x64 v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = b2i(int32(c) != int32(d)) + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = c + d + v.AddArg(v0) return true } - goto endf9f3d0814854d2d0879d331e9bdfcae2 -endf9f3d0814854d2d0879d331e9bdfcae2: + goto endf96a7c9571797fe61a5b63a4923d7e6e +endf96a7c9571797fe61a5b63a4923d7e6e: ; return false } -func rewriteValuegeneric_OpNeq64(v *Value, config *Config) bool { +func rewriteValuegeneric_OpLsh32x8(v *Value, config *Config) bool { b := v.Block _ = b - // match: (Neq64 x x) + // match: (Lsh32x8 x (Const8 [c])) // cond: - // result: (ConstBool [0]) + // result: (Lsh32x64 x (Const64 [int64(uint8(c))])) { + t := v.Type x := v.Args[0] - if v.Args[1] != x { - goto end3601ad382705ea12b79d2008c1e5725c + if v.Args[1].Op != OpConst8 { + goto end1759d7c25a5bcda288e34d1d197c0b8f } - v.Op = OpConstBool + c := v.Args[1].AuxInt + v.Op = OpLsh32x64 v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = int64(uint8(c)) + v.AddArg(v0) + return true + } + goto end1759d7c25a5bcda288e34d1d197c0b8f +end1759d7c25a5bcda288e34d1d197c0b8f: + ; + return false +} +func rewriteValuegeneric_OpLsh64x16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Lsh64x16 x (Const16 [c])) + // cond: + // result: (Lsh64x64 x (Const64 [int64(uint16(c))])) + { + t := v.Type + x := v.Args[0] + if v.Args[1].Op != OpConst16 { + goto enda649fbb5e14490c9eea9616550a76b5c + } + c := v.Args[1].AuxInt + v.Op = OpLsh64x64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = int64(uint16(c)) + v.AddArg(v0) + return true + } + goto enda649fbb5e14490c9eea9616550a76b5c +enda649fbb5e14490c9eea9616550a76b5c: + ; + return false +} +func rewriteValuegeneric_OpLsh64x32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Lsh64x32 x (Const32 [c])) + // cond: + // result: (Lsh64x64 x (Const64 [int64(uint32(c))])) + { + t := v.Type + x := v.Args[0] + if v.Args[1].Op != OpConst32 { + goto end40069675cde851a63cce81b1b02751f9 + } + c := v.Args[1].AuxInt + v.Op = OpLsh64x64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = int64(uint32(c)) + v.AddArg(v0) + return true + } + goto end40069675cde851a63cce81b1b02751f9 +end40069675cde851a63cce81b1b02751f9: + ; + 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)]) + { + if v.Args[0].Op != OpConst64 { + goto end9c157a23e021f659f1568566435ed57b + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst64 { + goto end9c157a23e021f659f1568566435ed57b + } + d := v.Args[1].AuxInt + v.Op = OpConst64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c << uint64(d) + return true + } + goto end9c157a23e021f659f1568566435ed57b +end9c157a23e021f659f1568566435ed57b: + ; + // match: (Lsh64x64 x (Const64 [0])) + // cond: + // result: x + { + x := v.Args[0] + if v.Args[1].Op != OpConst64 { + goto end9f18ca0556dbb4b50fe888273fab20ca + } + if v.Args[1].AuxInt != 0 { + goto end9f18ca0556dbb4b50fe888273fab20ca + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end9f18ca0556dbb4b50fe888273fab20ca +end9f18ca0556dbb4b50fe888273fab20ca: + ; + // match: (Lsh64x64 _ (Const64 [c])) + // cond: uint64(c) >= 64 + // result: (Const64 [0]) + { + if v.Args[1].Op != OpConst64 { + goto end33da2e0ce5ca3e0554564477ef422402 + } + c := v.Args[1].AuxInt + if !(uint64(c) >= 64) { + goto end33da2e0ce5ca3e0554564477ef422402 + } + v.Op = OpConst64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end33da2e0ce5ca3e0554564477ef422402 +end33da2e0ce5ca3e0554564477ef422402: + ; + // match: (Lsh64x64 (Lsh64x64 x (Const64 [c])) (Const64 [d])) + // cond: !uaddOvf(c,d) + // result: (Lsh64x64 x (Const64 [c+d])) + { + t := v.Type + if v.Args[0].Op != OpLsh64x64 { + goto end001c62ee580a700ec7b07ccaa3740ac2 + } + x := v.Args[0].Args[0] + if v.Args[0].Args[1].Op != OpConst64 { + goto end001c62ee580a700ec7b07ccaa3740ac2 + } + c := v.Args[0].Args[1].AuxInt + if v.Args[1].Op != OpConst64 { + goto end001c62ee580a700ec7b07ccaa3740ac2 + } + d := v.Args[1].AuxInt + if !(!uaddOvf(c, d)) { + goto end001c62ee580a700ec7b07ccaa3740ac2 + } + v.Op = OpLsh64x64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = c + d + v.AddArg(v0) + return true + } + goto end001c62ee580a700ec7b07ccaa3740ac2 +end001c62ee580a700ec7b07ccaa3740ac2: + ; + return false +} +func rewriteValuegeneric_OpLsh64x8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Lsh64x8 x (Const8 [c])) + // cond: + // result: (Lsh64x64 x (Const64 [int64(uint8(c))])) + { + t := v.Type + x := v.Args[0] + if v.Args[1].Op != OpConst8 { + goto end4d9224069abdade8e405df343938d932 + } + c := v.Args[1].AuxInt + v.Op = OpLsh64x64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = int64(uint8(c)) + v.AddArg(v0) + return true + } + goto end4d9224069abdade8e405df343938d932 +end4d9224069abdade8e405df343938d932: + ; + return false +} +func rewriteValuegeneric_OpLsh8x16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Lsh8x16 x (Const16 [c])) + // cond: + // result: (Lsh8x64 x (Const64 [int64(uint16(c))])) + { + t := v.Type + x := v.Args[0] + if v.Args[1].Op != OpConst16 { + goto end0ad4a82e2eb4c7ca7407d79ec3aa5142 + } + c := v.Args[1].AuxInt + v.Op = OpLsh8x64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = int64(uint16(c)) + v.AddArg(v0) + return true + } + goto end0ad4a82e2eb4c7ca7407d79ec3aa5142 +end0ad4a82e2eb4c7ca7407d79ec3aa5142: + ; + return false +} +func rewriteValuegeneric_OpLsh8x32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Lsh8x32 x (Const32 [c])) + // cond: + // result: (Lsh8x64 x (Const64 [int64(uint32(c))])) + { + t := v.Type + x := v.Args[0] + if v.Args[1].Op != OpConst32 { + goto enddaacda113ecc79fe0621fd22ebc548dd + } + c := v.Args[1].AuxInt + v.Op = OpLsh8x64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = int64(uint32(c)) + v.AddArg(v0) + return true + } + goto enddaacda113ecc79fe0621fd22ebc548dd +enddaacda113ecc79fe0621fd22ebc548dd: + ; + 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))]) + { + if v.Args[0].Op != OpConst8 { + goto endbc3297ea9642b97eb71f0a9735048d7b + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst64 { + goto endbc3297ea9642b97eb71f0a9735048d7b + } + d := v.Args[1].AuxInt + v.Op = OpConst8 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = int64(int8(c) << uint64(d)) + return true + } + goto endbc3297ea9642b97eb71f0a9735048d7b +endbc3297ea9642b97eb71f0a9735048d7b: + ; + // match: (Lsh8x64 x (Const64 [0])) + // cond: + // result: x + { + x := v.Args[0] + if v.Args[1].Op != OpConst64 { + goto end715f3db41cccf963e25a20c33f618a04 + } + if v.Args[1].AuxInt != 0 { + goto end715f3db41cccf963e25a20c33f618a04 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end715f3db41cccf963e25a20c33f618a04 +end715f3db41cccf963e25a20c33f618a04: + ; + // match: (Lsh8x64 _ (Const64 [c])) + // cond: uint64(c) >= 8 + // result: (Const64 [0]) + { + if v.Args[1].Op != OpConst64 { + goto endb6749df4d0cdc0cd9acc627187d73488 + } + c := v.Args[1].AuxInt + if !(uint64(c) >= 8) { + goto endb6749df4d0cdc0cd9acc627187d73488 + } + v.Op = OpConst64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto endb6749df4d0cdc0cd9acc627187d73488 +endb6749df4d0cdc0cd9acc627187d73488: + ; + // match: (Lsh8x64 (Lsh8x64 x (Const64 [c])) (Const64 [d])) + // cond: !uaddOvf(c,d) + // result: (Lsh8x64 x (Const64 [c+d])) + { + t := v.Type + if v.Args[0].Op != OpLsh8x64 { + goto end73a4878b6bbd21c9e22fb99226ef947e + } + x := v.Args[0].Args[0] + if v.Args[0].Args[1].Op != OpConst64 { + goto end73a4878b6bbd21c9e22fb99226ef947e + } + c := v.Args[0].Args[1].AuxInt + if v.Args[1].Op != OpConst64 { + goto end73a4878b6bbd21c9e22fb99226ef947e + } + d := v.Args[1].AuxInt + if !(!uaddOvf(c, d)) { + goto end73a4878b6bbd21c9e22fb99226ef947e + } + v.Op = OpLsh8x64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = c + d + v.AddArg(v0) + return true + } + goto end73a4878b6bbd21c9e22fb99226ef947e +end73a4878b6bbd21c9e22fb99226ef947e: + ; + return false +} +func rewriteValuegeneric_OpLsh8x8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Lsh8x8 x (Const8 [c])) + // cond: + // result: (Lsh8x64 x (Const64 [int64(uint8(c))])) + { + t := v.Type + x := v.Args[0] + if v.Args[1].Op != OpConst8 { + goto end8b770597435467b0c96014624d522b33 + } + c := v.Args[1].AuxInt + v.Op = OpLsh8x64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = int64(uint8(c)) + v.AddArg(v0) + return true + } + goto end8b770597435467b0c96014624d522b33 +end8b770597435467b0c96014624d522b33: + ; + 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]) + { + if v.Args[0].Op != OpConst16 { + goto ende8dd468add3015aea24531cf3c89ccb7 + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst16 { + goto ende8dd468add3015aea24531cf3c89ccb7 + } + d := v.Args[1].AuxInt + v.Op = OpConst16 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c * d + return true + } + goto ende8dd468add3015aea24531cf3c89ccb7 +ende8dd468add3015aea24531cf3c89ccb7: + ; + 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]) + { + if v.Args[0].Op != OpConst32 { + goto end60b4523099fa7b55e2e872e05bd497a7 + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst32 { + goto end60b4523099fa7b55e2e872e05bd497a7 + } + d := v.Args[1].AuxInt + v.Op = OpConst32 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c * d + return true + } + goto end60b4523099fa7b55e2e872e05bd497a7 +end60b4523099fa7b55e2e872e05bd497a7: + ; + 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]) + { + if v.Args[0].Op != OpConst64 { + goto end7aea1048b5d1230974b97f17238380ae + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst64 { + goto end7aea1048b5d1230974b97f17238380ae + } + d := v.Args[1].AuxInt + v.Op = OpConst64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c * d + return true + } + goto end7aea1048b5d1230974b97f17238380ae +end7aea1048b5d1230974b97f17238380ae: + ; + 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]) + { + if v.Args[0].Op != OpConst8 { + goto end2f1952fd654c4a62ff00511041728809 + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst8 { + goto end2f1952fd654c4a62ff00511041728809 + } + d := v.Args[1].AuxInt + v.Op = OpConst8 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c * d + return true + } + goto end2f1952fd654c4a62ff00511041728809 +end2f1952fd654c4a62ff00511041728809: + ; + return false +} +func rewriteValuegeneric_OpNeq16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Neq16 x x) + // cond: + // result: (ConstBool [0]) + { + x := v.Args[0] + if v.Args[1] != x { + goto ende76a50b524aeb16c7aeccf5f5cc60c06 + } + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto ende76a50b524aeb16c7aeccf5f5cc60c06 +ende76a50b524aeb16c7aeccf5f5cc60c06: + ; + // match: (Neq16 (Const16 [c]) (Add16 (Const16 [d]) x)) + // cond: + // result: (Neq16 (Const16 [c-d]) x) + { + if v.Args[0].Op != OpConst16 { + goto end552011bd97e6f92ebc2672aa1843eadd + } + t := v.Args[0].Type + c := v.Args[0].AuxInt + if v.Args[1].Op != OpAdd16 { + goto end552011bd97e6f92ebc2672aa1843eadd + } + if v.Args[1].Args[0].Op != OpConst16 { + goto end552011bd97e6f92ebc2672aa1843eadd + } + if v.Args[1].Args[0].Type != v.Args[0].Type { + goto end552011bd97e6f92ebc2672aa1843eadd + } + d := v.Args[1].Args[0].AuxInt + x := v.Args[1].Args[1] + v.Op = OpNeq16 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpConst16, t) + v0.AuxInt = c - d + v.AddArg(v0) + v.AddArg(x) + return true + } + goto end552011bd97e6f92ebc2672aa1843eadd +end552011bd97e6f92ebc2672aa1843eadd: + ; + // match: (Neq16 x (Const16 [c])) + // cond: x.Op != OpConst16 + // result: (Neq16 (Const16 [c]) x) + { + x := v.Args[0] + if v.Args[1].Op != OpConst16 { + goto end0e45958f29e87997f632248aa9ee97e0 + } + t := v.Args[1].Type + c := v.Args[1].AuxInt + if !(x.Op != OpConst16) { + goto end0e45958f29e87997f632248aa9ee97e0 + } + v.Op = OpNeq16 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpConst16, t) + v0.AuxInt = c + v.AddArg(v0) + v.AddArg(x) + return true + } + goto end0e45958f29e87997f632248aa9ee97e0 +end0e45958f29e87997f632248aa9ee97e0: + ; + // match: (Neq16 (Const16 [c]) (Const16 [d])) + // cond: + // result: (ConstBool [b2i(int16(c) != int16(d))]) + { + if v.Args[0].Op != OpConst16 { + goto end6302c9b645bb191982d28c2f846904d6 + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst16 { + goto end6302c9b645bb191982d28c2f846904d6 + } + d := v.Args[1].AuxInt + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = b2i(int16(c) != int16(d)) + return true + } + goto end6302c9b645bb191982d28c2f846904d6 +end6302c9b645bb191982d28c2f846904d6: + ; + return false +} +func rewriteValuegeneric_OpNeq32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Neq32 x x) + // cond: + // result: (ConstBool [0]) + { + x := v.Args[0] + if v.Args[1] != x { + goto end3713a608cffd29b40ff7c3b3f2585cbb + } + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end3713a608cffd29b40ff7c3b3f2585cbb +end3713a608cffd29b40ff7c3b3f2585cbb: + ; + // match: (Neq32 (Const32 [c]) (Add32 (Const32 [d]) x)) + // cond: + // result: (Neq32 (Const32 [c-d]) x) + { + if v.Args[0].Op != OpConst32 { + goto end93fc3b4a3639b965b414891111b16245 + } + t := v.Args[0].Type + c := v.Args[0].AuxInt + if v.Args[1].Op != OpAdd32 { + goto end93fc3b4a3639b965b414891111b16245 + } + if v.Args[1].Args[0].Op != OpConst32 { + goto end93fc3b4a3639b965b414891111b16245 + } + if v.Args[1].Args[0].Type != v.Args[0].Type { + goto end93fc3b4a3639b965b414891111b16245 + } + d := v.Args[1].Args[0].AuxInt + x := v.Args[1].Args[1] + v.Op = OpNeq32 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpConst32, t) + v0.AuxInt = c - d + v.AddArg(v0) + v.AddArg(x) + return true + } + goto end93fc3b4a3639b965b414891111b16245 +end93fc3b4a3639b965b414891111b16245: + ; + // match: (Neq32 x (Const32 [c])) + // cond: x.Op != OpConst32 + // result: (Neq32 (Const32 [c]) x) + { + x := v.Args[0] + if v.Args[1].Op != OpConst32 { + goto end5376f9ab90e282450f49011d0e0ce236 + } + t := v.Args[1].Type + c := v.Args[1].AuxInt + if !(x.Op != OpConst32) { + goto end5376f9ab90e282450f49011d0e0ce236 + } + v.Op = OpNeq32 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpConst32, t) + v0.AuxInt = c + v.AddArg(v0) + v.AddArg(x) + return true + } + goto end5376f9ab90e282450f49011d0e0ce236 +end5376f9ab90e282450f49011d0e0ce236: + ; + // match: (Neq32 (Const32 [c]) (Const32 [d])) + // cond: + // result: (ConstBool [b2i(int32(c) != int32(d))]) + { + if v.Args[0].Op != OpConst32 { + goto endf9f3d0814854d2d0879d331e9bdfcae2 + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst32 { + goto endf9f3d0814854d2d0879d331e9bdfcae2 + } + d := v.Args[1].AuxInt + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = b2i(int32(c) != int32(d)) + return true + } + goto endf9f3d0814854d2d0879d331e9bdfcae2 +endf9f3d0814854d2d0879d331e9bdfcae2: + ; + return false +} +func rewriteValuegeneric_OpNeq64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Neq64 x x) + // cond: + // result: (ConstBool [0]) + { + x := v.Args[0] + if v.Args[1] != x { + goto end3601ad382705ea12b79d2008c1e5725c + } + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end3601ad382705ea12b79d2008c1e5725c +end3601ad382705ea12b79d2008c1e5725c: + ; + // match: (Neq64 (Const64 [c]) (Add64 (Const64 [d]) x)) + // cond: + // result: (Neq64 (Const64 [c-d]) x) + { + if v.Args[0].Op != OpConst64 { + goto enda3d39cad13a557a2aa6d086f43596c1b + } + t := v.Args[0].Type + c := v.Args[0].AuxInt + if v.Args[1].Op != OpAdd64 { + goto enda3d39cad13a557a2aa6d086f43596c1b + } + if v.Args[1].Args[0].Op != OpConst64 { + goto enda3d39cad13a557a2aa6d086f43596c1b + } + if v.Args[1].Args[0].Type != v.Args[0].Type { + goto enda3d39cad13a557a2aa6d086f43596c1b + } + d := v.Args[1].Args[0].AuxInt + x := v.Args[1].Args[1] + v.Op = OpNeq64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = c - d + v.AddArg(v0) + v.AddArg(x) + return true + } + goto enda3d39cad13a557a2aa6d086f43596c1b +enda3d39cad13a557a2aa6d086f43596c1b: + ; + // match: (Neq64 x (Const64 [c])) + // cond: x.Op != OpConst64 + // result: (Neq64 (Const64 [c]) x) + { + x := v.Args[0] + if v.Args[1].Op != OpConst64 { + goto end0936a57de20373ca6cacb9506ddde708 + } + t := v.Args[1].Type + c := v.Args[1].AuxInt + if !(x.Op != OpConst64) { + goto end0936a57de20373ca6cacb9506ddde708 + } + v.Op = OpNeq64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = c + v.AddArg(v0) + v.AddArg(x) + return true + } + goto end0936a57de20373ca6cacb9506ddde708 +end0936a57de20373ca6cacb9506ddde708: + ; + // match: (Neq64 (Const64 [c]) (Const64 [d])) + // cond: + // result: (ConstBool [b2i(int64(c) != int64(d))]) + { + if v.Args[0].Op != OpConst64 { + goto endf07433ecd3c150b1b75e943aa44a7203 + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst64 { + goto endf07433ecd3c150b1b75e943aa44a7203 + } + d := v.Args[1].AuxInt + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = b2i(int64(c) != int64(d)) + return true + } + goto endf07433ecd3c150b1b75e943aa44a7203 +endf07433ecd3c150b1b75e943aa44a7203: + ; + return false +} +func rewriteValuegeneric_OpNeq8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Neq8 x x) + // cond: + // result: (ConstBool [0]) + { + x := v.Args[0] + if v.Args[1] != x { + goto end09a0deaf3c42627d0d2d3efa96e30745 + } + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end09a0deaf3c42627d0d2d3efa96e30745 +end09a0deaf3c42627d0d2d3efa96e30745: + ; + // match: (Neq8 (Const8 [c]) (Add8 (Const8 [d]) x)) + // cond: + // result: (Neq8 (Const8 [c-d]) x) + { + if v.Args[0].Op != OpConst8 { + goto endc8f853c610c460c887cbfdca958e3691 + } + t := v.Args[0].Type + c := v.Args[0].AuxInt + if v.Args[1].Op != OpAdd8 { + goto endc8f853c610c460c887cbfdca958e3691 + } + if v.Args[1].Args[0].Op != OpConst8 { + goto endc8f853c610c460c887cbfdca958e3691 + } + if v.Args[1].Args[0].Type != v.Args[0].Type { + goto endc8f853c610c460c887cbfdca958e3691 + } + d := v.Args[1].Args[0].AuxInt + x := v.Args[1].Args[1] + v.Op = OpNeq8 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpConst8, t) + v0.AuxInt = c - d + v.AddArg(v0) + v.AddArg(x) + return true + } + goto endc8f853c610c460c887cbfdca958e3691 +endc8f853c610c460c887cbfdca958e3691: + ; + // match: (Neq8 x (Const8 [c])) + // cond: x.Op != OpConst8 + // result: (Neq8 (Const8 [c]) x) + { + x := v.Args[0] + if v.Args[1].Op != OpConst8 { + goto end04dc0ae2b08cf0447b50e5b8ef469252 + } + t := v.Args[1].Type + c := v.Args[1].AuxInt + if !(x.Op != OpConst8) { + goto end04dc0ae2b08cf0447b50e5b8ef469252 + } + v.Op = OpNeq8 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v0 := b.NewValue0(v.Line, OpConst8, t) + v0.AuxInt = c + v.AddArg(v0) + v.AddArg(x) + return true + } + goto end04dc0ae2b08cf0447b50e5b8ef469252 +end04dc0ae2b08cf0447b50e5b8ef469252: + ; + // match: (Neq8 (Const8 [c]) (Const8 [d])) + // cond: + // result: (ConstBool [b2i(int8(c) != int8(d))]) + { + if v.Args[0].Op != OpConst8 { + goto end72ebdaf2de9b3aa57cf0cb8e068b5f9c + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst8 { + goto end72ebdaf2de9b3aa57cf0cb8e068b5f9c + } + d := v.Args[1].AuxInt + v.Op = OpConstBool + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = b2i(int8(c) != int8(d)) + return true + } + goto end72ebdaf2de9b3aa57cf0cb8e068b5f9c +end72ebdaf2de9b3aa57cf0cb8e068b5f9c: + ; + 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)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpNeqPtr + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + 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 + } + goto end17b2333bf57e9fe81a671be02f9c4c14 +end17b2333bf57e9fe81a671be02f9c4c14: + ; + return false +} +func rewriteValuegeneric_OpNeqPtr(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (NeqPtr p (ConstNil)) + // cond: + // result: (IsNonNil p) + { + p := v.Args[0] + if v.Args[1].Op != OpConstNil { + goto endba798520b4d41172b110347158c44791 + } + v.Op = OpIsNonNil + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(p) + return true + } + goto endba798520b4d41172b110347158c44791 +endba798520b4d41172b110347158c44791: + ; + // match: (NeqPtr (ConstNil) p) + // cond: + // result: (IsNonNil p) + { + if v.Args[0].Op != OpConstNil { + goto enddd95e9c3606d9fd48034f1a703561e45 + } + p := v.Args[1] + v.Op = OpIsNonNil + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(p) + return true + } + goto enddd95e9c3606d9fd48034f1a703561e45 +enddd95e9c3606d9fd48034f1a703561e45: + ; + 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)) + { + x := v.Args[0] + y := v.Args[1] + v.Op = OpNeqPtr + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + 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 + } + goto endc6bc83c506e491236ca66ea1081231a2 +endc6bc83c506e491236ca66ea1081231a2: + ; + return false +} +func rewriteValuegeneric_OpOr16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Or16 x x) + // cond: + // result: x + { + x := v.Args[0] + if v.Args[1] != x { + goto end47a2f25fd31a76807aced3e2b126acdc + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end47a2f25fd31a76807aced3e2b126acdc +end47a2f25fd31a76807aced3e2b126acdc: + ; + return false +} +func rewriteValuegeneric_OpOr32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Or32 x x) + // cond: + // result: x + { + x := v.Args[0] + if v.Args[1] != x { + goto end231e283e568e90bd9a3e6a4fa328c8a4 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end231e283e568e90bd9a3e6a4fa328c8a4 +end231e283e568e90bd9a3e6a4fa328c8a4: + ; + return false +} +func rewriteValuegeneric_OpOr64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Or64 x x) + // cond: + // result: x + { + x := v.Args[0] + if v.Args[1] != x { + goto end6b0efc212016dc97d0e3939db04c81d9 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end6b0efc212016dc97d0e3939db04c81d9 +end6b0efc212016dc97d0e3939db04c81d9: + ; + return false +} +func rewriteValuegeneric_OpOr8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Or8 x x) + // cond: + // result: x + { + x := v.Args[0] + if v.Args[1] != x { + goto end05295dbfafd6869af79b4daee9fda000 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end05295dbfafd6869af79b4daee9fda000 +end05295dbfafd6869af79b4daee9fda000: + ; + return false +} +func rewriteValuegeneric_OpPtrIndex(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (PtrIndex ptr idx) + // cond: config.PtrSize == 4 + // result: (AddPtr ptr (Mul32 idx (Const32 [t.Elem().Size()]))) + { + t := v.Type + ptr := v.Args[0] + idx := v.Args[1] + if !(config.PtrSize == 4) { + goto endd902622aaa1e7545b5a2a0c08b47d287 + } + v.Op = OpAddPtr + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + 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 + } + goto endd902622aaa1e7545b5a2a0c08b47d287 +endd902622aaa1e7545b5a2a0c08b47d287: + ; + // match: (PtrIndex ptr idx) + // cond: config.PtrSize == 8 + // result: (AddPtr ptr (Mul64 idx (Const64 [t.Elem().Size()]))) + { + t := v.Type + ptr := v.Args[0] + idx := v.Args[1] + if !(config.PtrSize == 8) { + goto end47a5f1d1b158914fa383de024bbe3b08 + } + v.Op = OpAddPtr + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + 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 + } + goto end47a5f1d1b158914fa383de024bbe3b08 +end47a5f1d1b158914fa383de024bbe3b08: + ; + return false +} +func rewriteValuegeneric_OpRsh16Ux16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh16Ux16 x (Const16 [c])) + // cond: + // result: (Rsh16Ux64 x (Const64 [int64(uint16(c))])) + { + t := v.Type + x := v.Args[0] + if v.Args[1].Op != OpConst16 { + goto endd981df40f353104ef828d13ad4ccdf02 + } + c := v.Args[1].AuxInt + v.Op = OpRsh16Ux64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = int64(uint16(c)) + v.AddArg(v0) + return true + } + goto endd981df40f353104ef828d13ad4ccdf02 +endd981df40f353104ef828d13ad4ccdf02: + ; + return false +} +func rewriteValuegeneric_OpRsh16Ux32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh16Ux32 x (Const32 [c])) + // cond: + // result: (Rsh16Ux64 x (Const64 [int64(uint32(c))])) + { + t := v.Type + x := v.Args[0] + if v.Args[1].Op != OpConst32 { + goto ende0be9ee562725206dcf96d3e5750b5ea + } + c := v.Args[1].AuxInt + v.Op = OpRsh16Ux64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = int64(uint32(c)) + v.AddArg(v0) + return true + } + goto ende0be9ee562725206dcf96d3e5750b5ea +ende0be9ee562725206dcf96d3e5750b5ea: + ; + 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))]) + { + if v.Args[0].Op != OpConst16 { + goto ended17f40375fb44bcbaf2d87161c5ed3c + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst64 { + goto ended17f40375fb44bcbaf2d87161c5ed3c + } + d := v.Args[1].AuxInt + v.Op = OpConst16 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = int64(uint16(c) >> uint64(d)) + return true + } + goto ended17f40375fb44bcbaf2d87161c5ed3c +ended17f40375fb44bcbaf2d87161c5ed3c: + ; + // match: (Rsh16Ux64 x (Const64 [0])) + // cond: + // result: x + { + x := v.Args[0] + if v.Args[1].Op != OpConst64 { + goto end752d1b5a60f87afa7e40febbf1bce309 + } + if v.Args[1].AuxInt != 0 { + goto end752d1b5a60f87afa7e40febbf1bce309 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end752d1b5a60f87afa7e40febbf1bce309 +end752d1b5a60f87afa7e40febbf1bce309: + ; + // match: (Rsh16Ux64 _ (Const64 [c])) + // cond: uint64(c) >= 16 + // result: (Const64 [0]) + { + if v.Args[1].Op != OpConst64 { + goto endca5c7ae2e51f2ae32486c2b1a3033b77 + } + c := v.Args[1].AuxInt + if !(uint64(c) >= 16) { + goto endca5c7ae2e51f2ae32486c2b1a3033b77 + } + v.Op = OpConst64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto endca5c7ae2e51f2ae32486c2b1a3033b77 +endca5c7ae2e51f2ae32486c2b1a3033b77: + ; + // match: (Rsh16Ux64 (Rsh16Ux64 x (Const64 [c])) (Const64 [d])) + // cond: !uaddOvf(c,d) + // result: (Rsh16Ux64 x (Const64 [c+d])) + { + t := v.Type + if v.Args[0].Op != OpRsh16Ux64 { + goto end56f2c0034c9fbe651abb36fb640af465 + } + x := v.Args[0].Args[0] + if v.Args[0].Args[1].Op != OpConst64 { + goto end56f2c0034c9fbe651abb36fb640af465 + } + c := v.Args[0].Args[1].AuxInt + if v.Args[1].Op != OpConst64 { + goto end56f2c0034c9fbe651abb36fb640af465 + } + d := v.Args[1].AuxInt + if !(!uaddOvf(c, d)) { + goto end56f2c0034c9fbe651abb36fb640af465 + } + v.Op = OpRsh16Ux64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = c + d + v.AddArg(v0) + return true + } + goto end56f2c0034c9fbe651abb36fb640af465 +end56f2c0034c9fbe651abb36fb640af465: + ; + return false +} +func rewriteValuegeneric_OpRsh16Ux8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh16Ux8 x (Const8 [c])) + // cond: + // result: (Rsh16Ux64 x (Const64 [int64(uint8(c))])) + { + t := v.Type + x := v.Args[0] + if v.Args[1].Op != OpConst8 { + goto end20d4667094c32c71bac4e0805dab85c9 + } + c := v.Args[1].AuxInt + v.Op = OpRsh16Ux64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = int64(uint8(c)) + v.AddArg(v0) + return true + } + goto end20d4667094c32c71bac4e0805dab85c9 +end20d4667094c32c71bac4e0805dab85c9: + ; + return false +} +func rewriteValuegeneric_OpRsh16x16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh16x16 x (Const16 [c])) + // cond: + // result: (Rsh16x64 x (Const64 [int64(uint16(c))])) + { + t := v.Type + x := v.Args[0] + if v.Args[1].Op != OpConst16 { + goto end1b501c7ae2fe58ad3a88b467f2d95389 + } + c := v.Args[1].AuxInt + v.Op = OpRsh16x64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = int64(uint16(c)) + v.AddArg(v0) + return true + } + goto end1b501c7ae2fe58ad3a88b467f2d95389 +end1b501c7ae2fe58ad3a88b467f2d95389: + ; + return false +} +func rewriteValuegeneric_OpRsh16x32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh16x32 x (Const32 [c])) + // cond: + // result: (Rsh16x64 x (Const64 [int64(uint32(c))])) + { + t := v.Type + x := v.Args[0] + if v.Args[1].Op != OpConst32 { + goto end4d3a41113d2d0b09924bf5759ca49cab + } + c := v.Args[1].AuxInt + v.Op = OpRsh16x64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = int64(uint32(c)) + v.AddArg(v0) + return true + } + goto end4d3a41113d2d0b09924bf5759ca49cab +end4d3a41113d2d0b09924bf5759ca49cab: + ; + 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))]) + { + if v.Args[0].Op != OpConst16 { + goto end8f05fede35a3d2f687fcd4a5829a25ad + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst64 { + goto end8f05fede35a3d2f687fcd4a5829a25ad + } + d := v.Args[1].AuxInt + v.Op = OpConst16 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = int64(int16(c) >> uint64(d)) + return true + } + goto end8f05fede35a3d2f687fcd4a5829a25ad +end8f05fede35a3d2f687fcd4a5829a25ad: + ; + // match: (Rsh16x64 x (Const64 [0])) + // cond: + // result: x + { + x := v.Args[0] + if v.Args[1].Op != OpConst64 { + goto end750fafe01fcc689d953101d53efc19ab + } + if v.Args[1].AuxInt != 0 { + goto end750fafe01fcc689d953101d53efc19ab + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end750fafe01fcc689d953101d53efc19ab +end750fafe01fcc689d953101d53efc19ab: + ; + // match: (Rsh16x64 (Rsh16x64 x (Const64 [c])) (Const64 [d])) + // cond: !uaddOvf(c,d) + // result: (Rsh16x64 x (Const64 [c+d])) + { + t := v.Type + if v.Args[0].Op != OpRsh16x64 { + goto endf425eff9e05aad27194af957e3383c76 + } + x := v.Args[0].Args[0] + if v.Args[0].Args[1].Op != OpConst64 { + goto endf425eff9e05aad27194af957e3383c76 + } + c := v.Args[0].Args[1].AuxInt + if v.Args[1].Op != OpConst64 { + goto endf425eff9e05aad27194af957e3383c76 + } + d := v.Args[1].AuxInt + if !(!uaddOvf(c, d)) { + goto endf425eff9e05aad27194af957e3383c76 + } + v.Op = OpRsh16x64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = c + d + v.AddArg(v0) + return true + } + goto endf425eff9e05aad27194af957e3383c76 +endf425eff9e05aad27194af957e3383c76: + ; + return false +} +func rewriteValuegeneric_OpRsh16x8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh16x8 x (Const8 [c])) + // cond: + // result: (Rsh16x64 x (Const64 [int64(uint8(c))])) + { + t := v.Type + x := v.Args[0] + if v.Args[1].Op != OpConst8 { + goto end0b5e274d62a3ae8df9f4089756c6a9d4 + } + c := v.Args[1].AuxInt + v.Op = OpRsh16x64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = int64(uint8(c)) + v.AddArg(v0) + return true + } + goto end0b5e274d62a3ae8df9f4089756c6a9d4 +end0b5e274d62a3ae8df9f4089756c6a9d4: + ; + return false +} +func rewriteValuegeneric_OpRsh32Ux16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh32Ux16 x (Const16 [c])) + // cond: + // result: (Rsh32Ux64 x (Const64 [int64(uint16(c))])) + { + t := v.Type + x := v.Args[0] + if v.Args[1].Op != OpConst16 { + goto end8d8f9f3e2e1f7a5e9a186fb792fc40a8 + } + c := v.Args[1].AuxInt + v.Op = OpRsh32Ux64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = int64(uint16(c)) + v.AddArg(v0) + return true + } + goto end8d8f9f3e2e1f7a5e9a186fb792fc40a8 +end8d8f9f3e2e1f7a5e9a186fb792fc40a8: + ; + return false +} +func rewriteValuegeneric_OpRsh32Ux32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh32Ux32 x (Const32 [c])) + // cond: + // result: (Rsh32Ux64 x (Const64 [int64(uint32(c))])) + { + t := v.Type + x := v.Args[0] + if v.Args[1].Op != OpConst32 { + goto endd23d060f74e00f34cc967b6fb9a4d320 + } + c := v.Args[1].AuxInt + v.Op = OpRsh32Ux64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = int64(uint32(c)) + v.AddArg(v0) + return true + } + goto endd23d060f74e00f34cc967b6fb9a4d320 +endd23d060f74e00f34cc967b6fb9a4d320: + ; + 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))]) + { + if v.Args[0].Op != OpConst32 { + goto enda101e6b765d7ecffd9b7410c9dc3be82 + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst64 { + goto enda101e6b765d7ecffd9b7410c9dc3be82 + } + d := v.Args[1].AuxInt + v.Op = OpConst32 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = int64(uint32(c) >> uint64(d)) + return true + } + goto enda101e6b765d7ecffd9b7410c9dc3be82 +enda101e6b765d7ecffd9b7410c9dc3be82: + ; + // match: (Rsh32Ux64 x (Const64 [0])) + // cond: + // result: x + { + x := v.Args[0] + if v.Args[1].Op != OpConst64 { + goto end162e4e182a665d4e6f0d85fe131e7288 + } + if v.Args[1].AuxInt != 0 { + goto end162e4e182a665d4e6f0d85fe131e7288 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end162e4e182a665d4e6f0d85fe131e7288 +end162e4e182a665d4e6f0d85fe131e7288: + ; + // match: (Rsh32Ux64 _ (Const64 [c])) + // cond: uint64(c) >= 32 + // result: (Const64 [0]) + { + if v.Args[1].Op != OpConst64 { + goto endca322c370839b4264b219ee042a6ab33 + } + c := v.Args[1].AuxInt + if !(uint64(c) >= 32) { + goto endca322c370839b4264b219ee042a6ab33 + } + v.Op = OpConst64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto endca322c370839b4264b219ee042a6ab33 +endca322c370839b4264b219ee042a6ab33: + ; + // match: (Rsh32Ux64 (Rsh32Ux64 x (Const64 [c])) (Const64 [d])) + // cond: !uaddOvf(c,d) + // result: (Rsh32Ux64 x (Const64 [c+d])) + { + t := v.Type + if v.Args[0].Op != OpRsh32Ux64 { + goto end2e502d68a32663142684194adbe6c297 + } + x := v.Args[0].Args[0] + if v.Args[0].Args[1].Op != OpConst64 { + goto end2e502d68a32663142684194adbe6c297 + } + c := v.Args[0].Args[1].AuxInt + if v.Args[1].Op != OpConst64 { + goto end2e502d68a32663142684194adbe6c297 + } + d := v.Args[1].AuxInt + if !(!uaddOvf(c, d)) { + goto end2e502d68a32663142684194adbe6c297 + } + v.Op = OpRsh32Ux64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = c + d + v.AddArg(v0) + return true + } + goto end2e502d68a32663142684194adbe6c297 +end2e502d68a32663142684194adbe6c297: + ; + return false +} +func rewriteValuegeneric_OpRsh32Ux8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh32Ux8 x (Const8 [c])) + // cond: + // result: (Rsh32Ux64 x (Const64 [int64(uint8(c))])) + { + t := v.Type + x := v.Args[0] + if v.Args[1].Op != OpConst8 { + goto end967cea80158afaffb783f6da7aa898ca + } + c := v.Args[1].AuxInt + v.Op = OpRsh32Ux64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = int64(uint8(c)) + v.AddArg(v0) + return true + } + goto end967cea80158afaffb783f6da7aa898ca +end967cea80158afaffb783f6da7aa898ca: + ; + return false +} +func rewriteValuegeneric_OpRsh32x16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh32x16 x (Const16 [c])) + // cond: + // result: (Rsh32x64 x (Const64 [int64(uint16(c))])) + { + t := v.Type + x := v.Args[0] + if v.Args[1].Op != OpConst16 { + goto end6a62ebdcc98ea2e3214559214708d26a + } + c := v.Args[1].AuxInt + v.Op = OpRsh32x64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = int64(uint16(c)) + v.AddArg(v0) + return true + } + goto end6a62ebdcc98ea2e3214559214708d26a +end6a62ebdcc98ea2e3214559214708d26a: + ; + return false +} +func rewriteValuegeneric_OpRsh32x32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh32x32 x (Const32 [c])) + // cond: + // result: (Rsh32x64 x (Const64 [int64(uint32(c))])) + { + t := v.Type + x := v.Args[0] + if v.Args[1].Op != OpConst32 { + goto end6e3b467acdca74f58e9177fb42a1968b + } + c := v.Args[1].AuxInt + v.Op = OpRsh32x64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = int64(uint32(c)) + v.AddArg(v0) + return true + } + goto end6e3b467acdca74f58e9177fb42a1968b +end6e3b467acdca74f58e9177fb42a1968b: + ; + 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))]) + { + if v.Args[0].Op != OpConst32 { + goto end7e4b8c499cffe1fef73a16e6be54d4d2 + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst64 { + goto end7e4b8c499cffe1fef73a16e6be54d4d2 + } + d := v.Args[1].AuxInt + v.Op = OpConst32 v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = int64(int32(c) >> uint64(d)) return true } - goto end3601ad382705ea12b79d2008c1e5725c -end3601ad382705ea12b79d2008c1e5725c: + goto end7e4b8c499cffe1fef73a16e6be54d4d2 +end7e4b8c499cffe1fef73a16e6be54d4d2: ; - // match: (Neq64 (Const64 [c]) (Add64 (Const64 [d]) x)) + // match: (Rsh32x64 x (Const64 [0])) // cond: - // result: (Neq64 (Const64 [c-d]) x) + // result: x { - if v.Args[0].Op != OpConst64 { - goto enda3d39cad13a557a2aa6d086f43596c1b + x := v.Args[0] + if v.Args[1].Op != OpConst64 { + goto end72da2611eaaffe407efa1cc45c23ade3 } - t := v.Args[0].Type - c := v.Args[0].AuxInt - if v.Args[1].Op != OpAdd64 { - goto enda3d39cad13a557a2aa6d086f43596c1b + if v.Args[1].AuxInt != 0 { + goto end72da2611eaaffe407efa1cc45c23ade3 } - if v.Args[1].Args[0].Op != OpConst64 { - goto enda3d39cad13a557a2aa6d086f43596c1b + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end72da2611eaaffe407efa1cc45c23ade3 +end72da2611eaaffe407efa1cc45c23ade3: + ; + // match: (Rsh32x64 (Rsh32x64 x (Const64 [c])) (Const64 [d])) + // cond: !uaddOvf(c,d) + // result: (Rsh32x64 x (Const64 [c+d])) + { + t := v.Type + if v.Args[0].Op != OpRsh32x64 { + goto endadb415be78ee46a8a4135ec50df772b0 } - if v.Args[1].Args[0].Type != v.Args[0].Type { - goto enda3d39cad13a557a2aa6d086f43596c1b + x := v.Args[0].Args[0] + if v.Args[0].Args[1].Op != OpConst64 { + goto endadb415be78ee46a8a4135ec50df772b0 } - d := v.Args[1].Args[0].AuxInt - x := v.Args[1].Args[1] - v.Op = OpNeq64 + c := v.Args[0].Args[1].AuxInt + if v.Args[1].Op != OpConst64 { + goto endadb415be78ee46a8a4135ec50df772b0 + } + d := v.Args[1].AuxInt + if !(!uaddOvf(c, d)) { + goto endadb415be78ee46a8a4135ec50df772b0 + } + v.Op = OpRsh32x64 v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpConst64, TypeInvalid) - v0.Type = t - v0.AuxInt = c - d - v.AddArg(v0) v.AddArg(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = c + d + v.AddArg(v0) return true } - goto enda3d39cad13a557a2aa6d086f43596c1b -enda3d39cad13a557a2aa6d086f43596c1b: + goto endadb415be78ee46a8a4135ec50df772b0 +endadb415be78ee46a8a4135ec50df772b0: ; - // match: (Neq64 x (Const64 [c])) - // cond: x.Op != OpConst64 - // result: (Neq64 (Const64 [c]) x) + return false +} +func rewriteValuegeneric_OpRsh32x8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh32x8 x (Const8 [c])) + // cond: + // result: (Rsh32x64 x (Const64 [int64(uint8(c))])) { + t := v.Type x := v.Args[0] - if v.Args[1].Op != OpConst64 { - goto end0936a57de20373ca6cacb9506ddde708 + if v.Args[1].Op != OpConst8 { + goto end7b59b42c5c68a2d55be469a0c086dd8b } - t := v.Args[1].Type c := v.Args[1].AuxInt - if !(x.Op != OpConst64) { - goto end0936a57de20373ca6cacb9506ddde708 + v.Op = OpRsh32x64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = int64(uint8(c)) + v.AddArg(v0) + return true + } + goto end7b59b42c5c68a2d55be469a0c086dd8b +end7b59b42c5c68a2d55be469a0c086dd8b: + ; + return false +} +func rewriteValuegeneric_OpRsh64Ux16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh64Ux16 x (Const16 [c])) + // cond: + // result: (Rsh64Ux64 x (Const64 [int64(uint16(c))])) + { + t := v.Type + x := v.Args[0] + if v.Args[1].Op != OpConst16 { + goto end733d85a7b599bcba969ca1cb4bdb9e48 } - v.Op = OpNeq64 + c := v.Args[1].AuxInt + v.Op = OpRsh64Ux64 v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpConst64, TypeInvalid) - v0.Type = t - v0.AuxInt = c + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = int64(uint16(c)) v.AddArg(v0) + return true + } + goto end733d85a7b599bcba969ca1cb4bdb9e48 +end733d85a7b599bcba969ca1cb4bdb9e48: + ; + return false +} +func rewriteValuegeneric_OpRsh64Ux32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh64Ux32 x (Const32 [c])) + // cond: + // result: (Rsh64Ux64 x (Const64 [int64(uint32(c))])) + { + t := v.Type + x := v.Args[0] + if v.Args[1].Op != OpConst32 { + goto endeac7b34169de1fb0393b833e65b9bb19 + } + c := v.Args[1].AuxInt + v.Op = OpRsh64Ux64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() v.AddArg(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = int64(uint32(c)) + v.AddArg(v0) return true } - goto end0936a57de20373ca6cacb9506ddde708 -end0936a57de20373ca6cacb9506ddde708: + goto endeac7b34169de1fb0393b833e65b9bb19 +endeac7b34169de1fb0393b833e65b9bb19: ; - // match: (Neq64 (Const64 [c]) (Const64 [d])) + return false +} +func rewriteValuegeneric_OpRsh64Ux64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh64Ux64 (Const64 [c]) (Const64 [d])) // cond: - // result: (ConstBool [b2i(int64(c) != int64(d))]) + // result: (Const64 [int64(uint64(c) >> uint64(d))]) { if v.Args[0].Op != OpConst64 { - goto endf07433ecd3c150b1b75e943aa44a7203 + goto end102f4cfd7979a2aa222d52c34ac6802d } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst64 { - goto endf07433ecd3c150b1b75e943aa44a7203 + goto end102f4cfd7979a2aa222d52c34ac6802d } d := v.Args[1].AuxInt - v.Op = OpConstBool + v.Op = OpConst64 v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = b2i(int64(c) != int64(d)) + v.AuxInt = int64(uint64(c) >> uint64(d)) return true } - goto endf07433ecd3c150b1b75e943aa44a7203 -endf07433ecd3c150b1b75e943aa44a7203: + goto end102f4cfd7979a2aa222d52c34ac6802d +end102f4cfd7979a2aa222d52c34ac6802d: + ; + // match: (Rsh64Ux64 x (Const64 [0])) + // cond: + // result: x + { + x := v.Args[0] + if v.Args[1].Op != OpConst64 { + goto end5ad037b910698f2847df90177c23a6ac + } + if v.Args[1].AuxInt != 0 { + goto end5ad037b910698f2847df90177c23a6ac + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto end5ad037b910698f2847df90177c23a6ac +end5ad037b910698f2847df90177c23a6ac: + ; + // match: (Rsh64Ux64 _ (Const64 [c])) + // cond: uint64(c) >= 64 + // result: (Const64 [0]) + { + if v.Args[1].Op != OpConst64 { + goto end16ea16aa61862207ea64e514369d608b + } + c := v.Args[1].AuxInt + if !(uint64(c) >= 64) { + goto end16ea16aa61862207ea64e514369d608b + } + v.Op = OpConst64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = 0 + return true + } + goto end16ea16aa61862207ea64e514369d608b +end16ea16aa61862207ea64e514369d608b: + ; + // match: (Rsh64Ux64 (Rsh64Ux64 x (Const64 [c])) (Const64 [d])) + // cond: !uaddOvf(c,d) + // result: (Rsh64Ux64 x (Const64 [c+d])) + { + t := v.Type + if v.Args[0].Op != OpRsh64Ux64 { + goto end32bfdb1b4ccc23a5cd62fc0348ebd877 + } + x := v.Args[0].Args[0] + if v.Args[0].Args[1].Op != OpConst64 { + goto end32bfdb1b4ccc23a5cd62fc0348ebd877 + } + c := v.Args[0].Args[1].AuxInt + if v.Args[1].Op != OpConst64 { + goto end32bfdb1b4ccc23a5cd62fc0348ebd877 + } + d := v.Args[1].AuxInt + if !(!uaddOvf(c, d)) { + goto end32bfdb1b4ccc23a5cd62fc0348ebd877 + } + v.Op = OpRsh64Ux64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = c + d + v.AddArg(v0) + return true + } + goto end32bfdb1b4ccc23a5cd62fc0348ebd877 +end32bfdb1b4ccc23a5cd62fc0348ebd877: ; return false } -func rewriteValuegeneric_OpNeq8(v *Value, config *Config) bool { +func rewriteValuegeneric_OpRsh64Ux8(v *Value, config *Config) bool { b := v.Block _ = b - // match: (Neq8 x x) + // match: (Rsh64Ux8 x (Const8 [c])) // cond: - // result: (ConstBool [0]) + // result: (Rsh64Ux64 x (Const64 [int64(uint8(c))])) { + t := v.Type x := v.Args[0] - if v.Args[1] != x { - goto end09a0deaf3c42627d0d2d3efa96e30745 + if v.Args[1].Op != OpConst8 { + goto ende3d8090a67a52dbcd24b52ee32c9d7f0 } - v.Op = OpConstBool + c := v.Args[1].AuxInt + v.Op = OpRsh64Ux64 v.AuxInt = 0 v.Aux = nil v.resetArgs() + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = int64(uint8(c)) + v.AddArg(v0) + return true + } + goto ende3d8090a67a52dbcd24b52ee32c9d7f0 +ende3d8090a67a52dbcd24b52ee32c9d7f0: + ; + return false +} +func rewriteValuegeneric_OpRsh64x16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh64x16 x (Const16 [c])) + // cond: + // result: (Rsh64x64 x (Const64 [int64(uint16(c))])) + { + t := v.Type + x := v.Args[0] + if v.Args[1].Op != OpConst16 { + goto endd5151d0bfc38c55ae6ae6836014df3bc + } + c := v.Args[1].AuxInt + v.Op = OpRsh64x64 v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = int64(uint16(c)) + v.AddArg(v0) return true } - goto end09a0deaf3c42627d0d2d3efa96e30745 -end09a0deaf3c42627d0d2d3efa96e30745: + goto endd5151d0bfc38c55ae6ae6836014df3bc +endd5151d0bfc38c55ae6ae6836014df3bc: ; - // match: (Neq8 (Const8 [c]) (Add8 (Const8 [d]) x)) + return false +} +func rewriteValuegeneric_OpRsh64x32(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh64x32 x (Const32 [c])) // cond: - // result: (Neq8 (Const8 [c-d]) x) + // result: (Rsh64x64 x (Const64 [int64(uint32(c))])) { - if v.Args[0].Op != OpConst8 { - goto endc8f853c610c460c887cbfdca958e3691 + t := v.Type + x := v.Args[0] + if v.Args[1].Op != OpConst32 { + goto end0f2dbca5c7d6b100890c94a97bf0de7c + } + c := v.Args[1].AuxInt + v.Op = OpRsh64x64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = int64(uint32(c)) + v.AddArg(v0) + return true + } + goto end0f2dbca5c7d6b100890c94a97bf0de7c +end0f2dbca5c7d6b100890c94a97bf0de7c: + ; + 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)]) + { + if v.Args[0].Op != OpConst64 { + goto endfa4609d6bea8a3e3d3a777b1968c97d9 } - t := v.Args[0].Type c := v.Args[0].AuxInt - if v.Args[1].Op != OpAdd8 { - goto endc8f853c610c460c887cbfdca958e3691 + if v.Args[1].Op != OpConst64 { + goto endfa4609d6bea8a3e3d3a777b1968c97d9 } - if v.Args[1].Args[0].Op != OpConst8 { - goto endc8f853c610c460c887cbfdca958e3691 + d := v.Args[1].AuxInt + v.Op = OpConst64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = c >> uint64(d) + return true + } + goto endfa4609d6bea8a3e3d3a777b1968c97d9 +endfa4609d6bea8a3e3d3a777b1968c97d9: + ; + // match: (Rsh64x64 x (Const64 [0])) + // cond: + // result: x + { + x := v.Args[0] + if v.Args[1].Op != OpConst64 { + goto ende62e0c67d3f04eb221646371a2a91d05 } - if v.Args[1].Args[0].Type != v.Args[0].Type { - goto endc8f853c610c460c887cbfdca958e3691 + if v.Args[1].AuxInt != 0 { + goto ende62e0c67d3f04eb221646371a2a91d05 + } + v.Op = OpCopy + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.Type = x.Type + v.AddArg(x) + return true + } + goto ende62e0c67d3f04eb221646371a2a91d05 +ende62e0c67d3f04eb221646371a2a91d05: + ; + // match: (Rsh64x64 (Rsh64x64 x (Const64 [c])) (Const64 [d])) + // cond: !uaddOvf(c,d) + // result: (Rsh64x64 x (Const64 [c+d])) + { + t := v.Type + if v.Args[0].Op != OpRsh64x64 { + goto endd3e8ea66dc3ad0bc393001d6babb7160 + } + x := v.Args[0].Args[0] + if v.Args[0].Args[1].Op != OpConst64 { + goto endd3e8ea66dc3ad0bc393001d6babb7160 + } + c := v.Args[0].Args[1].AuxInt + if v.Args[1].Op != OpConst64 { + goto endd3e8ea66dc3ad0bc393001d6babb7160 + } + d := v.Args[1].AuxInt + if !(!uaddOvf(c, d)) { + goto endd3e8ea66dc3ad0bc393001d6babb7160 } - d := v.Args[1].Args[0].AuxInt - x := v.Args[1].Args[1] - v.Op = OpNeq8 + v.Op = OpRsh64x64 v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpConst8, TypeInvalid) - v0.Type = t - v0.AuxInt = c - d - v.AddArg(v0) v.AddArg(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = c + d + v.AddArg(v0) return true } - goto endc8f853c610c460c887cbfdca958e3691 -endc8f853c610c460c887cbfdca958e3691: + goto endd3e8ea66dc3ad0bc393001d6babb7160 +endd3e8ea66dc3ad0bc393001d6babb7160: ; - // match: (Neq8 x (Const8 [c])) - // cond: x.Op != OpConst8 - // result: (Neq8 (Const8 [c]) x) + return false +} +func rewriteValuegeneric_OpRsh64x8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh64x8 x (Const8 [c])) + // cond: + // result: (Rsh64x64 x (Const64 [int64(uint8(c))])) { + t := v.Type x := v.Args[0] if v.Args[1].Op != OpConst8 { - goto end04dc0ae2b08cf0447b50e5b8ef469252 + goto end1a9e5a89849344396210da7c7ec810be } - t := v.Args[1].Type c := v.Args[1].AuxInt - if !(x.Op != OpConst8) { - goto end04dc0ae2b08cf0447b50e5b8ef469252 - } - v.Op = OpNeq8 + v.Op = OpRsh64x64 v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpConst8, TypeInvalid) - v0.Type = t - v0.AuxInt = c - v.AddArg(v0) v.AddArg(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = int64(uint8(c)) + v.AddArg(v0) return true } - goto end04dc0ae2b08cf0447b50e5b8ef469252 -end04dc0ae2b08cf0447b50e5b8ef469252: + goto end1a9e5a89849344396210da7c7ec810be +end1a9e5a89849344396210da7c7ec810be: ; - // match: (Neq8 (Const8 [c]) (Const8 [d])) + return false +} +func rewriteValuegeneric_OpRsh8Ux16(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh8Ux16 x (Const16 [c])) // cond: - // result: (ConstBool [b2i(int8(c) != int8(d))]) + // result: (Rsh8Ux64 x (Const64 [int64(uint16(c))])) { - if v.Args[0].Op != OpConst8 { - goto end72ebdaf2de9b3aa57cf0cb8e068b5f9c - } - c := v.Args[0].AuxInt - if v.Args[1].Op != OpConst8 { - goto end72ebdaf2de9b3aa57cf0cb8e068b5f9c + t := v.Type + x := v.Args[0] + if v.Args[1].Op != OpConst16 { + goto end7acc015610273092e9efcce2949ee0f9 } - d := v.Args[1].AuxInt - v.Op = OpConstBool + c := v.Args[1].AuxInt + v.Op = OpRsh8Ux64 v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AuxInt = b2i(int8(c) != int8(d)) + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = int64(uint16(c)) + v.AddArg(v0) return true } - goto end72ebdaf2de9b3aa57cf0cb8e068b5f9c -end72ebdaf2de9b3aa57cf0cb8e068b5f9c: + goto end7acc015610273092e9efcce2949ee0f9 +end7acc015610273092e9efcce2949ee0f9: ; return false } -func rewriteValuegeneric_OpNeqInter(v *Value, config *Config) bool { +func rewriteValuegeneric_OpRsh8Ux32(v *Value, config *Config) bool { b := v.Block _ = b - // match: (NeqInter x y) + // match: (Rsh8Ux32 x (Const32 [c])) // cond: - // result: (NeqPtr (ITab x) (ITab y)) + // result: (Rsh8Ux64 x (Const64 [int64(uint32(c))])) { + t := v.Type x := v.Args[0] - y := v.Args[1] - v.Op = OpNeqPtr + if v.Args[1].Op != OpConst32 { + goto end27e9b4472e085b653a105b1d67554ce8 + } + c := v.Args[1].AuxInt + v.Op = OpRsh8Ux64 v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpITab, config.fe.TypeBytePtr()) - v0.AddArg(x) + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = int64(uint32(c)) v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpITab, config.fe.TypeBytePtr()) - v1.AddArg(y) - v.AddArg(v1) return true } - goto end17b2333bf57e9fe81a671be02f9c4c14 -end17b2333bf57e9fe81a671be02f9c4c14: + goto end27e9b4472e085b653a105b1d67554ce8 +end27e9b4472e085b653a105b1d67554ce8: ; return false } -func rewriteValuegeneric_OpNeqPtr(v *Value, config *Config) bool { +func rewriteValuegeneric_OpRsh8Ux64(v *Value, config *Config) bool { b := v.Block _ = b - // match: (NeqPtr p (ConstNil)) + // match: (Rsh8Ux64 (Const8 [c]) (Const64 [d])) // cond: - // result: (IsNonNil p) + // result: (Const8 [int64(uint8(c) >> uint64(d))]) { - p := v.Args[0] - if v.Args[1].Op != OpConstNil { - goto endba798520b4d41172b110347158c44791 + if v.Args[0].Op != OpConst8 { + goto enddd166e450d81ba7b466d61d2fbec178c } - v.Op = OpIsNonNil + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst64 { + goto enddd166e450d81ba7b466d61d2fbec178c + } + d := v.Args[1].AuxInt + v.Op = OpConst8 v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AddArg(p) + v.AuxInt = int64(uint8(c) >> uint64(d)) return true } - goto endba798520b4d41172b110347158c44791 -endba798520b4d41172b110347158c44791: + goto enddd166e450d81ba7b466d61d2fbec178c +enddd166e450d81ba7b466d61d2fbec178c: ; - // match: (NeqPtr (ConstNil) p) + // match: (Rsh8Ux64 x (Const64 [0])) // cond: - // result: (IsNonNil p) + // result: x { - if v.Args[0].Op != OpConstNil { - goto enddd95e9c3606d9fd48034f1a703561e45 + x := v.Args[0] + if v.Args[1].Op != OpConst64 { + goto end570cb1d9db3c7bebd85e485eeb2c0969 } - p := v.Args[1] - v.Op = OpIsNonNil + if v.Args[1].AuxInt != 0 { + goto end570cb1d9db3c7bebd85e485eeb2c0969 + } + v.Op = OpCopy v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.AddArg(p) + v.Type = x.Type + v.AddArg(x) return true } - goto enddd95e9c3606d9fd48034f1a703561e45 -enddd95e9c3606d9fd48034f1a703561e45: + goto end570cb1d9db3c7bebd85e485eeb2c0969 +end570cb1d9db3c7bebd85e485eeb2c0969: ; - 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)) + // match: (Rsh8Ux64 _ (Const64 [c])) + // cond: uint64(c) >= 8 + // result: (Const64 [0]) { - x := v.Args[0] - y := v.Args[1] - v.Op = OpNeqPtr + if v.Args[1].Op != OpConst64 { + goto endb63e1a7d1d91716ca0d9d74215361323 + } + c := v.Args[1].AuxInt + if !(uint64(c) >= 8) { + goto endb63e1a7d1d91716ca0d9d74215361323 + } + v.Op = OpConst64 v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpSlicePtr, config.fe.TypeBytePtr()) - v0.AddArg(x) + v.AuxInt = 0 + return true + } + goto endb63e1a7d1d91716ca0d9d74215361323 +endb63e1a7d1d91716ca0d9d74215361323: + ; + // match: (Rsh8Ux64 (Rsh8Ux64 x (Const64 [c])) (Const64 [d])) + // cond: !uaddOvf(c,d) + // result: (Rsh8Ux64 x (Const64 [c+d])) + { + t := v.Type + if v.Args[0].Op != OpRsh8Ux64 { + goto endee8824b7071ed1a6dba4fcbaab98229e + } + x := v.Args[0].Args[0] + if v.Args[0].Args[1].Op != OpConst64 { + goto endee8824b7071ed1a6dba4fcbaab98229e + } + c := v.Args[0].Args[1].AuxInt + if v.Args[1].Op != OpConst64 { + goto endee8824b7071ed1a6dba4fcbaab98229e + } + d := v.Args[1].AuxInt + if !(!uaddOvf(c, d)) { + goto endee8824b7071ed1a6dba4fcbaab98229e + } + v.Op = OpRsh8Ux64 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AddArg(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = c + d v.AddArg(v0) - v1 := b.NewValue0(v.Line, OpSlicePtr, config.fe.TypeBytePtr()) - v1.AddArg(y) - v.AddArg(v1) return true } - goto endc6bc83c506e491236ca66ea1081231a2 -endc6bc83c506e491236ca66ea1081231a2: + goto endee8824b7071ed1a6dba4fcbaab98229e +endee8824b7071ed1a6dba4fcbaab98229e: ; return false } -func rewriteValuegeneric_OpOr16(v *Value, config *Config) bool { +func rewriteValuegeneric_OpRsh8Ux8(v *Value, config *Config) bool { b := v.Block _ = b - // match: (Or16 x x) + // match: (Rsh8Ux8 x (Const8 [c])) // cond: - // result: x + // result: (Rsh8Ux64 x (Const64 [int64(uint8(c))])) { + t := v.Type x := v.Args[0] - if v.Args[1] != x { - goto end47a2f25fd31a76807aced3e2b126acdc + if v.Args[1].Op != OpConst8 { + goto ended7e4f4d9ab89dc26e6649d466577930 } - v.Op = OpCopy + c := v.Args[1].AuxInt + v.Op = OpRsh8Ux64 v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Type = x.Type v.AddArg(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = int64(uint8(c)) + v.AddArg(v0) return true } - goto end47a2f25fd31a76807aced3e2b126acdc -end47a2f25fd31a76807aced3e2b126acdc: + goto ended7e4f4d9ab89dc26e6649d466577930 +ended7e4f4d9ab89dc26e6649d466577930: ; return false } -func rewriteValuegeneric_OpOr32(v *Value, config *Config) bool { +func rewriteValuegeneric_OpRsh8x16(v *Value, config *Config) bool { b := v.Block _ = b - // match: (Or32 x x) + // match: (Rsh8x16 x (Const16 [c])) // cond: - // result: x + // result: (Rsh8x64 x (Const64 [int64(uint16(c))])) { + t := v.Type x := v.Args[0] - if v.Args[1] != x { - goto end231e283e568e90bd9a3e6a4fa328c8a4 + if v.Args[1].Op != OpConst16 { + goto end136bef6f60180bc8b4befbfc370af7ef } - v.Op = OpCopy + c := v.Args[1].AuxInt + v.Op = OpRsh8x64 v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Type = x.Type v.AddArg(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = int64(uint16(c)) + v.AddArg(v0) return true } - goto end231e283e568e90bd9a3e6a4fa328c8a4 -end231e283e568e90bd9a3e6a4fa328c8a4: + goto end136bef6f60180bc8b4befbfc370af7ef +end136bef6f60180bc8b4befbfc370af7ef: ; return false } -func rewriteValuegeneric_OpOr64(v *Value, config *Config) bool { +func rewriteValuegeneric_OpRsh8x32(v *Value, config *Config) bool { b := v.Block _ = b - // match: (Or64 x x) + // match: (Rsh8x32 x (Const32 [c])) // cond: - // result: x + // result: (Rsh8x64 x (Const64 [int64(uint32(c))])) { + t := v.Type x := v.Args[0] - if v.Args[1] != x { - goto end6b0efc212016dc97d0e3939db04c81d9 + if v.Args[1].Op != OpConst32 { + goto end2ef95c222a7c552fa9cc86e36196644e } - v.Op = OpCopy + c := v.Args[1].AuxInt + v.Op = OpRsh8x64 v.AuxInt = 0 v.Aux = nil v.resetArgs() - v.Type = x.Type v.AddArg(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = int64(uint32(c)) + v.AddArg(v0) return true } - goto end6b0efc212016dc97d0e3939db04c81d9 -end6b0efc212016dc97d0e3939db04c81d9: + goto end2ef95c222a7c552fa9cc86e36196644e +end2ef95c222a7c552fa9cc86e36196644e: ; return false } -func rewriteValuegeneric_OpOr8(v *Value, config *Config) bool { +func rewriteValuegeneric_OpRsh8x64(v *Value, config *Config) bool { b := v.Block _ = b - // match: (Or8 x x) + // match: (Rsh8x64 (Const8 [c]) (Const64 [d])) + // cond: + // result: (Const8 [int64(int8(c) >> uint64(d))]) + { + if v.Args[0].Op != OpConst8 { + goto end3b90206d75365466dfd1368e5b69db35 + } + c := v.Args[0].AuxInt + if v.Args[1].Op != OpConst64 { + goto end3b90206d75365466dfd1368e5b69db35 + } + d := v.Args[1].AuxInt + v.Op = OpConst8 + v.AuxInt = 0 + v.Aux = nil + v.resetArgs() + v.AuxInt = int64(int8(c) >> uint64(d)) + return true + } + goto end3b90206d75365466dfd1368e5b69db35 +end3b90206d75365466dfd1368e5b69db35: + ; + // match: (Rsh8x64 x (Const64 [0])) // cond: // result: x { x := v.Args[0] - if v.Args[1] != x { - goto end05295dbfafd6869af79b4daee9fda000 + if v.Args[1].Op != OpConst64 { + goto end1e664cc720a11d1c769de8081cfa1de4 + } + if v.Args[1].AuxInt != 0 { + goto end1e664cc720a11d1c769de8081cfa1de4 } v.Op = OpCopy v.AuxInt = 0 @@ -3749,65 +5981,69 @@ func rewriteValuegeneric_OpOr8(v *Value, config *Config) bool { v.AddArg(x) return true } - goto end05295dbfafd6869af79b4daee9fda000 -end05295dbfafd6869af79b4daee9fda000: + goto end1e664cc720a11d1c769de8081cfa1de4 +end1e664cc720a11d1c769de8081cfa1de4: ; - return false -} -func rewriteValuegeneric_OpPtrIndex(v *Value, config *Config) bool { - b := v.Block - _ = b - // match: (PtrIndex ptr idx) - // cond: config.PtrSize == 4 - // result: (AddPtr ptr (Mul32 idx (Const32 [t.Elem().Size()]))) + // match: (Rsh8x64 (Rsh8x64 x (Const64 [c])) (Const64 [d])) + // cond: !uaddOvf(c,d) + // result: (Rsh8x64 x (Const64 [c+d])) { t := v.Type - ptr := v.Args[0] - idx := v.Args[1] - if !(config.PtrSize == 4) { - goto endd902622aaa1e7545b5a2a0c08b47d287 + if v.Args[0].Op != OpRsh8x64 { + goto end6408685a7276af7e76ec086f359c942c } - v.Op = OpAddPtr + x := v.Args[0].Args[0] + if v.Args[0].Args[1].Op != OpConst64 { + goto end6408685a7276af7e76ec086f359c942c + } + c := v.Args[0].Args[1].AuxInt + if v.Args[1].Op != OpConst64 { + goto end6408685a7276af7e76ec086f359c942c + } + d := v.Args[1].AuxInt + if !(!uaddOvf(c, d)) { + goto end6408685a7276af7e76ec086f359c942c + } + v.Op = OpRsh8x64 v.AuxInt = 0 v.Aux = nil v.resetArgs() - 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(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = c + d v.AddArg(v0) return true } - goto endd902622aaa1e7545b5a2a0c08b47d287 -endd902622aaa1e7545b5a2a0c08b47d287: + goto end6408685a7276af7e76ec086f359c942c +end6408685a7276af7e76ec086f359c942c: ; - // match: (PtrIndex ptr idx) - // cond: config.PtrSize == 8 - // result: (AddPtr ptr (Mul64 idx (Const64 [t.Elem().Size()]))) + return false +} +func rewriteValuegeneric_OpRsh8x8(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Rsh8x8 x (Const8 [c])) + // cond: + // result: (Rsh8x64 x (Const64 [int64(uint8(c))])) { t := v.Type - ptr := v.Args[0] - idx := v.Args[1] - if !(config.PtrSize == 8) { - goto end47a5f1d1b158914fa383de024bbe3b08 + x := v.Args[0] + if v.Args[1].Op != OpConst8 { + goto endae44f60f364cddd8903763dd921a007e } - v.Op = OpAddPtr + c := v.Args[1].AuxInt + v.Op = OpRsh8x64 v.AuxInt = 0 v.Aux = nil v.resetArgs() - 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(x) + v0 := b.NewValue0(v.Line, OpConst64, t) + v0.AuxInt = int64(uint8(c)) v.AddArg(v0) return true } - goto end47a5f1d1b158914fa383de024bbe3b08 -end47a5f1d1b158914fa383de024bbe3b08: + goto endae44f60f364cddd8903763dd921a007e +endae44f60f364cddd8903763dd921a007e: ; return false } @@ -4652,8 +6888,7 @@ end5c6fab95c9dbeff5973119096bfd4e78: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpConst16, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpConst16, t) v0.AuxInt = -c v.AddArg(v0) v.AddArg(x) @@ -4770,8 +7005,7 @@ end7623799db780e1bcc42c6ea0df9c49d3: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpConst32, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpConst32, t) v0.AuxInt = -c v.AddArg(v0) v.AddArg(x) @@ -4888,8 +7122,7 @@ end5a84a285ff0ff48b8ad3c64b15e3459f: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpConst64, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = -c v.AddArg(v0) v.AddArg(x) @@ -5006,8 +7239,7 @@ endc00ea11c7535529e211710574f5cff24: v.AuxInt = 0 v.Aux = nil v.resetArgs() - v0 := b.NewValue0(v.Line, OpConst8, TypeInvalid) - v0.Type = t + v0 := b.NewValue0(v.Line, OpConst8, t) v0.AuxInt = -c v.AddArg(v0) v.AddArg(x) -- cgit v1.3 From 2df4b9c265f4d2552141ad42cd537b28495a9c81 Mon Sep 17 00:00:00 2001 From: Alexandru Moșoi Date: Thu, 4 Feb 2016 17:21:57 +0100 Subject: [dev.ssa] cmd/compile/internal/ssa/gen: move variable reset code into a function Shaves about 3 lines per generated rule. Change-Id: I94adc94ab79f90ac5fd033f896ece3b1eddf0f3d Reviewed-on: https://go-review.googlesource.com/19197 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/decompose.go | 25 +- src/cmd/compile/internal/ssa/gen/rulegen.go | 15 +- src/cmd/compile/internal/ssa/rewriteAMD64.go | 3330 +++++------------------- src/cmd/compile/internal/ssa/rewritegeneric.go | 1340 ++-------- src/cmd/compile/internal/ssa/value.go | 7 + 5 files changed, 949 insertions(+), 3768 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/decompose.go b/src/cmd/compile/internal/ssa/decompose.go index 6dc11250ca..fd8d6b802c 100644 --- a/src/cmd/compile/internal/ssa/decompose.go +++ b/src/cmd/compile/internal/ssa/decompose.go @@ -122,10 +122,7 @@ func decomposeStringPhi(v *Value) { ptr.AddArg(a.Block.NewValue1(v.Line, OpStringPtr, ptrType, a)) len.AddArg(a.Block.NewValue1(v.Line, OpStringLen, lenType, a)) } - v.Op = OpStringMake - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpStringMake) v.AddArg(ptr) v.AddArg(len) } @@ -143,10 +140,7 @@ func decomposeSlicePhi(v *Value) { len.AddArg(a.Block.NewValue1(v.Line, OpSliceLen, lenType, a)) cap.AddArg(a.Block.NewValue1(v.Line, OpSliceCap, lenType, a)) } - v.Op = OpSliceMake - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpSliceMake) v.AddArg(ptr) v.AddArg(len) v.AddArg(cap) @@ -170,10 +164,7 @@ func decomposeComplexPhi(v *Value) { real.AddArg(a.Block.NewValue1(v.Line, OpComplexReal, partType, a)) imag.AddArg(a.Block.NewValue1(v.Line, OpComplexImag, partType, a)) } - v.Op = OpComplexMake - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpComplexMake) v.AddArg(real) v.AddArg(imag) } @@ -187,10 +178,7 @@ func decomposeInterfacePhi(v *Value) { itab.AddArg(a.Block.NewValue1(v.Line, OpITab, ptrType, a)) data.AddArg(a.Block.NewValue1(v.Line, OpIData, ptrType, a)) } - v.Op = OpIMake - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpIMake) v.AddArg(itab) v.AddArg(data) } @@ -206,10 +194,7 @@ func decomposeStructPhi(v *Value) { fields[i].AddArg(a.Block.NewValue1I(v.Line, OpStructSelect, t.FieldType(i), i, a)) } } - v.Op = StructMakeOp(n) - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(StructMakeOp(n)) v.AddArgs(fields[:n]...) // Recursively decompose phis for each field. diff --git a/src/cmd/compile/internal/ssa/gen/rulegen.go b/src/cmd/compile/internal/ssa/gen/rulegen.go index 8d6d00846d..c39271eaa6 100644 --- a/src/cmd/compile/internal/ssa/gen/rulegen.go +++ b/src/cmd/compile/internal/ssa/gen/rulegen.go @@ -435,10 +435,7 @@ func genResult0(w io.Writer, arch arch, result string, alloc *int, top bool, loc // 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.Op = OpCopy\n") - fmt.Fprintf(w, "v.AuxInt = 0\n") - fmt.Fprintf(w, "v.Aux = nil\n") - fmt.Fprintf(w, "v.resetArgs()\n") + fmt.Fprintf(w, "v.reset(OpCopy)\n") fmt.Fprintf(w, "v.Type = %s.Type\n", result) fmt.Fprintf(w, "v.AddArg(%s)\n", result) } @@ -478,13 +475,10 @@ func genResult0(w io.Writer, arch arch, result string, alloc *int, top bool, loc var v string if top && loc == "b" { v = "v" + fmt.Fprintf(w, "v.reset(%s)\n", opName(s[0], arch)) if typeOverride { fmt.Fprintf(w, "v.Type = %s\n", opType) } - fmt.Fprintf(w, "v.Op = %s\n", opName(s[0], arch)) - fmt.Fprintf(w, "v.AuxInt = 0\n") - fmt.Fprintf(w, "v.Aux = nil\n") - fmt.Fprintf(w, "v.resetArgs()\n") } else { if opType == "" { log.Fatalf("sub-expression %s (op=%s) must have a type", result, s[0]) @@ -494,10 +488,7 @@ func genResult0(w io.Writer, arch arch, result string, alloc *int, top bool, loc fmt.Fprintf(w, "%s := %s.NewValue0(v.Line, %s, %s)\n", v, loc, opName(s[0], arch), opType) if top { // Rewrite original into a copy - fmt.Fprintf(w, "v.Op = OpCopy\n") - fmt.Fprintf(w, "v.AuxInt = 0\n") - fmt.Fprintf(w, "v.Aux = nil\n") - fmt.Fprintf(w, "v.resetArgs()\n") + fmt.Fprintf(w, "v.reset(OpCopy)\n") fmt.Fprintf(w, "v.AddArg(%s)\n", v) } } diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index ed62d3f958..965e9a56dc 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -740,10 +740,7 @@ func rewriteValueAMD64_OpAMD64ADDB(v *Value, config *Config) bool { goto endab690db69bfd8192eea57a2f9f76bf84 } c := v.Args[1].AuxInt - v.Op = OpAMD64ADDBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ADDBconst) v.AuxInt = c v.AddArg(x) return true @@ -760,10 +757,7 @@ endab690db69bfd8192eea57a2f9f76bf84: } c := v.Args[0].AuxInt x := v.Args[1] - v.Op = OpAMD64ADDBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ADDBconst) v.AuxInt = c v.AddArg(x) return true @@ -780,10 +774,7 @@ end28aa1a4abe7e1abcdd64135e9967d39d: goto end9464509b8874ffb00b43b843da01f0bc } y := v.Args[1].Args[0] - v.Op = OpAMD64SUBB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SUBB) v.AddArg(x) v.AddArg(y) return true @@ -805,10 +796,7 @@ func rewriteValueAMD64_OpAMD64ADDBconst(v *Value, config *Config) bool { if !(int8(c) == 0) { goto end3fbe38dfc1de8f48c755862c4c8b6bac } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -825,10 +813,7 @@ end3fbe38dfc1de8f48c755862c4c8b6bac: goto enda9b1e9e31ccdf0af5f4fe57bf4b1343f } d := v.Args[0].AuxInt - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = c + d return true } @@ -845,10 +830,7 @@ enda9b1e9e31ccdf0af5f4fe57bf4b1343f: } d := v.Args[0].AuxInt x := v.Args[0].Args[0] - v.Op = OpAMD64ADDBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ADDBconst) v.AuxInt = c + d v.AddArg(x) return true @@ -870,10 +852,7 @@ func rewriteValueAMD64_OpAMD64ADDL(v *Value, config *Config) bool { goto end8d6d3b99a7be8da6b7a254b7e709cc95 } c := v.Args[1].AuxInt - v.Op = OpAMD64ADDLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ADDLconst) v.AuxInt = c v.AddArg(x) return true @@ -890,10 +869,7 @@ end8d6d3b99a7be8da6b7a254b7e709cc95: } c := v.Args[0].AuxInt x := v.Args[1] - v.Op = OpAMD64ADDLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ADDLconst) v.AuxInt = c v.AddArg(x) return true @@ -910,10 +886,7 @@ end739561e08a561e26ce3634dc0d5ec733: goto end9596df31f2685a49df67c6fb912a521d } y := v.Args[1].Args[0] - v.Op = OpAMD64SUBL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SUBL) v.AddArg(x) v.AddArg(y) return true @@ -935,10 +908,7 @@ func rewriteValueAMD64_OpAMD64ADDLconst(v *Value, config *Config) bool { if !(int32(c) == 0) { goto endf04fb6232fbd3b460bb0d1bdcdc57d65 } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -955,10 +925,7 @@ endf04fb6232fbd3b460bb0d1bdcdc57d65: goto ende04850e987890abf1d66199042a19c23 } d := v.Args[0].AuxInt - v.Op = OpAMD64MOVLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVLconst) v.AuxInt = c + d return true } @@ -975,10 +942,7 @@ ende04850e987890abf1d66199042a19c23: } d := v.Args[0].AuxInt x := v.Args[0].Args[0] - v.Op = OpAMD64ADDLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ADDLconst) v.AuxInt = c + d v.AddArg(x) return true @@ -1003,10 +967,7 @@ func rewriteValueAMD64_OpAMD64ADDQ(v *Value, config *Config) bool { if !(is32Bit(c)) { goto end1de8aeb1d043e0dadcffd169a99ce5c0 } - v.Op = OpAMD64ADDQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ADDQconst) v.AuxInt = c v.AddArg(x) return true @@ -1026,10 +987,7 @@ end1de8aeb1d043e0dadcffd169a99ce5c0: if !(is32Bit(c)) { goto endca635e3bdecd9e3aeb892f841021dfaa } - v.Op = OpAMD64ADDQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ADDQconst) v.AuxInt = c v.AddArg(x) return true @@ -1049,10 +1007,7 @@ endca635e3bdecd9e3aeb892f841021dfaa: goto endc02313d35a0525d1d680cd58992e820d } y := v.Args[1].Args[0] - v.Op = OpAMD64LEAQ8 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64LEAQ8) v.AddArg(x) v.AddArg(y) return true @@ -1069,10 +1024,7 @@ endc02313d35a0525d1d680cd58992e820d: goto endec8f899c6e175a0147a90750f9bfe0a2 } y := v.Args[1].Args[0] - v.Op = OpAMD64SUBQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SUBQ) v.AddArg(x) v.AddArg(y) return true @@ -1096,10 +1048,7 @@ func rewriteValueAMD64_OpAMD64ADDQconst(v *Value, config *Config) bool { d := v.Args[0].AuxInt x := v.Args[0].Args[0] y := v.Args[0].Args[1] - v.Op = OpAMD64LEAQ8 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64LEAQ8) v.AuxInt = addOff(c, d) v.AddArg(x) v.AddArg(y) @@ -1116,10 +1065,7 @@ ende2cc681c9abf9913288803fb1b39e639: goto end03d9f5a3e153048b0afa781401e2a849 } x := v.Args[0] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -1136,10 +1082,7 @@ end03d9f5a3e153048b0afa781401e2a849: goto end09dc54395b4e96e8332cf8e4e7481c52 } d := v.Args[0].AuxInt - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVQconst) v.AuxInt = c + d return true } @@ -1156,10 +1099,7 @@ end09dc54395b4e96e8332cf8e4e7481c52: } d := v.Args[0].AuxInt x := v.Args[0].Args[0] - v.Op = OpAMD64ADDQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ADDQconst) v.AuxInt = c + d v.AddArg(x) return true @@ -1181,10 +1121,7 @@ func rewriteValueAMD64_OpAMD64ADDW(v *Value, config *Config) bool { goto end1aabd2317de77c7dfc4876fd7e4c5011 } c := v.Args[1].AuxInt - v.Op = OpAMD64ADDWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ADDWconst) v.AuxInt = c v.AddArg(x) return true @@ -1201,10 +1138,7 @@ end1aabd2317de77c7dfc4876fd7e4c5011: } c := v.Args[0].AuxInt x := v.Args[1] - v.Op = OpAMD64ADDWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ADDWconst) v.AuxInt = c v.AddArg(x) return true @@ -1221,10 +1155,7 @@ ende3aede99966f388afc624f9e86676fd2: goto end55cf2af0d75f3ec413528eeb799e94d5 } y := v.Args[1].Args[0] - v.Op = OpAMD64SUBW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SUBW) v.AddArg(x) v.AddArg(y) return true @@ -1246,10 +1177,7 @@ func rewriteValueAMD64_OpAMD64ADDWconst(v *Value, config *Config) bool { if !(int16(c) == 0) { goto end8564670ff18b2a91eb92d5e5775464cd } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -1266,10 +1194,7 @@ end8564670ff18b2a91eb92d5e5775464cd: goto end32541920f2f5a920dfae41d8ebbef00f } d := v.Args[0].AuxInt - v.Op = OpAMD64MOVWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVWconst) v.AuxInt = c + d return true } @@ -1286,10 +1211,7 @@ end32541920f2f5a920dfae41d8ebbef00f: } d := v.Args[0].AuxInt x := v.Args[0].Args[0] - v.Op = OpAMD64ADDWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ADDWconst) v.AuxInt = c + d v.AddArg(x) return true @@ -1311,10 +1233,7 @@ func rewriteValueAMD64_OpAMD64ANDB(v *Value, config *Config) bool { goto end01100cd255396e29bfdb130f4fbc9bbc } c := v.Args[1].AuxInt - v.Op = OpAMD64ANDBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDBconst) v.AuxInt = c v.AddArg(x) return true @@ -1331,10 +1250,7 @@ end01100cd255396e29bfdb130f4fbc9bbc: } c := v.Args[0].AuxInt x := v.Args[1] - v.Op = OpAMD64ANDBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDBconst) v.AuxInt = c v.AddArg(x) return true @@ -1351,10 +1267,7 @@ end70830ce2834dc5f8d786fa6789460926: goto endd275ec2e73768cb3d201478fc934e06c } c := v.Args[1].AuxInt - v.Op = OpAMD64ANDBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDBconst) v.AuxInt = c v.AddArg(x) return true @@ -1371,10 +1284,7 @@ endd275ec2e73768cb3d201478fc934e06c: } c := v.Args[0].AuxInt x := v.Args[1] - v.Op = OpAMD64ANDBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDBconst) v.AuxInt = c v.AddArg(x) return true @@ -1390,10 +1300,7 @@ end4068edac2ae0f354cf581db210288b98: if v.Args[1] != x { goto endb8ff272a1456513da708603abe37541c } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -1414,10 +1321,7 @@ func rewriteValueAMD64_OpAMD64ANDBconst(v *Value, config *Config) bool { if !(int8(c) == 0) { goto end2106d410c949da14d7c00041f40eca76 } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } @@ -1433,10 +1337,7 @@ end2106d410c949da14d7c00041f40eca76: if !(int8(c) == -1) { goto enda0b78503c204c8225de1433949a71fe4 } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -1453,10 +1354,7 @@ enda0b78503c204c8225de1433949a71fe4: goto end946312b1f216933da86febe293eb956f } d := v.Args[0].AuxInt - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = c & d return true } @@ -1477,10 +1375,7 @@ func rewriteValueAMD64_OpAMD64ANDL(v *Value, config *Config) bool { goto end0a4c49d9a26759c0fd21369dafcd7abb } c := v.Args[1].AuxInt - v.Op = OpAMD64ANDLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDLconst) v.AuxInt = c v.AddArg(x) return true @@ -1497,10 +1392,7 @@ end0a4c49d9a26759c0fd21369dafcd7abb: } c := v.Args[0].AuxInt x := v.Args[1] - v.Op = OpAMD64ANDLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDLconst) v.AuxInt = c v.AddArg(x) return true @@ -1516,10 +1408,7 @@ end0529ba323d9b6f15c41add401ef67959: if v.Args[1] != x { goto enddfb08a0d0c262854db3905cb323388c7 } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -1540,10 +1429,7 @@ func rewriteValueAMD64_OpAMD64ANDLconst(v *Value, config *Config) bool { if !(int32(c) == 0) { goto end5efb241208aef28c950b7bcf8d85d5de } - v.Op = OpAMD64MOVLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVLconst) v.AuxInt = 0 return true } @@ -1559,10 +1445,7 @@ end5efb241208aef28c950b7bcf8d85d5de: if !(int32(c) == -1) { goto end0e852ae30bb8289d6ffee0c9267e3e0c } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -1579,10 +1462,7 @@ end0e852ae30bb8289d6ffee0c9267e3e0c: goto end7bfd24059369753eadd235f07e2dd7b8 } d := v.Args[0].AuxInt - v.Op = OpAMD64MOVLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVLconst) v.AuxInt = c & d return true } @@ -1606,10 +1486,7 @@ func rewriteValueAMD64_OpAMD64ANDQ(v *Value, config *Config) bool { if !(is32Bit(c)) { goto end048fadc69e81103480015b84b9cafff7 } - v.Op = OpAMD64ANDQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDQconst) v.AuxInt = c v.AddArg(x) return true @@ -1629,10 +1506,7 @@ end048fadc69e81103480015b84b9cafff7: if !(is32Bit(c)) { goto end3035a3bf650b708705fd27dd857ab0a4 } - v.Op = OpAMD64ANDQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDQconst) v.AuxInt = c v.AddArg(x) return true @@ -1648,10 +1522,7 @@ end3035a3bf650b708705fd27dd857ab0a4: if v.Args[1] != x { goto end06b5ec19efdd4e79f03a5e4a2c3c3427 } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -1671,10 +1542,7 @@ func rewriteValueAMD64_OpAMD64ANDQconst(v *Value, config *Config) bool { if v.AuxInt != 0 { goto end57018c1d0f54fd721521095b4832bab2 } - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVQconst) v.AuxInt = 0 return true } @@ -1689,10 +1557,7 @@ end57018c1d0f54fd721521095b4832bab2: goto endb542c4b42ab94a7bedb32dec8f610d67 } x := v.Args[0] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -1709,10 +1574,7 @@ endb542c4b42ab94a7bedb32dec8f610d67: goto end67ca66494705b0345a5f22c710225292 } d := v.Args[0].AuxInt - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVQconst) v.AuxInt = c & d return true } @@ -1733,10 +1595,7 @@ func rewriteValueAMD64_OpAMD64ANDW(v *Value, config *Config) bool { goto endce6f557823ee2fdd7a8f47b6f925fc7c } c := v.Args[1].AuxInt - v.Op = OpAMD64ANDWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDWconst) v.AuxInt = c v.AddArg(x) return true @@ -1753,10 +1612,7 @@ endce6f557823ee2fdd7a8f47b6f925fc7c: } c := v.Args[0].AuxInt x := v.Args[1] - v.Op = OpAMD64ANDWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDWconst) v.AuxInt = c v.AddArg(x) return true @@ -1773,10 +1629,7 @@ endc46af0d9265c08b09f1f1fba24feda80: goto enda77a39f65a5eb3436a5842eab69a3103 } c := v.Args[1].AuxInt - v.Op = OpAMD64ANDWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDWconst) v.AuxInt = c v.AddArg(x) return true @@ -1793,10 +1646,7 @@ enda77a39f65a5eb3436a5842eab69a3103: } c := v.Args[0].AuxInt x := v.Args[1] - v.Op = OpAMD64ANDWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDWconst) v.AuxInt = c v.AddArg(x) return true @@ -1812,10 +1662,7 @@ endea2a25eb525a5dbf6d5132d84ea4e7a5: if v.Args[1] != x { goto end3a26cf52dd1b77f07cc9e005760dbb11 } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -1836,10 +1683,7 @@ func rewriteValueAMD64_OpAMD64ANDWconst(v *Value, config *Config) bool { if !(int16(c) == 0) { goto end336ece33b4f0fb44dfe1f24981df7b74 } - v.Op = OpAMD64MOVWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVWconst) v.AuxInt = 0 return true } @@ -1855,10 +1699,7 @@ end336ece33b4f0fb44dfe1f24981df7b74: if !(int16(c) == -1) { goto endfb111c3afa8c5c4040fa6000fadee810 } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -1875,10 +1716,7 @@ endfb111c3afa8c5c4040fa6000fadee810: goto end250eb27fcac10bf6c0d96ce66a21726e } d := v.Args[0].AuxInt - v.Op = OpAMD64MOVWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVWconst) v.AuxInt = c & d return true } @@ -1896,10 +1734,7 @@ func rewriteValueAMD64_OpAdd16(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ADDW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ADDW) v.AddArg(x) v.AddArg(y) return true @@ -1918,10 +1753,7 @@ func rewriteValueAMD64_OpAdd32(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ADDL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ADDL) v.AddArg(x) v.AddArg(y) return true @@ -1940,10 +1772,7 @@ func rewriteValueAMD64_OpAdd32F(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ADDSS - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ADDSS) v.AddArg(x) v.AddArg(y) return true @@ -1962,10 +1791,7 @@ func rewriteValueAMD64_OpAdd64(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ADDQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ADDQ) v.AddArg(x) v.AddArg(y) return true @@ -1984,10 +1810,7 @@ func rewriteValueAMD64_OpAdd64F(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ADDSD - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ADDSD) v.AddArg(x) v.AddArg(y) return true @@ -2006,10 +1829,7 @@ func rewriteValueAMD64_OpAdd8(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ADDB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ADDB) v.AddArg(x) v.AddArg(y) return true @@ -2028,10 +1848,7 @@ func rewriteValueAMD64_OpAddPtr(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ADDQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ADDQ) v.AddArg(x) v.AddArg(y) return true @@ -2050,10 +1867,7 @@ func rewriteValueAMD64_OpAddr(v *Value, config *Config) bool { { sym := v.Aux base := v.Args[0] - v.Op = OpAMD64LEAQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64LEAQ) v.Aux = sym v.AddArg(base) return true @@ -2072,10 +1886,7 @@ func rewriteValueAMD64_OpAnd16(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ANDW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDW) v.AddArg(x) v.AddArg(y) return true @@ -2094,10 +1905,7 @@ func rewriteValueAMD64_OpAnd32(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ANDL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDL) v.AddArg(x) v.AddArg(y) return true @@ -2116,10 +1924,7 @@ func rewriteValueAMD64_OpAnd64(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ANDQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDQ) v.AddArg(x) v.AddArg(y) return true @@ -2138,10 +1943,7 @@ func rewriteValueAMD64_OpAnd8(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ANDB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDB) v.AddArg(x) v.AddArg(y) return true @@ -2163,10 +1965,7 @@ func rewriteValueAMD64_OpAMD64CMPB(v *Value, config *Config) bool { goto end52190c0b8759133aa6c540944965c4c0 } c := v.Args[1].AuxInt - v.Op = OpAMD64CMPBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64CMPBconst) v.AddArg(x) v.AuxInt = c return true @@ -2183,10 +1982,7 @@ end52190c0b8759133aa6c540944965c4c0: } c := v.Args[0].AuxInt x := v.Args[1] - v.Op = OpAMD64InvertFlags - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64InvertFlags) v0 := b.NewValue0(v.Line, OpAMD64CMPBconst, TypeFlags) v0.AddArg(x) v0.AuxInt = c @@ -2213,10 +2009,7 @@ func rewriteValueAMD64_OpAMD64CMPBconst(v *Value, config *Config) bool { if !(int8(x) == int8(y)) { goto end1be300bd80b7d8cd0fa37e1907c75a77 } - v.Op = OpAMD64FlagEQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64FlagEQ) return true } goto end1be300bd80b7d8cd0fa37e1907c75a77 @@ -2234,10 +2027,7 @@ end1be300bd80b7d8cd0fa37e1907c75a77: if !(int8(x) < int8(y) && uint8(x) < uint8(y)) { goto endbe76e73088c59765dd0132e2ac15fc6e } - v.Op = OpAMD64FlagLT_ULT - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64FlagLT_ULT) return true } goto endbe76e73088c59765dd0132e2ac15fc6e @@ -2255,10 +2045,7 @@ endbe76e73088c59765dd0132e2ac15fc6e: if !(int8(x) < int8(y) && uint8(x) > uint8(y)) { goto endbfa2ca974f69ec9ceb8a24ad6db45efb } - v.Op = OpAMD64FlagLT_UGT - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64FlagLT_UGT) return true } goto endbfa2ca974f69ec9ceb8a24ad6db45efb @@ -2276,10 +2063,7 @@ endbfa2ca974f69ec9ceb8a24ad6db45efb: if !(int8(x) > int8(y) && uint8(x) < uint8(y)) { goto end68ac2e7dcb3704e235e1c292669320ed } - v.Op = OpAMD64FlagGT_ULT - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64FlagGT_ULT) return true } goto end68ac2e7dcb3704e235e1c292669320ed @@ -2297,10 +2081,7 @@ end68ac2e7dcb3704e235e1c292669320ed: if !(int8(x) > int8(y) && uint8(x) > uint8(y)) { goto endac1c49c82fb6b76dd324042c4588973c } - v.Op = OpAMD64FlagGT_UGT - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64FlagGT_UGT) return true } goto endac1c49c82fb6b76dd324042c4588973c @@ -2318,10 +2099,7 @@ endac1c49c82fb6b76dd324042c4588973c: if !(int8(m)+1 == int8(n) && isPowerOfTwo(int64(int8(n)))) { goto end82aa9d89330cb5dc58592048bfc16ebc } - v.Op = OpAMD64FlagLT_ULT - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64FlagLT_ULT) return true } goto end82aa9d89330cb5dc58592048bfc16ebc @@ -2339,10 +2117,7 @@ end82aa9d89330cb5dc58592048bfc16ebc: if v.AuxInt != 0 { goto endc1dd0adee6d97d0f2644600fa5247db5 } - v.Op = OpAMD64TESTB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64TESTB) v.AddArg(x) v.AddArg(y) return true @@ -2362,10 +2137,7 @@ endc1dd0adee6d97d0f2644600fa5247db5: if v.AuxInt != 0 { goto end575fd7ac1086d0c37e6946db5bbc7e94 } - v.Op = OpAMD64TESTBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64TESTBconst) v.AuxInt = c v.AddArg(x) return true @@ -2387,10 +2159,7 @@ func rewriteValueAMD64_OpAMD64CMPL(v *Value, config *Config) bool { goto end49ff4559c4bdecb2aef0c905e2d9a6cf } c := v.Args[1].AuxInt - v.Op = OpAMD64CMPLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64CMPLconst) v.AddArg(x) v.AuxInt = c return true @@ -2407,10 +2176,7 @@ end49ff4559c4bdecb2aef0c905e2d9a6cf: } c := v.Args[0].AuxInt x := v.Args[1] - v.Op = OpAMD64InvertFlags - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64InvertFlags) v0 := b.NewValue0(v.Line, OpAMD64CMPLconst, TypeFlags) v0.AddArg(x) v0.AuxInt = c @@ -2437,10 +2203,7 @@ func rewriteValueAMD64_OpAMD64CMPLconst(v *Value, config *Config) bool { if !(int32(x) == int32(y)) { goto end7c53f3fc20f710e60f327bf63b4c8d4e } - v.Op = OpAMD64FlagEQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64FlagEQ) return true } goto end7c53f3fc20f710e60f327bf63b4c8d4e @@ -2458,10 +2221,7 @@ end7c53f3fc20f710e60f327bf63b4c8d4e: if !(int32(x) < int32(y) && uint32(x) < uint32(y)) { goto enda12309892d1f4166bfffc9aa62b37111 } - v.Op = OpAMD64FlagLT_ULT - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64FlagLT_ULT) return true } goto enda12309892d1f4166bfffc9aa62b37111 @@ -2479,10 +2239,7 @@ enda12309892d1f4166bfffc9aa62b37111: if !(int32(x) < int32(y) && uint32(x) > uint32(y)) { goto end66603988bfeb71e410328b40425c3418 } - v.Op = OpAMD64FlagLT_UGT - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64FlagLT_UGT) return true } goto end66603988bfeb71e410328b40425c3418 @@ -2500,10 +2257,7 @@ end66603988bfeb71e410328b40425c3418: if !(int32(x) > int32(y) && uint32(x) < uint32(y)) { goto endb1b0b14302e765637328dade12e1ce87 } - v.Op = OpAMD64FlagGT_ULT - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64FlagGT_ULT) return true } goto endb1b0b14302e765637328dade12e1ce87 @@ -2521,10 +2275,7 @@ endb1b0b14302e765637328dade12e1ce87: if !(int32(x) > int32(y) && uint32(x) > uint32(y)) { goto endc7b8e86e537d6e106e237023dc2c9a7b } - v.Op = OpAMD64FlagGT_UGT - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64FlagGT_UGT) return true } goto endc7b8e86e537d6e106e237023dc2c9a7b @@ -2542,10 +2293,7 @@ endc7b8e86e537d6e106e237023dc2c9a7b: if !(int32(m)+1 == int32(n) && isPowerOfTwo(int64(int32(n)))) { goto endf202b9830a1e45f3888f2598c762c702 } - v.Op = OpAMD64FlagLT_ULT - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64FlagLT_ULT) return true } goto endf202b9830a1e45f3888f2598c762c702 @@ -2563,10 +2311,7 @@ endf202b9830a1e45f3888f2598c762c702: if v.AuxInt != 0 { goto endc99c55b2fd4bbe4f6eba9675087f215d } - v.Op = OpAMD64TESTL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64TESTL) v.AddArg(x) v.AddArg(y) return true @@ -2586,10 +2331,7 @@ endc99c55b2fd4bbe4f6eba9675087f215d: if v.AuxInt != 0 { goto end218077662043c7cfb0b92334ec8d691f } - v.Op = OpAMD64TESTLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64TESTLconst) v.AuxInt = c v.AddArg(x) return true @@ -2614,10 +2356,7 @@ func rewriteValueAMD64_OpAMD64CMPQ(v *Value, config *Config) bool { if !(is32Bit(c)) { goto end3bbb2c6caa57853a7561738ce3c0c630 } - v.Op = OpAMD64CMPQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64CMPQconst) v.AddArg(x) v.AuxInt = c return true @@ -2637,10 +2376,7 @@ end3bbb2c6caa57853a7561738ce3c0c630: if !(is32Bit(c)) { goto end153e951c4d9890ee40bf6f189ff6280e } - v.Op = OpAMD64InvertFlags - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64InvertFlags) v0 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeFlags) v0.AddArg(x) v0.AuxInt = c @@ -2667,10 +2403,7 @@ func rewriteValueAMD64_OpAMD64CMPQconst(v *Value, config *Config) bool { if !(x == y) { goto enda7a434ec055a51246d67ff14b48e455d } - v.Op = OpAMD64FlagEQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64FlagEQ) return true } goto enda7a434ec055a51246d67ff14b48e455d @@ -2688,10 +2421,7 @@ enda7a434ec055a51246d67ff14b48e455d: if !(x < y && uint64(x) < uint64(y)) { goto end88f2277949392f2b8d03934fd812d3ee } - v.Op = OpAMD64FlagLT_ULT - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64FlagLT_ULT) return true } goto end88f2277949392f2b8d03934fd812d3ee @@ -2709,10 +2439,7 @@ end88f2277949392f2b8d03934fd812d3ee: if !(x < y && uint64(x) > uint64(y)) { goto end38a2207ac4547f3f0cfb2bc48748e033 } - v.Op = OpAMD64FlagLT_UGT - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64FlagLT_UGT) return true } goto end38a2207ac4547f3f0cfb2bc48748e033 @@ -2730,10 +2457,7 @@ end38a2207ac4547f3f0cfb2bc48748e033: if !(x > y && uint64(x) < uint64(y)) { goto end0adaa13f82a881b97095d7a210b96f3c } - v.Op = OpAMD64FlagGT_ULT - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64FlagGT_ULT) return true } goto end0adaa13f82a881b97095d7a210b96f3c @@ -2751,10 +2475,7 @@ end0adaa13f82a881b97095d7a210b96f3c: if !(x > y && uint64(x) > uint64(y)) { goto end1248b87e4a141c78bc8eff05d3fac70e } - v.Op = OpAMD64FlagGT_UGT - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64FlagGT_UGT) return true } goto end1248b87e4a141c78bc8eff05d3fac70e @@ -2772,10 +2493,7 @@ end1248b87e4a141c78bc8eff05d3fac70e: if !(m+1 == n && isPowerOfTwo(n)) { goto end934098fb12e383829b654938269abc12 } - v.Op = OpAMD64FlagLT_ULT - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64FlagLT_ULT) return true } goto end934098fb12e383829b654938269abc12 @@ -2793,10 +2511,7 @@ end934098fb12e383829b654938269abc12: if v.AuxInt != 0 { goto endd253b271c624b83def50b061d8a945a1 } - v.Op = OpAMD64TESTQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64TESTQ) v.AddArg(x) v.AddArg(y) return true @@ -2816,10 +2531,7 @@ endd253b271c624b83def50b061d8a945a1: if v.AuxInt != 0 { goto endcf00c5ad714d2152d72184b163c8d57c } - v.Op = OpAMD64TESTQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64TESTQconst) v.AuxInt = c v.AddArg(x) return true @@ -2841,10 +2553,7 @@ func rewriteValueAMD64_OpAMD64CMPW(v *Value, config *Config) bool { goto end310a9ba58ac35c97587e08c63fe8a46c } c := v.Args[1].AuxInt - v.Op = OpAMD64CMPWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64CMPWconst) v.AddArg(x) v.AuxInt = c return true @@ -2861,10 +2570,7 @@ end310a9ba58ac35c97587e08c63fe8a46c: } c := v.Args[0].AuxInt x := v.Args[1] - v.Op = OpAMD64InvertFlags - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64InvertFlags) v0 := b.NewValue0(v.Line, OpAMD64CMPWconst, TypeFlags) v0.AddArg(x) v0.AuxInt = c @@ -2891,10 +2597,7 @@ func rewriteValueAMD64_OpAMD64CMPWconst(v *Value, config *Config) bool { if !(int16(x) == int16(y)) { goto endff7e81d2095a9997513cae77cd245b43 } - v.Op = OpAMD64FlagEQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64FlagEQ) return true } goto endff7e81d2095a9997513cae77cd245b43 @@ -2912,10 +2615,7 @@ endff7e81d2095a9997513cae77cd245b43: if !(int16(x) < int16(y) && uint16(x) < uint16(y)) { goto end13137b0dee5a1ef5d508b312e4fa947c } - v.Op = OpAMD64FlagLT_ULT - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64FlagLT_ULT) return true } goto end13137b0dee5a1ef5d508b312e4fa947c @@ -2933,10 +2633,7 @@ end13137b0dee5a1ef5d508b312e4fa947c: if !(int16(x) < int16(y) && uint16(x) > uint16(y)) { goto ended901a2a49e592c431e45ffc17ca213d } - v.Op = OpAMD64FlagLT_UGT - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64FlagLT_UGT) return true } goto ended901a2a49e592c431e45ffc17ca213d @@ -2954,10 +2651,7 @@ ended901a2a49e592c431e45ffc17ca213d: if !(int16(x) > int16(y) && uint16(x) < uint16(y)) { goto end66b1d55596a00cdc04ad83bfdeb6be8b } - v.Op = OpAMD64FlagGT_ULT - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64FlagGT_ULT) return true } goto end66b1d55596a00cdc04ad83bfdeb6be8b @@ -2975,10 +2669,7 @@ end66b1d55596a00cdc04ad83bfdeb6be8b: if !(int16(x) > int16(y) && uint16(x) > uint16(y)) { goto end4493f5af38d242ebb4bc2f64055a0854 } - v.Op = OpAMD64FlagGT_UGT - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64FlagGT_UGT) return true } goto end4493f5af38d242ebb4bc2f64055a0854 @@ -2996,10 +2687,7 @@ end4493f5af38d242ebb4bc2f64055a0854: if !(int16(m)+1 == int16(n) && isPowerOfTwo(int64(int16(n)))) { goto endfcea07d93ded49b0e02d5fa0059309a4 } - v.Op = OpAMD64FlagLT_ULT - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64FlagLT_ULT) return true } goto endfcea07d93ded49b0e02d5fa0059309a4 @@ -3017,10 +2705,7 @@ endfcea07d93ded49b0e02d5fa0059309a4: if v.AuxInt != 0 { goto end390cbc150fec59cbf63a209c485ef8b2 } - v.Op = OpAMD64TESTW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64TESTW) v.AddArg(x) v.AddArg(y) return true @@ -3040,10 +2725,7 @@ end390cbc150fec59cbf63a209c485ef8b2: if v.AuxInt != 0 { goto end1bde0fea3dcffeb66b314bc6b4c9aae5 } - v.Op = OpAMD64TESTWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64TESTWconst) v.AuxInt = c v.AddArg(x) return true @@ -3064,10 +2746,7 @@ func rewriteValueAMD64_OpClosureCall(v *Value, config *Config) bool { entry := v.Args[0] closure := v.Args[1] mem := v.Args[2] - v.Op = OpAMD64CALLclosure - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64CALLclosure) v.AuxInt = argwid v.AddArg(entry) v.AddArg(closure) @@ -3087,10 +2766,7 @@ func rewriteValueAMD64_OpCom16(v *Value, config *Config) bool { // result: (NOTW x) { x := v.Args[0] - v.Op = OpAMD64NOTW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64NOTW) v.AddArg(x) return true } @@ -3107,10 +2783,7 @@ func rewriteValueAMD64_OpCom32(v *Value, config *Config) bool { // result: (NOTL x) { x := v.Args[0] - v.Op = OpAMD64NOTL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64NOTL) v.AddArg(x) return true } @@ -3127,10 +2800,7 @@ func rewriteValueAMD64_OpCom64(v *Value, config *Config) bool { // result: (NOTQ x) { x := v.Args[0] - v.Op = OpAMD64NOTQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64NOTQ) v.AddArg(x) return true } @@ -3147,10 +2817,7 @@ func rewriteValueAMD64_OpCom8(v *Value, config *Config) bool { // result: (NOTB x) { x := v.Args[0] - v.Op = OpAMD64NOTB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64NOTB) v.AddArg(x) return true } @@ -3167,10 +2834,7 @@ func rewriteValueAMD64_OpConst16(v *Value, config *Config) bool { // result: (MOVWconst [val]) { val := v.AuxInt - v.Op = OpAMD64MOVWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVWconst) v.AuxInt = val return true } @@ -3187,10 +2851,7 @@ func rewriteValueAMD64_OpConst32(v *Value, config *Config) bool { // result: (MOVLconst [val]) { val := v.AuxInt - v.Op = OpAMD64MOVLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVLconst) v.AuxInt = val return true } @@ -3207,10 +2868,7 @@ func rewriteValueAMD64_OpConst32F(v *Value, config *Config) bool { // result: (MOVSSconst [val]) { val := v.AuxInt - v.Op = OpAMD64MOVSSconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVSSconst) v.AuxInt = val return true } @@ -3227,10 +2885,7 @@ func rewriteValueAMD64_OpConst64(v *Value, config *Config) bool { // result: (MOVQconst [val]) { val := v.AuxInt - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVQconst) v.AuxInt = val return true } @@ -3247,10 +2902,7 @@ func rewriteValueAMD64_OpConst64F(v *Value, config *Config) bool { // result: (MOVSDconst [val]) { val := v.AuxInt - v.Op = OpAMD64MOVSDconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVSDconst) v.AuxInt = val return true } @@ -3267,10 +2919,7 @@ func rewriteValueAMD64_OpConst8(v *Value, config *Config) bool { // result: (MOVBconst [val]) { val := v.AuxInt - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = val return true } @@ -3287,10 +2936,7 @@ func rewriteValueAMD64_OpConstBool(v *Value, config *Config) bool { // result: (MOVBconst [b]) { b := v.AuxInt - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = b return true } @@ -3306,10 +2952,7 @@ func rewriteValueAMD64_OpConstNil(v *Value, config *Config) bool { // cond: // result: (MOVQconst [0]) { - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVQconst) v.AuxInt = 0 return true } @@ -3328,11 +2971,8 @@ func rewriteValueAMD64_OpConvert(v *Value, config *Config) bool { t := v.Type x := v.Args[0] mem := v.Args[1] + v.reset(OpAMD64MOVQconvert) v.Type = t - v.Op = OpAMD64MOVQconvert - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() v.AddArg(x) v.AddArg(mem) return true @@ -3350,10 +2990,7 @@ func rewriteValueAMD64_OpCvt32Fto32(v *Value, config *Config) bool { // result: (CVTTSS2SL x) { x := v.Args[0] - v.Op = OpAMD64CVTTSS2SL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64CVTTSS2SL) v.AddArg(x) return true } @@ -3370,10 +3007,7 @@ func rewriteValueAMD64_OpCvt32Fto64(v *Value, config *Config) bool { // result: (CVTTSS2SQ x) { x := v.Args[0] - v.Op = OpAMD64CVTTSS2SQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64CVTTSS2SQ) v.AddArg(x) return true } @@ -3390,10 +3024,7 @@ func rewriteValueAMD64_OpCvt32Fto64F(v *Value, config *Config) bool { // result: (CVTSS2SD x) { x := v.Args[0] - v.Op = OpAMD64CVTSS2SD - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64CVTSS2SD) v.AddArg(x) return true } @@ -3410,10 +3041,7 @@ func rewriteValueAMD64_OpCvt32to32F(v *Value, config *Config) bool { // result: (CVTSL2SS x) { x := v.Args[0] - v.Op = OpAMD64CVTSL2SS - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64CVTSL2SS) v.AddArg(x) return true } @@ -3430,10 +3058,7 @@ func rewriteValueAMD64_OpCvt32to64F(v *Value, config *Config) bool { // result: (CVTSL2SD x) { x := v.Args[0] - v.Op = OpAMD64CVTSL2SD - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64CVTSL2SD) v.AddArg(x) return true } @@ -3450,10 +3075,7 @@ func rewriteValueAMD64_OpCvt64Fto32(v *Value, config *Config) bool { // result: (CVTTSD2SL x) { x := v.Args[0] - v.Op = OpAMD64CVTTSD2SL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64CVTTSD2SL) v.AddArg(x) return true } @@ -3470,10 +3092,7 @@ func rewriteValueAMD64_OpCvt64Fto32F(v *Value, config *Config) bool { // result: (CVTSD2SS x) { x := v.Args[0] - v.Op = OpAMD64CVTSD2SS - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64CVTSD2SS) v.AddArg(x) return true } @@ -3490,10 +3109,7 @@ func rewriteValueAMD64_OpCvt64Fto64(v *Value, config *Config) bool { // result: (CVTTSD2SQ x) { x := v.Args[0] - v.Op = OpAMD64CVTTSD2SQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64CVTTSD2SQ) v.AddArg(x) return true } @@ -3510,10 +3126,7 @@ func rewriteValueAMD64_OpCvt64to32F(v *Value, config *Config) bool { // result: (CVTSQ2SS x) { x := v.Args[0] - v.Op = OpAMD64CVTSQ2SS - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64CVTSQ2SS) v.AddArg(x) return true } @@ -3530,10 +3143,7 @@ func rewriteValueAMD64_OpCvt64to64F(v *Value, config *Config) bool { // result: (CVTSQ2SD x) { x := v.Args[0] - v.Op = OpAMD64CVTSQ2SD - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64CVTSQ2SD) v.AddArg(x) return true } @@ -3551,10 +3161,7 @@ func rewriteValueAMD64_OpDeferCall(v *Value, config *Config) bool { { argwid := v.AuxInt mem := v.Args[0] - v.Op = OpAMD64CALLdefer - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64CALLdefer) v.AuxInt = argwid v.AddArg(mem) return true @@ -3573,10 +3180,7 @@ func rewriteValueAMD64_OpDiv16(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64DIVW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64DIVW) v.AddArg(x) v.AddArg(y) return true @@ -3595,10 +3199,7 @@ func rewriteValueAMD64_OpDiv16u(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64DIVWU - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64DIVWU) v.AddArg(x) v.AddArg(y) return true @@ -3617,10 +3218,7 @@ func rewriteValueAMD64_OpDiv32(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64DIVL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64DIVL) v.AddArg(x) v.AddArg(y) return true @@ -3639,10 +3237,7 @@ func rewriteValueAMD64_OpDiv32F(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64DIVSS - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64DIVSS) v.AddArg(x) v.AddArg(y) return true @@ -3661,10 +3256,7 @@ func rewriteValueAMD64_OpDiv32u(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64DIVLU - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64DIVLU) v.AddArg(x) v.AddArg(y) return true @@ -3683,10 +3275,7 @@ func rewriteValueAMD64_OpDiv64(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64DIVQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64DIVQ) v.AddArg(x) v.AddArg(y) return true @@ -3705,10 +3294,7 @@ func rewriteValueAMD64_OpDiv64F(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64DIVSD - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64DIVSD) v.AddArg(x) v.AddArg(y) return true @@ -3727,10 +3313,7 @@ func rewriteValueAMD64_OpDiv64u(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64DIVQU - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64DIVQU) v.AddArg(x) v.AddArg(y) return true @@ -3749,10 +3332,7 @@ func rewriteValueAMD64_OpDiv8(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64DIVW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64DIVW) v0 := b.NewValue0(v.Line, OpSignExt8to16, config.fe.TypeInt16()) v0.AddArg(x) v.AddArg(v0) @@ -3775,10 +3355,7 @@ func rewriteValueAMD64_OpDiv8u(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64DIVWU - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64DIVWU) v0 := b.NewValue0(v.Line, OpZeroExt8to16, config.fe.TypeUInt16()) v0.AddArg(x) v.AddArg(v0) @@ -3801,10 +3378,7 @@ func rewriteValueAMD64_OpEq16(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETEQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETEQ) v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -3825,10 +3399,7 @@ func rewriteValueAMD64_OpEq32(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETEQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETEQ) v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -3849,10 +3420,7 @@ func rewriteValueAMD64_OpEq32F(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETEQF - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETEQF) v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -3873,10 +3441,7 @@ func rewriteValueAMD64_OpEq64(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETEQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETEQ) v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -3897,10 +3462,7 @@ func rewriteValueAMD64_OpEq64F(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETEQF - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETEQF) v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -3921,10 +3483,7 @@ func rewriteValueAMD64_OpEq8(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETEQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETEQ) v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -3945,10 +3504,7 @@ func rewriteValueAMD64_OpEqPtr(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETEQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETEQ) v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -3969,10 +3525,7 @@ func rewriteValueAMD64_OpGeq16(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETGE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETGE) v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -3993,10 +3546,7 @@ func rewriteValueAMD64_OpGeq16U(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETAE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETAE) v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -4017,10 +3567,7 @@ func rewriteValueAMD64_OpGeq32(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETGE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETGE) v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -4041,10 +3588,7 @@ func rewriteValueAMD64_OpGeq32F(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETGEF - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETGEF) v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -4065,10 +3609,7 @@ func rewriteValueAMD64_OpGeq32U(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETAE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETAE) v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -4089,10 +3630,7 @@ func rewriteValueAMD64_OpGeq64(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETGE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETGE) v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -4113,10 +3651,7 @@ func rewriteValueAMD64_OpGeq64F(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETGEF - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETGEF) v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -4137,10 +3672,7 @@ func rewriteValueAMD64_OpGeq64U(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETAE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETAE) v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -4161,10 +3693,7 @@ func rewriteValueAMD64_OpGeq8(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETGE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETGE) v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -4185,10 +3714,7 @@ func rewriteValueAMD64_OpGeq8U(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETAE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETAE) v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -4207,10 +3733,7 @@ func rewriteValueAMD64_OpGetClosurePtr(v *Value, config *Config) bool { // cond: // result: (LoweredGetClosurePtr) { - v.Op = OpAMD64LoweredGetClosurePtr - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64LoweredGetClosurePtr) return true } goto end6fd0b53f0acb4d35e7d7fa78d2ca1392 @@ -4226,10 +3749,7 @@ func rewriteValueAMD64_OpGetG(v *Value, config *Config) bool { // result: (LoweredGetG mem) { mem := v.Args[0] - v.Op = OpAMD64LoweredGetG - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64LoweredGetG) v.AddArg(mem) return true } @@ -4247,10 +3767,7 @@ func rewriteValueAMD64_OpGoCall(v *Value, config *Config) bool { { argwid := v.AuxInt mem := v.Args[0] - v.Op = OpAMD64CALLgo - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64CALLgo) v.AuxInt = argwid v.AddArg(mem) return true @@ -4269,10 +3786,7 @@ func rewriteValueAMD64_OpGreater16(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETG - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETG) v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -4293,10 +3807,7 @@ func rewriteValueAMD64_OpGreater16U(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETA - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETA) v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -4317,10 +3828,7 @@ func rewriteValueAMD64_OpGreater32(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETG - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETG) v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -4341,10 +3849,7 @@ func rewriteValueAMD64_OpGreater32F(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETGF - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETGF) v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -4365,10 +3870,7 @@ func rewriteValueAMD64_OpGreater32U(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETA - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETA) v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -4389,10 +3891,7 @@ func rewriteValueAMD64_OpGreater64(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETG - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETG) v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -4413,10 +3912,7 @@ func rewriteValueAMD64_OpGreater64F(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETGF - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETGF) v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -4437,10 +3933,7 @@ func rewriteValueAMD64_OpGreater64U(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETA - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETA) v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -4461,10 +3954,7 @@ func rewriteValueAMD64_OpGreater8(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETG - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETG) v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -4485,10 +3975,7 @@ func rewriteValueAMD64_OpGreater8U(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETA - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETA) v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -4509,10 +3996,7 @@ func rewriteValueAMD64_OpHmul16(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64HMULW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64HMULW) v.AddArg(x) v.AddArg(y) return true @@ -4531,10 +4015,7 @@ func rewriteValueAMD64_OpHmul16u(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64HMULWU - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64HMULWU) v.AddArg(x) v.AddArg(y) return true @@ -4553,10 +4034,7 @@ func rewriteValueAMD64_OpHmul32(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64HMULL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64HMULL) v.AddArg(x) v.AddArg(y) return true @@ -4575,10 +4053,7 @@ func rewriteValueAMD64_OpHmul32u(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64HMULLU - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64HMULLU) v.AddArg(x) v.AddArg(y) return true @@ -4597,10 +4072,7 @@ func rewriteValueAMD64_OpHmul8(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64HMULB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64HMULB) v.AddArg(x) v.AddArg(y) return true @@ -4619,10 +4091,7 @@ func rewriteValueAMD64_OpHmul8u(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64HMULBU - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64HMULBU) v.AddArg(x) v.AddArg(y) return true @@ -4644,10 +4113,7 @@ func rewriteValueAMD64_OpITab(v *Value, config *Config) bool { } ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] - v.Op = OpAMD64MOVQload - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVQload) v.AddArg(ptr) v.AddArg(mem) return true @@ -4667,10 +4133,7 @@ func rewriteValueAMD64_OpInterCall(v *Value, config *Config) bool { argwid := v.AuxInt entry := v.Args[0] mem := v.Args[1] - v.Op = OpAMD64CALLinter - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64CALLinter) v.AuxInt = argwid v.AddArg(entry) v.AddArg(mem) @@ -4690,10 +4153,7 @@ func rewriteValueAMD64_OpIsInBounds(v *Value, config *Config) bool { { idx := v.Args[0] len := v.Args[1] - v.Op = OpAMD64SETB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETB) v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeFlags) v0.AddArg(idx) v0.AddArg(len) @@ -4713,10 +4173,7 @@ func rewriteValueAMD64_OpIsNonNil(v *Value, config *Config) bool { // result: (SETNE (TESTQ p p)) { p := v.Args[0] - v.Op = OpAMD64SETNE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETNE) v0 := b.NewValue0(v.Line, OpAMD64TESTQ, TypeFlags) v0.AddArg(p) v0.AddArg(p) @@ -4737,10 +4194,7 @@ func rewriteValueAMD64_OpIsSliceInBounds(v *Value, config *Config) bool { { idx := v.Args[0] len := v.Args[1] - v.Op = OpAMD64SETBE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETBE) v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeFlags) v0.AddArg(idx) v0.AddArg(len) @@ -4770,10 +4224,7 @@ func rewriteValueAMD64_OpAMD64LEAQ(v *Value, config *Config) bool { if !(canMergeSym(sym1, sym2)) { goto end2e2249051d6776a92bcb0d83107e0d82 } - v.Op = OpAMD64LEAQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64LEAQ) v.AuxInt = addOff(off1, off2) v.Aux = mergeSym(sym1, sym2) v.AddArg(x) @@ -4798,10 +4249,7 @@ end2e2249051d6776a92bcb0d83107e0d82: if !(canMergeSym(sym1, sym2)) { goto end4e2502574680cc8e02dcc07561e96ef9 } - v.Op = OpAMD64LEAQ1 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64LEAQ1) v.AuxInt = addOff(off1, off2) v.Aux = mergeSym(sym1, sym2) v.AddArg(x) @@ -4827,10 +4275,7 @@ end4e2502574680cc8e02dcc07561e96ef9: if !(canMergeSym(sym1, sym2)) { goto end92e54b1fbb5ba0b17a6006fe56b4d57b } - v.Op = OpAMD64LEAQ2 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64LEAQ2) v.AuxInt = addOff(off1, off2) v.Aux = mergeSym(sym1, sym2) v.AddArg(x) @@ -4856,10 +4301,7 @@ end92e54b1fbb5ba0b17a6006fe56b4d57b: if !(canMergeSym(sym1, sym2)) { goto end5da4c89d542d34d0d7f8848c3ea0fead } - v.Op = OpAMD64LEAQ4 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64LEAQ4) v.AuxInt = addOff(off1, off2) v.Aux = mergeSym(sym1, sym2) v.AddArg(x) @@ -4885,10 +4327,7 @@ end5da4c89d542d34d0d7f8848c3ea0fead: if !(canMergeSym(sym1, sym2)) { goto endc051937df5f12598e76c0923b5a60a39 } - v.Op = OpAMD64LEAQ8 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64LEAQ8) v.AuxInt = addOff(off1, off2) v.Aux = mergeSym(sym1, sym2) v.AddArg(x) @@ -4919,10 +4358,7 @@ func rewriteValueAMD64_OpAMD64LEAQ1(v *Value, config *Config) bool { if !(canMergeSym(sym1, sym2) && x.Op != OpSB) { goto end3b837b0ce1bd6a79804a28ee529fc65b } - v.Op = OpAMD64LEAQ1 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64LEAQ1) v.AuxInt = addOff(off1, off2) v.Aux = mergeSym(sym1, sym2) v.AddArg(x) @@ -4948,10 +4384,7 @@ end3b837b0ce1bd6a79804a28ee529fc65b: if !(canMergeSym(sym1, sym2) && y.Op != OpSB) { goto endfd9dd9448d726fc7d82274b404cddb67 } - v.Op = OpAMD64LEAQ1 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64LEAQ1) v.AuxInt = addOff(off1, off2) v.Aux = mergeSym(sym1, sym2) v.AddArg(x) @@ -4982,10 +4415,7 @@ func rewriteValueAMD64_OpAMD64LEAQ2(v *Value, config *Config) bool { if !(canMergeSym(sym1, sym2) && x.Op != OpSB) { goto end2bf3cb6e212c3f62ab83ce10059e672e } - v.Op = OpAMD64LEAQ2 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64LEAQ2) v.AuxInt = addOff(off1, off2) v.Aux = mergeSym(sym1, sym2) v.AddArg(x) @@ -5016,10 +4446,7 @@ func rewriteValueAMD64_OpAMD64LEAQ4(v *Value, config *Config) bool { if !(canMergeSym(sym1, sym2) && x.Op != OpSB) { goto end066907f169f09e56139e801397316c95 } - v.Op = OpAMD64LEAQ4 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64LEAQ4) v.AuxInt = addOff(off1, off2) v.Aux = mergeSym(sym1, sym2) v.AddArg(x) @@ -5050,10 +4477,7 @@ func rewriteValueAMD64_OpAMD64LEAQ8(v *Value, config *Config) bool { if !(canMergeSym(sym1, sym2) && x.Op != OpSB) { goto end6bde9448027690b01bbf30dee061ce23 } - v.Op = OpAMD64LEAQ8 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64LEAQ8) v.AuxInt = addOff(off1, off2) v.Aux = mergeSym(sym1, sym2) v.AddArg(x) @@ -5074,10 +4498,7 @@ func rewriteValueAMD64_OpLeq16(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETLE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETLE) v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -5098,10 +4519,7 @@ func rewriteValueAMD64_OpLeq16U(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETBE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETBE) v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -5122,10 +4540,7 @@ func rewriteValueAMD64_OpLeq32(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETLE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETLE) v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -5146,10 +4561,7 @@ func rewriteValueAMD64_OpLeq32F(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETGEF - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETGEF) v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeFlags) v0.AddArg(y) v0.AddArg(x) @@ -5170,10 +4582,7 @@ func rewriteValueAMD64_OpLeq32U(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETBE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETBE) v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -5194,10 +4603,7 @@ func rewriteValueAMD64_OpLeq64(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETLE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETLE) v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -5218,10 +4624,7 @@ func rewriteValueAMD64_OpLeq64F(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETGEF - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETGEF) v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeFlags) v0.AddArg(y) v0.AddArg(x) @@ -5242,10 +4645,7 @@ func rewriteValueAMD64_OpLeq64U(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETBE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETBE) v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -5266,10 +4666,7 @@ func rewriteValueAMD64_OpLeq8(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETLE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETLE) v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -5290,10 +4687,7 @@ func rewriteValueAMD64_OpLeq8U(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETBE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETBE) v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -5314,10 +4708,7 @@ func rewriteValueAMD64_OpLess16(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETL) v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -5338,10 +4729,7 @@ func rewriteValueAMD64_OpLess16U(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETB) v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -5362,10 +4750,7 @@ func rewriteValueAMD64_OpLess32(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETL) v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -5386,10 +4771,7 @@ func rewriteValueAMD64_OpLess32F(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETGF - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETGF) v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeFlags) v0.AddArg(y) v0.AddArg(x) @@ -5410,10 +4792,7 @@ func rewriteValueAMD64_OpLess32U(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETB) v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -5434,10 +4813,7 @@ func rewriteValueAMD64_OpLess64(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETL) v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -5458,10 +4834,7 @@ func rewriteValueAMD64_OpLess64F(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETGF - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETGF) v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeFlags) v0.AddArg(y) v0.AddArg(x) @@ -5482,10 +4855,7 @@ func rewriteValueAMD64_OpLess64U(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETB) v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -5506,10 +4876,7 @@ func rewriteValueAMD64_OpLess8(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETL) v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -5530,10 +4897,7 @@ func rewriteValueAMD64_OpLess8U(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETB) v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -5558,10 +4922,7 @@ func rewriteValueAMD64_OpLoad(v *Value, config *Config) bool { if !(is64BitInt(t) || isPtr(t)) { goto end7c4c53acf57ebc5f03273652ba1d5934 } - v.Op = OpAMD64MOVQload - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVQload) v.AddArg(ptr) v.AddArg(mem) return true @@ -5579,10 +4940,7 @@ end7c4c53acf57ebc5f03273652ba1d5934: if !(is32BitInt(t)) { goto ende1cfcb15bfbcfd448ce303d0882a4057 } - v.Op = OpAMD64MOVLload - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVLload) v.AddArg(ptr) v.AddArg(mem) return true @@ -5600,10 +4958,7 @@ ende1cfcb15bfbcfd448ce303d0882a4057: if !(is16BitInt(t)) { goto end2d0a1304501ed9f4e9e2d288505a9c7c } - v.Op = OpAMD64MOVWload - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVWload) v.AddArg(ptr) v.AddArg(mem) return true @@ -5621,10 +4976,7 @@ end2d0a1304501ed9f4e9e2d288505a9c7c: if !(t.IsBoolean() || is8BitInt(t)) { goto end8f83bf72293670e75b22d6627bd13f0b } - v.Op = OpAMD64MOVBload - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBload) v.AddArg(ptr) v.AddArg(mem) return true @@ -5642,10 +4994,7 @@ end8f83bf72293670e75b22d6627bd13f0b: if !(is32BitFloat(t)) { goto end63383c4895805881aabceebea3c4c533 } - v.Op = OpAMD64MOVSSload - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVSSload) v.AddArg(ptr) v.AddArg(mem) return true @@ -5663,10 +5012,7 @@ end63383c4895805881aabceebea3c4c533: if !(is64BitFloat(t)) { goto end99d0858c0a5bb72f0fe4decc748da812 } - v.Op = OpAMD64MOVSDload - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVSDload) v.AddArg(ptr) v.AddArg(mem) return true @@ -5686,11 +5032,8 @@ func rewriteValueAMD64_OpLrot16(v *Value, config *Config) bool { t := v.Type x := v.Args[0] c := v.AuxInt + v.reset(OpAMD64ROLWconst) v.Type = t - v.Op = OpAMD64ROLWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() v.AuxInt = c & 15 v.AddArg(x) return true @@ -5710,11 +5053,8 @@ func rewriteValueAMD64_OpLrot32(v *Value, config *Config) bool { t := v.Type x := v.Args[0] c := v.AuxInt + v.reset(OpAMD64ROLLconst) v.Type = t - v.Op = OpAMD64ROLLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() v.AuxInt = c & 31 v.AddArg(x) return true @@ -5734,11 +5074,8 @@ func rewriteValueAMD64_OpLrot64(v *Value, config *Config) bool { t := v.Type x := v.Args[0] c := v.AuxInt + v.reset(OpAMD64ROLQconst) v.Type = t - v.Op = OpAMD64ROLQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() v.AuxInt = c & 63 v.AddArg(x) return true @@ -5758,11 +5095,8 @@ func rewriteValueAMD64_OpLrot8(v *Value, config *Config) bool { t := v.Type x := v.Args[0] c := v.AuxInt + v.reset(OpAMD64ROLBconst) v.Type = t - v.Op = OpAMD64ROLBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() v.AuxInt = c & 7 v.AddArg(x) return true @@ -5782,10 +5116,7 @@ func rewriteValueAMD64_OpLsh16x16(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ANDW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDW) v0 := b.NewValue0(v.Line, OpAMD64SHLW, t) v0.AddArg(x) v0.AddArg(y) @@ -5813,10 +5144,7 @@ func rewriteValueAMD64_OpLsh16x32(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ANDW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDW) v0 := b.NewValue0(v.Line, OpAMD64SHLW, t) v0.AddArg(x) v0.AddArg(y) @@ -5844,10 +5172,7 @@ func rewriteValueAMD64_OpLsh16x64(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ANDW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDW) v0 := b.NewValue0(v.Line, OpAMD64SHLW, t) v0.AddArg(x) v0.AddArg(y) @@ -5875,10 +5200,7 @@ func rewriteValueAMD64_OpLsh16x8(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ANDW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDW) v0 := b.NewValue0(v.Line, OpAMD64SHLW, t) v0.AddArg(x) v0.AddArg(y) @@ -5906,10 +5228,7 @@ func rewriteValueAMD64_OpLsh32x16(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ANDL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDL) v0 := b.NewValue0(v.Line, OpAMD64SHLL, t) v0.AddArg(x) v0.AddArg(y) @@ -5937,10 +5256,7 @@ func rewriteValueAMD64_OpLsh32x32(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ANDL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDL) v0 := b.NewValue0(v.Line, OpAMD64SHLL, t) v0.AddArg(x) v0.AddArg(y) @@ -5968,10 +5284,7 @@ func rewriteValueAMD64_OpLsh32x64(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ANDL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDL) v0 := b.NewValue0(v.Line, OpAMD64SHLL, t) v0.AddArg(x) v0.AddArg(y) @@ -5999,10 +5312,7 @@ func rewriteValueAMD64_OpLsh32x8(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ANDL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDL) v0 := b.NewValue0(v.Line, OpAMD64SHLL, t) v0.AddArg(x) v0.AddArg(y) @@ -6030,10 +5340,7 @@ func rewriteValueAMD64_OpLsh64x16(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ANDQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDQ) v0 := b.NewValue0(v.Line, OpAMD64SHLQ, t) v0.AddArg(x) v0.AddArg(y) @@ -6061,10 +5368,7 @@ func rewriteValueAMD64_OpLsh64x32(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ANDQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDQ) v0 := b.NewValue0(v.Line, OpAMD64SHLQ, t) v0.AddArg(x) v0.AddArg(y) @@ -6092,10 +5396,7 @@ func rewriteValueAMD64_OpLsh64x64(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ANDQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDQ) v0 := b.NewValue0(v.Line, OpAMD64SHLQ, t) v0.AddArg(x) v0.AddArg(y) @@ -6123,10 +5424,7 @@ func rewriteValueAMD64_OpLsh64x8(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ANDQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDQ) v0 := b.NewValue0(v.Line, OpAMD64SHLQ, t) v0.AddArg(x) v0.AddArg(y) @@ -6154,10 +5452,7 @@ func rewriteValueAMD64_OpLsh8x16(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ANDB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDB) v0 := b.NewValue0(v.Line, OpAMD64SHLB, t) v0.AddArg(x) v0.AddArg(y) @@ -6185,10 +5480,7 @@ func rewriteValueAMD64_OpLsh8x32(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ANDB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDB) v0 := b.NewValue0(v.Line, OpAMD64SHLB, t) v0.AddArg(x) v0.AddArg(y) @@ -6216,10 +5508,7 @@ func rewriteValueAMD64_OpLsh8x64(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ANDB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDB) v0 := b.NewValue0(v.Line, OpAMD64SHLB, t) v0.AddArg(x) v0.AddArg(y) @@ -6247,10 +5536,7 @@ func rewriteValueAMD64_OpLsh8x8(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ANDB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDB) v0 := b.NewValue0(v.Line, OpAMD64SHLB, t) v0.AddArg(x) v0.AddArg(y) @@ -6283,10 +5569,7 @@ func rewriteValueAMD64_OpAMD64MOVBQSX(v *Value, config *Config) bool { ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] v0 := v.Args[0].Block.NewValue0(v.Line, OpAMD64MOVBQSXload, v.Type) - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.AddArg(v0) v0.AuxInt = off v0.Aux = sym @@ -6309,10 +5592,7 @@ end19c38f3a1a37dca50637c917fa26e4f7: if !(c&0x80 == 0) { goto endf998318725c3cc6c701ebb69a2473650 } - v.Op = OpAMD64ANDQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDQconst) v.AuxInt = c & 0x7f v.AddArg(x) return true @@ -6337,10 +5617,7 @@ func rewriteValueAMD64_OpAMD64MOVBQZX(v *Value, config *Config) bool { ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] v0 := v.Args[0].Block.NewValue0(v.Line, OpAMD64MOVBQZXload, v.Type) - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.AddArg(v0) v0.AuxInt = off v0.Aux = sym @@ -6360,10 +5637,7 @@ end1169bcf3d56fa24321b002eaebd5a62d: } c := v.Args[0].AuxInt x := v.Args[0].Args[0] - v.Op = OpAMD64ANDQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDQconst) v.AuxInt = c & 0xff v.AddArg(x) return true @@ -6388,10 +5662,7 @@ func rewriteValueAMD64_OpAMD64MOVBload(v *Value, config *Config) bool { off2 := v.Args[0].AuxInt ptr := v.Args[0].Args[0] mem := v.Args[1] - v.Op = OpAMD64MOVBload - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBload) v.AuxInt = addOff(off1, off2) v.Aux = sym v.AddArg(ptr) @@ -6417,10 +5688,7 @@ end7ec9147ab863c1bd59190fed81f894b6: if !(canMergeSym(sym1, sym2)) { goto end3771a59cf66b0df99120d76f4c358fab } - v.Op = OpAMD64MOVBload - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBload) v.AuxInt = addOff(off1, off2) v.Aux = mergeSym(sym1, sym2) v.AddArg(base) @@ -6447,10 +5715,7 @@ func rewriteValueAMD64_OpAMD64MOVBstore(v *Value, config *Config) bool { } x := v.Args[1].Args[0] mem := v.Args[2] - v.Op = OpAMD64MOVBstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBstore) v.AuxInt = off v.Aux = sym v.AddArg(ptr) @@ -6473,10 +5738,7 @@ end5b3f41f0770d566ff1647dea1d4a40e8: } x := v.Args[1].Args[0] mem := v.Args[2] - v.Op = OpAMD64MOVBstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBstore) v.AuxInt = off v.Aux = sym v.AddArg(ptr) @@ -6500,10 +5762,7 @@ end3a2e55db7e03920700c4875f6a55de3b: ptr := v.Args[0].Args[0] val := v.Args[1] mem := v.Args[2] - v.Op = OpAMD64MOVBstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBstore) v.AuxInt = addOff(off1, off2) v.Aux = sym v.AddArg(ptr) @@ -6529,10 +5788,7 @@ ende6347ac19d0469ee59d2e7f2e18d1070: if !(validOff(off)) { goto endfdf24c49923451a076f1868988b8c9d9 } - v.Op = OpAMD64MOVBstoreconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBstoreconst) v.AuxInt = makeValAndOff(int64(int8(c)), off) v.Aux = sym v.AddArg(ptr) @@ -6559,10 +5815,7 @@ endfdf24c49923451a076f1868988b8c9d9: if !(canMergeSym(sym1, sym2)) { goto enda7086cf7f6b8cf81972e2c3d4b12f3fc } - v.Op = OpAMD64MOVBstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBstore) v.AuxInt = addOff(off1, off2) v.Aux = mergeSym(sym1, sym2) v.AddArg(base) @@ -6591,10 +5844,7 @@ enda7086cf7f6b8cf81972e2c3d4b12f3fc: if !(canMergeSym(sym1, sym2)) { goto ende386ced77f1acdae2e8bbc379803b7cf } - v.Op = OpAMD64MOVBstoreidx1 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBstoreidx1) v.AuxInt = addOff(off1, off2) v.Aux = mergeSym(sym1, sym2) v.AddArg(ptr) @@ -6619,10 +5869,7 @@ ende386ced77f1acdae2e8bbc379803b7cf: idx := v.Args[0].Args[1] val := v.Args[1] mem := v.Args[2] - v.Op = OpAMD64MOVBstoreidx1 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBstoreidx1) v.AuxInt = off v.Aux = sym v.AddArg(ptr) @@ -6654,10 +5901,7 @@ func rewriteValueAMD64_OpAMD64MOVBstoreconst(v *Value, config *Config) bool { if !(ValAndOff(sc).canAdd(off)) { goto end8d35ca650b7c40bc43984d3f5925a052 } - v.Op = OpAMD64MOVBstoreconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBstoreconst) v.AuxInt = ValAndOff(sc).add(off) v.Aux = s v.AddArg(ptr) @@ -6683,10 +5927,7 @@ end8d35ca650b7c40bc43984d3f5925a052: if !(canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off)) { goto end8deb839acf84818dd8fc827c0338f42c } - v.Op = OpAMD64MOVBstoreconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBstoreconst) v.AuxInt = ValAndOff(sc).add(off) v.Aux = mergeSym(sym1, sym2) v.AddArg(ptr) @@ -6715,10 +5956,7 @@ func rewriteValueAMD64_OpAMD64MOVBstoreidx1(v *Value, config *Config) bool { idx := v.Args[1] val := v.Args[2] mem := v.Args[3] - v.Op = OpAMD64MOVBstoreidx1 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBstoreidx1) v.AuxInt = addOff(off1, off2) v.Aux = sym v.AddArg(ptr) @@ -6747,10 +5985,7 @@ func rewriteValueAMD64_OpAMD64MOVLQSX(v *Value, config *Config) bool { ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] v0 := v.Args[0].Block.NewValue0(v.Line, OpAMD64MOVLQSXload, v.Type) - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.AddArg(v0) v0.AuxInt = off v0.Aux = sym @@ -6773,10 +6008,7 @@ end9498ad52d5051e8e3ee9b0ed7af68d01: if !(c&0x80000000 == 0) { goto end286a5aa0d10b04039cbe6e09307b4cbe } - v.Op = OpAMD64ANDQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDQconst) v.AuxInt = c & 0x7fffffff v.AddArg(x) return true @@ -6801,10 +6033,7 @@ func rewriteValueAMD64_OpAMD64MOVLQZX(v *Value, config *Config) bool { ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] v0 := v.Args[0].Block.NewValue0(v.Line, OpAMD64MOVLQZXload, v.Type) - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.AddArg(v0) v0.AuxInt = off v0.Aux = sym @@ -6824,10 +6053,7 @@ endb00602ccd4180bd749a3b01914264fbc: } c := v.Args[0].AuxInt x := v.Args[0].Args[0] - v.Op = OpAMD64ANDQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDQconst) v.AuxInt = c & 0xffffffff v.AddArg(x) return true @@ -6852,10 +6078,7 @@ func rewriteValueAMD64_OpAMD64MOVLload(v *Value, config *Config) bool { off2 := v.Args[0].AuxInt ptr := v.Args[0].Args[0] mem := v.Args[1] - v.Op = OpAMD64MOVLload - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVLload) v.AuxInt = addOff(off1, off2) v.Aux = sym v.AddArg(ptr) @@ -6881,10 +6104,7 @@ end0c8b8a40360c5c581d92723eca04d340: if !(canMergeSym(sym1, sym2)) { goto enddb9e59335876d8a565c425731438a1b3 } - v.Op = OpAMD64MOVLload - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVLload) v.AuxInt = addOff(off1, off2) v.Aux = mergeSym(sym1, sym2) v.AddArg(base) @@ -6911,10 +6131,7 @@ func rewriteValueAMD64_OpAMD64MOVLstore(v *Value, config *Config) bool { } x := v.Args[1].Args[0] mem := v.Args[2] - v.Op = OpAMD64MOVLstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVLstore) v.AuxInt = off v.Aux = sym v.AddArg(ptr) @@ -6937,10 +6154,7 @@ end1fb7b2ae707c76d30927c21f85d77472: } x := v.Args[1].Args[0] mem := v.Args[2] - v.Op = OpAMD64MOVLstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVLstore) v.AuxInt = off v.Aux = sym v.AddArg(ptr) @@ -6964,10 +6178,7 @@ end199e8c23a5e7e99728a43d6a83b2c2cf: ptr := v.Args[0].Args[0] val := v.Args[1] mem := v.Args[2] - v.Op = OpAMD64MOVLstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVLstore) v.AuxInt = addOff(off1, off2) v.Aux = sym v.AddArg(ptr) @@ -6993,10 +6204,7 @@ end43bffdb8d9c1fc85a95778d4911955f1: if !(validOff(off)) { goto enda62a54c45bf42db801af4095d27faccd } - v.Op = OpAMD64MOVLstoreconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVLstoreconst) v.AuxInt = makeValAndOff(int64(int32(c)), off) v.Aux = sym v.AddArg(ptr) @@ -7023,10 +6231,7 @@ enda62a54c45bf42db801af4095d27faccd: if !(canMergeSym(sym1, sym2)) { goto endd57b1e4313fc7a3331340a9af00ba116 } - v.Op = OpAMD64MOVLstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVLstore) v.AuxInt = addOff(off1, off2) v.Aux = mergeSym(sym1, sym2) v.AddArg(base) @@ -7055,10 +6260,7 @@ endd57b1e4313fc7a3331340a9af00ba116: if !(canMergeSym(sym1, sym2)) { goto end6d2bbe089d6de8d261fcdeef263d2f7c } - v.Op = OpAMD64MOVLstoreidx4 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVLstoreidx4) v.AuxInt = addOff(off1, off2) v.Aux = mergeSym(sym1, sym2) v.AddArg(ptr) @@ -7090,10 +6292,7 @@ func rewriteValueAMD64_OpAMD64MOVLstoreconst(v *Value, config *Config) bool { if !(ValAndOff(sc).canAdd(off)) { goto end4981598152dd0763f1d735810a7d34e8 } - v.Op = OpAMD64MOVLstoreconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVLstoreconst) v.AuxInt = ValAndOff(sc).add(off) v.Aux = s v.AddArg(ptr) @@ -7119,10 +6318,7 @@ end4981598152dd0763f1d735810a7d34e8: if !(canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off)) { goto endd579250954b5df84a77518b36f739e12 } - v.Op = OpAMD64MOVLstoreconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVLstoreconst) v.AuxInt = ValAndOff(sc).add(off) v.Aux = mergeSym(sym1, sym2) v.AddArg(ptr) @@ -7151,10 +6347,7 @@ func rewriteValueAMD64_OpAMD64MOVLstoreidx4(v *Value, config *Config) bool { idx := v.Args[1] val := v.Args[2] mem := v.Args[3] - v.Op = OpAMD64MOVLstoreidx4 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVLstoreidx4) v.AuxInt = addOff(off1, off2) v.Aux = sym v.AddArg(ptr) @@ -7183,10 +6376,7 @@ func rewriteValueAMD64_OpAMD64MOVOload(v *Value, config *Config) bool { off2 := v.Args[0].AuxInt ptr := v.Args[0].Args[0] mem := v.Args[1] - v.Op = OpAMD64MOVOload - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVOload) v.AuxInt = addOff(off1, off2) v.Aux = sym v.AddArg(ptr) @@ -7212,10 +6402,7 @@ endf1e8fcf569ddd8b3f7a2f61696971913: if !(canMergeSym(sym1, sym2)) { goto endd36cf9b00af7a8f44fb8c60067a8efb2 } - v.Op = OpAMD64MOVOload - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVOload) v.AuxInt = addOff(off1, off2) v.Aux = mergeSym(sym1, sym2) v.AddArg(base) @@ -7243,10 +6430,7 @@ func rewriteValueAMD64_OpAMD64MOVOstore(v *Value, config *Config) bool { ptr := v.Args[0].Args[0] val := v.Args[1] mem := v.Args[2] - v.Op = OpAMD64MOVOstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVOstore) v.AuxInt = addOff(off1, off2) v.Aux = sym v.AddArg(ptr) @@ -7274,10 +6458,7 @@ end2be573aa1bd919e567e6156a4ee36517: if !(canMergeSym(sym1, sym2)) { goto endc28b9b3efe9eb235e1586c4555280c20 } - v.Op = OpAMD64MOVOstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVOstore) v.AuxInt = addOff(off1, off2) v.Aux = mergeSym(sym1, sym2) v.AddArg(base) @@ -7305,10 +6486,7 @@ func rewriteValueAMD64_OpAMD64MOVQload(v *Value, config *Config) bool { off2 := v.Args[0].AuxInt ptr := v.Args[0].Args[0] mem := v.Args[1] - v.Op = OpAMD64MOVQload - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVQload) v.AuxInt = addOff(off1, off2) v.Aux = sym v.AddArg(ptr) @@ -7334,10 +6512,7 @@ end0b8c50dd7faefb7d046f9a27e054df77: if !(canMergeSym(sym1, sym2)) { goto endd0c093adc4f05f2037005734c77d3cc4 } - v.Op = OpAMD64MOVQload - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVQload) v.AuxInt = addOff(off1, off2) v.Aux = mergeSym(sym1, sym2) v.AddArg(base) @@ -7364,10 +6539,7 @@ endd0c093adc4f05f2037005734c77d3cc4: if !(canMergeSym(sym1, sym2)) { goto end74a50d810fb3945e809f608cd094a59c } - v.Op = OpAMD64MOVQloadidx8 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVQloadidx8) v.AuxInt = addOff(off1, off2) v.Aux = mergeSym(sym1, sym2) v.AddArg(ptr) @@ -7396,10 +6568,7 @@ func rewriteValueAMD64_OpAMD64MOVQloadidx8(v *Value, config *Config) bool { ptr := v.Args[0].Args[0] idx := v.Args[1] mem := v.Args[2] - v.Op = OpAMD64MOVQloadidx8 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVQloadidx8) v.AuxInt = addOff(off1, off2) v.Aux = sym v.AddArg(ptr) @@ -7428,10 +6597,7 @@ func rewriteValueAMD64_OpAMD64MOVQstore(v *Value, config *Config) bool { ptr := v.Args[0].Args[0] val := v.Args[1] mem := v.Args[2] - v.Op = OpAMD64MOVQstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVQstore) v.AuxInt = addOff(off1, off2) v.Aux = sym v.AddArg(ptr) @@ -7457,10 +6623,7 @@ end0a110b5e42a4576c32fda50590092848: if !(validValAndOff(c, off)) { goto endda0f4b36e19753762dbd1c6ee05e4c81 } - v.Op = OpAMD64MOVQstoreconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVQstoreconst) v.AuxInt = makeValAndOff(c, off) v.Aux = sym v.AddArg(ptr) @@ -7487,10 +6650,7 @@ endda0f4b36e19753762dbd1c6ee05e4c81: if !(canMergeSym(sym1, sym2)) { goto end9a0cfe20b3b0f587e252760907c1b5c0 } - v.Op = OpAMD64MOVQstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVQstore) v.AuxInt = addOff(off1, off2) v.Aux = mergeSym(sym1, sym2) v.AddArg(base) @@ -7519,10 +6679,7 @@ end9a0cfe20b3b0f587e252760907c1b5c0: if !(canMergeSym(sym1, sym2)) { goto end442c322e6719e280b6be1c12858e49d7 } - v.Op = OpAMD64MOVQstoreidx8 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVQstoreidx8) v.AuxInt = addOff(off1, off2) v.Aux = mergeSym(sym1, sym2) v.AddArg(ptr) @@ -7554,10 +6711,7 @@ func rewriteValueAMD64_OpAMD64MOVQstoreconst(v *Value, config *Config) bool { if !(ValAndOff(sc).canAdd(off)) { goto end3694207cd20e8e1cc719e179bdfe0c74 } - v.Op = OpAMD64MOVQstoreconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVQstoreconst) v.AuxInt = ValAndOff(sc).add(off) v.Aux = s v.AddArg(ptr) @@ -7583,10 +6737,7 @@ end3694207cd20e8e1cc719e179bdfe0c74: if !(canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off)) { goto endf405b27b22dbf76f83abd1b5ad5e53d9 } - v.Op = OpAMD64MOVQstoreconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVQstoreconst) v.AuxInt = ValAndOff(sc).add(off) v.Aux = mergeSym(sym1, sym2) v.AddArg(ptr) @@ -7615,10 +6766,7 @@ func rewriteValueAMD64_OpAMD64MOVQstoreidx8(v *Value, config *Config) bool { idx := v.Args[1] val := v.Args[2] mem := v.Args[3] - v.Op = OpAMD64MOVQstoreidx8 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVQstoreidx8) v.AuxInt = addOff(off1, off2) v.Aux = sym v.AddArg(ptr) @@ -7647,10 +6795,7 @@ func rewriteValueAMD64_OpAMD64MOVSDload(v *Value, config *Config) bool { off2 := v.Args[0].AuxInt ptr := v.Args[0].Args[0] mem := v.Args[1] - v.Op = OpAMD64MOVSDload - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVSDload) v.AuxInt = addOff(off1, off2) v.Aux = sym v.AddArg(ptr) @@ -7676,10 +6821,7 @@ end6dad9bf78e7368bb095eb2dfba7e244a: if !(canMergeSym(sym1, sym2)) { goto end96fa9c439e31050aa91582bc2a9f2c20 } - v.Op = OpAMD64MOVSDload - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVSDload) v.AuxInt = addOff(off1, off2) v.Aux = mergeSym(sym1, sym2) v.AddArg(base) @@ -7706,10 +6848,7 @@ end96fa9c439e31050aa91582bc2a9f2c20: if !(canMergeSym(sym1, sym2)) { goto endbcb2ce441824d0e3a4b501018cfa7f60 } - v.Op = OpAMD64MOVSDloadidx8 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVSDloadidx8) v.AuxInt = addOff(off1, off2) v.Aux = mergeSym(sym1, sym2) v.AddArg(ptr) @@ -7741,10 +6880,7 @@ func rewriteValueAMD64_OpAMD64MOVSDloadidx8(v *Value, config *Config) bool { ptr := v.Args[0].Args[0] idx := v.Args[1] mem := v.Args[2] - v.Op = OpAMD64MOVSDloadidx8 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVSDloadidx8) v.AuxInt = addOff(off1, off2) v.Aux = sym v.AddArg(ptr) @@ -7773,10 +6909,7 @@ func rewriteValueAMD64_OpAMD64MOVSDstore(v *Value, config *Config) bool { ptr := v.Args[0].Args[0] val := v.Args[1] mem := v.Args[2] - v.Op = OpAMD64MOVSDstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVSDstore) v.AuxInt = addOff(off1, off2) v.Aux = sym v.AddArg(ptr) @@ -7804,10 +6937,7 @@ end6c6160664143cc66e63e67b9aa43a7ef: if !(canMergeSym(sym1, sym2)) { goto end415dde14f3400bec1b2756174a5d7179 } - v.Op = OpAMD64MOVSDstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVSDstore) v.AuxInt = addOff(off1, off2) v.Aux = mergeSym(sym1, sym2) v.AddArg(base) @@ -7836,10 +6966,7 @@ end415dde14f3400bec1b2756174a5d7179: if !(canMergeSym(sym1, sym2)) { goto end1ad6fc0c5b59610dabf7f9595a48a230 } - v.Op = OpAMD64MOVSDstoreidx8 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVSDstoreidx8) v.AuxInt = addOff(off1, off2) v.Aux = mergeSym(sym1, sym2) v.AddArg(ptr) @@ -7873,10 +7000,7 @@ func rewriteValueAMD64_OpAMD64MOVSDstoreidx8(v *Value, config *Config) bool { idx := v.Args[1] val := v.Args[2] mem := v.Args[3] - v.Op = OpAMD64MOVSDstoreidx8 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVSDstoreidx8) v.AuxInt = addOff(off1, off2) v.Aux = sym v.AddArg(ptr) @@ -7905,10 +7029,7 @@ func rewriteValueAMD64_OpAMD64MOVSSload(v *Value, config *Config) bool { off2 := v.Args[0].AuxInt ptr := v.Args[0].Args[0] mem := v.Args[1] - v.Op = OpAMD64MOVSSload - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVSSload) v.AuxInt = addOff(off1, off2) v.Aux = sym v.AddArg(ptr) @@ -7934,10 +7055,7 @@ end96d63dbb64b0adfa944684c9e939c972: if !(canMergeSym(sym1, sym2)) { goto end15f2583bd72ad7fc077b3952634a1c85 } - v.Op = OpAMD64MOVSSload - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVSSload) v.AuxInt = addOff(off1, off2) v.Aux = mergeSym(sym1, sym2) v.AddArg(base) @@ -7964,10 +7082,7 @@ end15f2583bd72ad7fc077b3952634a1c85: if !(canMergeSym(sym1, sym2)) { goto end49722f4a0adba31bb143601ce1d2aae0 } - v.Op = OpAMD64MOVSSloadidx4 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVSSloadidx4) v.AuxInt = addOff(off1, off2) v.Aux = mergeSym(sym1, sym2) v.AddArg(ptr) @@ -7999,10 +7114,7 @@ func rewriteValueAMD64_OpAMD64MOVSSloadidx4(v *Value, config *Config) bool { ptr := v.Args[0].Args[0] idx := v.Args[1] mem := v.Args[2] - v.Op = OpAMD64MOVSSloadidx4 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVSSloadidx4) v.AuxInt = addOff(off1, off2) v.Aux = sym v.AddArg(ptr) @@ -8031,10 +7143,7 @@ func rewriteValueAMD64_OpAMD64MOVSSstore(v *Value, config *Config) bool { ptr := v.Args[0].Args[0] val := v.Args[1] mem := v.Args[2] - v.Op = OpAMD64MOVSSstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVSSstore) v.AuxInt = addOff(off1, off2) v.Aux = sym v.AddArg(ptr) @@ -8062,10 +7171,7 @@ endf711aa4081a9b2924b55387d4f70cfd6: if !(canMergeSym(sym1, sym2)) { goto end70ebc170131920e515e3f416a6b952c5 } - v.Op = OpAMD64MOVSSstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVSSstore) v.AuxInt = addOff(off1, off2) v.Aux = mergeSym(sym1, sym2) v.AddArg(base) @@ -8094,10 +7200,7 @@ end70ebc170131920e515e3f416a6b952c5: if !(canMergeSym(sym1, sym2)) { goto end1622dc435e45833eda4d29d44df7cc34 } - v.Op = OpAMD64MOVSSstoreidx4 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVSSstoreidx4) v.AuxInt = addOff(off1, off2) v.Aux = mergeSym(sym1, sym2) v.AddArg(ptr) @@ -8131,10 +7234,7 @@ func rewriteValueAMD64_OpAMD64MOVSSstoreidx4(v *Value, config *Config) bool { idx := v.Args[1] val := v.Args[2] mem := v.Args[3] - v.Op = OpAMD64MOVSSstoreidx4 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVSSstoreidx4) v.AuxInt = addOff(off1, off2) v.Aux = sym v.AddArg(ptr) @@ -8163,10 +7263,7 @@ func rewriteValueAMD64_OpAMD64MOVWQSX(v *Value, config *Config) bool { ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] v0 := v.Args[0].Block.NewValue0(v.Line, OpAMD64MOVWQSXload, v.Type) - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.AddArg(v0) v0.AuxInt = off v0.Aux = sym @@ -8189,10 +7286,7 @@ endef39da125e2794cdafd008426ecc91eb: if !(c&0x8000 == 0) { goto end8581b4c4dfd1278e97aa536308519e68 } - v.Op = OpAMD64ANDQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDQconst) v.AuxInt = c & 0x7fff v.AddArg(x) return true @@ -8217,10 +7311,7 @@ func rewriteValueAMD64_OpAMD64MOVWQZX(v *Value, config *Config) bool { ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] v0 := v.Args[0].Block.NewValue0(v.Line, OpAMD64MOVWQZXload, v.Type) - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.AddArg(v0) v0.AuxInt = off v0.Aux = sym @@ -8240,10 +7331,7 @@ end348d59b382c9d0c64896811facbe4c5e: } c := v.Args[0].AuxInt x := v.Args[0].Args[0] - v.Op = OpAMD64ANDQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDQconst) v.AuxInt = c & 0xffff v.AddArg(x) return true @@ -8268,10 +7356,7 @@ func rewriteValueAMD64_OpAMD64MOVWload(v *Value, config *Config) bool { off2 := v.Args[0].AuxInt ptr := v.Args[0].Args[0] mem := v.Args[1] - v.Op = OpAMD64MOVWload - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVWload) v.AuxInt = addOff(off1, off2) v.Aux = sym v.AddArg(ptr) @@ -8297,10 +7382,7 @@ endfcb0ce76f96e8b0c2eb19a9b827c1b73: if !(canMergeSym(sym1, sym2)) { goto end7a79314cb49bf53d79c38c3077d87457 } - v.Op = OpAMD64MOVWload - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVWload) v.AuxInt = addOff(off1, off2) v.Aux = mergeSym(sym1, sym2) v.AddArg(base) @@ -8327,10 +7409,7 @@ func rewriteValueAMD64_OpAMD64MOVWstore(v *Value, config *Config) bool { } x := v.Args[1].Args[0] mem := v.Args[2] - v.Op = OpAMD64MOVWstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVWstore) v.AuxInt = off v.Aux = sym v.AddArg(ptr) @@ -8353,10 +7432,7 @@ endca90c534e75c7f5cb803504d119a853f: } x := v.Args[1].Args[0] mem := v.Args[2] - v.Op = OpAMD64MOVWstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVWstore) v.AuxInt = off v.Aux = sym v.AddArg(ptr) @@ -8380,10 +7456,7 @@ end187fe73dfaf9cf5f4c349283b4dfd9d1: ptr := v.Args[0].Args[0] val := v.Args[1] mem := v.Args[2] - v.Op = OpAMD64MOVWstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVWstore) v.AuxInt = addOff(off1, off2) v.Aux = sym v.AddArg(ptr) @@ -8409,10 +7482,7 @@ endda15fdd59aa956ded0440188f38de1aa: if !(validOff(off)) { goto end60327daf9965d73a8c1971d098e1e31d } - v.Op = OpAMD64MOVWstoreconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVWstoreconst) v.AuxInt = makeValAndOff(int64(int16(c)), off) v.Aux = sym v.AddArg(ptr) @@ -8439,10 +7509,7 @@ end60327daf9965d73a8c1971d098e1e31d: if !(canMergeSym(sym1, sym2)) { goto end4cc466ede8e64e415c899ccac81c0f27 } - v.Op = OpAMD64MOVWstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVWstore) v.AuxInt = addOff(off1, off2) v.Aux = mergeSym(sym1, sym2) v.AddArg(base) @@ -8471,10 +7538,7 @@ end4cc466ede8e64e415c899ccac81c0f27: if !(canMergeSym(sym1, sym2)) { goto endecfc76d1ba8fcce5d4110a452cd39752 } - v.Op = OpAMD64MOVWstoreidx2 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVWstoreidx2) v.AuxInt = addOff(off1, off2) v.Aux = mergeSym(sym1, sym2) v.AddArg(ptr) @@ -8506,10 +7570,7 @@ func rewriteValueAMD64_OpAMD64MOVWstoreconst(v *Value, config *Config) bool { if !(ValAndOff(sc).canAdd(off)) { goto end8825edac065f0e1c615ca5e6ba40e2de } - v.Op = OpAMD64MOVWstoreconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVWstoreconst) v.AuxInt = ValAndOff(sc).add(off) v.Aux = s v.AddArg(ptr) @@ -8535,10 +7596,7 @@ end8825edac065f0e1c615ca5e6ba40e2de: if !(canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off)) { goto endba47397e07b40a64fa4cad36ac2e32ad } - v.Op = OpAMD64MOVWstoreconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVWstoreconst) v.AuxInt = ValAndOff(sc).add(off) v.Aux = mergeSym(sym1, sym2) v.AddArg(ptr) @@ -8567,10 +7625,7 @@ func rewriteValueAMD64_OpAMD64MOVWstoreidx2(v *Value, config *Config) bool { idx := v.Args[1] val := v.Args[2] mem := v.Args[3] - v.Op = OpAMD64MOVWstoreidx2 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVWstoreidx2) v.AuxInt = addOff(off1, off2) v.Aux = sym v.AddArg(ptr) @@ -8596,10 +7651,7 @@ func rewriteValueAMD64_OpAMD64MULB(v *Value, config *Config) bool { goto end66c6419213ddeb52b1c53fb589a70e5f } c := v.Args[1].AuxInt - v.Op = OpAMD64MULBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MULBconst) v.AuxInt = c v.AddArg(x) return true @@ -8616,10 +7668,7 @@ end66c6419213ddeb52b1c53fb589a70e5f: } c := v.Args[0].AuxInt x := v.Args[1] - v.Op = OpAMD64MULBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MULBconst) v.AuxInt = c v.AddArg(x) return true @@ -8641,10 +7690,7 @@ func rewriteValueAMD64_OpAMD64MULBconst(v *Value, config *Config) bool { goto endf2db9f96016085f8cb4082b4af01b2aa } d := v.Args[0].AuxInt - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = c * d return true } @@ -8665,10 +7711,7 @@ func rewriteValueAMD64_OpAMD64MULL(v *Value, config *Config) bool { goto end893477a261bcad6c2821b77c83075c6c } c := v.Args[1].AuxInt - v.Op = OpAMD64MULLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MULLconst) v.AuxInt = c v.AddArg(x) return true @@ -8685,10 +7728,7 @@ end893477a261bcad6c2821b77c83075c6c: } c := v.Args[0].AuxInt x := v.Args[1] - v.Op = OpAMD64MULLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MULLconst) v.AuxInt = c v.AddArg(x) return true @@ -8710,10 +7750,7 @@ func rewriteValueAMD64_OpAMD64MULLconst(v *Value, config *Config) bool { goto endd5732835ed1276ef8b728bcfc1289f73 } d := v.Args[0].AuxInt - v.Op = OpAMD64MOVLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVLconst) v.AuxInt = c * d return true } @@ -8737,10 +7774,7 @@ func rewriteValueAMD64_OpAMD64MULQ(v *Value, config *Config) bool { if !(is32Bit(c)) { goto endb38c6e3e0ddfa25ba0ef9684ac1528c0 } - v.Op = OpAMD64MULQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MULQconst) v.AuxInt = c v.AddArg(x) return true @@ -8760,10 +7794,7 @@ endb38c6e3e0ddfa25ba0ef9684ac1528c0: if !(is32Bit(c)) { goto end9cb4f29b0bd7141639416735dcbb3b87 } - v.Op = OpAMD64MULQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MULQconst) v.AuxInt = c v.AddArg(x) return true @@ -8784,10 +7815,7 @@ func rewriteValueAMD64_OpAMD64MULQconst(v *Value, config *Config) bool { goto end82501cca6b5fb121a7f8b197e55f2fec } x := v.Args[0] - v.Op = OpAMD64NEGQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64NEGQ) v.AddArg(x) return true } @@ -8801,10 +7829,7 @@ end82501cca6b5fb121a7f8b197e55f2fec: if v.AuxInt != 0 { goto endcb9faa068e3558ff44daaf1d47d091b5 } - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVQconst) v.AuxInt = 0 return true } @@ -8819,10 +7844,7 @@ endcb9faa068e3558ff44daaf1d47d091b5: goto end0b527e71db2b288b2841a1f757aa580d } x := v.Args[0] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -8838,10 +7860,7 @@ end0b527e71db2b288b2841a1f757aa580d: goto end34a86f261671b5852bec6c57155fe0da } x := v.Args[0] - v.Op = OpAMD64LEAQ2 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64LEAQ2) v.AddArg(x) v.AddArg(x) return true @@ -8857,10 +7876,7 @@ end34a86f261671b5852bec6c57155fe0da: goto end534601906c45a9171a9fec3e4b82b189 } x := v.Args[0] - v.Op = OpAMD64LEAQ4 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64LEAQ4) v.AddArg(x) v.AddArg(x) return true @@ -8876,10 +7892,7 @@ end534601906c45a9171a9fec3e4b82b189: goto end48a2280b6459821289c56073b8354997 } x := v.Args[0] - v.Op = OpAMD64LEAQ8 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64LEAQ8) v.AddArg(x) v.AddArg(x) return true @@ -8896,10 +7909,7 @@ end48a2280b6459821289c56073b8354997: if !(isPowerOfTwo(c)) { goto end75076953dbfe022526a153eda99b39b2 } - v.Op = OpAMD64SHLQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SHLQconst) v.AuxInt = log2(c) v.AddArg(x) return true @@ -8916,10 +7926,7 @@ end75076953dbfe022526a153eda99b39b2: goto end55c38c5c405101e610d7ba7fc702ddc0 } d := v.Args[0].AuxInt - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVQconst) v.AuxInt = c * d return true } @@ -8940,10 +7947,7 @@ func rewriteValueAMD64_OpAMD64MULW(v *Value, config *Config) bool { goto end542112cc08217d4bdffc1a645d290ffb } c := v.Args[1].AuxInt - v.Op = OpAMD64MULWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MULWconst) v.AuxInt = c v.AddArg(x) return true @@ -8960,10 +7964,7 @@ end542112cc08217d4bdffc1a645d290ffb: } c := v.Args[0].AuxInt x := v.Args[1] - v.Op = OpAMD64MULWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MULWconst) v.AuxInt = c v.AddArg(x) return true @@ -8985,10 +7986,7 @@ func rewriteValueAMD64_OpAMD64MULWconst(v *Value, config *Config) bool { goto end61dbc9d9e93dd6946a20a1f475b3f74b } d := v.Args[0].AuxInt - v.Op = OpAMD64MOVWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVWconst) v.AuxInt = c * d return true } @@ -9006,10 +8004,7 @@ func rewriteValueAMD64_OpMod16(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64MODW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MODW) v.AddArg(x) v.AddArg(y) return true @@ -9028,10 +8023,7 @@ func rewriteValueAMD64_OpMod16u(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64MODWU - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MODWU) v.AddArg(x) v.AddArg(y) return true @@ -9050,10 +8042,7 @@ func rewriteValueAMD64_OpMod32(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64MODL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MODL) v.AddArg(x) v.AddArg(y) return true @@ -9072,10 +8061,7 @@ func rewriteValueAMD64_OpMod32u(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64MODLU - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MODLU) v.AddArg(x) v.AddArg(y) return true @@ -9094,10 +8080,7 @@ func rewriteValueAMD64_OpMod64(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64MODQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MODQ) v.AddArg(x) v.AddArg(y) return true @@ -9116,10 +8099,7 @@ func rewriteValueAMD64_OpMod64u(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64MODQU - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MODQU) v.AddArg(x) v.AddArg(y) return true @@ -9138,10 +8118,7 @@ func rewriteValueAMD64_OpMod8(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64MODW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MODW) v0 := b.NewValue0(v.Line, OpSignExt8to16, config.fe.TypeInt16()) v0.AddArg(x) v.AddArg(v0) @@ -9164,10 +8141,7 @@ func rewriteValueAMD64_OpMod8u(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64MODWU - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MODWU) v0 := b.NewValue0(v.Line, OpZeroExt8to16, config.fe.TypeUInt16()) v0.AddArg(x) v.AddArg(v0) @@ -9192,10 +8166,7 @@ func rewriteValueAMD64_OpMove(v *Value, config *Config) bool { goto end0961cbfe144a616cba75190d07d65e41 } mem := v.Args[2] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = mem.Type v.AddArg(mem) return true @@ -9213,10 +8184,7 @@ end0961cbfe144a616cba75190d07d65e41: dst := v.Args[0] src := v.Args[1] mem := v.Args[2] - v.Op = OpAMD64MOVBstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBstore) v.AddArg(dst) v0 := b.NewValue0(v.Line, OpAMD64MOVBload, config.fe.TypeUInt8()) v0.AddArg(src) @@ -9238,10 +8206,7 @@ end72e5dd27e999493b67ea3af4ecc60d48: dst := v.Args[0] src := v.Args[1] mem := v.Args[2] - v.Op = OpAMD64MOVWstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVWstore) v.AddArg(dst) v0 := b.NewValue0(v.Line, OpAMD64MOVWload, config.fe.TypeUInt16()) v0.AddArg(src) @@ -9263,10 +8228,7 @@ end017f774e406d4578b4bcefcd8db8ec1e: dst := v.Args[0] src := v.Args[1] mem := v.Args[2] - v.Op = OpAMD64MOVLstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVLstore) v.AddArg(dst) v0 := b.NewValue0(v.Line, OpAMD64MOVLload, config.fe.TypeUInt32()) v0.AddArg(src) @@ -9288,10 +8250,7 @@ end938ec47a2ddf8e9b4bf71ffade6e5b3f: dst := v.Args[0] src := v.Args[1] mem := v.Args[2] - v.Op = OpAMD64MOVQstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVQstore) v.AddArg(dst) v0 := b.NewValue0(v.Line, OpAMD64MOVQload, config.fe.TypeUInt64()) v0.AddArg(src) @@ -9313,10 +8272,7 @@ end696b3498f5fee17f49ae0f708d3dfe4b: dst := v.Args[0] src := v.Args[1] mem := v.Args[2] - v.Op = OpAMD64MOVOstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVOstore) v.AddArg(dst) v0 := b.NewValue0(v.Line, OpAMD64MOVOload, TypeInt128) v0.AddArg(src) @@ -9338,10 +8294,7 @@ end4894ace925d468c10a5b0c5b91fc4c1c: dst := v.Args[0] src := v.Args[1] mem := v.Args[2] - v.Op = OpAMD64MOVBstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBstore) v.AuxInt = 2 v.AddArg(dst) v0 := b.NewValue0(v.Line, OpAMD64MOVBload, config.fe.TypeUInt8()) @@ -9372,10 +8325,7 @@ end76ce0004999139fe4608c3c5356eb364: dst := v.Args[0] src := v.Args[1] mem := v.Args[2] - v.Op = OpAMD64MOVBstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBstore) v.AuxInt = 4 v.AddArg(dst) v0 := b.NewValue0(v.Line, OpAMD64MOVBload, config.fe.TypeUInt8()) @@ -9406,10 +8356,7 @@ end21378690c0f39bdd6b46566d57da34e3: dst := v.Args[0] src := v.Args[1] mem := v.Args[2] - v.Op = OpAMD64MOVWstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVWstore) v.AuxInt = 4 v.AddArg(dst) v0 := b.NewValue0(v.Line, OpAMD64MOVWload, config.fe.TypeUInt16()) @@ -9440,10 +8387,7 @@ endcb6e509881d8638d8cae3af4f2b19a8e: dst := v.Args[0] src := v.Args[1] mem := v.Args[2] - v.Op = OpAMD64MOVLstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVLstore) v.AuxInt = 3 v.AddArg(dst) v0 := b.NewValue0(v.Line, OpAMD64MOVLload, config.fe.TypeUInt32()) @@ -9475,10 +8419,7 @@ end3429ae54bc071c0856ad366c79b7ab97: if !(size > 8 && size < 16) { goto endc90f121709d5411d389649dea89a2251 } - v.Op = OpAMD64MOVQstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVQstore) v.AuxInt = size - 8 v.AddArg(dst) v0 := b.NewValue0(v.Line, OpAMD64MOVQload, config.fe.TypeUInt64()) @@ -9510,10 +8451,7 @@ endc90f121709d5411d389649dea89a2251: if !(size > 16 && size%16 != 0 && size%16 <= 8) { goto end376c57db23b866866f23677c6cde43ba } - v.Op = OpMove - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpMove) v.AuxInt = size - size%16 v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, dst.Type) v0.AddArg(dst) @@ -9547,10 +8485,7 @@ end376c57db23b866866f23677c6cde43ba: if !(size > 16 && size%16 != 0 && size%16 > 8) { goto end2f82f76766a21f8802768380cf10a497 } - v.Op = OpMove - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpMove) v.AuxInt = size - size%16 v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, dst.Type) v0.AddArg(dst) @@ -9584,10 +8519,7 @@ end2f82f76766a21f8802768380cf10a497: if !(size >= 32 && size <= 16*64 && size%16 == 0) { goto endcb66da6685f0079ee1f84d10fa561f22 } - v.Op = OpAMD64DUFFCOPY - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64DUFFCOPY) v.AuxInt = 14 * (64 - size/16) v.AddArg(dst) v.AddArg(src) @@ -9608,10 +8540,7 @@ endcb66da6685f0079ee1f84d10fa561f22: if !(size > 16*64 && size%8 == 0) { goto end7ae25ff1bbdcf34efef09613745e9d6e } - v.Op = OpAMD64REPMOVSQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64REPMOVSQ) v.AddArg(dst) v.AddArg(src) v0 := b.NewValue0(v.Line, OpAMD64MOVQconst, config.fe.TypeUInt64()) @@ -9634,10 +8563,7 @@ func rewriteValueAMD64_OpMul16(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64MULW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MULW) v.AddArg(x) v.AddArg(y) return true @@ -9656,10 +8582,7 @@ func rewriteValueAMD64_OpMul32(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64MULL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MULL) v.AddArg(x) v.AddArg(y) return true @@ -9678,10 +8601,7 @@ func rewriteValueAMD64_OpMul32F(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64MULSS - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MULSS) v.AddArg(x) v.AddArg(y) return true @@ -9700,10 +8620,7 @@ func rewriteValueAMD64_OpMul64(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64MULQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MULQ) v.AddArg(x) v.AddArg(y) return true @@ -9722,10 +8639,7 @@ func rewriteValueAMD64_OpMul64F(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64MULSD - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MULSD) v.AddArg(x) v.AddArg(y) return true @@ -9744,10 +8658,7 @@ func rewriteValueAMD64_OpMul8(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64MULB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MULB) v.AddArg(x) v.AddArg(y) return true @@ -9768,10 +8679,7 @@ func rewriteValueAMD64_OpAMD64NEGB(v *Value, config *Config) bool { goto end36d0300ba9eab8c9da86246ff653ca96 } c := v.Args[0].AuxInt - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = -c return true } @@ -9791,10 +8699,7 @@ func rewriteValueAMD64_OpAMD64NEGL(v *Value, config *Config) bool { goto end7a245ec67e56bd51911e5ba2d0aa0a16 } c := v.Args[0].AuxInt - v.Op = OpAMD64MOVLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVLconst) v.AuxInt = -c return true } @@ -9814,10 +8719,7 @@ func rewriteValueAMD64_OpAMD64NEGQ(v *Value, config *Config) bool { goto end04ddd98bc6724ecb85c80c2a4e2bca5a } c := v.Args[0].AuxInt - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVQconst) v.AuxInt = -c return true } @@ -9837,10 +8739,7 @@ func rewriteValueAMD64_OpAMD64NEGW(v *Value, config *Config) bool { goto end1db6636f0a51848d8a34f6561ecfe7ae } c := v.Args[0].AuxInt - v.Op = OpAMD64MOVWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVWconst) v.AuxInt = -c return true } @@ -9860,10 +8759,7 @@ func rewriteValueAMD64_OpAMD64NOTB(v *Value, config *Config) bool { goto end9e383a9ceb29a9e2bf890ec6a67212a8 } c := v.Args[0].AuxInt - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = ^c return true } @@ -9883,10 +8779,7 @@ func rewriteValueAMD64_OpAMD64NOTL(v *Value, config *Config) bool { goto endcc73972c088d5e652a1370a96e56502d } c := v.Args[0].AuxInt - v.Op = OpAMD64MOVLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVLconst) v.AuxInt = ^c return true } @@ -9906,10 +8799,7 @@ func rewriteValueAMD64_OpAMD64NOTQ(v *Value, config *Config) bool { goto endb39ddb6bf7339d46f74114baad4333b6 } c := v.Args[0].AuxInt - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVQconst) v.AuxInt = ^c return true } @@ -9929,10 +8819,7 @@ func rewriteValueAMD64_OpAMD64NOTW(v *Value, config *Config) bool { goto end35848095ebcf894c6957ad3be5f82c43 } c := v.Args[0].AuxInt - v.Op = OpAMD64MOVWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVWconst) v.AuxInt = ^c return true } @@ -9949,10 +8836,7 @@ func rewriteValueAMD64_OpNeg16(v *Value, config *Config) bool { // result: (NEGW x) { x := v.Args[0] - v.Op = OpAMD64NEGW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64NEGW) v.AddArg(x) return true } @@ -9969,10 +8853,7 @@ func rewriteValueAMD64_OpNeg32(v *Value, config *Config) bool { // result: (NEGL x) { x := v.Args[0] - v.Op = OpAMD64NEGL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64NEGL) v.AddArg(x) return true } @@ -9989,10 +8870,7 @@ func rewriteValueAMD64_OpNeg32F(v *Value, config *Config) bool { // result: (PXOR x (MOVSSconst [f2i(math.Copysign(0, -1))])) { x := v.Args[0] - v.Op = OpAMD64PXOR - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64PXOR) v.AddArg(x) v0 := b.NewValue0(v.Line, OpAMD64MOVSSconst, config.Frontend().TypeFloat32()) v0.AuxInt = f2i(math.Copysign(0, -1)) @@ -10012,10 +8890,7 @@ func rewriteValueAMD64_OpNeg64(v *Value, config *Config) bool { // result: (NEGQ x) { x := v.Args[0] - v.Op = OpAMD64NEGQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64NEGQ) v.AddArg(x) return true } @@ -10032,10 +8907,7 @@ func rewriteValueAMD64_OpNeg64F(v *Value, config *Config) bool { // result: (PXOR x (MOVSDconst [f2i(math.Copysign(0, -1))])) { x := v.Args[0] - v.Op = OpAMD64PXOR - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64PXOR) v.AddArg(x) v0 := b.NewValue0(v.Line, OpAMD64MOVSDconst, config.Frontend().TypeFloat64()) v0.AuxInt = f2i(math.Copysign(0, -1)) @@ -10055,10 +8927,7 @@ func rewriteValueAMD64_OpNeg8(v *Value, config *Config) bool { // result: (NEGB x) { x := v.Args[0] - v.Op = OpAMD64NEGB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64NEGB) v.AddArg(x) return true } @@ -10076,10 +8945,7 @@ func rewriteValueAMD64_OpNeq16(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETNE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETNE) v0 := b.NewValue0(v.Line, OpAMD64CMPW, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -10100,10 +8966,7 @@ func rewriteValueAMD64_OpNeq32(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETNE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETNE) v0 := b.NewValue0(v.Line, OpAMD64CMPL, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -10124,10 +8987,7 @@ func rewriteValueAMD64_OpNeq32F(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETNEF - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETNEF) v0 := b.NewValue0(v.Line, OpAMD64UCOMISS, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -10148,10 +9008,7 @@ func rewriteValueAMD64_OpNeq64(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETNE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETNE) v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -10172,10 +9029,7 @@ func rewriteValueAMD64_OpNeq64F(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETNEF - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETNEF) v0 := b.NewValue0(v.Line, OpAMD64UCOMISD, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -10196,10 +9050,7 @@ func rewriteValueAMD64_OpNeq8(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETNE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETNE) v0 := b.NewValue0(v.Line, OpAMD64CMPB, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -10220,10 +9071,7 @@ func rewriteValueAMD64_OpNeqPtr(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SETNE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETNE) v0 := b.NewValue0(v.Line, OpAMD64CMPQ, TypeFlags) v0.AddArg(x) v0.AddArg(y) @@ -10244,10 +9092,7 @@ func rewriteValueAMD64_OpNilCheck(v *Value, config *Config) bool { { ptr := v.Args[0] mem := v.Args[1] - v.Op = OpAMD64LoweredNilCheck - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64LoweredNilCheck) v.AddArg(ptr) v.AddArg(mem) return true @@ -10265,10 +9110,7 @@ func rewriteValueAMD64_OpNot(v *Value, config *Config) bool { // result: (XORBconst [1] x) { x := v.Args[0] - v.Op = OpAMD64XORBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64XORBconst) v.AuxInt = 1 v.AddArg(x) return true @@ -10290,10 +9132,7 @@ func rewriteValueAMD64_OpAMD64ORB(v *Value, config *Config) bool { goto end7b63870decde2515cb77ec4f8f76817c } c := v.Args[1].AuxInt - v.Op = OpAMD64ORBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ORBconst) v.AuxInt = c v.AddArg(x) return true @@ -10310,10 +9149,7 @@ end7b63870decde2515cb77ec4f8f76817c: } c := v.Args[0].AuxInt x := v.Args[1] - v.Op = OpAMD64ORBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ORBconst) v.AuxInt = c v.AddArg(x) return true @@ -10329,10 +9165,7 @@ end70b43d531e2097a4f6293f66256a642e: if v.Args[1] != x { goto enddca5ce800a9eca157f243cb2fdb1408a } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -10354,10 +9187,7 @@ func rewriteValueAMD64_OpAMD64ORBconst(v *Value, config *Config) bool { if !(int8(c) == 0) { goto end565f78e3a843dc73943b59227b39a1b3 } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -10373,10 +9203,7 @@ end565f78e3a843dc73943b59227b39a1b3: if !(int8(c) == -1) { goto end6033c7910d8cd536b31446e179e4610d } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = -1 return true } @@ -10392,10 +9219,7 @@ end6033c7910d8cd536b31446e179e4610d: goto endbe5263f022dc10a5cf53c118937d79dd } d := v.Args[0].AuxInt - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = c | d return true } @@ -10416,10 +9240,7 @@ func rewriteValueAMD64_OpAMD64ORL(v *Value, config *Config) bool { goto end1b883e30d860b6fac14ae98462c4f61a } c := v.Args[1].AuxInt - v.Op = OpAMD64ORLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ORLconst) v.AuxInt = c v.AddArg(x) return true @@ -10436,10 +9257,7 @@ end1b883e30d860b6fac14ae98462c4f61a: } c := v.Args[0].AuxInt x := v.Args[1] - v.Op = OpAMD64ORLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ORLconst) v.AuxInt = c v.AddArg(x) return true @@ -10455,10 +9273,7 @@ enda5bc49524a0cbd2241f792837d0a48a8: if v.Args[1] != x { goto end2dd719b68f4938777ef0d820aab93659 } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -10480,10 +9295,7 @@ func rewriteValueAMD64_OpAMD64ORLconst(v *Value, config *Config) bool { if !(int32(c) == 0) { goto end5b52623a724e8a7167c71289fb7192f1 } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -10499,10 +9311,7 @@ end5b52623a724e8a7167c71289fb7192f1: if !(int32(c) == -1) { goto end345a8ea439ef2ef54bd84fc8a0f73e97 } - v.Op = OpAMD64MOVLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVLconst) v.AuxInt = -1 return true } @@ -10518,10 +9327,7 @@ end345a8ea439ef2ef54bd84fc8a0f73e97: goto ende9ca05024248f782c88084715f81d727 } d := v.Args[0].AuxInt - v.Op = OpAMD64MOVLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVLconst) v.AuxInt = c | d return true } @@ -10545,10 +9351,7 @@ func rewriteValueAMD64_OpAMD64ORQ(v *Value, config *Config) bool { if !(is32Bit(c)) { goto end601f2bb3ccda102e484ff60adeaf6d26 } - v.Op = OpAMD64ORQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ORQconst) v.AuxInt = c v.AddArg(x) return true @@ -10568,10 +9371,7 @@ end601f2bb3ccda102e484ff60adeaf6d26: if !(is32Bit(c)) { goto end010afbebcd314e288509d79a16a6d5cc } - v.Op = OpAMD64ORQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ORQconst) v.AuxInt = c v.AddArg(x) return true @@ -10587,10 +9387,7 @@ end010afbebcd314e288509d79a16a6d5cc: if v.Args[1] != x { goto end47a27d30b82db576978c5a3a57b520fb } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -10611,10 +9408,7 @@ func rewriteValueAMD64_OpAMD64ORQconst(v *Value, config *Config) bool { goto end44534da6b9ce98d33fad7e20f0be1fbd } x := v.Args[0] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -10629,10 +9423,7 @@ end44534da6b9ce98d33fad7e20f0be1fbd: if v.AuxInt != -1 { goto endcde9b9d7c4527eaa5d50b252f50b43c1 } - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVQconst) v.AuxInt = -1 return true } @@ -10648,10 +9439,7 @@ endcde9b9d7c4527eaa5d50b252f50b43c1: goto enda2488509b71db9abcb06a5115c4ddc2c } d := v.Args[0].AuxInt - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVQconst) v.AuxInt = c | d return true } @@ -10672,10 +9460,7 @@ func rewriteValueAMD64_OpAMD64ORW(v *Value, config *Config) bool { goto end9f98df10892dbf170b49aace86ee0d7f } c := v.Args[1].AuxInt - v.Op = OpAMD64ORWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ORWconst) v.AuxInt = c v.AddArg(x) return true @@ -10692,10 +9477,7 @@ end9f98df10892dbf170b49aace86ee0d7f: } c := v.Args[0].AuxInt x := v.Args[1] - v.Op = OpAMD64ORWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ORWconst) v.AuxInt = c v.AddArg(x) return true @@ -10711,10 +9493,7 @@ end96405942c9ceb5fcb0ddb85a8709d015: if v.Args[1] != x { goto endc6a23b64e541dc9cfc6a90fd7028e8c1 } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -10736,10 +9515,7 @@ func rewriteValueAMD64_OpAMD64ORWconst(v *Value, config *Config) bool { if !(int16(c) == 0) { goto endbbbdec9091c8b4c58e587eac8a43402d } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -10755,10 +9531,7 @@ endbbbdec9091c8b4c58e587eac8a43402d: if !(int16(c) == -1) { goto ended87a5775f5e04b2d2a117a63d82dd9b } - v.Op = OpAMD64MOVWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVWconst) v.AuxInt = -1 return true } @@ -10774,10 +9547,7 @@ ended87a5775f5e04b2d2a117a63d82dd9b: goto endba9221a8462b5c62e8d7c686f64c2778 } d := v.Args[0].AuxInt - v.Op = OpAMD64MOVWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVWconst) v.AuxInt = c | d return true } @@ -10795,10 +9565,7 @@ func rewriteValueAMD64_OpOffPtr(v *Value, config *Config) bool { { off := v.AuxInt ptr := v.Args[0] - v.Op = OpAMD64ADDQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ADDQconst) v.AuxInt = off v.AddArg(ptr) return true @@ -10817,10 +9584,7 @@ func rewriteValueAMD64_OpOr16(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ORW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ORW) v.AddArg(x) v.AddArg(y) return true @@ -10839,10 +9603,7 @@ func rewriteValueAMD64_OpOr32(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ORL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ORL) v.AddArg(x) v.AddArg(y) return true @@ -10861,10 +9622,7 @@ func rewriteValueAMD64_OpOr64(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ORQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ORQ) v.AddArg(x) v.AddArg(y) return true @@ -10883,10 +9641,7 @@ func rewriteValueAMD64_OpOr8(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ORB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ORB) v.AddArg(x) v.AddArg(y) return true @@ -10906,10 +9661,7 @@ func rewriteValueAMD64_OpRsh16Ux16(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ANDW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDW) v0 := b.NewValue0(v.Line, OpAMD64SHRW, t) v0.AddArg(x) v0.AddArg(y) @@ -10937,10 +9689,7 @@ func rewriteValueAMD64_OpRsh16Ux32(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ANDW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDW) v0 := b.NewValue0(v.Line, OpAMD64SHRW, t) v0.AddArg(x) v0.AddArg(y) @@ -10968,10 +9717,7 @@ func rewriteValueAMD64_OpRsh16Ux64(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ANDW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDW) v0 := b.NewValue0(v.Line, OpAMD64SHRW, t) v0.AddArg(x) v0.AddArg(y) @@ -10999,10 +9745,7 @@ func rewriteValueAMD64_OpRsh16Ux8(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ANDW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDW) v0 := b.NewValue0(v.Line, OpAMD64SHRW, t) v0.AddArg(x) v0.AddArg(y) @@ -11030,11 +9773,8 @@ func rewriteValueAMD64_OpRsh16x16(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] + v.reset(OpAMD64SARW) v.Type = t - v.Op = OpAMD64SARW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() v.AddArg(x) v0 := b.NewValue0(v.Line, OpAMD64ORW, y.Type) v0.AddArg(y) @@ -11064,11 +9804,8 @@ func rewriteValueAMD64_OpRsh16x32(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] + v.reset(OpAMD64SARW) v.Type = t - v.Op = OpAMD64SARW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() v.AddArg(x) v0 := b.NewValue0(v.Line, OpAMD64ORL, y.Type) v0.AddArg(y) @@ -11098,11 +9835,8 @@ func rewriteValueAMD64_OpRsh16x64(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] + v.reset(OpAMD64SARW) v.Type = t - v.Op = OpAMD64SARW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() v.AddArg(x) v0 := b.NewValue0(v.Line, OpAMD64ORQ, y.Type) v0.AddArg(y) @@ -11132,11 +9866,8 @@ func rewriteValueAMD64_OpRsh16x8(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] + v.reset(OpAMD64SARW) v.Type = t - v.Op = OpAMD64SARW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() v.AddArg(x) v0 := b.NewValue0(v.Line, OpAMD64ORB, y.Type) v0.AddArg(y) @@ -11166,10 +9897,7 @@ func rewriteValueAMD64_OpRsh32Ux16(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ANDL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDL) v0 := b.NewValue0(v.Line, OpAMD64SHRL, t) v0.AddArg(x) v0.AddArg(y) @@ -11197,10 +9925,7 @@ func rewriteValueAMD64_OpRsh32Ux32(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ANDL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDL) v0 := b.NewValue0(v.Line, OpAMD64SHRL, t) v0.AddArg(x) v0.AddArg(y) @@ -11228,10 +9953,7 @@ func rewriteValueAMD64_OpRsh32Ux64(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ANDL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDL) v0 := b.NewValue0(v.Line, OpAMD64SHRL, t) v0.AddArg(x) v0.AddArg(y) @@ -11259,10 +9981,7 @@ func rewriteValueAMD64_OpRsh32Ux8(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ANDL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDL) v0 := b.NewValue0(v.Line, OpAMD64SHRL, t) v0.AddArg(x) v0.AddArg(y) @@ -11290,11 +10009,8 @@ func rewriteValueAMD64_OpRsh32x16(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] + v.reset(OpAMD64SARL) v.Type = t - v.Op = OpAMD64SARL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() v.AddArg(x) v0 := b.NewValue0(v.Line, OpAMD64ORW, y.Type) v0.AddArg(y) @@ -11324,11 +10040,8 @@ func rewriteValueAMD64_OpRsh32x32(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] + v.reset(OpAMD64SARL) v.Type = t - v.Op = OpAMD64SARL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() v.AddArg(x) v0 := b.NewValue0(v.Line, OpAMD64ORL, y.Type) v0.AddArg(y) @@ -11358,11 +10071,8 @@ func rewriteValueAMD64_OpRsh32x64(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] + v.reset(OpAMD64SARL) v.Type = t - v.Op = OpAMD64SARL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() v.AddArg(x) v0 := b.NewValue0(v.Line, OpAMD64ORQ, y.Type) v0.AddArg(y) @@ -11392,11 +10102,8 @@ func rewriteValueAMD64_OpRsh32x8(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] + v.reset(OpAMD64SARL) v.Type = t - v.Op = OpAMD64SARL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() v.AddArg(x) v0 := b.NewValue0(v.Line, OpAMD64ORB, y.Type) v0.AddArg(y) @@ -11426,10 +10133,7 @@ func rewriteValueAMD64_OpRsh64Ux16(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ANDQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDQ) v0 := b.NewValue0(v.Line, OpAMD64SHRQ, t) v0.AddArg(x) v0.AddArg(y) @@ -11457,10 +10161,7 @@ func rewriteValueAMD64_OpRsh64Ux32(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ANDQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDQ) v0 := b.NewValue0(v.Line, OpAMD64SHRQ, t) v0.AddArg(x) v0.AddArg(y) @@ -11488,10 +10189,7 @@ func rewriteValueAMD64_OpRsh64Ux64(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ANDQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDQ) v0 := b.NewValue0(v.Line, OpAMD64SHRQ, t) v0.AddArg(x) v0.AddArg(y) @@ -11519,10 +10217,7 @@ func rewriteValueAMD64_OpRsh64Ux8(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ANDQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDQ) v0 := b.NewValue0(v.Line, OpAMD64SHRQ, t) v0.AddArg(x) v0.AddArg(y) @@ -11550,11 +10245,8 @@ func rewriteValueAMD64_OpRsh64x16(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] + v.reset(OpAMD64SARQ) v.Type = t - v.Op = OpAMD64SARQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() v.AddArg(x) v0 := b.NewValue0(v.Line, OpAMD64ORW, y.Type) v0.AddArg(y) @@ -11584,11 +10276,8 @@ func rewriteValueAMD64_OpRsh64x32(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] + v.reset(OpAMD64SARQ) v.Type = t - v.Op = OpAMD64SARQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() v.AddArg(x) v0 := b.NewValue0(v.Line, OpAMD64ORL, y.Type) v0.AddArg(y) @@ -11618,11 +10307,8 @@ func rewriteValueAMD64_OpRsh64x64(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] + v.reset(OpAMD64SARQ) v.Type = t - v.Op = OpAMD64SARQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() v.AddArg(x) v0 := b.NewValue0(v.Line, OpAMD64ORQ, y.Type) v0.AddArg(y) @@ -11652,11 +10338,8 @@ func rewriteValueAMD64_OpRsh64x8(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] + v.reset(OpAMD64SARQ) v.Type = t - v.Op = OpAMD64SARQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() v.AddArg(x) v0 := b.NewValue0(v.Line, OpAMD64ORB, y.Type) v0.AddArg(y) @@ -11686,10 +10369,7 @@ func rewriteValueAMD64_OpRsh8Ux16(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ANDB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDB) v0 := b.NewValue0(v.Line, OpAMD64SHRB, t) v0.AddArg(x) v0.AddArg(y) @@ -11717,10 +10397,7 @@ func rewriteValueAMD64_OpRsh8Ux32(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ANDB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDB) v0 := b.NewValue0(v.Line, OpAMD64SHRB, t) v0.AddArg(x) v0.AddArg(y) @@ -11748,10 +10425,7 @@ func rewriteValueAMD64_OpRsh8Ux64(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ANDB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDB) v0 := b.NewValue0(v.Line, OpAMD64SHRB, t) v0.AddArg(x) v0.AddArg(y) @@ -11779,10 +10453,7 @@ func rewriteValueAMD64_OpRsh8Ux8(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64ANDB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ANDB) v0 := b.NewValue0(v.Line, OpAMD64SHRB, t) v0.AddArg(x) v0.AddArg(y) @@ -11810,11 +10481,8 @@ func rewriteValueAMD64_OpRsh8x16(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] + v.reset(OpAMD64SARB) v.Type = t - v.Op = OpAMD64SARB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() v.AddArg(x) v0 := b.NewValue0(v.Line, OpAMD64ORW, y.Type) v0.AddArg(y) @@ -11844,11 +10512,8 @@ func rewriteValueAMD64_OpRsh8x32(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] + v.reset(OpAMD64SARB) v.Type = t - v.Op = OpAMD64SARB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() v.AddArg(x) v0 := b.NewValue0(v.Line, OpAMD64ORL, y.Type) v0.AddArg(y) @@ -11878,11 +10543,8 @@ func rewriteValueAMD64_OpRsh8x64(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] + v.reset(OpAMD64SARB) v.Type = t - v.Op = OpAMD64SARB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() v.AddArg(x) v0 := b.NewValue0(v.Line, OpAMD64ORQ, y.Type) v0.AddArg(y) @@ -11912,11 +10574,8 @@ func rewriteValueAMD64_OpRsh8x8(v *Value, config *Config) bool { t := v.Type x := v.Args[0] y := v.Args[1] + v.reset(OpAMD64SARB) v.Type = t - v.Op = OpAMD64SARB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() v.AddArg(x) v0 := b.NewValue0(v.Line, OpAMD64ORB, y.Type) v0.AddArg(y) @@ -11948,10 +10607,7 @@ func rewriteValueAMD64_OpAMD64SARB(v *Value, config *Config) bool { goto end03194336f801b91c1423aed6f39247f0 } c := v.Args[1].AuxInt - v.Op = OpAMD64SARBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SARBconst) v.AuxInt = c & 31 v.AddArg(x) return true @@ -11968,10 +10624,7 @@ end03194336f801b91c1423aed6f39247f0: goto end3f623e78dd789403b299106625e0d6df } c := v.Args[1].AuxInt - v.Op = OpAMD64SARBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SARBconst) v.AuxInt = c & 31 v.AddArg(x) return true @@ -11988,10 +10641,7 @@ end3f623e78dd789403b299106625e0d6df: goto end4393e26c64e39342a0634d9a5706cb10 } c := v.Args[1].AuxInt - v.Op = OpAMD64SARBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SARBconst) v.AuxInt = c & 31 v.AddArg(x) return true @@ -12008,10 +10658,7 @@ end4393e26c64e39342a0634d9a5706cb10: goto end3bf3d17717aa6c04462e56d1c87902ce } c := v.Args[1].AuxInt - v.Op = OpAMD64SARBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SARBconst) v.AuxInt = c & 31 v.AddArg(x) return true @@ -12033,10 +10680,7 @@ func rewriteValueAMD64_OpAMD64SARBconst(v *Value, config *Config) bool { goto end06e0e38775f0650ed672427d19cd8fff } d := v.Args[0].AuxInt - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVQconst) v.AuxInt = d >> uint64(c) return true } @@ -12057,10 +10701,7 @@ func rewriteValueAMD64_OpAMD64SARL(v *Value, config *Config) bool { goto end8fb4e77be1f4d21d0f2a0facf9a60add } c := v.Args[1].AuxInt - v.Op = OpAMD64SARLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SARLconst) v.AuxInt = c & 31 v.AddArg(x) return true @@ -12077,10 +10718,7 @@ end8fb4e77be1f4d21d0f2a0facf9a60add: goto ende586a72c1b232ee0b63e37c71eeb8470 } c := v.Args[1].AuxInt - v.Op = OpAMD64SARLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SARLconst) v.AuxInt = c & 31 v.AddArg(x) return true @@ -12097,10 +10735,7 @@ ende586a72c1b232ee0b63e37c71eeb8470: goto end37389c13b9fb94c44bd10b1143809afb } c := v.Args[1].AuxInt - v.Op = OpAMD64SARLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SARLconst) v.AuxInt = c & 31 v.AddArg(x) return true @@ -12117,10 +10752,7 @@ end37389c13b9fb94c44bd10b1143809afb: goto end72550eb8c44c45e76e40888bce753160 } c := v.Args[1].AuxInt - v.Op = OpAMD64SARLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SARLconst) v.AuxInt = c & 31 v.AddArg(x) return true @@ -12142,10 +10774,7 @@ func rewriteValueAMD64_OpAMD64SARLconst(v *Value, config *Config) bool { goto end8f34dc94323303e75b7bcc8e731cf1db } d := v.Args[0].AuxInt - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVQconst) v.AuxInt = d >> uint64(c) return true } @@ -12166,10 +10795,7 @@ func rewriteValueAMD64_OpAMD64SARQ(v *Value, config *Config) bool { goto end25e720ab203be2745dded5550e6d8a7c } c := v.Args[1].AuxInt - v.Op = OpAMD64SARQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SARQconst) v.AuxInt = c & 63 v.AddArg(x) return true @@ -12186,10 +10812,7 @@ end25e720ab203be2745dded5550e6d8a7c: goto endd04cf826c5db444107cf4e0bf789bcda } c := v.Args[1].AuxInt - v.Op = OpAMD64SARQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SARQconst) v.AuxInt = c & 63 v.AddArg(x) return true @@ -12206,10 +10829,7 @@ endd04cf826c5db444107cf4e0bf789bcda: goto end6266051b3a126922286c298594535622 } c := v.Args[1].AuxInt - v.Op = OpAMD64SARQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SARQconst) v.AuxInt = c & 63 v.AddArg(x) return true @@ -12226,10 +10846,7 @@ end6266051b3a126922286c298594535622: goto endcf2a1bdfeda535fc96ae1e7f5c54d531 } c := v.Args[1].AuxInt - v.Op = OpAMD64SARQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SARQconst) v.AuxInt = c & 63 v.AddArg(x) return true @@ -12251,10 +10868,7 @@ func rewriteValueAMD64_OpAMD64SARQconst(v *Value, config *Config) bool { goto endd949ba69a1ff71ba62c49b39c68f269e } d := v.Args[0].AuxInt - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVQconst) v.AuxInt = d >> uint64(c) return true } @@ -12275,10 +10889,7 @@ func rewriteValueAMD64_OpAMD64SARW(v *Value, config *Config) bool { goto endec8cafea5ff91b2a1b5cf5a169be924f } c := v.Args[1].AuxInt - v.Op = OpAMD64SARWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SARWconst) v.AuxInt = c & 31 v.AddArg(x) return true @@ -12295,10 +10906,7 @@ endec8cafea5ff91b2a1b5cf5a169be924f: goto end9303d0edeebdc8a2a7e93fecf0fff61c } c := v.Args[1].AuxInt - v.Op = OpAMD64SARWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SARWconst) v.AuxInt = c & 31 v.AddArg(x) return true @@ -12315,10 +10923,7 @@ end9303d0edeebdc8a2a7e93fecf0fff61c: goto endc46e3f211f94238f9a0aec3c498af490 } c := v.Args[1].AuxInt - v.Op = OpAMD64SARWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SARWconst) v.AuxInt = c & 31 v.AddArg(x) return true @@ -12335,10 +10940,7 @@ endc46e3f211f94238f9a0aec3c498af490: goto end0bf07ce9cd2c536c07768f8dfbe13c62 } c := v.Args[1].AuxInt - v.Op = OpAMD64SARWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SARWconst) v.AuxInt = c & 31 v.AddArg(x) return true @@ -12360,10 +10962,7 @@ func rewriteValueAMD64_OpAMD64SARWconst(v *Value, config *Config) bool { goto endca23e80dba22ab574f843c7a4cef24ab } d := v.Args[0].AuxInt - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVQconst) v.AuxInt = d >> uint64(c) return true } @@ -12382,10 +10981,7 @@ func rewriteValueAMD64_OpAMD64SBBLcarrymask(v *Value, config *Config) bool { if v.Args[0].Op != OpAMD64FlagEQ { goto end49bb4f49864044e2cd06c9c8e2c05f12 } - v.Op = OpAMD64MOVLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVLconst) v.AuxInt = 0 return true } @@ -12399,10 +10995,7 @@ end49bb4f49864044e2cd06c9c8e2c05f12: if v.Args[0].Op != OpAMD64FlagLT_ULT { goto ende534d42c655e8b95b051e7ec44d4fdf9 } - v.Op = OpAMD64MOVLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVLconst) v.AuxInt = -1 return true } @@ -12416,10 +11009,7 @@ ende534d42c655e8b95b051e7ec44d4fdf9: if v.Args[0].Op != OpAMD64FlagLT_UGT { goto end212628069f217f165eaf49dcfd9e8c76 } - v.Op = OpAMD64MOVLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVLconst) v.AuxInt = 0 return true } @@ -12433,10 +11023,7 @@ end212628069f217f165eaf49dcfd9e8c76: if v.Args[0].Op != OpAMD64FlagGT_ULT { goto end4df0bf7db9772a6011ed89bd3ce95f1d } - v.Op = OpAMD64MOVLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVLconst) v.AuxInt = -1 return true } @@ -12450,10 +11037,7 @@ end4df0bf7db9772a6011ed89bd3ce95f1d: if v.Args[0].Op != OpAMD64FlagGT_UGT { goto end4d9d1509d6d260332f0a345332ce89e2 } - v.Op = OpAMD64MOVLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVLconst) v.AuxInt = 0 return true } @@ -12472,10 +11056,7 @@ func rewriteValueAMD64_OpAMD64SBBQcarrymask(v *Value, config *Config) bool { if v.Args[0].Op != OpAMD64FlagEQ { goto end6b4a6f105b53df8063846a528bab0abb } - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVQconst) v.AuxInt = 0 return true } @@ -12489,10 +11070,7 @@ end6b4a6f105b53df8063846a528bab0abb: if v.Args[0].Op != OpAMD64FlagLT_ULT { goto endbfed0a1a93d6d8570f304898550d9558 } - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVQconst) v.AuxInt = -1 return true } @@ -12506,10 +11084,7 @@ endbfed0a1a93d6d8570f304898550d9558: if v.Args[0].Op != OpAMD64FlagLT_UGT { goto end8edf88458891c571a6ea6e52e0267b40 } - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVQconst) v.AuxInt = 0 return true } @@ -12523,10 +11098,7 @@ end8edf88458891c571a6ea6e52e0267b40: if v.Args[0].Op != OpAMD64FlagGT_ULT { goto end4663340439f2fa7a666e81f0ebc68436 } - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVQconst) v.AuxInt = -1 return true } @@ -12540,10 +11112,7 @@ end4663340439f2fa7a666e81f0ebc68436: if v.Args[0].Op != OpAMD64FlagGT_UGT { goto end7262400b0380a163bd65b88e0c3db985 } - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVQconst) v.AuxInt = 0 return true } @@ -12563,10 +11132,7 @@ func rewriteValueAMD64_OpAMD64SETA(v *Value, config *Config) bool { goto enda4ac36e94fc279d762b5a6c7c6cc665d } x := v.Args[0].Args[0] - v.Op = OpAMD64SETB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETB) v.AddArg(x) return true } @@ -12580,10 +11146,7 @@ enda4ac36e94fc279d762b5a6c7c6cc665d: if v.Args[0].Op != OpAMD64FlagEQ { goto end1521942d06b7f0caba92883aee0bb90e } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } @@ -12597,10 +11160,7 @@ end1521942d06b7f0caba92883aee0bb90e: if v.Args[0].Op != OpAMD64FlagLT_ULT { goto endf79d69b18a140d5c6669216ad65f60f0 } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } @@ -12614,10 +11174,7 @@ endf79d69b18a140d5c6669216ad65f60f0: if v.Args[0].Op != OpAMD64FlagLT_UGT { goto end272c1e5fca714e319fb1c335023826db } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } @@ -12631,10 +11188,7 @@ end272c1e5fca714e319fb1c335023826db: if v.Args[0].Op != OpAMD64FlagGT_ULT { goto ende0cf0104de1315266d93ded9a092302c } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } @@ -12648,10 +11202,7 @@ ende0cf0104de1315266d93ded9a092302c: if v.Args[0].Op != OpAMD64FlagGT_UGT { goto end85507f7549319577f9994826ee379f3b } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } @@ -12671,10 +11222,7 @@ func rewriteValueAMD64_OpAMD64SETAE(v *Value, config *Config) bool { goto end0468f5be6caf682fdea6b91d6648991e } x := v.Args[0].Args[0] - v.Op = OpAMD64SETBE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETBE) v.AddArg(x) return true } @@ -12688,10 +11236,7 @@ end0468f5be6caf682fdea6b91d6648991e: if v.Args[0].Op != OpAMD64FlagEQ { goto endc6396df3825db703a99be0e624c6396f } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } @@ -12705,10 +11250,7 @@ endc6396df3825db703a99be0e624c6396f: if v.Args[0].Op != OpAMD64FlagLT_ULT { goto end2392c77d6746969c65a422c68ad193bc } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } @@ -12722,10 +11264,7 @@ end2392c77d6746969c65a422c68ad193bc: if v.Args[0].Op != OpAMD64FlagLT_UGT { goto end081f3b2b98d3a990739d2a5562d4f254 } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } @@ -12739,10 +11278,7 @@ end081f3b2b98d3a990739d2a5562d4f254: if v.Args[0].Op != OpAMD64FlagGT_ULT { goto end47a6cc5efdd00e349c5e23be3624d719 } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } @@ -12756,10 +11292,7 @@ end47a6cc5efdd00e349c5e23be3624d719: if v.Args[0].Op != OpAMD64FlagGT_UGT { goto endd47bb51035b00c560b5347b3be19e20e } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } @@ -12779,10 +11312,7 @@ func rewriteValueAMD64_OpAMD64SETB(v *Value, config *Config) bool { goto endc9eba7aa1e54a228570d2f5cc96f3565 } x := v.Args[0].Args[0] - v.Op = OpAMD64SETA - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETA) v.AddArg(x) return true } @@ -12796,10 +11326,7 @@ endc9eba7aa1e54a228570d2f5cc96f3565: if v.Args[0].Op != OpAMD64FlagEQ { goto endaf8a2c61689b00c8ad90dd090e634c81 } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } @@ -12813,10 +11340,7 @@ endaf8a2c61689b00c8ad90dd090e634c81: if v.Args[0].Op != OpAMD64FlagLT_ULT { goto endab96387d5f049ab9c87863473a5d6510 } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } @@ -12830,10 +11354,7 @@ endab96387d5f049ab9c87863473a5d6510: if v.Args[0].Op != OpAMD64FlagLT_UGT { goto endbf7af56278add8851974cd1a538b3b7f } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } @@ -12847,10 +11368,7 @@ endbf7af56278add8851974cd1a538b3b7f: if v.Args[0].Op != OpAMD64FlagGT_ULT { goto end2d07a10db28e5160fccf66ee44c4823e } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } @@ -12864,10 +11382,7 @@ end2d07a10db28e5160fccf66ee44c4823e: if v.Args[0].Op != OpAMD64FlagGT_UGT { goto end87ec5187683c0ee498c0a2c4de59f4c0 } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } @@ -12887,10 +11402,7 @@ func rewriteValueAMD64_OpAMD64SETBE(v *Value, config *Config) bool { goto end9d9031643469798b14b8cad1f5a7a1ba } x := v.Args[0].Args[0] - v.Op = OpAMD64SETAE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETAE) v.AddArg(x) return true } @@ -12904,10 +11416,7 @@ end9d9031643469798b14b8cad1f5a7a1ba: if v.Args[0].Op != OpAMD64FlagEQ { goto ende6a02d3ce0e1584e806c7861de97eb5b } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } @@ -12921,10 +11430,7 @@ ende6a02d3ce0e1584e806c7861de97eb5b: if v.Args[0].Op != OpAMD64FlagLT_ULT { goto end7ea0208cd10e6311655d09e8aa354169 } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } @@ -12938,10 +11444,7 @@ end7ea0208cd10e6311655d09e8aa354169: if v.Args[0].Op != OpAMD64FlagLT_UGT { goto enddbfa0595802c67348d3a3bd22b198231 } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } @@ -12955,10 +11458,7 @@ enddbfa0595802c67348d3a3bd22b198231: if v.Args[0].Op != OpAMD64FlagGT_ULT { goto end5b26e1d28d6a517ed004b0f9b80df27b } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } @@ -12972,10 +11472,7 @@ end5b26e1d28d6a517ed004b0f9b80df27b: if v.Args[0].Op != OpAMD64FlagGT_UGT { goto end679e2e0ccd0dd526ea781fc64102cb88 } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } @@ -12995,10 +11492,7 @@ func rewriteValueAMD64_OpAMD64SETEQ(v *Value, config *Config) bool { goto end5d2039c9368d8c0cfba23b5a85b459e1 } x := v.Args[0].Args[0] - v.Op = OpAMD64SETEQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETEQ) v.AddArg(x) return true } @@ -13012,10 +11506,7 @@ end5d2039c9368d8c0cfba23b5a85b459e1: if v.Args[0].Op != OpAMD64FlagEQ { goto end74e09087ca9d4bdf7740f4f052d2b9d3 } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } @@ -13029,10 +11520,7 @@ end74e09087ca9d4bdf7740f4f052d2b9d3: if v.Args[0].Op != OpAMD64FlagLT_ULT { goto ende5d3756d09e616648de68d364b2c308f } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } @@ -13046,10 +11534,7 @@ ende5d3756d09e616648de68d364b2c308f: if v.Args[0].Op != OpAMD64FlagLT_UGT { goto end1a86a603a5c6e0f328f63b9279137bcc } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } @@ -13063,10 +11548,7 @@ end1a86a603a5c6e0f328f63b9279137bcc: if v.Args[0].Op != OpAMD64FlagGT_ULT { goto endbf907332cd6004c73b88f43b5e20275f } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } @@ -13080,10 +11562,7 @@ endbf907332cd6004c73b88f43b5e20275f: if v.Args[0].Op != OpAMD64FlagGT_UGT { goto end707540a9904307c186884f60e425ca62 } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } @@ -13103,10 +11582,7 @@ func rewriteValueAMD64_OpAMD64SETG(v *Value, config *Config) bool { goto endf7586738694c9cd0b74ae28bbadb649f } x := v.Args[0].Args[0] - v.Op = OpAMD64SETL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETL) v.AddArg(x) return true } @@ -13120,10 +11596,7 @@ endf7586738694c9cd0b74ae28bbadb649f: if v.Args[0].Op != OpAMD64FlagEQ { goto endc952db8883f26126822bac29276b0690 } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } @@ -13137,10 +11610,7 @@ endc952db8883f26126822bac29276b0690: if v.Args[0].Op != OpAMD64FlagLT_ULT { goto end3b6d659c9285d30eba022a85c6c6f1c9 } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } @@ -13154,10 +11624,7 @@ end3b6d659c9285d30eba022a85c6c6f1c9: if v.Args[0].Op != OpAMD64FlagLT_UGT { goto end2eabfc908ca06e7d5d217142dd48af33 } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } @@ -13171,10 +11638,7 @@ end2eabfc908ca06e7d5d217142dd48af33: if v.Args[0].Op != OpAMD64FlagGT_ULT { goto end7c059e63a98776c77bb8e43759d2d864 } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } @@ -13188,10 +11652,7 @@ end7c059e63a98776c77bb8e43759d2d864: if v.Args[0].Op != OpAMD64FlagGT_UGT { goto enddcb3196491c82060bcb90da722ffa8bd } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } @@ -13211,10 +11672,7 @@ func rewriteValueAMD64_OpAMD64SETGE(v *Value, config *Config) bool { goto end82c11eff6f842159f564f2dad3d2eedc } x := v.Args[0].Args[0] - v.Op = OpAMD64SETLE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETLE) v.AddArg(x) return true } @@ -13228,10 +11686,7 @@ end82c11eff6f842159f564f2dad3d2eedc: if v.Args[0].Op != OpAMD64FlagEQ { goto end1152b03b15fb4ea1822b2cc1c6815887 } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } @@ -13245,10 +11700,7 @@ end1152b03b15fb4ea1822b2cc1c6815887: if v.Args[0].Op != OpAMD64FlagLT_ULT { goto endd55763184b306cc32397b421df6fc994 } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } @@ -13262,10 +11714,7 @@ endd55763184b306cc32397b421df6fc994: if v.Args[0].Op != OpAMD64FlagLT_UGT { goto end209fbc531c4d6696b0b226c1ac016add } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } @@ -13279,10 +11728,7 @@ end209fbc531c4d6696b0b226c1ac016add: if v.Args[0].Op != OpAMD64FlagGT_ULT { goto end41600cc6b5af1497fc534af49eaf60a2 } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } @@ -13296,10 +11742,7 @@ end41600cc6b5af1497fc534af49eaf60a2: if v.Args[0].Op != OpAMD64FlagGT_UGT { goto endaa33fb1204dba90a141a9a945a9643a2 } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } @@ -13319,10 +11762,7 @@ func rewriteValueAMD64_OpAMD64SETL(v *Value, config *Config) bool { goto ende33160cd86b9d4d3b77e02fb4658d5d3 } x := v.Args[0].Args[0] - v.Op = OpAMD64SETG - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETG) v.AddArg(x) return true } @@ -13336,10 +11776,7 @@ ende33160cd86b9d4d3b77e02fb4658d5d3: if v.Args[0].Op != OpAMD64FlagEQ { goto end52e421ca76fa5dfba6b9bc35b220c0bf } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } @@ -13353,10 +11790,7 @@ end52e421ca76fa5dfba6b9bc35b220c0bf: if v.Args[0].Op != OpAMD64FlagLT_ULT { goto end4d9781536010887bcf6f6ffd563e6aac } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } @@ -13370,10 +11804,7 @@ end4d9781536010887bcf6f6ffd563e6aac: if v.Args[0].Op != OpAMD64FlagLT_UGT { goto end9d0dd525ca800cb3ec73e94d60c3cbf1 } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } @@ -13387,10 +11818,7 @@ end9d0dd525ca800cb3ec73e94d60c3cbf1: if v.Args[0].Op != OpAMD64FlagGT_ULT { goto end6d77da1539ee0ebebee0e162c55e8f6e } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } @@ -13404,10 +11832,7 @@ end6d77da1539ee0ebebee0e162c55e8f6e: if v.Args[0].Op != OpAMD64FlagGT_UGT { goto end6c129bef0cc197325a338d17720516d1 } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } @@ -13427,10 +11852,7 @@ func rewriteValueAMD64_OpAMD64SETLE(v *Value, config *Config) bool { goto end9307d96753efbeb888d1c98a6aba7a29 } x := v.Args[0].Args[0] - v.Op = OpAMD64SETGE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETGE) v.AddArg(x) return true } @@ -13444,10 +11866,7 @@ end9307d96753efbeb888d1c98a6aba7a29: if v.Args[0].Op != OpAMD64FlagEQ { goto end43f998d2f9524fcdf45bab9fe672aa7c } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } @@ -13461,10 +11880,7 @@ end43f998d2f9524fcdf45bab9fe672aa7c: if v.Args[0].Op != OpAMD64FlagLT_ULT { goto end80212f1ca6a01bccdf4bbd5aa15d5aab } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } @@ -13478,10 +11894,7 @@ end80212f1ca6a01bccdf4bbd5aa15d5aab: if v.Args[0].Op != OpAMD64FlagLT_UGT { goto endd5ab2a8df7344cd7c8e1092d78bfd871 } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } @@ -13495,10 +11908,7 @@ endd5ab2a8df7344cd7c8e1092d78bfd871: if v.Args[0].Op != OpAMD64FlagGT_ULT { goto enda74997e85c6f82ff1c530e6051d01e21 } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } @@ -13512,10 +11922,7 @@ enda74997e85c6f82ff1c530e6051d01e21: if v.Args[0].Op != OpAMD64FlagGT_UGT { goto end7694b41632545d10fcc6339063c53f07 } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } @@ -13535,10 +11942,7 @@ func rewriteValueAMD64_OpAMD64SETNE(v *Value, config *Config) bool { goto endbc71811b789475308014550f638026eb } x := v.Args[0].Args[0] - v.Op = OpAMD64SETNE - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SETNE) v.AddArg(x) return true } @@ -13552,10 +11956,7 @@ endbc71811b789475308014550f638026eb: if v.Args[0].Op != OpAMD64FlagEQ { goto end6b66ea2ed518a926a071fe0d3dce46d8 } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } @@ -13569,10 +11970,7 @@ end6b66ea2ed518a926a071fe0d3dce46d8: if v.Args[0].Op != OpAMD64FlagLT_ULT { goto ende4d3b99f9dff014be3067a577ba0b016 } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } @@ -13586,10 +11984,7 @@ ende4d3b99f9dff014be3067a577ba0b016: if v.Args[0].Op != OpAMD64FlagLT_UGT { goto endb98d73ed6e5d3d21c2ea33840ab2a21c } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } @@ -13603,10 +11998,7 @@ endb98d73ed6e5d3d21c2ea33840ab2a21c: if v.Args[0].Op != OpAMD64FlagGT_ULT { goto end3bceb5cece8d0112cc8cd53435d64ef4 } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } @@ -13620,10 +12012,7 @@ end3bceb5cece8d0112cc8cd53435d64ef4: if v.Args[0].Op != OpAMD64FlagGT_UGT { goto end9249b3ed3e1e582dd5435fb73cbc13ac } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } @@ -13644,10 +12033,7 @@ func rewriteValueAMD64_OpAMD64SHLB(v *Value, config *Config) bool { goto endb1f377b81b6f4c1864893934230ecbd1 } c := v.Args[1].AuxInt - v.Op = OpAMD64SHLBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SHLBconst) v.AuxInt = c & 31 v.AddArg(x) return true @@ -13664,10 +12050,7 @@ endb1f377b81b6f4c1864893934230ecbd1: goto end434bc4ee26d93bf1c734be760d7a1aa6 } c := v.Args[1].AuxInt - v.Op = OpAMD64SHLBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SHLBconst) v.AuxInt = c & 31 v.AddArg(x) return true @@ -13684,10 +12067,7 @@ end434bc4ee26d93bf1c734be760d7a1aa6: goto end2c4fe4cce2ae24e0bc5c7d209d22e9d9 } c := v.Args[1].AuxInt - v.Op = OpAMD64SHLBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SHLBconst) v.AuxInt = c & 31 v.AddArg(x) return true @@ -13704,10 +12084,7 @@ end2c4fe4cce2ae24e0bc5c7d209d22e9d9: goto end2d0d0111d831d8a575b5627284a6337a } c := v.Args[1].AuxInt - v.Op = OpAMD64SHLBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SHLBconst) v.AuxInt = c & 31 v.AddArg(x) return true @@ -13729,10 +12106,7 @@ func rewriteValueAMD64_OpAMD64SHLL(v *Value, config *Config) bool { goto end1b4f8b8d62445fdcb3cf9cd5036b559b } c := v.Args[1].AuxInt - v.Op = OpAMD64SHLLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SHLLconst) v.AuxInt = c & 31 v.AddArg(x) return true @@ -13749,10 +12123,7 @@ end1b4f8b8d62445fdcb3cf9cd5036b559b: goto end633f9ddcfbb63374c895a5f78da75d25 } c := v.Args[1].AuxInt - v.Op = OpAMD64SHLLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SHLLconst) v.AuxInt = c & 31 v.AddArg(x) return true @@ -13769,10 +12140,7 @@ end633f9ddcfbb63374c895a5f78da75d25: goto enda4f59495061db6cfe796b6dba8d3cad8 } c := v.Args[1].AuxInt - v.Op = OpAMD64SHLLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SHLLconst) v.AuxInt = c & 31 v.AddArg(x) return true @@ -13789,10 +12157,7 @@ enda4f59495061db6cfe796b6dba8d3cad8: goto endd6f39b5f3174ca738ae1c48a96d837a6 } c := v.Args[1].AuxInt - v.Op = OpAMD64SHLLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SHLLconst) v.AuxInt = c & 31 v.AddArg(x) return true @@ -13814,10 +12179,7 @@ func rewriteValueAMD64_OpAMD64SHLQ(v *Value, config *Config) bool { goto end4d7e3a945cacdd6b6c8c0de6f465d4ae } c := v.Args[1].AuxInt - v.Op = OpAMD64SHLQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SHLQconst) v.AuxInt = c & 63 v.AddArg(x) return true @@ -13834,10 +12196,7 @@ end4d7e3a945cacdd6b6c8c0de6f465d4ae: goto end394bae2652a3e4bc4b70a6fc193949f8 } c := v.Args[1].AuxInt - v.Op = OpAMD64SHLQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SHLQconst) v.AuxInt = c & 63 v.AddArg(x) return true @@ -13854,10 +12213,7 @@ end394bae2652a3e4bc4b70a6fc193949f8: goto end358be4078efa15ceb443ccda7ce592a0 } c := v.Args[1].AuxInt - v.Op = OpAMD64SHLQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SHLQconst) v.AuxInt = c & 63 v.AddArg(x) return true @@ -13874,10 +12230,7 @@ end358be4078efa15ceb443ccda7ce592a0: goto end032e0efd085f37a12322dbc63795a1b2 } c := v.Args[1].AuxInt - v.Op = OpAMD64SHLQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SHLQconst) v.AuxInt = c & 63 v.AddArg(x) return true @@ -13899,10 +12252,7 @@ func rewriteValueAMD64_OpAMD64SHLW(v *Value, config *Config) bool { goto enda29aa85ce58b1fdb63d71e2632efd6db } c := v.Args[1].AuxInt - v.Op = OpAMD64SHLWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SHLWconst) v.AuxInt = c & 31 v.AddArg(x) return true @@ -13919,10 +12269,7 @@ enda29aa85ce58b1fdb63d71e2632efd6db: goto end59ce264ffde0ef9af8ea1a25db7173b6 } c := v.Args[1].AuxInt - v.Op = OpAMD64SHLWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SHLWconst) v.AuxInt = c & 31 v.AddArg(x) return true @@ -13939,10 +12286,7 @@ end59ce264ffde0ef9af8ea1a25db7173b6: goto endba96a52aa58d28b3357828051e0e695c } c := v.Args[1].AuxInt - v.Op = OpAMD64SHLWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SHLWconst) v.AuxInt = c & 31 v.AddArg(x) return true @@ -13959,10 +12303,7 @@ endba96a52aa58d28b3357828051e0e695c: goto endf9c2165ea24ac7bbdd46cdf0e084104f } c := v.Args[1].AuxInt - v.Op = OpAMD64SHLWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SHLWconst) v.AuxInt = c & 31 v.AddArg(x) return true @@ -13984,10 +12325,7 @@ func rewriteValueAMD64_OpAMD64SHRB(v *Value, config *Config) bool { goto end2e7fb7a5406cbf51c69a0d04dc73d16a } c := v.Args[1].AuxInt - v.Op = OpAMD64SHRBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SHRBconst) v.AuxInt = c & 31 v.AddArg(x) return true @@ -14004,10 +12342,7 @@ end2e7fb7a5406cbf51c69a0d04dc73d16a: goto end69603cc51e4f244388f368dd188a526a } c := v.Args[1].AuxInt - v.Op = OpAMD64SHRBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SHRBconst) v.AuxInt = c & 31 v.AddArg(x) return true @@ -14024,10 +12359,7 @@ end69603cc51e4f244388f368dd188a526a: goto endd96421647299a1bb1b68ad0a90fa0be3 } c := v.Args[1].AuxInt - v.Op = OpAMD64SHRBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SHRBconst) v.AuxInt = c & 31 v.AddArg(x) return true @@ -14044,10 +12376,7 @@ endd96421647299a1bb1b68ad0a90fa0be3: goto enddb1cd5aaa826d43fa4f6d1b2b8795e58 } c := v.Args[1].AuxInt - v.Op = OpAMD64SHRBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SHRBconst) v.AuxInt = c & 31 v.AddArg(x) return true @@ -14069,10 +12398,7 @@ func rewriteValueAMD64_OpAMD64SHRL(v *Value, config *Config) bool { goto end893880cdc59697295c1849a250163e59 } c := v.Args[1].AuxInt - v.Op = OpAMD64SHRLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SHRLconst) v.AuxInt = c & 31 v.AddArg(x) return true @@ -14089,10 +12415,7 @@ end893880cdc59697295c1849a250163e59: goto end344b8b9202e1925e8d0561f1c21412fc } c := v.Args[1].AuxInt - v.Op = OpAMD64SHRLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SHRLconst) v.AuxInt = c & 31 v.AddArg(x) return true @@ -14109,10 +12432,7 @@ end344b8b9202e1925e8d0561f1c21412fc: goto end561280f746f9983f4a4b4a5119b53028 } c := v.Args[1].AuxInt - v.Op = OpAMD64SHRLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SHRLconst) v.AuxInt = c & 31 v.AddArg(x) return true @@ -14129,10 +12449,7 @@ end561280f746f9983f4a4b4a5119b53028: goto enda339271c59d274b73c04ba1f2c44c2b9 } c := v.Args[1].AuxInt - v.Op = OpAMD64SHRLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SHRLconst) v.AuxInt = c & 31 v.AddArg(x) return true @@ -14154,10 +12471,7 @@ func rewriteValueAMD64_OpAMD64SHRQ(v *Value, config *Config) bool { goto end699d35e2d5cfa08b8a3b1c8a183ddcf3 } c := v.Args[1].AuxInt - v.Op = OpAMD64SHRQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SHRQconst) v.AuxInt = c & 63 v.AddArg(x) return true @@ -14174,10 +12488,7 @@ end699d35e2d5cfa08b8a3b1c8a183ddcf3: goto end3189f4abaac8028d9191c9ba64124999 } c := v.Args[1].AuxInt - v.Op = OpAMD64SHRQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SHRQconst) v.AuxInt = c & 63 v.AddArg(x) return true @@ -14194,10 +12505,7 @@ end3189f4abaac8028d9191c9ba64124999: goto end0cbc86ae04a355c0e2a96400242f4633 } c := v.Args[1].AuxInt - v.Op = OpAMD64SHRQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SHRQconst) v.AuxInt = c & 63 v.AddArg(x) return true @@ -14214,10 +12522,7 @@ end0cbc86ae04a355c0e2a96400242f4633: goto endb9c003612674e7a1ea7c13e463c229d2 } c := v.Args[1].AuxInt - v.Op = OpAMD64SHRQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SHRQconst) v.AuxInt = c & 63 v.AddArg(x) return true @@ -14239,10 +12544,7 @@ func rewriteValueAMD64_OpAMD64SHRW(v *Value, config *Config) bool { goto endc5c82eea9a6b51b1d6b76e57f21f46ff } c := v.Args[1].AuxInt - v.Op = OpAMD64SHRWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SHRWconst) v.AuxInt = c & 31 v.AddArg(x) return true @@ -14259,10 +12561,7 @@ endc5c82eea9a6b51b1d6b76e57f21f46ff: goto end773e94c857256ae9a31eb5b3d667e64b } c := v.Args[1].AuxInt - v.Op = OpAMD64SHRWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SHRWconst) v.AuxInt = c & 31 v.AddArg(x) return true @@ -14279,10 +12578,7 @@ end773e94c857256ae9a31eb5b3d667e64b: goto endd75ff1f9b3e9ec9c942a39b6179da1b3 } c := v.Args[1].AuxInt - v.Op = OpAMD64SHRWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SHRWconst) v.AuxInt = c & 31 v.AddArg(x) return true @@ -14299,10 +12595,7 @@ endd75ff1f9b3e9ec9c942a39b6179da1b3: goto end6761530cd742ad00057c19a6a3c38ada } c := v.Args[1].AuxInt - v.Op = OpAMD64SHRWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SHRWconst) v.AuxInt = c & 31 v.AddArg(x) return true @@ -14324,10 +12617,7 @@ func rewriteValueAMD64_OpAMD64SUBB(v *Value, config *Config) bool { goto end9ca5d2a70e2df1a5a3ed6786bce1f7b2 } c := v.Args[1].AuxInt - v.Op = OpAMD64SUBBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SUBBconst) v.AddArg(x) v.AuxInt = c return true @@ -14344,10 +12634,7 @@ end9ca5d2a70e2df1a5a3ed6786bce1f7b2: } c := v.Args[0].AuxInt x := v.Args[1] - v.Op = OpAMD64NEGB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64NEGB) v0 := b.NewValue0(v.Line, OpAMD64SUBBconst, v.Type) v0.AddArg(x) v0.AuxInt = c @@ -14365,10 +12652,7 @@ endc288755d69b04d24a6aac32a73956411: if v.Args[1] != x { goto ende8904403d937d95b0d6133d3ec92bb45 } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } @@ -14389,10 +12673,7 @@ func rewriteValueAMD64_OpAMD64SUBBconst(v *Value, config *Config) bool { if !(int8(c) == 0) { goto end974a26e947badc62fc104581f49138e6 } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -14409,10 +12690,7 @@ end974a26e947badc62fc104581f49138e6: goto enddc5383558e2f3eae507afcb94eada964 } d := v.Args[0].AuxInt - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = d - c return true } @@ -14429,10 +12707,7 @@ enddc5383558e2f3eae507afcb94eada964: } d := v.Args[0].AuxInt x := v.Args[0].Args[0] - v.Op = OpAMD64ADDBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ADDBconst) v.AuxInt = -c - d v.AddArg(x) return true @@ -14454,10 +12729,7 @@ func rewriteValueAMD64_OpAMD64SUBL(v *Value, config *Config) bool { goto end178c1d6c86f9c16f6497586c2f7d8625 } c := v.Args[1].AuxInt - v.Op = OpAMD64SUBLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SUBLconst) v.AddArg(x) v.AuxInt = c return true @@ -14474,10 +12746,7 @@ end178c1d6c86f9c16f6497586c2f7d8625: } c := v.Args[0].AuxInt x := v.Args[1] - v.Op = OpAMD64NEGL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64NEGL) v0 := b.NewValue0(v.Line, OpAMD64SUBLconst, v.Type) v0.AddArg(x) v0.AuxInt = c @@ -14495,10 +12764,7 @@ endb0efe6e15ec20486b849534a00483ae2: if v.Args[1] != x { goto end332f1f641f875c69bea7289191e69133 } - v.Op = OpAMD64MOVLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVLconst) v.AuxInt = 0 return true } @@ -14519,10 +12785,7 @@ func rewriteValueAMD64_OpAMD64SUBLconst(v *Value, config *Config) bool { if !(int32(c) == 0) { goto end3fa10eaa42f9e283cf1757e1b2d3cac2 } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -14539,10 +12802,7 @@ end3fa10eaa42f9e283cf1757e1b2d3cac2: goto end6c5c6d58d4bdd0a5c2f7bf10b343b41e } d := v.Args[0].AuxInt - v.Op = OpAMD64MOVLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVLconst) v.AuxInt = d - c return true } @@ -14559,10 +12819,7 @@ end6c5c6d58d4bdd0a5c2f7bf10b343b41e: } d := v.Args[0].AuxInt x := v.Args[0].Args[0] - v.Op = OpAMD64ADDLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ADDLconst) v.AuxInt = -c - d v.AddArg(x) return true @@ -14587,10 +12844,7 @@ func rewriteValueAMD64_OpAMD64SUBQ(v *Value, config *Config) bool { if !(is32Bit(c)) { goto end9bbb7b20824a498752c605942fad89c2 } - v.Op = OpAMD64SUBQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SUBQconst) v.AddArg(x) v.AuxInt = c return true @@ -14610,10 +12864,7 @@ end9bbb7b20824a498752c605942fad89c2: if !(is32Bit(c)) { goto end8beb96de3efee9206d1bd4b7d777d2cb } - v.Op = OpAMD64NEGQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64NEGQ) v0 := b.NewValue0(v.Line, OpAMD64SUBQconst, v.Type) v0.AddArg(x) v0.AuxInt = c @@ -14631,10 +12882,7 @@ end8beb96de3efee9206d1bd4b7d777d2cb: if v.Args[1] != x { goto endd87d1d839d2dc54d9c90fa4f73383480 } - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVQconst) v.AuxInt = 0 return true } @@ -14654,10 +12902,7 @@ func rewriteValueAMD64_OpAMD64SUBQconst(v *Value, config *Config) bool { goto endfce1d3cec7c543c9dd80a27d944eb09e } x := v.Args[0] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -14674,10 +12919,7 @@ endfce1d3cec7c543c9dd80a27d944eb09e: goto endb0daebe6831cf381377c3e4248070f25 } d := v.Args[0].AuxInt - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVQconst) v.AuxInt = d - c return true } @@ -14694,10 +12936,7 @@ endb0daebe6831cf381377c3e4248070f25: } d := v.Args[0].AuxInt x := v.Args[0].Args[0] - v.Op = OpAMD64ADDQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ADDQconst) v.AuxInt = -c - d v.AddArg(x) return true @@ -14719,10 +12958,7 @@ func rewriteValueAMD64_OpAMD64SUBW(v *Value, config *Config) bool { goto end135aa9100b2f61d58b37cede37b63731 } c := v.Args[1].AuxInt - v.Op = OpAMD64SUBWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SUBWconst) v.AddArg(x) v.AuxInt = c return true @@ -14739,10 +12975,7 @@ end135aa9100b2f61d58b37cede37b63731: } c := v.Args[0].AuxInt x := v.Args[1] - v.Op = OpAMD64NEGW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64NEGW) v0 := b.NewValue0(v.Line, OpAMD64SUBWconst, v.Type) v0.AddArg(x) v0.AuxInt = c @@ -14760,10 +12993,7 @@ end44d23f7e65a4b1c42d0e6463f8e493b6: if v.Args[1] != x { goto endb970e7c318d04a1afe1dfe08a7ca0d9c } - v.Op = OpAMD64MOVWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVWconst) v.AuxInt = 0 return true } @@ -14784,10 +13014,7 @@ func rewriteValueAMD64_OpAMD64SUBWconst(v *Value, config *Config) bool { if !(int16(c) == 0) { goto end1e7a493992465c9cc8314e3256ed6394 } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -14804,10 +13031,7 @@ end1e7a493992465c9cc8314e3256ed6394: goto endae629a229c399eaed7dbb95b1b0e6f8a } d := v.Args[0].AuxInt - v.Op = OpAMD64MOVWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVWconst) v.AuxInt = d - c return true } @@ -14824,10 +13048,7 @@ endae629a229c399eaed7dbb95b1b0e6f8a: } d := v.Args[0].AuxInt x := v.Args[0].Args[0] - v.Op = OpAMD64ADDWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64ADDWconst) v.AuxInt = -c - d v.AddArg(x) return true @@ -14845,10 +13066,7 @@ func rewriteValueAMD64_OpSignExt16to32(v *Value, config *Config) bool { // result: (MOVWQSX x) { x := v.Args[0] - v.Op = OpAMD64MOVWQSX - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVWQSX) v.AddArg(x) return true } @@ -14865,10 +13083,7 @@ func rewriteValueAMD64_OpSignExt16to64(v *Value, config *Config) bool { // result: (MOVWQSX x) { x := v.Args[0] - v.Op = OpAMD64MOVWQSX - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVWQSX) v.AddArg(x) return true } @@ -14885,10 +13100,7 @@ func rewriteValueAMD64_OpSignExt32to64(v *Value, config *Config) bool { // result: (MOVLQSX x) { x := v.Args[0] - v.Op = OpAMD64MOVLQSX - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVLQSX) v.AddArg(x) return true } @@ -14905,10 +13117,7 @@ func rewriteValueAMD64_OpSignExt8to16(v *Value, config *Config) bool { // result: (MOVBQSX x) { x := v.Args[0] - v.Op = OpAMD64MOVBQSX - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBQSX) v.AddArg(x) return true } @@ -14925,10 +13134,7 @@ func rewriteValueAMD64_OpSignExt8to32(v *Value, config *Config) bool { // result: (MOVBQSX x) { x := v.Args[0] - v.Op = OpAMD64MOVBQSX - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBQSX) v.AddArg(x) return true } @@ -14945,10 +13151,7 @@ func rewriteValueAMD64_OpSignExt8to64(v *Value, config *Config) bool { // result: (MOVBQSX x) { x := v.Args[0] - v.Op = OpAMD64MOVBQSX - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBQSX) v.AddArg(x) return true } @@ -14965,10 +13168,7 @@ func rewriteValueAMD64_OpSqrt(v *Value, config *Config) bool { // result: (SQRTSD x) { x := v.Args[0] - v.Op = OpAMD64SQRTSD - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SQRTSD) v.AddArg(x) return true } @@ -14987,10 +13187,7 @@ func rewriteValueAMD64_OpStaticCall(v *Value, config *Config) bool { argwid := v.AuxInt target := v.Aux mem := v.Args[0] - v.Op = OpAMD64CALLstatic - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64CALLstatic) v.AuxInt = argwid v.Aux = target v.AddArg(mem) @@ -15017,10 +13214,7 @@ func rewriteValueAMD64_OpStore(v *Value, config *Config) bool { if !(is64BitFloat(val.Type)) { goto endaeec4f61bc8e67dbf3fa2f79fe4c2b9e } - v.Op = OpAMD64MOVSDstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVSDstore) v.AddArg(ptr) v.AddArg(val) v.AddArg(mem) @@ -15042,10 +13236,7 @@ endaeec4f61bc8e67dbf3fa2f79fe4c2b9e: if !(is32BitFloat(val.Type)) { goto endf638ca0a75871b5062da15324d0e0384 } - v.Op = OpAMD64MOVSSstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVSSstore) v.AddArg(ptr) v.AddArg(val) v.AddArg(mem) @@ -15064,10 +13255,7 @@ endf638ca0a75871b5062da15324d0e0384: ptr := v.Args[0] val := v.Args[1] mem := v.Args[2] - v.Op = OpAMD64MOVQstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVQstore) v.AddArg(ptr) v.AddArg(val) v.AddArg(mem) @@ -15086,10 +13274,7 @@ endd1eb7c3ea0c806e7a53ff3be86186eb7: ptr := v.Args[0] val := v.Args[1] mem := v.Args[2] - v.Op = OpAMD64MOVLstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVLstore) v.AddArg(ptr) v.AddArg(val) v.AddArg(mem) @@ -15108,10 +13293,7 @@ end44e3b22360da76ecd59be9a8c2dd1347: ptr := v.Args[0] val := v.Args[1] mem := v.Args[2] - v.Op = OpAMD64MOVWstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVWstore) v.AddArg(ptr) v.AddArg(val) v.AddArg(mem) @@ -15130,10 +13312,7 @@ endd0342b7fd3d0713f3e26922660047c71: ptr := v.Args[0] val := v.Args[1] mem := v.Args[2] - v.Op = OpAMD64MOVBstore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBstore) v.AddArg(ptr) v.AddArg(val) v.AddArg(mem) @@ -15153,10 +13332,7 @@ func rewriteValueAMD64_OpSub16(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SUBW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SUBW) v.AddArg(x) v.AddArg(y) return true @@ -15175,10 +13351,7 @@ func rewriteValueAMD64_OpSub32(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SUBL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SUBL) v.AddArg(x) v.AddArg(y) return true @@ -15197,10 +13370,7 @@ func rewriteValueAMD64_OpSub32F(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SUBSS - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SUBSS) v.AddArg(x) v.AddArg(y) return true @@ -15219,10 +13389,7 @@ func rewriteValueAMD64_OpSub64(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SUBQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SUBQ) v.AddArg(x) v.AddArg(y) return true @@ -15241,10 +13408,7 @@ func rewriteValueAMD64_OpSub64F(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SUBSD - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SUBSD) v.AddArg(x) v.AddArg(y) return true @@ -15263,10 +13427,7 @@ func rewriteValueAMD64_OpSub8(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SUBB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SUBB) v.AddArg(x) v.AddArg(y) return true @@ -15285,10 +13446,7 @@ func rewriteValueAMD64_OpSubPtr(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64SUBQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64SUBQ) v.AddArg(x) v.AddArg(y) return true @@ -15306,10 +13464,7 @@ func rewriteValueAMD64_OpTrunc16to8(v *Value, config *Config) bool { // result: x { x := v.Args[0] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -15327,10 +13482,7 @@ func rewriteValueAMD64_OpTrunc32to16(v *Value, config *Config) bool { // result: x { x := v.Args[0] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -15348,10 +13500,7 @@ func rewriteValueAMD64_OpTrunc32to8(v *Value, config *Config) bool { // result: x { x := v.Args[0] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -15369,10 +13518,7 @@ func rewriteValueAMD64_OpTrunc64to16(v *Value, config *Config) bool { // result: x { x := v.Args[0] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -15390,10 +13536,7 @@ func rewriteValueAMD64_OpTrunc64to32(v *Value, config *Config) bool { // result: x { x := v.Args[0] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -15411,10 +13554,7 @@ func rewriteValueAMD64_OpTrunc64to8(v *Value, config *Config) bool { // result: x { x := v.Args[0] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -15436,10 +13576,7 @@ func rewriteValueAMD64_OpAMD64XORB(v *Value, config *Config) bool { goto enda9ed9fdd115ffdffa8127c007c34d7b7 } c := v.Args[1].AuxInt - v.Op = OpAMD64XORBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64XORBconst) v.AuxInt = c v.AddArg(x) return true @@ -15456,10 +13593,7 @@ enda9ed9fdd115ffdffa8127c007c34d7b7: } c := v.Args[0].AuxInt x := v.Args[1] - v.Op = OpAMD64XORBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64XORBconst) v.AuxInt = c v.AddArg(x) return true @@ -15475,10 +13609,7 @@ endb02a07d9dc7b802c59f013116e952f3f: if v.Args[1] != x { goto end2afddc39503d04d572a3a07878f6c9c9 } - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } @@ -15499,10 +13630,7 @@ func rewriteValueAMD64_OpAMD64XORBconst(v *Value, config *Config) bool { if !(int8(c) == 0) { goto end14b03b70e5579dfe3f9b243e02a887c3 } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -15519,10 +13647,7 @@ end14b03b70e5579dfe3f9b243e02a887c3: goto end6d8d1b612af9d253605c8bc69b822903 } d := v.Args[0].AuxInt - v.Op = OpAMD64MOVBconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBconst) v.AuxInt = c ^ d return true } @@ -15543,10 +13668,7 @@ func rewriteValueAMD64_OpAMD64XORL(v *Value, config *Config) bool { goto enda9459d509d3416da67d13a22dd074a9c } c := v.Args[1].AuxInt - v.Op = OpAMD64XORLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64XORLconst) v.AuxInt = c v.AddArg(x) return true @@ -15563,10 +13685,7 @@ enda9459d509d3416da67d13a22dd074a9c: } c := v.Args[0].AuxInt x := v.Args[1] - v.Op = OpAMD64XORLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64XORLconst) v.AuxInt = c v.AddArg(x) return true @@ -15582,10 +13701,7 @@ end9c1a0af00eeadd8aa325e55f1f3fb89c: if v.Args[1] != x { goto end7bcf9cfeb69a0d7647389124eb53ce2a } - v.Op = OpAMD64MOVLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVLconst) v.AuxInt = 0 return true } @@ -15606,10 +13722,7 @@ func rewriteValueAMD64_OpAMD64XORLconst(v *Value, config *Config) bool { if !(int32(c) == 0) { goto end99808ca9fb8e3220e42f5678e1042a08 } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -15626,10 +13739,7 @@ end99808ca9fb8e3220e42f5678e1042a08: goto end71238075b10b68a226903cc453c4715c } d := v.Args[0].AuxInt - v.Op = OpAMD64MOVLconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVLconst) v.AuxInt = c ^ d return true } @@ -15653,10 +13763,7 @@ func rewriteValueAMD64_OpAMD64XORQ(v *Value, config *Config) bool { if !(is32Bit(c)) { goto end452341f950062e0483f16438fb9ec500 } - v.Op = OpAMD64XORQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64XORQconst) v.AuxInt = c v.AddArg(x) return true @@ -15676,10 +13783,7 @@ end452341f950062e0483f16438fb9ec500: if !(is32Bit(c)) { goto endd221a7e3daaaaa29ee385ad36e061b57 } - v.Op = OpAMD64XORQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64XORQconst) v.AuxInt = c v.AddArg(x) return true @@ -15695,10 +13799,7 @@ endd221a7e3daaaaa29ee385ad36e061b57: if v.Args[1] != x { goto end10575a5d711cf14e6d4dffbb0e8dfaeb } - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVQconst) v.AuxInt = 0 return true } @@ -15718,10 +13819,7 @@ func rewriteValueAMD64_OpAMD64XORQconst(v *Value, config *Config) bool { goto end0ee8d195a97eff476cf1f69a4dc0ec75 } x := v.Args[0] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -15738,10 +13836,7 @@ end0ee8d195a97eff476cf1f69a4dc0ec75: goto end3f404d4f07362319fbad2e1ba0827a9f } d := v.Args[0].AuxInt - v.Op = OpAMD64MOVQconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVQconst) v.AuxInt = c ^ d return true } @@ -15762,10 +13857,7 @@ func rewriteValueAMD64_OpAMD64XORW(v *Value, config *Config) bool { goto end2ca109efd66c221a5691a4da95ec6c67 } c := v.Args[1].AuxInt - v.Op = OpAMD64XORWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64XORWconst) v.AuxInt = c v.AddArg(x) return true @@ -15782,10 +13874,7 @@ end2ca109efd66c221a5691a4da95ec6c67: } c := v.Args[0].AuxInt x := v.Args[1] - v.Op = OpAMD64XORWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64XORWconst) v.AuxInt = c v.AddArg(x) return true @@ -15801,10 +13890,7 @@ end51ee62a06d4301e5a4aed7a6639b1d53: if v.Args[1] != x { goto end07f332e857be0c2707797ed480a2faf4 } - v.Op = OpAMD64MOVWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVWconst) v.AuxInt = 0 return true } @@ -15825,10 +13911,7 @@ func rewriteValueAMD64_OpAMD64XORWconst(v *Value, config *Config) bool { if !(int16(c) == 0) { goto enda371132353dee83828836da851240f0a } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -15845,10 +13928,7 @@ enda371132353dee83828836da851240f0a: goto ende24881ccdfa8486c4593fd9aa5df1ed6 } d := v.Args[0].AuxInt - v.Op = OpAMD64MOVWconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVWconst) v.AuxInt = c ^ d return true } @@ -15866,10 +13946,7 @@ func rewriteValueAMD64_OpXor16(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64XORW - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64XORW) v.AddArg(x) v.AddArg(y) return true @@ -15888,10 +13965,7 @@ func rewriteValueAMD64_OpXor32(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64XORL - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64XORL) v.AddArg(x) v.AddArg(y) return true @@ -15910,10 +13984,7 @@ func rewriteValueAMD64_OpXor64(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64XORQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64XORQ) v.AddArg(x) v.AddArg(y) return true @@ -15932,10 +14003,7 @@ func rewriteValueAMD64_OpXor8(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpAMD64XORB - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64XORB) v.AddArg(x) v.AddArg(y) return true @@ -15956,10 +14024,7 @@ func rewriteValueAMD64_OpZero(v *Value, config *Config) bool { goto endc9a38a60f0322f93682daa824611272c } mem := v.Args[1] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = mem.Type v.AddArg(mem) return true @@ -15976,10 +14041,7 @@ endc9a38a60f0322f93682daa824611272c: } destptr := v.Args[0] mem := v.Args[1] - v.Op = OpAMD64MOVBstoreconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBstoreconst) v.AuxInt = 0 v.AddArg(destptr) v.AddArg(mem) @@ -15997,10 +14059,7 @@ ende0161981658beee468c9e2368fe31eb8: } destptr := v.Args[0] mem := v.Args[1] - v.Op = OpAMD64MOVWstoreconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVWstoreconst) v.AuxInt = 0 v.AddArg(destptr) v.AddArg(mem) @@ -16018,10 +14077,7 @@ end4e4aaf641bf2818bb71f1397e4685bdd: } destptr := v.Args[0] mem := v.Args[1] - v.Op = OpAMD64MOVLstoreconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVLstoreconst) v.AuxInt = 0 v.AddArg(destptr) v.AddArg(mem) @@ -16039,10 +14095,7 @@ end7612f59dd66ebfc632ea5bc85f5437b5: } destptr := v.Args[0] mem := v.Args[1] - v.Op = OpAMD64MOVQstoreconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVQstoreconst) v.AuxInt = 0 v.AddArg(destptr) v.AddArg(mem) @@ -16060,10 +14113,7 @@ end07aaaebfa15a48c52cd79b68e28d266f: } destptr := v.Args[0] mem := v.Args[1] - v.Op = OpAMD64MOVBstoreconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBstoreconst) v.AuxInt = makeValAndOff(0, 2) v.AddArg(destptr) v0 := b.NewValue0(v.Line, OpAMD64MOVWstoreconst, TypeMem) @@ -16085,10 +14135,7 @@ end3bf4a24a87e0727b9bcfbb5fcd24aabe: } destptr := v.Args[0] mem := v.Args[1] - v.Op = OpAMD64MOVBstoreconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBstoreconst) v.AuxInt = makeValAndOff(0, 4) v.AddArg(destptr) v0 := b.NewValue0(v.Line, OpAMD64MOVLstoreconst, TypeMem) @@ -16110,10 +14157,7 @@ end567e4a90c6867faf1dfc2cd57daf2ce4: } destptr := v.Args[0] mem := v.Args[1] - v.Op = OpAMD64MOVWstoreconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVWstoreconst) v.AuxInt = makeValAndOff(0, 4) v.AddArg(destptr) v0 := b.NewValue0(v.Line, OpAMD64MOVLstoreconst, TypeMem) @@ -16135,10 +14179,7 @@ end7cddcaf215fcc2cbca9aa958147b2380: } destptr := v.Args[0] mem := v.Args[1] - v.Op = OpAMD64MOVLstoreconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVLstoreconst) v.AuxInt = makeValAndOff(0, 3) v.AddArg(destptr) v0 := b.NewValue0(v.Line, OpAMD64MOVLstoreconst, TypeMem) @@ -16161,10 +14202,7 @@ end1b58cabccbc912ea4e1cf99be8a9fbf7: if !(size%8 != 0 && size > 8) { goto endc8760f86b83b1372fce0042ab5200fc1 } - v.Op = OpZero - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpZero) v.AuxInt = size - size%8 v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, config.fe.TypeUInt64()) v0.AddArg(destptr) @@ -16189,10 +14227,7 @@ endc8760f86b83b1372fce0042ab5200fc1: } destptr := v.Args[0] mem := v.Args[1] - v.Op = OpAMD64MOVQstoreconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVQstoreconst) v.AuxInt = makeValAndOff(0, 8) v.AddArg(destptr) v0 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeMem) @@ -16214,10 +14249,7 @@ endf1447d60cbf8025adaf1a02a2cd219c4: } destptr := v.Args[0] mem := v.Args[1] - v.Op = OpAMD64MOVQstoreconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVQstoreconst) v.AuxInt = makeValAndOff(0, 16) v.AddArg(destptr) v0 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeMem) @@ -16243,10 +14275,7 @@ end57f2984a61c64f71a528e7fa75576095: } destptr := v.Args[0] mem := v.Args[1] - v.Op = OpAMD64MOVQstoreconst - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVQstoreconst) v.AuxInt = makeValAndOff(0, 24) v.AddArg(destptr) v0 := b.NewValue0(v.Line, OpAMD64MOVQstoreconst, TypeMem) @@ -16277,10 +14306,7 @@ end418a59f9f84dd389d37ae5c24aba2760: if !(size <= 1024 && size%8 == 0 && size%16 != 0) { goto end240266449c3e493db1c3b38a78682ff0 } - v.Op = OpZero - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpZero) v.AuxInt = size - 8 v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, config.fe.TypeUInt64()) v0.AuxInt = 8 @@ -16308,10 +14334,7 @@ end240266449c3e493db1c3b38a78682ff0: if !(size <= 1024 && size%16 == 0) { goto endf508bb887eee9119069b22c23dbca138 } - v.Op = OpAMD64DUFFZERO - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64DUFFZERO) v.AuxInt = duffStart(size) v0 := b.NewValue0(v.Line, OpAMD64ADDQconst, config.fe.TypeUInt64()) v0.AuxInt = duffAdj(size) @@ -16336,10 +14359,7 @@ endf508bb887eee9119069b22c23dbca138: if !(size > 1024 && size%8 == 0) { goto endb9d55d4ba0e70ed918e3ac757727441b } - v.Op = OpAMD64REPSTOSQ - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64REPSTOSQ) v.AddArg(destptr) v0 := b.NewValue0(v.Line, OpAMD64MOVQconst, config.fe.TypeUInt64()) v0.AuxInt = size / 8 @@ -16363,10 +14383,7 @@ func rewriteValueAMD64_OpZeroExt16to32(v *Value, config *Config) bool { // result: (MOVWQZX x) { x := v.Args[0] - v.Op = OpAMD64MOVWQZX - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVWQZX) v.AddArg(x) return true } @@ -16383,10 +14400,7 @@ func rewriteValueAMD64_OpZeroExt16to64(v *Value, config *Config) bool { // result: (MOVWQZX x) { x := v.Args[0] - v.Op = OpAMD64MOVWQZX - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVWQZX) v.AddArg(x) return true } @@ -16403,10 +14417,7 @@ func rewriteValueAMD64_OpZeroExt32to64(v *Value, config *Config) bool { // result: (MOVLQZX x) { x := v.Args[0] - v.Op = OpAMD64MOVLQZX - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVLQZX) v.AddArg(x) return true } @@ -16423,10 +14434,7 @@ func rewriteValueAMD64_OpZeroExt8to16(v *Value, config *Config) bool { // result: (MOVBQZX x) { x := v.Args[0] - v.Op = OpAMD64MOVBQZX - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBQZX) v.AddArg(x) return true } @@ -16443,10 +14451,7 @@ func rewriteValueAMD64_OpZeroExt8to32(v *Value, config *Config) bool { // result: (MOVBQZX x) { x := v.Args[0] - v.Op = OpAMD64MOVBQZX - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBQZX) v.AddArg(x) return true } @@ -16463,10 +14468,7 @@ func rewriteValueAMD64_OpZeroExt8to64(v *Value, config *Config) bool { // result: (MOVBQZX x) { x := v.Args[0] - v.Op = OpAMD64MOVBQZX - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAMD64MOVBQZX) v.AddArg(x) return true } diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index 67f07e65dc..505ea77457 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -311,10 +311,7 @@ func rewriteValuegeneric_OpAdd16(v *Value, config *Config) bool { goto end359c546ef662b7990116329cb30d6892 } d := v.Args[1].AuxInt - v.Op = OpConst16 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConst16) v.AuxInt = c + d return true } @@ -334,10 +331,7 @@ end359c546ef662b7990116329cb30d6892: if !(x.Op != OpConst16) { goto end89b69a89778f375b0ebbc683b0c63176 } - v.Op = OpAdd16 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAdd16) v0 := b.NewValue0(v.Line, OpConst16, t) v0.AuxInt = c v.AddArg(v0) @@ -364,10 +358,7 @@ func rewriteValuegeneric_OpAdd32(v *Value, config *Config) bool { goto enda3edaa9a512bd1d7a95f002c890bfb88 } d := v.Args[1].AuxInt - v.Op = OpConst32 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConst32) v.AuxInt = c + d return true } @@ -387,10 +378,7 @@ enda3edaa9a512bd1d7a95f002c890bfb88: if !(x.Op != OpConst32) { goto end28a8c474bfa6968950dce0ed73b14a0b } - v.Op = OpAdd32 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAdd32) v0 := b.NewValue0(v.Line, OpConst32, t) v0.AuxInt = c v.AddArg(v0) @@ -417,10 +405,7 @@ func rewriteValuegeneric_OpAdd64(v *Value, config *Config) bool { goto end8c46df6f85a11cb1d594076b0e467908 } d := v.Args[1].AuxInt - v.Op = OpConst64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConst64) v.AuxInt = c + d return true } @@ -440,10 +425,7 @@ end8c46df6f85a11cb1d594076b0e467908: if !(x.Op != OpConst64) { goto end39caa6cf1044f5c47ddbeb062d1a13bd } - v.Op = OpAdd64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAdd64) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = c v.AddArg(v0) @@ -470,10 +452,7 @@ func rewriteValuegeneric_OpAdd8(v *Value, config *Config) bool { goto end60c66721511a442aade8e4da2fb326bd } d := v.Args[1].AuxInt - v.Op = OpConst8 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConst8) v.AuxInt = c + d return true } @@ -493,10 +472,7 @@ end60c66721511a442aade8e4da2fb326bd: if !(x.Op != OpConst8) { goto end8c2901b8d12fa5c37f190783b4db8df5 } - v.Op = OpAdd8 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAdd8) v0 := b.NewValue0(v.Line, OpConst8, t) v0.AuxInt = c v.AddArg(v0) @@ -519,10 +495,7 @@ func rewriteValuegeneric_OpAnd16(v *Value, config *Config) bool { if v.Args[1] != x { goto end69ed6ee2a4fb0491b56c17f3c1926b10 } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -543,10 +516,7 @@ func rewriteValuegeneric_OpAnd32(v *Value, config *Config) bool { if v.Args[1] != x { goto endbbe8c3c5b2ca8f013aa178d856f3a99c } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -567,10 +537,7 @@ func rewriteValuegeneric_OpAnd64(v *Value, config *Config) bool { if v.Args[1] != x { goto endc9736bf24d2e5cd8d662e1bcf3164640 } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -591,10 +558,7 @@ func rewriteValuegeneric_OpAnd8(v *Value, config *Config) bool { if v.Args[1] != x { goto endeaf127389bd0d4b0e0e297830f8f463b } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -616,10 +580,7 @@ func rewriteValuegeneric_OpArg(v *Value, config *Config) bool { if !(v.Type.IsString()) { goto end939d3f946bf61eb85b46b374e7afa9e9 } - v.Op = OpStringMake - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpStringMake) v0 := b.NewValue0(v.Line, OpArg, config.fe.TypeBytePtr()) v0.Aux = n v0.AuxInt = off @@ -642,10 +603,7 @@ end939d3f946bf61eb85b46b374e7afa9e9: if !(v.Type.IsSlice()) { goto endab4b93ad3b1cf55e5bf25d1fd9cd498e } - v.Op = OpSliceMake - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpSliceMake) v0 := b.NewValue0(v.Line, OpArg, config.fe.TypeBytePtr()) v0.Aux = n v0.AuxInt = off @@ -672,10 +630,7 @@ endab4b93ad3b1cf55e5bf25d1fd9cd498e: if !(v.Type.IsInterface()) { goto end851de8e588a39e81b4e2aef06566bf3e } - v.Op = OpIMake - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpIMake) v0 := b.NewValue0(v.Line, OpArg, config.fe.TypeBytePtr()) v0.Aux = n v0.AuxInt = off @@ -698,10 +653,7 @@ end851de8e588a39e81b4e2aef06566bf3e: if !(v.Type.IsComplex() && v.Type.Size() == 16) { goto end0988fc6a62c810b2f4976cb6cf44387f } - v.Op = OpComplexMake - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpComplexMake) v0 := b.NewValue0(v.Line, OpArg, config.fe.TypeFloat64()) v0.Aux = n v0.AuxInt = off @@ -724,10 +676,7 @@ end0988fc6a62c810b2f4976cb6cf44387f: if !(v.Type.IsComplex() && v.Type.Size() == 8) { goto enda348e93e0036873dd7089a2939c22e3e } - v.Op = OpComplexMake - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpComplexMake) v0 := b.NewValue0(v.Line, OpArg, config.fe.TypeFloat32()) v0.Aux = n v0.AuxInt = off @@ -749,10 +698,7 @@ enda348e93e0036873dd7089a2939c22e3e: if !(t.IsStruct() && t.NumFields() == 0 && config.fe.CanSSA(t)) { goto ende233eeefa826638b0e541bcca531d701 } - v.Op = OpStructMake0 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpStructMake0) return true } goto ende233eeefa826638b0e541bcca531d701 @@ -768,10 +714,7 @@ ende233eeefa826638b0e541bcca531d701: if !(t.IsStruct() && t.NumFields() == 1 && config.fe.CanSSA(t)) { goto ende953e77a0617051dd3f7ad4d58c9ab37 } - v.Op = OpStructMake1 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpStructMake1) v0 := b.NewValue0(v.Line, OpArg, t.FieldType(0)) v0.Aux = n v0.AuxInt = off + t.FieldOff(0) @@ -791,10 +734,7 @@ ende953e77a0617051dd3f7ad4d58c9ab37: if !(t.IsStruct() && t.NumFields() == 2 && config.fe.CanSSA(t)) { goto end9a008048978aabad9de0723212e60631 } - v.Op = OpStructMake2 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpStructMake2) v0 := b.NewValue0(v.Line, OpArg, t.FieldType(0)) v0.Aux = n v0.AuxInt = off + t.FieldOff(0) @@ -818,10 +758,7 @@ end9a008048978aabad9de0723212e60631: if !(t.IsStruct() && t.NumFields() == 3 && config.fe.CanSSA(t)) { goto end0196e61dbeebc6402f3aa1e9a182210b } - v.Op = OpStructMake3 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpStructMake3) v0 := b.NewValue0(v.Line, OpArg, t.FieldType(0)) v0.Aux = n v0.AuxInt = off + t.FieldOff(0) @@ -849,10 +786,7 @@ end0196e61dbeebc6402f3aa1e9a182210b: if !(t.IsStruct() && t.NumFields() == 4 && config.fe.CanSSA(t)) { goto end6bc133c93e50cb14c2e6cc9401850738 } - v.Op = OpStructMake4 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpStructMake4) v0 := b.NewValue0(v.Line, OpArg, t.FieldType(0)) v0.Aux = n v0.AuxInt = off + t.FieldOff(0) @@ -892,10 +826,7 @@ func rewriteValuegeneric_OpArrayIndex(v *Value, config *Config) bool { if !(b == v.Args[0].Block) { goto end68b373270d9d605c420497edefaa71df } - v.Op = OpLoad - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpLoad) v0 := b.NewValue0(v.Line, OpPtrIndex, v.Type.PtrTo()) v0.AddArg(ptr) v0.AddArg(idx) @@ -919,10 +850,7 @@ func rewriteValuegeneric_OpCom16(v *Value, config *Config) bool { goto end1ea17710dd4dd7ba4e710e0e4c7b5a56 } x := v.Args[0].Args[0] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -943,10 +871,7 @@ func rewriteValuegeneric_OpCom32(v *Value, config *Config) bool { goto end9a04ed536496e292c27bef4414128cbf } x := v.Args[0].Args[0] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -967,10 +892,7 @@ func rewriteValuegeneric_OpCom64(v *Value, config *Config) bool { goto ended44e29d5968f0f7b86972b7bf417ab3 } x := v.Args[0].Args[0] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -991,10 +913,7 @@ func rewriteValuegeneric_OpCom8(v *Value, config *Config) bool { goto end4d92ff3ba567d9afd38fc9ca113602ad } x := v.Args[0].Args[0] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -1015,10 +934,7 @@ func rewriteValuegeneric_OpComplexImag(v *Value, config *Config) bool { goto endec3009fd8727d03002021997936e091f } imag := v.Args[0].Args[1] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = imag.Type v.AddArg(imag) return true @@ -1039,10 +955,7 @@ func rewriteValuegeneric_OpComplexReal(v *Value, config *Config) bool { goto end8db3e16bd59af1adaa4b734c8adcc71d } real := v.Args[0].Args[0] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = real.Type v.AddArg(real) return true @@ -1059,10 +972,7 @@ func rewriteValuegeneric_OpConstInterface(v *Value, config *Config) bool { // cond: // result: (IMake (ConstNil ) (ConstNil )) { - v.Op = OpIMake - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpIMake) v0 := b.NewValue0(v.Line, OpConstNil, config.fe.TypeBytePtr()) v.AddArg(v0) v1 := b.NewValue0(v.Line, OpConstNil, config.fe.TypeBytePtr()) @@ -1084,10 +994,7 @@ func rewriteValuegeneric_OpConstSlice(v *Value, config *Config) bool { if !(config.PtrSize == 4) { goto end9ba6baf9c7247b1f5ba4099c0c3910ce } - v.Op = OpSliceMake - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpSliceMake) v0 := b.NewValue0(v.Line, OpConstNil, config.fe.TypeBytePtr()) v.AddArg(v0) v1 := b.NewValue0(v.Line, OpConst32, config.fe.TypeInt()) @@ -1108,10 +1015,7 @@ end9ba6baf9c7247b1f5ba4099c0c3910ce: if !(config.PtrSize == 8) { goto endabee2aa6bd3e3261628f677221ad2640 } - v.Op = OpSliceMake - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpSliceMake) v0 := b.NewValue0(v.Line, OpConstNil, config.fe.TypeBytePtr()) v.AddArg(v0) v1 := b.NewValue0(v.Line, OpConst64, config.fe.TypeInt()) @@ -1138,10 +1042,7 @@ func rewriteValuegeneric_OpConstString(v *Value, config *Config) bool { if !(config.PtrSize == 4 && s.(string) == "") { goto end85d5f388ba947643af63cdc68c1155a5 } - v.Op = OpStringMake - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpStringMake) v0 := b.NewValue0(v.Line, OpConstNil, config.fe.TypeBytePtr()) v.AddArg(v0) v1 := b.NewValue0(v.Line, OpConst32, config.fe.TypeInt()) @@ -1160,10 +1061,7 @@ end85d5f388ba947643af63cdc68c1155a5: if !(config.PtrSize == 8 && s.(string) == "") { goto endc807259a5ed2760fbbd3dc7386641343 } - v.Op = OpStringMake - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpStringMake) v0 := b.NewValue0(v.Line, OpConstNil, config.fe.TypeBytePtr()) v.AddArg(v0) v1 := b.NewValue0(v.Line, OpConst64, config.fe.TypeInt()) @@ -1182,10 +1080,7 @@ endc807259a5ed2760fbbd3dc7386641343: if !(config.PtrSize == 4 && s.(string) != "") { goto end107a700a4519d18f418602421444ddb6 } - v.Op = OpStringMake - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + 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()) @@ -1207,10 +1102,7 @@ end107a700a4519d18f418602421444ddb6: if !(config.PtrSize == 8 && s.(string) != "") { goto end7ce9db29d17866f26d21e6e12f442e54 } - v.Op = OpStringMake - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + 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()) @@ -1245,10 +1137,7 @@ func rewriteValuegeneric_OpConvert(v *Value, config *Config) bool { if v.Args[1] != mem { goto endbbc9f1666b4d39a130e1b86f109e7c1b } - v.Op = OpAdd64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAdd64) v.AddArg(ptr) v.AddArg(off) return true @@ -1268,10 +1157,7 @@ endbbc9f1666b4d39a130e1b86f109e7c1b: if v.Args[1] != mem { goto end98c5e0ca257eb216989171786f91b42d } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = ptr.Type v.AddArg(ptr) return true @@ -1292,10 +1178,7 @@ func rewriteValuegeneric_OpEq16(v *Value, config *Config) bool { if v.Args[1] != x { goto end0c0fe5fdfba3821add3448fd3f1fc6b7 } - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = 1 return true } @@ -1322,10 +1205,7 @@ end0c0fe5fdfba3821add3448fd3f1fc6b7: } d := v.Args[1].Args[0].AuxInt x := v.Args[1].Args[1] - v.Op = OpEq16 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpEq16) v0 := b.NewValue0(v.Line, OpConst16, t) v0.AuxInt = c - d v.AddArg(v0) @@ -1348,10 +1228,7 @@ end79c830afa265161fc0f0532c4c4e7f50: if !(x.Op != OpConst16) { goto end5d89fe1eeb145f14e11578f41282c904 } - v.Op = OpEq16 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpEq16) v0 := b.NewValue0(v.Line, OpConst16, t) v0.AuxInt = c v.AddArg(v0) @@ -1373,10 +1250,7 @@ end5d89fe1eeb145f14e11578f41282c904: goto end4532e1d01c10d8906fe1da14f9dfaa88 } d := v.Args[1].AuxInt - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = b2i(int16(c) == int16(d)) return true } @@ -1396,10 +1270,7 @@ func rewriteValuegeneric_OpEq32(v *Value, config *Config) bool { if v.Args[1] != x { goto end6da547ec4ee93d787434f3bda873e4a0 } - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = 1 return true } @@ -1426,10 +1297,7 @@ end6da547ec4ee93d787434f3bda873e4a0: } d := v.Args[1].Args[0].AuxInt x := v.Args[1].Args[1] - v.Op = OpEq32 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpEq32) v0 := b.NewValue0(v.Line, OpConst32, t) v0.AuxInt = c - d v.AddArg(v0) @@ -1452,10 +1320,7 @@ end1a69730a32c6e432784dcdf643320ecd: if !(x.Op != OpConst32) { goto end0ca4ef4cf416ec3083d38667e263cf45 } - v.Op = OpEq32 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpEq32) v0 := b.NewValue0(v.Line, OpConst32, t) v0.AuxInt = c v.AddArg(v0) @@ -1477,10 +1342,7 @@ end0ca4ef4cf416ec3083d38667e263cf45: goto end00a2464e02c9ca00e8d0077acacbb5ad } d := v.Args[1].AuxInt - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = b2i(int32(c) == int32(d)) return true } @@ -1500,10 +1362,7 @@ func rewriteValuegeneric_OpEq64(v *Value, config *Config) bool { if v.Args[1] != x { goto endb1d471cc503ba8bb05440f01dbf33d81 } - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = 1 return true } @@ -1530,10 +1389,7 @@ endb1d471cc503ba8bb05440f01dbf33d81: } d := v.Args[1].Args[0].AuxInt x := v.Args[1].Args[1] - v.Op = OpEq64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpEq64) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = c - d v.AddArg(v0) @@ -1556,10 +1412,7 @@ endffd67f3b83f6972cd459153d318f714d: if !(x.Op != OpConst64) { goto endc2ecf8254dc736e97c5815362d0b477d } - v.Op = OpEq64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpEq64) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = c v.AddArg(v0) @@ -1581,10 +1434,7 @@ endc2ecf8254dc736e97c5815362d0b477d: goto end405568a707dbbc86432e91f4ce7d97d7 } d := v.Args[1].AuxInt - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = b2i(int64(c) == int64(d)) return true } @@ -1604,10 +1454,7 @@ func rewriteValuegeneric_OpEq8(v *Value, config *Config) bool { if v.Args[1] != x { goto enda66da0d3e7e51624ee46527727c48a9a } - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = 1 return true } @@ -1634,10 +1481,7 @@ enda66da0d3e7e51624ee46527727c48a9a: } d := v.Args[1].Args[0].AuxInt x := v.Args[1].Args[1] - v.Op = OpEq8 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpEq8) v0 := b.NewValue0(v.Line, OpConst8, t) v0.AuxInt = c - d v.AddArg(v0) @@ -1660,10 +1504,7 @@ end6912961350bb485f56ef176522aa683b: if !(x.Op != OpConst8) { goto end70d0b569427b24e7a912a1aa8fab3b20 } - v.Op = OpEq8 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpEq8) v0 := b.NewValue0(v.Line, OpConst8, t) v0.AuxInt = c v.AddArg(v0) @@ -1685,10 +1526,7 @@ end70d0b569427b24e7a912a1aa8fab3b20: goto endd49f3700ba2d1e500d3ab4fa34fd090d } d := v.Args[1].AuxInt - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = b2i(int8(c) == int8(d)) return true } @@ -1706,10 +1544,7 @@ func rewriteValuegeneric_OpEqInter(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpEqPtr - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpEqPtr) v0 := b.NewValue0(v.Line, OpITab, config.fe.TypeBytePtr()) v0.AddArg(x) v.AddArg(v0) @@ -1734,10 +1569,7 @@ func rewriteValuegeneric_OpEqPtr(v *Value, config *Config) bool { if v.Args[1].Op != OpConstNil { goto ende701cdb6a2c1fff4d4b283b7f8f6178b } - v.Op = OpNot - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpNot) v0 := b.NewValue0(v.Line, OpIsNonNil, config.fe.TypeBool()) v0.AddArg(p) v.AddArg(v0) @@ -1754,10 +1586,7 @@ ende701cdb6a2c1fff4d4b283b7f8f6178b: goto end7cdc0d5c38fbffe6287c8928803b038e } p := v.Args[1] - v.Op = OpNot - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpNot) v0 := b.NewValue0(v.Line, OpIsNonNil, config.fe.TypeBool()) v0.AddArg(p) v.AddArg(v0) @@ -1777,10 +1606,7 @@ func rewriteValuegeneric_OpEqSlice(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpEqPtr - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpEqPtr) v0 := b.NewValue0(v.Line, OpSlicePtr, config.fe.TypeBytePtr()) v0.AddArg(x) v.AddArg(v0) @@ -1809,10 +1635,7 @@ func rewriteValuegeneric_OpGeq16(v *Value, config *Config) bool { goto endbac100e9f1065e7d2ff863951f686f4b } d := v.Args[1].AuxInt - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = b2i(int16(c) >= int16(d)) return true } @@ -1836,10 +1659,7 @@ func rewriteValuegeneric_OpGeq16U(v *Value, config *Config) bool { goto end11c6acbc5827fc9508424b0ffcf98b34 } d := v.Args[1].AuxInt - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = b2i(uint16(c) >= uint16(d)) return true } @@ -1863,10 +1683,7 @@ func rewriteValuegeneric_OpGeq32(v *Value, config *Config) bool { goto end89ced97524ac75045911ca7cf6d44b28 } d := v.Args[1].AuxInt - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = b2i(int32(c) >= int32(d)) return true } @@ -1890,10 +1707,7 @@ func rewriteValuegeneric_OpGeq32U(v *Value, config *Config) bool { goto end92fbe85c7bbbf0db287932822bdde991 } d := v.Args[1].AuxInt - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = b2i(uint32(c) >= uint32(d)) return true } @@ -1917,10 +1731,7 @@ func rewriteValuegeneric_OpGeq64(v *Value, config *Config) bool { goto end08a5a4bff12a346befe05ad561b080ac } d := v.Args[1].AuxInt - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = b2i(int64(c) >= int64(d)) return true } @@ -1944,10 +1755,7 @@ func rewriteValuegeneric_OpGeq64U(v *Value, config *Config) bool { goto endd72c497b6cc2b01d43a39ec12d5010b3 } d := v.Args[1].AuxInt - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = b2i(uint64(c) >= uint64(d)) return true } @@ -1971,10 +1779,7 @@ func rewriteValuegeneric_OpGeq8(v *Value, config *Config) bool { goto endea141068e84038c63cbdd87a8cb227d7 } d := v.Args[1].AuxInt - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = b2i(int8(c) >= int8(d)) return true } @@ -1998,10 +1803,7 @@ func rewriteValuegeneric_OpGeq8U(v *Value, config *Config) bool { goto end47c128ccdc54151a243c5856b0c52ef1 } d := v.Args[1].AuxInt - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = b2i(uint8(c) >= uint8(d)) return true } @@ -2025,10 +1827,7 @@ func rewriteValuegeneric_OpGreater16(v *Value, config *Config) bool { goto end390bae49463ace4d703dd24e18920f66 } d := v.Args[1].AuxInt - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = b2i(int16(c) > int16(d)) return true } @@ -2052,10 +1851,7 @@ func rewriteValuegeneric_OpGreater16U(v *Value, config *Config) bool { goto end89ba3caf5c156fa6d908ac04c058187b } d := v.Args[1].AuxInt - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = b2i(uint16(c) > uint16(d)) return true } @@ -2079,10 +1875,7 @@ func rewriteValuegeneric_OpGreater32(v *Value, config *Config) bool { goto end86482a9dc6439e8470da5352dd74d68d } d := v.Args[1].AuxInt - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = b2i(int32(c) > int32(d)) return true } @@ -2106,10 +1899,7 @@ func rewriteValuegeneric_OpGreater32U(v *Value, config *Config) bool { goto end1bf3f05c1e3599a969b8be1f5f6949e4 } d := v.Args[1].AuxInt - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = b2i(uint32(c) > uint32(d)) return true } @@ -2133,10 +1923,7 @@ func rewriteValuegeneric_OpGreater64(v *Value, config *Config) bool { goto end96a82e893fda4882f23b6bab5f7fbff7 } d := v.Args[1].AuxInt - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = b2i(int64(c) > int64(d)) return true } @@ -2160,10 +1947,7 @@ func rewriteValuegeneric_OpGreater64U(v *Value, config *Config) bool { goto end2d8f5ad85fbffeb92af985a888f6fa69 } d := v.Args[1].AuxInt - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = b2i(uint64(c) > uint64(d)) return true } @@ -2187,10 +1971,7 @@ func rewriteValuegeneric_OpGreater8(v *Value, config *Config) bool { goto ende221967c7516b7749109cf8343fe9c83 } d := v.Args[1].AuxInt - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = b2i(int8(c) > int8(d)) return true } @@ -2214,10 +1995,7 @@ func rewriteValuegeneric_OpGreater8U(v *Value, config *Config) bool { goto enda9398c8188156dd46689fa2939147525 } d := v.Args[1].AuxInt - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = b2i(uint8(c) > uint8(d)) return true } @@ -2237,10 +2015,7 @@ func rewriteValuegeneric_OpIData(v *Value, config *Config) bool { goto endbfa1bb944cdc07933effb16a35152e12 } data := v.Args[0].Args[1] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = data.Type v.AddArg(data) return true @@ -2261,10 +2036,7 @@ func rewriteValuegeneric_OpITab(v *Value, config *Config) bool { goto endfcbb9414a776ff9c8512da3e0f4d8fbd } itab := v.Args[0].Args[0] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = itab.Type v.AddArg(itab) return true @@ -2289,10 +2061,7 @@ func rewriteValuegeneric_OpIsInBounds(v *Value, config *Config) bool { goto endf0a2ecfe84b293de6ff0919e45d19d9d } d := v.Args[1].AuxInt - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = b2i(inBounds32(c, d)) return true } @@ -2311,10 +2080,7 @@ endf0a2ecfe84b293de6ff0919e45d19d9d: goto end4b406f402c135f50f71effcc904ecb2b } d := v.Args[1].AuxInt - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = b2i(inBounds64(c, d)) return true } @@ -2338,10 +2104,7 @@ func rewriteValuegeneric_OpIsSliceInBounds(v *Value, config *Config) bool { goto end5e84a230c28cac987437cfed8f432cc3 } d := v.Args[1].AuxInt - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = b2i(sliceInBounds32(c, d)) return true } @@ -2360,10 +2123,7 @@ end5e84a230c28cac987437cfed8f432cc3: goto end3880a6fe20ad4152e98f76d84da233a7 } d := v.Args[1].AuxInt - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = b2i(sliceInBounds64(c, d)) return true } @@ -2387,10 +2147,7 @@ func rewriteValuegeneric_OpLeq16(v *Value, config *Config) bool { goto end76b1c51f9b7cd7ee2f75b9f7057569de } d := v.Args[1].AuxInt - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = b2i(int16(c) <= int16(d)) return true } @@ -2414,10 +2171,7 @@ func rewriteValuegeneric_OpLeq16U(v *Value, config *Config) bool { goto endf010fdf7f2c438ec18c33f493dd062aa } d := v.Args[1].AuxInt - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = b2i(uint16(c) <= uint16(d)) return true } @@ -2441,10 +2195,7 @@ func rewriteValuegeneric_OpLeq32(v *Value, config *Config) bool { goto end6c7d61cfd188680bea8a5e23f08ca1de } d := v.Args[1].AuxInt - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = b2i(int32(c) <= int32(d)) return true } @@ -2468,10 +2219,7 @@ func rewriteValuegeneric_OpLeq32U(v *Value, config *Config) bool { goto end4363555333511ee9b649b36f1a0ba34e } d := v.Args[1].AuxInt - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = b2i(uint32(c) <= uint32(d)) return true } @@ -2495,10 +2243,7 @@ func rewriteValuegeneric_OpLeq64(v *Value, config *Config) bool { goto enddc865cd7ac2093abc7617bedbf371c22 } d := v.Args[1].AuxInt - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = b2i(int64(c) <= int64(d)) return true } @@ -2522,10 +2267,7 @@ func rewriteValuegeneric_OpLeq64U(v *Value, config *Config) bool { goto end412eadb168738ba92f3f0705d4495305 } d := v.Args[1].AuxInt - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = b2i(uint64(c) <= uint64(d)) return true } @@ -2549,10 +2291,7 @@ func rewriteValuegeneric_OpLeq8(v *Value, config *Config) bool { goto endb5a459da8e18c40abc0c7a20e71d0187 } d := v.Args[1].AuxInt - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = b2i(int8(c) <= int8(d)) return true } @@ -2576,10 +2315,7 @@ func rewriteValuegeneric_OpLeq8U(v *Value, config *Config) bool { goto endd6622d55fcdf3fa7b08e7511cd3b7d85 } d := v.Args[1].AuxInt - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = b2i(uint8(c) <= uint8(d)) return true } @@ -2603,10 +2339,7 @@ func rewriteValuegeneric_OpLess16(v *Value, config *Config) bool { goto end0dc915d089f05e79589ebb5c498cc360 } d := v.Args[1].AuxInt - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = b2i(int16(c) < int16(d)) return true } @@ -2630,10 +2363,7 @@ func rewriteValuegeneric_OpLess16U(v *Value, config *Config) bool { goto endd2bb8249443788690946fc184631a00a } d := v.Args[1].AuxInt - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = b2i(uint16(c) < uint16(d)) return true } @@ -2657,10 +2387,7 @@ func rewriteValuegeneric_OpLess32(v *Value, config *Config) bool { goto endc86f65e499688809d414f03539bec5bf } d := v.Args[1].AuxInt - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = b2i(int32(c) < int32(d)) return true } @@ -2684,10 +2411,7 @@ func rewriteValuegeneric_OpLess32U(v *Value, config *Config) bool { goto end2cc68b5247b1afb90a9d3923b28ff247 } d := v.Args[1].AuxInt - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = b2i(uint32(c) < uint32(d)) return true } @@ -2711,10 +2435,7 @@ func rewriteValuegeneric_OpLess64(v *Value, config *Config) bool { goto end505de73cd15125dbb59b05d8975d3128 } d := v.Args[1].AuxInt - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = b2i(int64(c) < int64(d)) return true } @@ -2738,10 +2459,7 @@ func rewriteValuegeneric_OpLess64U(v *Value, config *Config) bool { goto endeb249ef36416cd1abf4f807026c059cd } d := v.Args[1].AuxInt - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = b2i(uint64(c) < uint64(d)) return true } @@ -2765,10 +2483,7 @@ func rewriteValuegeneric_OpLess8(v *Value, config *Config) bool { goto endef134de03bc8537ac1f38d5eccff7673 } d := v.Args[1].AuxInt - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = b2i(int8(c) < int8(d)) return true } @@ -2792,10 +2507,7 @@ func rewriteValuegeneric_OpLess8U(v *Value, config *Config) bool { goto end263ecdc279924bff8771dd1ac3f42222 } d := v.Args[1].AuxInt - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = b2i(uint8(c) < uint8(d)) return true } @@ -2815,10 +2527,7 @@ func rewriteValuegeneric_OpLoad(v *Value, config *Config) bool { if !(t.IsStruct() && t.NumFields() == 0 && config.fe.CanSSA(t)) { goto end8d25f5c949948132921b6be29ede6bde } - v.Op = OpStructMake0 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpStructMake0) return true } goto end8d25f5c949948132921b6be29ede6bde @@ -2834,10 +2543,7 @@ end8d25f5c949948132921b6be29ede6bde: if !(t.IsStruct() && t.NumFields() == 1 && config.fe.CanSSA(t)) { goto endfe908e5a8617dd39df2f9b2b92e93ae5 } - v.Op = OpStructMake1 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpStructMake1) v0 := b.NewValue0(v.Line, OpLoad, t.FieldType(0)) v0.AddArg(ptr) v0.AddArg(mem) @@ -2857,10 +2563,7 @@ endfe908e5a8617dd39df2f9b2b92e93ae5: if !(t.IsStruct() && t.NumFields() == 2 && config.fe.CanSSA(t)) { goto end20e20e64004b765012cfb80c575ef27b } - v.Op = OpStructMake2 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpStructMake2) v0 := b.NewValue0(v.Line, OpLoad, t.FieldType(0)) v0.AddArg(ptr) v0.AddArg(mem) @@ -2887,10 +2590,7 @@ end20e20e64004b765012cfb80c575ef27b: if !(t.IsStruct() && t.NumFields() == 3 && config.fe.CanSSA(t)) { goto ende612bf71067ed67541735cdc8b5a3288 } - v.Op = OpStructMake3 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpStructMake3) v0 := b.NewValue0(v.Line, OpLoad, t.FieldType(0)) v0.AddArg(ptr) v0.AddArg(mem) @@ -2924,10 +2624,7 @@ ende612bf71067ed67541735cdc8b5a3288: if !(t.IsStruct() && t.NumFields() == 4 && config.fe.CanSSA(t)) { goto end46c66c64d9030f2cc9a7a767f67953d1 } - v.Op = OpStructMake4 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpStructMake4) v0 := b.NewValue0(v.Line, OpLoad, t.FieldType(0)) v0.AddArg(ptr) v0.AddArg(mem) @@ -2968,10 +2665,7 @@ end46c66c64d9030f2cc9a7a767f67953d1: if !(t.IsComplex() && t.Size() == 8) { goto end665854b31b828893d90b36bb462ff381 } - v.Op = OpComplexMake - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpComplexMake) v0 := b.NewValue0(v.Line, OpLoad, config.fe.TypeFloat32()) v0.AddArg(ptr) v0.AddArg(mem) @@ -2998,10 +2692,7 @@ end665854b31b828893d90b36bb462ff381: if !(t.IsComplex() && t.Size() == 16) { goto end1b106f89e0e3e26c613b957a7c98d8ad } - v.Op = OpComplexMake - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpComplexMake) v0 := b.NewValue0(v.Line, OpLoad, config.fe.TypeFloat64()) v0.AddArg(ptr) v0.AddArg(mem) @@ -3028,10 +2719,7 @@ end1b106f89e0e3e26c613b957a7c98d8ad: if !(t.IsString()) { goto enddd15a6f3d53a6ce7a19d4e181dd1c13a } - v.Op = OpStringMake - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpStringMake) v0 := b.NewValue0(v.Line, OpLoad, config.fe.TypeBytePtr()) v0.AddArg(ptr) v0.AddArg(mem) @@ -3058,10 +2746,7 @@ enddd15a6f3d53a6ce7a19d4e181dd1c13a: if !(t.IsSlice()) { goto end65e8b0055aa7491b9b6066d9fe1b2c13 } - v.Op = OpSliceMake - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpSliceMake) v0 := b.NewValue0(v.Line, OpLoad, config.fe.TypeBytePtr()) v0.AddArg(ptr) v0.AddArg(mem) @@ -3095,10 +2780,7 @@ end65e8b0055aa7491b9b6066d9fe1b2c13: if !(t.IsInterface()) { goto end12671c83ebe3ccbc8e53383765ee7675 } - v.Op = OpIMake - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpIMake) v0 := b.NewValue0(v.Line, OpLoad, config.fe.TypeBytePtr()) v0.AddArg(ptr) v0.AddArg(mem) @@ -3130,10 +2812,7 @@ func rewriteValuegeneric_OpLsh16x16(v *Value, config *Config) bool { goto end2f5aa78b30ebd2471e8d03a307923b06 } c := v.Args[1].AuxInt - v.Op = OpLsh16x64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpLsh16x64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = int64(uint16(c)) @@ -3158,10 +2837,7 @@ func rewriteValuegeneric_OpLsh16x32(v *Value, config *Config) bool { goto endedeb000c8c97090261a47f08a2ff17e4 } c := v.Args[1].AuxInt - v.Op = OpLsh16x64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpLsh16x64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = int64(uint32(c)) @@ -3188,10 +2864,7 @@ func rewriteValuegeneric_OpLsh16x64(v *Value, config *Config) bool { goto endc9f0d91f3da4bdd46a634a62549810e0 } d := v.Args[1].AuxInt - v.Op = OpConst16 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConst16) v.AuxInt = int64(int16(c) << uint64(d)) return true } @@ -3209,10 +2882,7 @@ endc9f0d91f3da4bdd46a634a62549810e0: if v.Args[1].AuxInt != 0 { goto end7ecc343739fab9b50a0bdff6e9d121e6 } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -3231,10 +2901,7 @@ end7ecc343739fab9b50a0bdff6e9d121e6: if !(uint64(c) >= 16) { goto end1d2c74d359df9d89b16c4f658a231dfe } - v.Op = OpConst64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConst64) v.AuxInt = 0 return true } @@ -3261,10 +2928,7 @@ end1d2c74d359df9d89b16c4f658a231dfe: if !(!uaddOvf(c, d)) { goto end26a91e42735a02a30e94a998f54372dd } - v.Op = OpLsh16x64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpLsh16x64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = c + d @@ -3289,10 +2953,7 @@ func rewriteValuegeneric_OpLsh16x8(v *Value, config *Config) bool { goto endce2401b8a6c6190fe81d77e2d562a10c } c := v.Args[1].AuxInt - v.Op = OpLsh16x64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpLsh16x64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = int64(uint8(c)) @@ -3317,10 +2978,7 @@ func rewriteValuegeneric_OpLsh32x16(v *Value, config *Config) bool { goto end7205eb3e315971143ac5584d07045570 } c := v.Args[1].AuxInt - v.Op = OpLsh32x64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpLsh32x64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = int64(uint16(c)) @@ -3345,10 +3003,7 @@ func rewriteValuegeneric_OpLsh32x32(v *Value, config *Config) bool { goto endc1a330b287199c80228e665a53881298 } c := v.Args[1].AuxInt - v.Op = OpLsh32x64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpLsh32x64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = int64(uint32(c)) @@ -3375,10 +3030,7 @@ func rewriteValuegeneric_OpLsh32x64(v *Value, config *Config) bool { goto end5896bd9a3fe78f1e1712563642d33254 } d := v.Args[1].AuxInt - v.Op = OpConst32 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConst32) v.AuxInt = int64(int32(c) << uint64(d)) return true } @@ -3396,10 +3048,7 @@ end5896bd9a3fe78f1e1712563642d33254: if v.Args[1].AuxInt != 0 { goto endd9ce9639a91b11e601823be3d4d6c209 } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -3418,10 +3067,7 @@ endd9ce9639a91b11e601823be3d4d6c209: if !(uint64(c) >= 32) { goto end81247a2423f489be15859d3930738fdf } - v.Op = OpConst64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConst64) v.AuxInt = 0 return true } @@ -3448,10 +3094,7 @@ end81247a2423f489be15859d3930738fdf: if !(!uaddOvf(c, d)) { goto endf96a7c9571797fe61a5b63a4923d7e6e } - v.Op = OpLsh32x64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpLsh32x64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = c + d @@ -3476,10 +3119,7 @@ func rewriteValuegeneric_OpLsh32x8(v *Value, config *Config) bool { goto end1759d7c25a5bcda288e34d1d197c0b8f } c := v.Args[1].AuxInt - v.Op = OpLsh32x64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpLsh32x64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = int64(uint8(c)) @@ -3504,10 +3144,7 @@ func rewriteValuegeneric_OpLsh64x16(v *Value, config *Config) bool { goto enda649fbb5e14490c9eea9616550a76b5c } c := v.Args[1].AuxInt - v.Op = OpLsh64x64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpLsh64x64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = int64(uint16(c)) @@ -3532,10 +3169,7 @@ func rewriteValuegeneric_OpLsh64x32(v *Value, config *Config) bool { goto end40069675cde851a63cce81b1b02751f9 } c := v.Args[1].AuxInt - v.Op = OpLsh64x64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpLsh64x64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = int64(uint32(c)) @@ -3562,10 +3196,7 @@ func rewriteValuegeneric_OpLsh64x64(v *Value, config *Config) bool { goto end9c157a23e021f659f1568566435ed57b } d := v.Args[1].AuxInt - v.Op = OpConst64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConst64) v.AuxInt = c << uint64(d) return true } @@ -3583,10 +3214,7 @@ end9c157a23e021f659f1568566435ed57b: if v.Args[1].AuxInt != 0 { goto end9f18ca0556dbb4b50fe888273fab20ca } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -3605,10 +3233,7 @@ end9f18ca0556dbb4b50fe888273fab20ca: if !(uint64(c) >= 64) { goto end33da2e0ce5ca3e0554564477ef422402 } - v.Op = OpConst64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConst64) v.AuxInt = 0 return true } @@ -3635,10 +3260,7 @@ end33da2e0ce5ca3e0554564477ef422402: if !(!uaddOvf(c, d)) { goto end001c62ee580a700ec7b07ccaa3740ac2 } - v.Op = OpLsh64x64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpLsh64x64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = c + d @@ -3663,10 +3285,7 @@ func rewriteValuegeneric_OpLsh64x8(v *Value, config *Config) bool { goto end4d9224069abdade8e405df343938d932 } c := v.Args[1].AuxInt - v.Op = OpLsh64x64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpLsh64x64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = int64(uint8(c)) @@ -3691,10 +3310,7 @@ func rewriteValuegeneric_OpLsh8x16(v *Value, config *Config) bool { goto end0ad4a82e2eb4c7ca7407d79ec3aa5142 } c := v.Args[1].AuxInt - v.Op = OpLsh8x64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpLsh8x64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = int64(uint16(c)) @@ -3719,10 +3335,7 @@ func rewriteValuegeneric_OpLsh8x32(v *Value, config *Config) bool { goto enddaacda113ecc79fe0621fd22ebc548dd } c := v.Args[1].AuxInt - v.Op = OpLsh8x64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpLsh8x64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = int64(uint32(c)) @@ -3749,10 +3362,7 @@ func rewriteValuegeneric_OpLsh8x64(v *Value, config *Config) bool { goto endbc3297ea9642b97eb71f0a9735048d7b } d := v.Args[1].AuxInt - v.Op = OpConst8 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConst8) v.AuxInt = int64(int8(c) << uint64(d)) return true } @@ -3770,10 +3380,7 @@ endbc3297ea9642b97eb71f0a9735048d7b: if v.Args[1].AuxInt != 0 { goto end715f3db41cccf963e25a20c33f618a04 } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -3792,10 +3399,7 @@ end715f3db41cccf963e25a20c33f618a04: if !(uint64(c) >= 8) { goto endb6749df4d0cdc0cd9acc627187d73488 } - v.Op = OpConst64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConst64) v.AuxInt = 0 return true } @@ -3822,10 +3426,7 @@ endb6749df4d0cdc0cd9acc627187d73488: if !(!uaddOvf(c, d)) { goto end73a4878b6bbd21c9e22fb99226ef947e } - v.Op = OpLsh8x64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpLsh8x64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = c + d @@ -3850,10 +3451,7 @@ func rewriteValuegeneric_OpLsh8x8(v *Value, config *Config) bool { goto end8b770597435467b0c96014624d522b33 } c := v.Args[1].AuxInt - v.Op = OpLsh8x64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpLsh8x64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = int64(uint8(c)) @@ -3880,10 +3478,7 @@ func rewriteValuegeneric_OpMul16(v *Value, config *Config) bool { goto ende8dd468add3015aea24531cf3c89ccb7 } d := v.Args[1].AuxInt - v.Op = OpConst16 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConst16) v.AuxInt = c * d return true } @@ -3907,10 +3502,7 @@ func rewriteValuegeneric_OpMul32(v *Value, config *Config) bool { goto end60b4523099fa7b55e2e872e05bd497a7 } d := v.Args[1].AuxInt - v.Op = OpConst32 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConst32) v.AuxInt = c * d return true } @@ -3934,10 +3526,7 @@ func rewriteValuegeneric_OpMul64(v *Value, config *Config) bool { goto end7aea1048b5d1230974b97f17238380ae } d := v.Args[1].AuxInt - v.Op = OpConst64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConst64) v.AuxInt = c * d return true } @@ -3961,10 +3550,7 @@ func rewriteValuegeneric_OpMul8(v *Value, config *Config) bool { goto end2f1952fd654c4a62ff00511041728809 } d := v.Args[1].AuxInt - v.Op = OpConst8 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConst8) v.AuxInt = c * d return true } @@ -3984,10 +3570,7 @@ func rewriteValuegeneric_OpNeq16(v *Value, config *Config) bool { if v.Args[1] != x { goto ende76a50b524aeb16c7aeccf5f5cc60c06 } - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = 0 return true } @@ -4014,10 +3597,7 @@ ende76a50b524aeb16c7aeccf5f5cc60c06: } d := v.Args[1].Args[0].AuxInt x := v.Args[1].Args[1] - v.Op = OpNeq16 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpNeq16) v0 := b.NewValue0(v.Line, OpConst16, t) v0.AuxInt = c - d v.AddArg(v0) @@ -4040,10 +3620,7 @@ end552011bd97e6f92ebc2672aa1843eadd: if !(x.Op != OpConst16) { goto end0e45958f29e87997f632248aa9ee97e0 } - v.Op = OpNeq16 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpNeq16) v0 := b.NewValue0(v.Line, OpConst16, t) v0.AuxInt = c v.AddArg(v0) @@ -4065,10 +3642,7 @@ end0e45958f29e87997f632248aa9ee97e0: goto end6302c9b645bb191982d28c2f846904d6 } d := v.Args[1].AuxInt - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = b2i(int16(c) != int16(d)) return true } @@ -4088,10 +3662,7 @@ func rewriteValuegeneric_OpNeq32(v *Value, config *Config) bool { if v.Args[1] != x { goto end3713a608cffd29b40ff7c3b3f2585cbb } - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = 0 return true } @@ -4118,10 +3689,7 @@ end3713a608cffd29b40ff7c3b3f2585cbb: } d := v.Args[1].Args[0].AuxInt x := v.Args[1].Args[1] - v.Op = OpNeq32 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpNeq32) v0 := b.NewValue0(v.Line, OpConst32, t) v0.AuxInt = c - d v.AddArg(v0) @@ -4144,10 +3712,7 @@ end93fc3b4a3639b965b414891111b16245: if !(x.Op != OpConst32) { goto end5376f9ab90e282450f49011d0e0ce236 } - v.Op = OpNeq32 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpNeq32) v0 := b.NewValue0(v.Line, OpConst32, t) v0.AuxInt = c v.AddArg(v0) @@ -4169,10 +3734,7 @@ end5376f9ab90e282450f49011d0e0ce236: goto endf9f3d0814854d2d0879d331e9bdfcae2 } d := v.Args[1].AuxInt - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = b2i(int32(c) != int32(d)) return true } @@ -4192,10 +3754,7 @@ func rewriteValuegeneric_OpNeq64(v *Value, config *Config) bool { if v.Args[1] != x { goto end3601ad382705ea12b79d2008c1e5725c } - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = 0 return true } @@ -4222,10 +3781,7 @@ end3601ad382705ea12b79d2008c1e5725c: } d := v.Args[1].Args[0].AuxInt x := v.Args[1].Args[1] - v.Op = OpNeq64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpNeq64) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = c - d v.AddArg(v0) @@ -4248,10 +3804,7 @@ enda3d39cad13a557a2aa6d086f43596c1b: if !(x.Op != OpConst64) { goto end0936a57de20373ca6cacb9506ddde708 } - v.Op = OpNeq64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpNeq64) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = c v.AddArg(v0) @@ -4273,10 +3826,7 @@ end0936a57de20373ca6cacb9506ddde708: goto endf07433ecd3c150b1b75e943aa44a7203 } d := v.Args[1].AuxInt - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = b2i(int64(c) != int64(d)) return true } @@ -4296,10 +3846,7 @@ func rewriteValuegeneric_OpNeq8(v *Value, config *Config) bool { if v.Args[1] != x { goto end09a0deaf3c42627d0d2d3efa96e30745 } - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = 0 return true } @@ -4326,10 +3873,7 @@ end09a0deaf3c42627d0d2d3efa96e30745: } d := v.Args[1].Args[0].AuxInt x := v.Args[1].Args[1] - v.Op = OpNeq8 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpNeq8) v0 := b.NewValue0(v.Line, OpConst8, t) v0.AuxInt = c - d v.AddArg(v0) @@ -4352,10 +3896,7 @@ endc8f853c610c460c887cbfdca958e3691: if !(x.Op != OpConst8) { goto end04dc0ae2b08cf0447b50e5b8ef469252 } - v.Op = OpNeq8 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpNeq8) v0 := b.NewValue0(v.Line, OpConst8, t) v0.AuxInt = c v.AddArg(v0) @@ -4377,10 +3918,7 @@ end04dc0ae2b08cf0447b50e5b8ef469252: goto end72ebdaf2de9b3aa57cf0cb8e068b5f9c } d := v.Args[1].AuxInt - v.Op = OpConstBool - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConstBool) v.AuxInt = b2i(int8(c) != int8(d)) return true } @@ -4398,10 +3936,7 @@ func rewriteValuegeneric_OpNeqInter(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpNeqPtr - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpNeqPtr) v0 := b.NewValue0(v.Line, OpITab, config.fe.TypeBytePtr()) v0.AddArg(x) v.AddArg(v0) @@ -4426,10 +3961,7 @@ func rewriteValuegeneric_OpNeqPtr(v *Value, config *Config) bool { if v.Args[1].Op != OpConstNil { goto endba798520b4d41172b110347158c44791 } - v.Op = OpIsNonNil - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpIsNonNil) v.AddArg(p) return true } @@ -4444,10 +3976,7 @@ endba798520b4d41172b110347158c44791: goto enddd95e9c3606d9fd48034f1a703561e45 } p := v.Args[1] - v.Op = OpIsNonNil - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpIsNonNil) v.AddArg(p) return true } @@ -4465,10 +3994,7 @@ func rewriteValuegeneric_OpNeqSlice(v *Value, config *Config) bool { { x := v.Args[0] y := v.Args[1] - v.Op = OpNeqPtr - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpNeqPtr) v0 := b.NewValue0(v.Line, OpSlicePtr, config.fe.TypeBytePtr()) v0.AddArg(x) v.AddArg(v0) @@ -4493,10 +4019,7 @@ func rewriteValuegeneric_OpOr16(v *Value, config *Config) bool { if v.Args[1] != x { goto end47a2f25fd31a76807aced3e2b126acdc } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -4517,10 +4040,7 @@ func rewriteValuegeneric_OpOr32(v *Value, config *Config) bool { if v.Args[1] != x { goto end231e283e568e90bd9a3e6a4fa328c8a4 } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -4541,10 +4061,7 @@ func rewriteValuegeneric_OpOr64(v *Value, config *Config) bool { if v.Args[1] != x { goto end6b0efc212016dc97d0e3939db04c81d9 } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -4565,10 +4082,7 @@ func rewriteValuegeneric_OpOr8(v *Value, config *Config) bool { if v.Args[1] != x { goto end05295dbfafd6869af79b4daee9fda000 } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -4591,10 +4105,7 @@ func rewriteValuegeneric_OpPtrIndex(v *Value, config *Config) bool { if !(config.PtrSize == 4) { goto endd902622aaa1e7545b5a2a0c08b47d287 } - v.Op = OpAddPtr - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAddPtr) v.AddArg(ptr) v0 := b.NewValue0(v.Line, OpMul32, config.fe.TypeInt()) v0.AddArg(idx) @@ -4617,10 +4128,7 @@ endd902622aaa1e7545b5a2a0c08b47d287: if !(config.PtrSize == 8) { goto end47a5f1d1b158914fa383de024bbe3b08 } - v.Op = OpAddPtr - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAddPtr) v.AddArg(ptr) v0 := b.NewValue0(v.Line, OpMul64, config.fe.TypeInt()) v0.AddArg(idx) @@ -4648,10 +4156,7 @@ func rewriteValuegeneric_OpRsh16Ux16(v *Value, config *Config) bool { goto endd981df40f353104ef828d13ad4ccdf02 } c := v.Args[1].AuxInt - v.Op = OpRsh16Ux64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpRsh16Ux64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = int64(uint16(c)) @@ -4676,10 +4181,7 @@ func rewriteValuegeneric_OpRsh16Ux32(v *Value, config *Config) bool { goto ende0be9ee562725206dcf96d3e5750b5ea } c := v.Args[1].AuxInt - v.Op = OpRsh16Ux64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpRsh16Ux64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = int64(uint32(c)) @@ -4706,10 +4208,7 @@ func rewriteValuegeneric_OpRsh16Ux64(v *Value, config *Config) bool { goto ended17f40375fb44bcbaf2d87161c5ed3c } d := v.Args[1].AuxInt - v.Op = OpConst16 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConst16) v.AuxInt = int64(uint16(c) >> uint64(d)) return true } @@ -4727,10 +4226,7 @@ ended17f40375fb44bcbaf2d87161c5ed3c: if v.Args[1].AuxInt != 0 { goto end752d1b5a60f87afa7e40febbf1bce309 } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -4749,10 +4245,7 @@ end752d1b5a60f87afa7e40febbf1bce309: if !(uint64(c) >= 16) { goto endca5c7ae2e51f2ae32486c2b1a3033b77 } - v.Op = OpConst64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConst64) v.AuxInt = 0 return true } @@ -4779,10 +4272,7 @@ endca5c7ae2e51f2ae32486c2b1a3033b77: if !(!uaddOvf(c, d)) { goto end56f2c0034c9fbe651abb36fb640af465 } - v.Op = OpRsh16Ux64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpRsh16Ux64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = c + d @@ -4807,10 +4297,7 @@ func rewriteValuegeneric_OpRsh16Ux8(v *Value, config *Config) bool { goto end20d4667094c32c71bac4e0805dab85c9 } c := v.Args[1].AuxInt - v.Op = OpRsh16Ux64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpRsh16Ux64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = int64(uint8(c)) @@ -4835,10 +4322,7 @@ func rewriteValuegeneric_OpRsh16x16(v *Value, config *Config) bool { goto end1b501c7ae2fe58ad3a88b467f2d95389 } c := v.Args[1].AuxInt - v.Op = OpRsh16x64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpRsh16x64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = int64(uint16(c)) @@ -4863,10 +4347,7 @@ func rewriteValuegeneric_OpRsh16x32(v *Value, config *Config) bool { goto end4d3a41113d2d0b09924bf5759ca49cab } c := v.Args[1].AuxInt - v.Op = OpRsh16x64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpRsh16x64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = int64(uint32(c)) @@ -4893,10 +4374,7 @@ func rewriteValuegeneric_OpRsh16x64(v *Value, config *Config) bool { goto end8f05fede35a3d2f687fcd4a5829a25ad } d := v.Args[1].AuxInt - v.Op = OpConst16 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConst16) v.AuxInt = int64(int16(c) >> uint64(d)) return true } @@ -4914,10 +4392,7 @@ end8f05fede35a3d2f687fcd4a5829a25ad: if v.Args[1].AuxInt != 0 { goto end750fafe01fcc689d953101d53efc19ab } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -4945,10 +4420,7 @@ end750fafe01fcc689d953101d53efc19ab: if !(!uaddOvf(c, d)) { goto endf425eff9e05aad27194af957e3383c76 } - v.Op = OpRsh16x64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpRsh16x64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = c + d @@ -4973,10 +4445,7 @@ func rewriteValuegeneric_OpRsh16x8(v *Value, config *Config) bool { goto end0b5e274d62a3ae8df9f4089756c6a9d4 } c := v.Args[1].AuxInt - v.Op = OpRsh16x64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpRsh16x64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = int64(uint8(c)) @@ -5001,10 +4470,7 @@ func rewriteValuegeneric_OpRsh32Ux16(v *Value, config *Config) bool { goto end8d8f9f3e2e1f7a5e9a186fb792fc40a8 } c := v.Args[1].AuxInt - v.Op = OpRsh32Ux64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpRsh32Ux64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = int64(uint16(c)) @@ -5029,10 +4495,7 @@ func rewriteValuegeneric_OpRsh32Ux32(v *Value, config *Config) bool { goto endd23d060f74e00f34cc967b6fb9a4d320 } c := v.Args[1].AuxInt - v.Op = OpRsh32Ux64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpRsh32Ux64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = int64(uint32(c)) @@ -5059,10 +4522,7 @@ func rewriteValuegeneric_OpRsh32Ux64(v *Value, config *Config) bool { goto enda101e6b765d7ecffd9b7410c9dc3be82 } d := v.Args[1].AuxInt - v.Op = OpConst32 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConst32) v.AuxInt = int64(uint32(c) >> uint64(d)) return true } @@ -5080,10 +4540,7 @@ enda101e6b765d7ecffd9b7410c9dc3be82: if v.Args[1].AuxInt != 0 { goto end162e4e182a665d4e6f0d85fe131e7288 } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -5102,10 +4559,7 @@ end162e4e182a665d4e6f0d85fe131e7288: if !(uint64(c) >= 32) { goto endca322c370839b4264b219ee042a6ab33 } - v.Op = OpConst64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConst64) v.AuxInt = 0 return true } @@ -5132,10 +4586,7 @@ endca322c370839b4264b219ee042a6ab33: if !(!uaddOvf(c, d)) { goto end2e502d68a32663142684194adbe6c297 } - v.Op = OpRsh32Ux64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpRsh32Ux64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = c + d @@ -5160,10 +4611,7 @@ func rewriteValuegeneric_OpRsh32Ux8(v *Value, config *Config) bool { goto end967cea80158afaffb783f6da7aa898ca } c := v.Args[1].AuxInt - v.Op = OpRsh32Ux64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpRsh32Ux64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = int64(uint8(c)) @@ -5188,10 +4636,7 @@ func rewriteValuegeneric_OpRsh32x16(v *Value, config *Config) bool { goto end6a62ebdcc98ea2e3214559214708d26a } c := v.Args[1].AuxInt - v.Op = OpRsh32x64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpRsh32x64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = int64(uint16(c)) @@ -5216,10 +4661,7 @@ func rewriteValuegeneric_OpRsh32x32(v *Value, config *Config) bool { goto end6e3b467acdca74f58e9177fb42a1968b } c := v.Args[1].AuxInt - v.Op = OpRsh32x64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpRsh32x64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = int64(uint32(c)) @@ -5246,10 +4688,7 @@ func rewriteValuegeneric_OpRsh32x64(v *Value, config *Config) bool { goto end7e4b8c499cffe1fef73a16e6be54d4d2 } d := v.Args[1].AuxInt - v.Op = OpConst32 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConst32) v.AuxInt = int64(int32(c) >> uint64(d)) return true } @@ -5267,10 +4706,7 @@ end7e4b8c499cffe1fef73a16e6be54d4d2: if v.Args[1].AuxInt != 0 { goto end72da2611eaaffe407efa1cc45c23ade3 } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -5298,10 +4734,7 @@ end72da2611eaaffe407efa1cc45c23ade3: if !(!uaddOvf(c, d)) { goto endadb415be78ee46a8a4135ec50df772b0 } - v.Op = OpRsh32x64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpRsh32x64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = c + d @@ -5326,10 +4759,7 @@ func rewriteValuegeneric_OpRsh32x8(v *Value, config *Config) bool { goto end7b59b42c5c68a2d55be469a0c086dd8b } c := v.Args[1].AuxInt - v.Op = OpRsh32x64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpRsh32x64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = int64(uint8(c)) @@ -5354,10 +4784,7 @@ func rewriteValuegeneric_OpRsh64Ux16(v *Value, config *Config) bool { goto end733d85a7b599bcba969ca1cb4bdb9e48 } c := v.Args[1].AuxInt - v.Op = OpRsh64Ux64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpRsh64Ux64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = int64(uint16(c)) @@ -5382,10 +4809,7 @@ func rewriteValuegeneric_OpRsh64Ux32(v *Value, config *Config) bool { goto endeac7b34169de1fb0393b833e65b9bb19 } c := v.Args[1].AuxInt - v.Op = OpRsh64Ux64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpRsh64Ux64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = int64(uint32(c)) @@ -5412,10 +4836,7 @@ func rewriteValuegeneric_OpRsh64Ux64(v *Value, config *Config) bool { goto end102f4cfd7979a2aa222d52c34ac6802d } d := v.Args[1].AuxInt - v.Op = OpConst64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConst64) v.AuxInt = int64(uint64(c) >> uint64(d)) return true } @@ -5433,10 +4854,7 @@ end102f4cfd7979a2aa222d52c34ac6802d: if v.Args[1].AuxInt != 0 { goto end5ad037b910698f2847df90177c23a6ac } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -5455,10 +4873,7 @@ end5ad037b910698f2847df90177c23a6ac: if !(uint64(c) >= 64) { goto end16ea16aa61862207ea64e514369d608b } - v.Op = OpConst64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConst64) v.AuxInt = 0 return true } @@ -5485,10 +4900,7 @@ end16ea16aa61862207ea64e514369d608b: if !(!uaddOvf(c, d)) { goto end32bfdb1b4ccc23a5cd62fc0348ebd877 } - v.Op = OpRsh64Ux64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpRsh64Ux64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = c + d @@ -5513,10 +4925,7 @@ func rewriteValuegeneric_OpRsh64Ux8(v *Value, config *Config) bool { goto ende3d8090a67a52dbcd24b52ee32c9d7f0 } c := v.Args[1].AuxInt - v.Op = OpRsh64Ux64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpRsh64Ux64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = int64(uint8(c)) @@ -5541,10 +4950,7 @@ func rewriteValuegeneric_OpRsh64x16(v *Value, config *Config) bool { goto endd5151d0bfc38c55ae6ae6836014df3bc } c := v.Args[1].AuxInt - v.Op = OpRsh64x64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpRsh64x64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = int64(uint16(c)) @@ -5569,10 +4975,7 @@ func rewriteValuegeneric_OpRsh64x32(v *Value, config *Config) bool { goto end0f2dbca5c7d6b100890c94a97bf0de7c } c := v.Args[1].AuxInt - v.Op = OpRsh64x64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpRsh64x64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = int64(uint32(c)) @@ -5599,10 +5002,7 @@ func rewriteValuegeneric_OpRsh64x64(v *Value, config *Config) bool { goto endfa4609d6bea8a3e3d3a777b1968c97d9 } d := v.Args[1].AuxInt - v.Op = OpConst64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConst64) v.AuxInt = c >> uint64(d) return true } @@ -5620,10 +5020,7 @@ endfa4609d6bea8a3e3d3a777b1968c97d9: if v.Args[1].AuxInt != 0 { goto ende62e0c67d3f04eb221646371a2a91d05 } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -5651,10 +5048,7 @@ ende62e0c67d3f04eb221646371a2a91d05: if !(!uaddOvf(c, d)) { goto endd3e8ea66dc3ad0bc393001d6babb7160 } - v.Op = OpRsh64x64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpRsh64x64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = c + d @@ -5679,10 +5073,7 @@ func rewriteValuegeneric_OpRsh64x8(v *Value, config *Config) bool { goto end1a9e5a89849344396210da7c7ec810be } c := v.Args[1].AuxInt - v.Op = OpRsh64x64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpRsh64x64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = int64(uint8(c)) @@ -5707,10 +5098,7 @@ func rewriteValuegeneric_OpRsh8Ux16(v *Value, config *Config) bool { goto end7acc015610273092e9efcce2949ee0f9 } c := v.Args[1].AuxInt - v.Op = OpRsh8Ux64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpRsh8Ux64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = int64(uint16(c)) @@ -5735,10 +5123,7 @@ func rewriteValuegeneric_OpRsh8Ux32(v *Value, config *Config) bool { goto end27e9b4472e085b653a105b1d67554ce8 } c := v.Args[1].AuxInt - v.Op = OpRsh8Ux64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpRsh8Ux64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = int64(uint32(c)) @@ -5765,10 +5150,7 @@ func rewriteValuegeneric_OpRsh8Ux64(v *Value, config *Config) bool { goto enddd166e450d81ba7b466d61d2fbec178c } d := v.Args[1].AuxInt - v.Op = OpConst8 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConst8) v.AuxInt = int64(uint8(c) >> uint64(d)) return true } @@ -5786,10 +5168,7 @@ enddd166e450d81ba7b466d61d2fbec178c: if v.Args[1].AuxInt != 0 { goto end570cb1d9db3c7bebd85e485eeb2c0969 } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -5808,10 +5187,7 @@ end570cb1d9db3c7bebd85e485eeb2c0969: if !(uint64(c) >= 8) { goto endb63e1a7d1d91716ca0d9d74215361323 } - v.Op = OpConst64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConst64) v.AuxInt = 0 return true } @@ -5838,10 +5214,7 @@ endb63e1a7d1d91716ca0d9d74215361323: if !(!uaddOvf(c, d)) { goto endee8824b7071ed1a6dba4fcbaab98229e } - v.Op = OpRsh8Ux64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpRsh8Ux64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = c + d @@ -5866,10 +5239,7 @@ func rewriteValuegeneric_OpRsh8Ux8(v *Value, config *Config) bool { goto ended7e4f4d9ab89dc26e6649d466577930 } c := v.Args[1].AuxInt - v.Op = OpRsh8Ux64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpRsh8Ux64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = int64(uint8(c)) @@ -5894,10 +5264,7 @@ func rewriteValuegeneric_OpRsh8x16(v *Value, config *Config) bool { goto end136bef6f60180bc8b4befbfc370af7ef } c := v.Args[1].AuxInt - v.Op = OpRsh8x64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpRsh8x64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = int64(uint16(c)) @@ -5922,10 +5289,7 @@ func rewriteValuegeneric_OpRsh8x32(v *Value, config *Config) bool { goto end2ef95c222a7c552fa9cc86e36196644e } c := v.Args[1].AuxInt - v.Op = OpRsh8x64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpRsh8x64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = int64(uint32(c)) @@ -5952,10 +5316,7 @@ func rewriteValuegeneric_OpRsh8x64(v *Value, config *Config) bool { goto end3b90206d75365466dfd1368e5b69db35 } d := v.Args[1].AuxInt - v.Op = OpConst8 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConst8) v.AuxInt = int64(int8(c) >> uint64(d)) return true } @@ -5973,10 +5334,7 @@ end3b90206d75365466dfd1368e5b69db35: if v.Args[1].AuxInt != 0 { goto end1e664cc720a11d1c769de8081cfa1de4 } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -6004,10 +5362,7 @@ end1e664cc720a11d1c769de8081cfa1de4: if !(!uaddOvf(c, d)) { goto end6408685a7276af7e76ec086f359c942c } - v.Op = OpRsh8x64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpRsh8x64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = c + d @@ -6032,10 +5387,7 @@ func rewriteValuegeneric_OpRsh8x8(v *Value, config *Config) bool { goto endae44f60f364cddd8903763dd921a007e } c := v.Args[1].AuxInt - v.Op = OpRsh8x64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpRsh8x64) v.AddArg(x) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = int64(uint8(c)) @@ -6058,10 +5410,7 @@ func rewriteValuegeneric_OpSliceCap(v *Value, config *Config) bool { goto end1bd11616743632b33b410964667fb3c6 } cap := v.Args[0].Args[2] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = cap.Type v.AddArg(cap) return true @@ -6082,10 +5431,7 @@ func rewriteValuegeneric_OpSliceLen(v *Value, config *Config) bool { goto endebb2090199d13e4c2ae52fb3e778f7fd } len := v.Args[0].Args[1] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = len.Type v.AddArg(len) return true @@ -6106,10 +5452,7 @@ func rewriteValuegeneric_OpSlicePtr(v *Value, config *Config) bool { goto end526acc0a705137a5d25577499206720b } ptr := v.Args[0].Args[0] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = ptr.Type v.AddArg(ptr) return true @@ -6130,10 +5473,7 @@ func rewriteValuegeneric_OpStore(v *Value, config *Config) bool { goto endd4f364b0adfc229d8c200af183d4c808 } mem := v.Args[2] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = mem.Type v.AddArg(mem) return true @@ -6152,10 +5492,7 @@ endd4f364b0adfc229d8c200af183d4c808: t := v.Args[1].Type f0 := v.Args[1].Args[0] mem := v.Args[2] - v.Op = OpStore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpStore) v.AuxInt = t.FieldType(0).Size() v.AddArg(dst) v.AddArg(f0) @@ -6177,10 +5514,7 @@ end2cff6d06f4440132f48ca374b6b1e9d8: f0 := v.Args[1].Args[0] f1 := v.Args[1].Args[1] mem := v.Args[2] - v.Op = OpStore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpStore) v.AuxInt = t.FieldType(1).Size() v0 := b.NewValue0(v.Line, OpOffPtr, t.FieldType(1).PtrTo()) v0.AuxInt = t.FieldOff(1) @@ -6211,10 +5545,7 @@ end4e8ede6cc575a287795971da6b637973: f1 := v.Args[1].Args[1] f2 := v.Args[1].Args[2] mem := v.Args[2] - v.Op = OpStore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpStore) v.AuxInt = t.FieldType(2).Size() v0 := b.NewValue0(v.Line, OpOffPtr, t.FieldType(2).PtrTo()) v0.AuxInt = t.FieldOff(2) @@ -6254,10 +5585,7 @@ end6ad675267724a87c8f852dd1e185e911: f2 := v.Args[1].Args[2] f3 := v.Args[1].Args[3] mem := v.Args[2] - v.Op = OpStore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpStore) v.AuxInt = t.FieldType(3).Size() v0 := b.NewValue0(v.Line, OpOffPtr, t.FieldType(3).PtrTo()) v0.AuxInt = t.FieldOff(3) @@ -6305,10 +5633,7 @@ end7ea91abd44794f7653374502a5a405ea: real := v.Args[1].Args[0] imag := v.Args[1].Args[1] mem := v.Args[2] - v.Op = OpStore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpStore) v.AuxInt = 4 v0 := b.NewValue0(v.Line, OpOffPtr, config.fe.TypeFloat32().PtrTo()) v0.AuxInt = 4 @@ -6340,10 +5665,7 @@ endced898cb0a165662afe48ea44ad3318a: real := v.Args[1].Args[0] imag := v.Args[1].Args[1] mem := v.Args[2] - v.Op = OpStore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpStore) v.AuxInt = 8 v0 := b.NewValue0(v.Line, OpOffPtr, config.fe.TypeFloat64().PtrTo()) v0.AuxInt = 8 @@ -6375,10 +5697,7 @@ end3851a482d7bd37a93c4d81581e85b3ab: ptr := v.Args[1].Args[0] len := v.Args[1].Args[1] mem := v.Args[2] - v.Op = OpStore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpStore) v.AuxInt = config.PtrSize v0 := b.NewValue0(v.Line, OpOffPtr, config.fe.TypeInt().PtrTo()) v0.AuxInt = config.PtrSize @@ -6411,10 +5730,7 @@ endd3a6ecebdad5899570a79fe5c62f34f1: len := v.Args[1].Args[1] cap := v.Args[1].Args[2] mem := v.Args[2] - v.Op = OpStore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpStore) v.AuxInt = config.PtrSize v0 := b.NewValue0(v.Line, OpOffPtr, config.fe.TypeInt().PtrTo()) v0.AuxInt = 2 * config.PtrSize @@ -6454,10 +5770,7 @@ endd5cc8c3dad7d24c845b0b88fc51487ae: itab := v.Args[1].Args[0] data := v.Args[1].Args[1] mem := v.Args[2] - v.Op = OpStore - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpStore) v.AuxInt = config.PtrSize v0 := b.NewValue0(v.Line, OpOffPtr, config.fe.TypeBytePtr().PtrTo()) v0.AuxInt = config.PtrSize @@ -6493,10 +5806,7 @@ endaa801a871178ae3256b3f6f5d9f13514: if !(!config.fe.CanSSA(t)) { goto end45295326269ba18413dceb7b608a0b9d } - v.Op = OpMove - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpMove) v.AuxInt = size v.AddArg(dst) v.AddArg(src) @@ -6528,10 +5838,7 @@ end45295326269ba18413dceb7b608a0b9d: if !(!config.fe.CanSSA(t)) { goto end7f3cc0baffb82ba3ee879599b189a512 } - v.Op = OpMove - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpMove) v.AuxInt = size v.AddArg(dst) v.AddArg(src) @@ -6557,10 +5864,7 @@ func rewriteValuegeneric_OpStringLen(v *Value, config *Config) bool { goto end0d922460b7e5ca88324034f4bd6c027c } len := v.Args[0].Args[1] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = len.Type v.AddArg(len) return true @@ -6581,10 +5885,7 @@ func rewriteValuegeneric_OpStringPtr(v *Value, config *Config) bool { goto end061edc5d85c73ad909089af2556d9380 } ptr := v.Args[0].Args[0] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = ptr.Type v.AddArg(ptr) return true @@ -6605,10 +5906,7 @@ func rewriteValuegeneric_OpStructSelect(v *Value, config *Config) bool { goto end17af582e7eba5216b4a51fe6c9206d3c } x := v.Args[0].Args[0] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -6627,10 +5925,7 @@ end17af582e7eba5216b4a51fe6c9206d3c: goto end355cfff99c8e9af975c3ae450d49b7f9 } x := v.Args[0].Args[0] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -6649,10 +5944,7 @@ end355cfff99c8e9af975c3ae450d49b7f9: goto end69baa65e494ef9ae154e0943b53734f9 } x := v.Args[0].Args[1] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -6671,10 +5963,7 @@ end69baa65e494ef9ae154e0943b53734f9: goto endb0d98e2c46bb51c9abd4c3543392e0ec } x := v.Args[0].Args[0] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -6693,10 +5982,7 @@ endb0d98e2c46bb51c9abd4c3543392e0ec: goto end2e40457286d26c2f14ad4fd127946773 } x := v.Args[0].Args[1] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -6715,10 +6001,7 @@ end2e40457286d26c2f14ad4fd127946773: goto end3e3b96ad431206175d002ece87aa1409 } x := v.Args[0].Args[2] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -6737,10 +6020,7 @@ end3e3b96ad431206175d002ece87aa1409: goto end09f8a1ffa3d8c3124bc6d4083b941108 } x := v.Args[0].Args[0] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -6759,10 +6039,7 @@ end09f8a1ffa3d8c3124bc6d4083b941108: goto endd3ef25e605a927e9251be6d9221f4acf } x := v.Args[0].Args[1] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -6781,10 +6058,7 @@ endd3ef25e605a927e9251be6d9221f4acf: goto end0438e22cc8f41123fa42009a81ee723a } x := v.Args[0].Args[2] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -6803,10 +6077,7 @@ end0438e22cc8f41123fa42009a81ee723a: goto end56a7c7781fee35eeff0a3652dc206012 } x := v.Args[0].Args[3] - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -6829,10 +6100,7 @@ end56a7c7781fee35eeff0a3652dc206012: goto end2afd47b4fcaaab7a73325bd8a75e3e8e } v0 := v.Args[0].Block.NewValue0(v.Line, OpLoad, v.Type) - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.AddArg(v0) v1 := v.Args[0].Block.NewValue0(v.Line, OpOffPtr, v.Type.PtrTo()) v1.AuxInt = t.FieldOff(i) @@ -6861,10 +6129,7 @@ func rewriteValuegeneric_OpSub16(v *Value, config *Config) bool { goto end5c6fab95c9dbeff5973119096bfd4e78 } d := v.Args[1].AuxInt - v.Op = OpConst16 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConst16) v.AuxInt = c - d return true } @@ -6884,10 +6149,7 @@ end5c6fab95c9dbeff5973119096bfd4e78: if !(x.Op != OpConst16) { goto end493545258a8e7e79d005b34c712ddd0c } - v.Op = OpAdd16 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAdd16) v0 := b.NewValue0(v.Line, OpConst16, t) v0.AuxInt = -c v.AddArg(v0) @@ -6905,10 +6167,7 @@ end493545258a8e7e79d005b34c712ddd0c: if v.Args[1] != x { goto end83da541391be564f2a08464e674a49e7 } - v.Op = OpConst16 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConst16) v.AuxInt = 0 return true } @@ -6927,10 +6186,7 @@ end83da541391be564f2a08464e674a49e7: if v.Args[1] != x { goto end0dd8f250c457b9c005ecbed59fc2e758 } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = y.Type v.AddArg(y) return true @@ -6950,10 +6206,7 @@ end0dd8f250c457b9c005ecbed59fc2e758: if v.Args[1] != y { goto end01c8db2e0bce69e048cf79f3bdc82b9b } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -6978,10 +6231,7 @@ func rewriteValuegeneric_OpSub32(v *Value, config *Config) bool { goto end7623799db780e1bcc42c6ea0df9c49d3 } d := v.Args[1].AuxInt - v.Op = OpConst32 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConst32) v.AuxInt = c - d return true } @@ -7001,10 +6251,7 @@ end7623799db780e1bcc42c6ea0df9c49d3: if !(x.Op != OpConst32) { goto end391e2f2ba8c7502b62c0153ec69c4fbd } - v.Op = OpAdd32 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAdd32) v0 := b.NewValue0(v.Line, OpConst32, t) v0.AuxInt = -c v.AddArg(v0) @@ -7022,10 +6269,7 @@ end391e2f2ba8c7502b62c0153ec69c4fbd: if v.Args[1] != x { goto enda747581e798f199e07f4ad69747cd069 } - v.Op = OpConst32 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConst32) v.AuxInt = 0 return true } @@ -7044,10 +6288,7 @@ enda747581e798f199e07f4ad69747cd069: if v.Args[1] != x { goto end70c1e60e58a6c106d060f10cd3f179ea } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = y.Type v.AddArg(y) return true @@ -7067,10 +6308,7 @@ end70c1e60e58a6c106d060f10cd3f179ea: if v.Args[1] != y { goto end20e42db178ec4f423cc56a991863a4a2 } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -7095,10 +6333,7 @@ func rewriteValuegeneric_OpSub64(v *Value, config *Config) bool { goto end5a84a285ff0ff48b8ad3c64b15e3459f } d := v.Args[1].AuxInt - v.Op = OpConst64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConst64) v.AuxInt = c - d return true } @@ -7118,10 +6353,7 @@ end5a84a285ff0ff48b8ad3c64b15e3459f: if !(x.Op != OpConst64) { goto enda80d30f6794bcf02cd4442b238f68333 } - v.Op = OpAdd64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAdd64) v0 := b.NewValue0(v.Line, OpConst64, t) v0.AuxInt = -c v.AddArg(v0) @@ -7139,10 +6371,7 @@ enda80d30f6794bcf02cd4442b238f68333: if v.Args[1] != x { goto end0387dc2b7bbe57d4aa54eab5d959da4b } - v.Op = OpConst64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConst64) v.AuxInt = 0 return true } @@ -7161,10 +6390,7 @@ end0387dc2b7bbe57d4aa54eab5d959da4b: if v.Args[1] != x { goto end7d177451cf8959cb781f52d5ded46fff } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = y.Type v.AddArg(y) return true @@ -7184,10 +6410,7 @@ end7d177451cf8959cb781f52d5ded46fff: if v.Args[1] != y { goto end6ea8172b21100cfe3dc86b7a850fbe97 } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -7212,10 +6435,7 @@ func rewriteValuegeneric_OpSub8(v *Value, config *Config) bool { goto endc00ea11c7535529e211710574f5cff24 } d := v.Args[1].AuxInt - v.Op = OpConst8 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConst8) v.AuxInt = c - d return true } @@ -7235,10 +6455,7 @@ endc00ea11c7535529e211710574f5cff24: if !(x.Op != OpConst8) { goto end0bfab5b6f1037e55dc049b79e2636678 } - v.Op = OpAdd8 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpAdd8) v0 := b.NewValue0(v.Line, OpConst8, t) v0.AuxInt = -c v.AddArg(v0) @@ -7256,10 +6473,7 @@ end0bfab5b6f1037e55dc049b79e2636678: if v.Args[1] != x { goto end4e2ee15ef17611919a1a6b5f80bbfe18 } - v.Op = OpConst8 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConst8) v.AuxInt = 0 return true } @@ -7278,10 +6492,7 @@ end4e2ee15ef17611919a1a6b5f80bbfe18: if v.Args[1] != x { goto endd79d561e14dc3d11da4c3bb20270b541 } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = y.Type v.AddArg(y) return true @@ -7301,10 +6512,7 @@ endd79d561e14dc3d11da4c3bb20270b541: if v.Args[1] != y { goto endcb7111b11d6d068c97026a97ecff8248 } - v.Op = OpCopy - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true @@ -7325,10 +6533,7 @@ func rewriteValuegeneric_OpXor16(v *Value, config *Config) bool { if v.Args[1] != x { goto end5733ceb1903b8140248d8e2cac02fefe } - v.Op = OpConst16 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConst16) v.AuxInt = 0 return true } @@ -7348,10 +6553,7 @@ func rewriteValuegeneric_OpXor32(v *Value, config *Config) bool { if v.Args[1] != x { goto end268ca02df6515d648e0bfb4e90981d25 } - v.Op = OpConst32 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConst32) v.AuxInt = 0 return true } @@ -7371,10 +6573,7 @@ func rewriteValuegeneric_OpXor64(v *Value, config *Config) bool { if v.Args[1] != x { goto endaf44e7f9fc58af30df69070953fb45ce } - v.Op = OpConst64 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConst64) v.AuxInt = 0 return true } @@ -7394,10 +6593,7 @@ func rewriteValuegeneric_OpXor8(v *Value, config *Config) bool { if v.Args[1] != x { goto end949b3a60b7d181688e6f79f93c782fc8 } - v.Op = OpConst8 - v.AuxInt = 0 - v.Aux = nil - v.resetArgs() + v.reset(OpConst8) v.AuxInt = 0 return true } diff --git a/src/cmd/compile/internal/ssa/value.go b/src/cmd/compile/internal/ssa/value.go index af6bb3b97e..d71fd8fb87 100644 --- a/src/cmd/compile/internal/ssa/value.go +++ b/src/cmd/compile/internal/ssa/value.go @@ -170,6 +170,13 @@ func (v *Value) resetArgs() { 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) -- cgit v1.3 From 7de8cfdf9ce3942a255172e03c8f2ad380a30aca Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Thu, 4 Feb 2016 11:21:31 -0800 Subject: [dev.ssa] cmd/internal/obj/x86: don't clobber flags with dynlink rewrite LEAQ symbol+100(SB), AX Under dynamic link, rewrites to MOVQ symbol@GOT(SB), AX ADDQ $100, AX but ADDQ clobbers flags, whereas the original LEAQ (when not dynamic linking) doesn't. Use LEAQ instead of ADDQ to add that constant in so we preserve flags. Change-Id: Ibb055403d94a4c5163e1c7d2f45da633ffd0b6a3 Reviewed-on: https://go-review.googlesource.com/19230 Reviewed-by: David Chase Run-TryBot: David Chase Reviewed-by: Ian Lance Taylor --- src/cmd/internal/obj/x86/obj6.go | 7 ++++--- src/cmd/internal/obj/x86/obj6_test.go | 4 ++-- 2 files changed, 6 insertions(+), 5 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/internal/obj/x86/obj6.go b/src/cmd/internal/obj/x86/obj6.go index e545374828..1955aa560d 100644 --- a/src/cmd/internal/obj/x86/obj6.go +++ b/src/cmd/internal/obj/x86/obj6.go @@ -377,7 +377,7 @@ func rewriteToUseGot(ctxt *obj.Link, p *obj.Prog) { } 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+, Rx becomes $MOV sym@GOT, Rx; $ADD , Rx + // $MOV $sym+, Rx becomes $MOV sym@GOT, Rx; $LEA (Rx), Rx // On 386 only, more complicated things like PUSHL $sym become $MOV sym@GOT, CX; PUSHL CX cmplxdest := false pAs := p.As @@ -399,8 +399,9 @@ func rewriteToUseGot(ctxt *obj.Link, p *obj.Prog) { 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 diff --git a/src/cmd/internal/obj/x86/obj6_test.go b/src/cmd/internal/obj/x86/obj6_test.go index 4387db696d..d83ab24ab8 100644 --- a/src/cmd/internal/obj/x86/obj6_test.go +++ b/src/cmd/internal/obj/x86/obj6_test.go @@ -20,9 +20,9 @@ const testdata = ` 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 -- cgit v1.3 From 9278a04a8fca27cdfb556313c82c052f28504b9f Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Tue, 2 Feb 2016 11:13:50 -0800 Subject: [dev.ssa] cmd/compile: more combining of ops into instructions Mostly indexed loads. A few more LEA cases. Change-Id: Idc1d447ed0dd6e906cd48e70307a95e77f61cf5f Reviewed-on: https://go-review.googlesource.com/19172 Reviewed-by: Todd Neal Run-TryBot: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 20 +- src/cmd/compile/internal/ssa/gen/AMD64.rules | 79 +- src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 42 +- src/cmd/compile/internal/ssa/opGen.go | 107 ++- src/cmd/compile/internal/ssa/rewriteAMD64.go | 1176 +++++++++++++++++++++++--- src/cmd/compile/internal/ssa/value.go | 2 +- 6 files changed, 1260 insertions(+), 166 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 59993c23dd..8ae02bd4ca 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -4061,7 +4061,7 @@ func (s *genState) genValue(v *ssa.Value) { p.From.Index = regnum(v.Args[1]) p.To.Type = obj.TYPE_REG p.To.Reg = regnum(v) - case ssa.OpAMD64MOVSSloadidx4: + case ssa.OpAMD64MOVLloadidx4, ssa.OpAMD64MOVSSloadidx4: p := Prog(v.Op.Asm()) p.From.Type = obj.TYPE_MEM p.From.Reg = regnum(v.Args[0]) @@ -4070,6 +4070,24 @@ func (s *genState) genValue(v *ssa.Value) { 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 diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index ee21e5643b..692ea467e4 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -546,9 +546,34 @@ (MULQconst [9] x) -> (LEAQ8 x x) (MULQconst [c] x) && isPowerOfTwo(c) -> (SHLQconst [log2(c)] x) -// fold add/shift into leaq +// combine add/shift into LEAQ (ADDQ x (SHLQconst [3] y)) -> (LEAQ8 x y) -(ADDQconst [c] (LEAQ8 [d] x y)) -> (LEAQ8 [addOff(c, d)] 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) + +// 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) @@ -672,17 +697,13 @@ (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) -// indexed loads and stores -(MOVQloadidx8 [off1] {sym} (ADDQconst [off2] ptr) idx mem) -> (MOVQloadidx8 [addOff(off1, off2)] {sym} ptr idx mem) -(MOVQstoreidx8 [off1] {sym} (ADDQconst [off2] ptr) idx val mem) -> (MOVQstoreidx8 [addOff(off1, off2)] {sym} ptr idx val mem) -(MOVSSloadidx4 [off1] {sym} (ADDQconst [off2] {sym} ptr) idx mem) -> (MOVSSloadidx4 [addOff(off1, off2)] {sym} ptr idx mem) -(MOVSSstoreidx4 [off1] {sym} (ADDQconst [off2] {sym} ptr) idx val mem) -> (MOVSSstoreidx4 [addOff(off1, off2)] {sym} ptr idx val mem) -(MOVSDloadidx8 [off1] {sym} (ADDQconst [off2] {sym} ptr) idx mem) -> (MOVSDloadidx8 [addOff(off1, off2)] {sym} ptr idx mem) -(MOVSDstoreidx8 [off1] {sym} (ADDQconst [off2] {sym} ptr) idx val mem) -> (MOVSDstoreidx8 [addOff(off1, off2)] {sym} ptr idx val mem) -(MOVLstoreidx4 [off1] {sym} (ADDQconst [off2] ptr) idx val mem) -> (MOVLstoreidx4 [addOff(off1, off2)] {sym} ptr idx val mem) -(MOVWstoreidx2 [off1] {sym} (ADDQconst [off2] ptr) idx val mem) -> (MOVWstoreidx2 [addOff(off1, off2)] {sym} ptr idx val mem) -(MOVBstoreidx1 [off1] {sym} (ADDQconst [off2] ptr) idx val mem) -> (MOVBstoreidx1 [addOff(off1, off2)] {sym} ptr idx val 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) -> @@ -703,7 +724,37 @@ (MOVSDstore [off1] {sym1} (LEAQ8 [off2] {sym2} ptr idx) val mem) && canMergeSym(sym1, sym2) -> (MOVSDstoreidx8 [addOff(off1, off2)] {mergeSym(sym1,sym2)} ptr idx val mem) -(MOVBstore [off] {sym} (ADDQ ptr idx) val mem) -> (MOVBstoreidx1 [off] {sym} 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) + +// 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) // fold LEAQs together (LEAQ [off1] {sym1} (LEAQ [off2] {sym2} x)) && canMergeSym(sym1, sym2) -> diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 1cf44f148f..bb7a42ea07 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -362,31 +362,37 @@ func init() { {name: "LEAQ2", reg: gp21sb, aux: "SymOff"}, // arg0 + 2*arg1 + auxint + aux {name: "LEAQ4", reg: gp21sb, aux: "SymOff"}, // arg0 + 4*arg1 + auxint + aux {name: "LEAQ8", 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", reg: gpload, asm: "MOVB", aux: "SymOff", typ: "UInt8"}, // load byte from arg0+auxint+aux. arg1=mem - {name: "MOVBQSXload", reg: gpload, asm: "MOVBQSX", aux: "SymOff"}, // ditto, extend to int64 - {name: "MOVBQZXload", reg: gpload, asm: "MOVBQZX", aux: "SymOff"}, // ditto, extend to uint64 - {name: "MOVWload", reg: gpload, asm: "MOVW", aux: "SymOff", typ: "UInt16"}, // load 2 bytes from arg0+auxint+aux. arg1=mem - {name: "MOVWQSXload", reg: gpload, asm: "MOVWQSX", aux: "SymOff"}, // ditto, extend to int64 - {name: "MOVWQZXload", reg: gpload, asm: "MOVWQZX", aux: "SymOff"}, // ditto, extend to uint64 - {name: "MOVLload", reg: gpload, asm: "MOVL", aux: "SymOff", typ: "UInt32"}, // load 4 bytes from arg0+auxint+aux. arg1=mem - {name: "MOVLQSXload", reg: gpload, asm: "MOVLQSX", aux: "SymOff"}, // ditto, extend to int64 - {name: "MOVLQZXload", reg: gpload, asm: "MOVLQZX", aux: "SymOff"}, // ditto, extend to uint64 - {name: "MOVQload", reg: gpload, asm: "MOVQ", aux: "SymOff", typ: "UInt64"}, // load 8 bytes from arg0+auxint+aux. arg1=mem - {name: "MOVQloadidx8", reg: gploadidx, asm: "MOVQ", aux: "SymOff"}, // load 8 bytes from arg0+8*arg1+auxint+aux. arg2=mem - {name: "MOVBstore", reg: gpstore, asm: "MOVB", aux: "SymOff", typ: "Mem"}, // store byte in arg1 to arg0+auxint+aux. arg2=mem - {name: "MOVWstore", reg: gpstore, asm: "MOVW", aux: "SymOff", typ: "Mem"}, // store 2 bytes in arg1 to arg0+auxint+aux. arg2=mem - {name: "MOVLstore", reg: gpstore, asm: "MOVL", aux: "SymOff", typ: "Mem"}, // store 4 bytes in arg1 to arg0+auxint+aux. arg2=mem - {name: "MOVQstore", reg: gpstore, asm: "MOVQ", aux: "SymOff", typ: "Mem"}, // store 8 bytes in arg1 to arg0+auxint+aux. arg2=mem + {name: "MOVBload", reg: gpload, asm: "MOVB", aux: "SymOff", typ: "UInt8"}, // load byte from arg0+auxint+aux. arg1=mem + {name: "MOVBQSXload", reg: gpload, asm: "MOVBQSX", aux: "SymOff"}, // ditto, extend to int64 + {name: "MOVBQZXload", reg: gpload, asm: "MOVBQZX", aux: "SymOff"}, // ditto, extend to uint64 + {name: "MOVWload", reg: gpload, asm: "MOVW", aux: "SymOff", typ: "UInt16"}, // load 2 bytes from arg0+auxint+aux. arg1=mem + {name: "MOVWQSXload", reg: gpload, asm: "MOVWQSX", aux: "SymOff"}, // ditto, extend to int64 + {name: "MOVWQZXload", reg: gpload, asm: "MOVWQZX", aux: "SymOff"}, // ditto, extend to uint64 + {name: "MOVLload", reg: gpload, asm: "MOVL", aux: "SymOff", typ: "UInt32"}, // load 4 bytes from arg0+auxint+aux. arg1=mem + {name: "MOVLQSXload", reg: gpload, asm: "MOVLQSX", aux: "SymOff"}, // ditto, extend to int64 + {name: "MOVLQZXload", reg: gpload, asm: "MOVLQZX", aux: "SymOff"}, // ditto, extend to uint64 + {name: "MOVQload", reg: gpload, asm: "MOVQ", aux: "SymOff", typ: "UInt64"}, // load 8 bytes from arg0+auxint+aux. arg1=mem + {name: "MOVBstore", reg: gpstore, asm: "MOVB", aux: "SymOff", typ: "Mem"}, // store byte in arg1 to arg0+auxint+aux. arg2=mem + {name: "MOVWstore", reg: gpstore, asm: "MOVW", aux: "SymOff", typ: "Mem"}, // store 2 bytes in arg1 to arg0+auxint+aux. arg2=mem + {name: "MOVLstore", reg: gpstore, asm: "MOVL", aux: "SymOff", typ: "Mem"}, // store 4 bytes in arg1 to arg0+auxint+aux. arg2=mem + {name: "MOVQstore", reg: gpstore, asm: "MOVQ", aux: "SymOff", typ: "Mem"}, // store 8 bytes in arg1 to arg0+auxint+aux. arg2=mem + {name: "MOVOload", reg: fpload, asm: "MOVUPS", aux: "SymOff", typ: "Int128"}, // load 16 bytes from arg0+auxint+aux. arg1=mem + {name: "MOVOstore", reg: fpstore, asm: "MOVUPS", aux: "SymOff", typ: "Mem"}, // store 16 bytes in arg1 to arg0+auxint+aux. arg2=mem + // indexed loads/stores + {name: "MOVBloadidx1", reg: gploadidx, asm: "MOVB", aux: "SymOff"}, // load a byte from arg0+arg1+auxint+aux. arg2=mem + {name: "MOVWloadidx2", reg: gploadidx, asm: "MOVW", aux: "SymOff"}, // load 2 bytes from arg0+2*arg1+auxint+aux. arg2=mem + {name: "MOVLloadidx4", reg: gploadidx, asm: "MOVL", aux: "SymOff"}, // load 4 bytes from arg0+4*arg1+auxint+aux. arg2=mem + {name: "MOVQloadidx8", reg: gploadidx, asm: "MOVQ", aux: "SymOff"}, // load 8 bytes from arg0+8*arg1+auxint+aux. arg2=mem + // TODO: sign-extending indexed loads {name: "MOVBstoreidx1", reg: gpstoreidx, asm: "MOVB", aux: "SymOff"}, // store byte in arg2 to arg0+arg1+auxint+aux. arg3=mem {name: "MOVWstoreidx2", reg: gpstoreidx, asm: "MOVW", aux: "SymOff"}, // store 2 bytes in arg2 to arg0+2*arg1+auxint+aux. arg3=mem {name: "MOVLstoreidx4", reg: gpstoreidx, asm: "MOVL", aux: "SymOff"}, // store 4 bytes in arg2 to arg0+4*arg1+auxint+aux. arg3=mem {name: "MOVQstoreidx8", reg: gpstoreidx, asm: "MOVQ", aux: "SymOff"}, // store 8 bytes in arg2 to arg0+8*arg1+auxint+aux. arg3=mem - - {name: "MOVOload", reg: fpload, asm: "MOVUPS", aux: "SymOff", typ: "Int128"}, // load 16 bytes from arg0+auxint+aux. arg1=mem - {name: "MOVOstore", reg: fpstore, asm: "MOVUPS", aux: "SymOff", typ: "Mem"}, // store 16 bytes in arg1 to arg0+auxint+aux. arg2=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. diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 089adfdec2..219d526cad 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -260,17 +260,20 @@ const ( OpAMD64MOVLQSXload OpAMD64MOVLQZXload OpAMD64MOVQload - OpAMD64MOVQloadidx8 OpAMD64MOVBstore OpAMD64MOVWstore OpAMD64MOVLstore OpAMD64MOVQstore + OpAMD64MOVOload + OpAMD64MOVOstore + OpAMD64MOVBloadidx1 + OpAMD64MOVWloadidx2 + OpAMD64MOVLloadidx4 + OpAMD64MOVQloadidx8 OpAMD64MOVBstoreidx1 OpAMD64MOVWstoreidx2 OpAMD64MOVLstoreidx4 OpAMD64MOVQstoreidx8 - OpAMD64MOVOload - OpAMD64MOVOstore OpAMD64MOVBstoreconst OpAMD64MOVWstoreconst OpAMD64MOVLstoreconst @@ -3129,20 +3132,6 @@ var opcodeTable = [...]opInfo{ }, }, }, - { - name: "MOVQloadidx8", - auxType: auxSymOff, - 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: "MOVBstore", auxType: auxSymOff, @@ -3188,45 +3177,89 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVBstoreidx1", + name: "MOVOload", + auxType: auxSymOff, + 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, + 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, 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 }, + outputs: []regMask{ + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, }, }, { - name: "MOVWstoreidx2", + name: "MOVWloadidx2", auxType: auxSymOff, 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 }, + outputs: []regMask{ + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, }, }, { - name: "MOVLstoreidx4", + name: "MOVLloadidx4", auxType: auxSymOff, 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 }, + outputs: []regMask{ + 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 + }, }, }, { - name: "MOVQstoreidx8", + name: "MOVQloadidx8", auxType: auxSymOff, 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, + 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 @@ -3236,25 +3269,37 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVOload", + name: "MOVWstoreidx2", auxType: auxSymOff, - asm: x86.AMOVUPS, + 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 }, - outputs: []regMask{ - 4294901760, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15 + }, + }, + { + name: "MOVLstoreidx4", + auxType: auxSymOff, + 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: "MOVOstore", + name: "MOVQstoreidx8", auxType: auxSymOff, - asm: x86.AMOVUPS, + asm: x86.AMOVQ, reg: regInfo{ inputs: []inputInfo{ - {1, 4294901760}, // .X0 .X1 .X2 .X3 .X4 .X5 .X6 .X7 .X8 .X9 .X10 .X11 .X12 .X13 .X14 .X15 + {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 }, }, diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 965e9a56dc..beaf0acc7f 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -329,6 +329,8 @@ func rewriteValueAMD64(v *Value, config *Config) bool { 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: @@ -341,6 +343,8 @@ func rewriteValueAMD64(v *Value, config *Config) bool { 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: @@ -383,6 +387,8 @@ func rewriteValueAMD64(v *Value, config *Config) bool { 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: @@ -1014,6 +1020,154 @@ endca635e3bdecd9e3aeb892f841021dfaa: } goto endc02313d35a0525d1d680cd58992e820d endc02313d35a0525d1d680cd58992e820d: + ; + // match: (ADDQ x (SHLQconst [2] y)) + // cond: + // result: (LEAQ4 x y) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64SHLQconst { + goto end153955fe292c5ecb20b76bba7da8f451 + } + if v.Args[1].AuxInt != 2 { + goto end153955fe292c5ecb20b76bba7da8f451 + } + y := v.Args[1].Args[0] + v.reset(OpAMD64LEAQ4) + v.AddArg(x) + v.AddArg(y) + return true + } + goto end153955fe292c5ecb20b76bba7da8f451 +end153955fe292c5ecb20b76bba7da8f451: + ; + // match: (ADDQ x (SHLQconst [1] y)) + // cond: + // result: (LEAQ2 x y) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64SHLQconst { + goto enda863d175a7a59f03d4306df57e8351f6 + } + if v.Args[1].AuxInt != 1 { + goto enda863d175a7a59f03d4306df57e8351f6 + } + y := v.Args[1].Args[0] + v.reset(OpAMD64LEAQ2) + v.AddArg(x) + v.AddArg(y) + return true + } + goto enda863d175a7a59f03d4306df57e8351f6 +enda863d175a7a59f03d4306df57e8351f6: + ; + // match: (ADDQ x (ADDQ y y)) + // cond: + // result: (LEAQ2 x y) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64ADDQ { + goto endf7dd9841c41eec66eddd351ee39cfbf3 + } + y := v.Args[1].Args[0] + if v.Args[1].Args[1] != y { + goto endf7dd9841c41eec66eddd351ee39cfbf3 + } + v.reset(OpAMD64LEAQ2) + v.AddArg(x) + v.AddArg(y) + return true + } + goto endf7dd9841c41eec66eddd351ee39cfbf3 +endf7dd9841c41eec66eddd351ee39cfbf3: + ; + // match: (ADDQ x (ADDQ x y)) + // cond: + // result: (LEAQ2 y x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64ADDQ { + goto end5547794ce29adef7d31260653a56bcb5 + } + if v.Args[1].Args[0] != x { + goto end5547794ce29adef7d31260653a56bcb5 + } + y := v.Args[1].Args[1] + v.reset(OpAMD64LEAQ2) + v.AddArg(y) + v.AddArg(x) + return true + } + goto end5547794ce29adef7d31260653a56bcb5 +end5547794ce29adef7d31260653a56bcb5: + ; + // match: (ADDQ x (ADDQ y x)) + // cond: + // result: (LEAQ2 y x) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64ADDQ { + goto end0ef5fb7590c377b6274991aaea41fae2 + } + y := v.Args[1].Args[0] + if v.Args[1].Args[1] != x { + goto end0ef5fb7590c377b6274991aaea41fae2 + } + v.reset(OpAMD64LEAQ2) + v.AddArg(y) + v.AddArg(x) + return true + } + goto end0ef5fb7590c377b6274991aaea41fae2 +end0ef5fb7590c377b6274991aaea41fae2: + ; + // match: (ADDQ x (LEAQ [c] {s} y)) + // cond: x.Op != OpSB && y.Op != OpSB + // result: (LEAQ1 [c] {s} x y) + { + x := v.Args[0] + if v.Args[1].Op != OpAMD64LEAQ { + goto endadc48e1a7f3d0a3505b68ffc771bb086 + } + c := v.Args[1].AuxInt + s := v.Args[1].Aux + y := v.Args[1].Args[0] + if !(x.Op != OpSB && y.Op != OpSB) { + goto endadc48e1a7f3d0a3505b68ffc771bb086 + } + v.reset(OpAMD64LEAQ1) + v.AuxInt = c + v.Aux = s + v.AddArg(x) + v.AddArg(y) + return true + } + goto endadc48e1a7f3d0a3505b68ffc771bb086 +endadc48e1a7f3d0a3505b68ffc771bb086: + ; + // match: (ADDQ (LEAQ [c] {s} x) y) + // cond: x.Op != OpSB && y.Op != OpSB + // result: (LEAQ1 [c] {s} x y) + { + if v.Args[0].Op != OpAMD64LEAQ { + goto end2696de9ef8f27dbc96dd4ad5878b0779 + } + 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) { + goto end2696de9ef8f27dbc96dd4ad5878b0779 + } + v.reset(OpAMD64LEAQ1) + v.AuxInt = c + v.Aux = s + v.AddArg(x) + v.AddArg(y) + return true + } + goto end2696de9ef8f27dbc96dd4ad5878b0779 +end2696de9ef8f27dbc96dd4ad5878b0779: ; // match: (ADDQ x (NEGQ y)) // cond: @@ -1037,25 +1191,113 @@ endec8f899c6e175a0147a90750f9bfe0a2: func rewriteValueAMD64_OpAMD64ADDQconst(v *Value, config *Config) bool { b := v.Block _ = b - // match: (ADDQconst [c] (LEAQ8 [d] x y)) + // match: (ADDQconst [c] (LEAQ [d] {s} x)) + // cond: + // result: (LEAQ [c+d] {s} x) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64LEAQ { + goto end5bfebc265098e6e57905269bb95daa3f + } + 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 + } + goto end5bfebc265098e6e57905269bb95daa3f +end5bfebc265098e6e57905269bb95daa3f: + ; + // match: (ADDQconst [c] (LEAQ1 [d] {s} x y)) + // cond: + // result: (LEAQ1 [c+d] {s} x y) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64LEAQ1 { + goto end71505b5ee2217f51c50569efc37499e7 + } + 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 + } + goto end71505b5ee2217f51c50569efc37499e7 +end71505b5ee2217f51c50569efc37499e7: + ; + // match: (ADDQconst [c] (LEAQ2 [d] {s} x y)) + // cond: + // result: (LEAQ2 [c+d] {s} x y) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64LEAQ2 { + goto end9f155ec07598aec52f602a92a5d719a9 + } + 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 + } + goto end9f155ec07598aec52f602a92a5d719a9 +end9f155ec07598aec52f602a92a5d719a9: + ; + // match: (ADDQconst [c] (LEAQ4 [d] {s} x y)) + // cond: + // result: (LEAQ4 [c+d] {s} x y) + { + c := v.AuxInt + if v.Args[0].Op != OpAMD64LEAQ4 { + goto end95f58aac9e8ea7efaef2bec6400cf7f8 + } + 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 + } + goto end95f58aac9e8ea7efaef2bec6400cf7f8 +end95f58aac9e8ea7efaef2bec6400cf7f8: + ; + // match: (ADDQconst [c] (LEAQ8 [d] {s} x y)) // cond: - // result: (LEAQ8 [addOff(c, d)] x y) + // result: (LEAQ8 [c+d] {s} x y) { c := v.AuxInt if v.Args[0].Op != OpAMD64LEAQ8 { - goto ende2cc681c9abf9913288803fb1b39e639 + goto end9d4328824aff954a1f47f1109500e826 } 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 = addOff(c, d) + v.AuxInt = c + d + v.Aux = s v.AddArg(x) v.AddArg(y) return true } - goto ende2cc681c9abf9913288803fb1b39e639 -ende2cc681c9abf9913288803fb1b39e639: + goto end9d4328824aff954a1f47f1109500e826 +end9d4328824aff954a1f47f1109500e826: ; // match: (ADDQconst [0] x) // cond: @@ -4209,6 +4451,50 @@ end02799ad95fe7fb5ce3c2c8ab313b737c: 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) + { + c := v.AuxInt + s := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto endb764d049517eb7c125b442ec9246c2c6 + } + 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 + } + goto endb764d049517eb7c125b442ec9246c2c6 +endb764d049517eb7c125b442ec9246c2c6: + ; + // match: (LEAQ [c] {s} (ADDQ x y)) + // cond: x.Op != OpSB && y.Op != OpSB + // result: (LEAQ1 [c] {s} x y) + { + c := v.AuxInt + s := v.Aux + if v.Args[0].Op != OpAMD64ADDQ { + goto end8ee88dfb1a197184ebe10e479fafd322 + } + x := v.Args[0].Args[0] + y := v.Args[0].Args[1] + if !(x.Op != OpSB && y.Op != OpSB) { + goto end8ee88dfb1a197184ebe10e479fafd322 + } + v.reset(OpAMD64LEAQ1) + v.AuxInt = c + v.Aux = s + v.AddArg(x) + v.AddArg(y) + return true + } + goto end8ee88dfb1a197184ebe10e479fafd322 +end8ee88dfb1a197184ebe10e479fafd322: + ; // match: (LEAQ [off1] {sym1} (LEAQ [off2] {sym2} x)) // cond: canMergeSym(sym1, sym2) // result: (LEAQ [addOff(off1,off2)] {mergeSym(sym1,sym2)} x) @@ -4342,6 +4628,56 @@ endc051937df5f12598e76c0923b5a60a39: 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) + { + c := v.AuxInt + s := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto endcee67e6c005f58a521fc4f33a98b11c6 + } + d := v.Args[0].AuxInt + x := v.Args[0].Args[0] + y := v.Args[1] + if !(x.Op != OpSB) { + goto endcee67e6c005f58a521fc4f33a98b11c6 + } + v.reset(OpAMD64LEAQ1) + v.AuxInt = c + d + v.Aux = s + v.AddArg(x) + v.AddArg(y) + return true + } + goto endcee67e6c005f58a521fc4f33a98b11c6 +endcee67e6c005f58a521fc4f33a98b11c6: + ; + // match: (LEAQ1 [c] {s} x (ADDQconst [d] y)) + // cond: y.Op != OpSB + // result: (LEAQ1 [c+d] {s} x y) + { + c := v.AuxInt + s := v.Aux + x := v.Args[0] + if v.Args[1].Op != OpAMD64ADDQconst { + goto end8ae759893af2b32c6dbcdeeca12ca207 + } + d := v.Args[1].AuxInt + y := v.Args[1].Args[0] + if !(y.Op != OpSB) { + goto end8ae759893af2b32c6dbcdeeca12ca207 + } + v.reset(OpAMD64LEAQ1) + v.AuxInt = c + d + v.Aux = s + v.AddArg(x) + v.AddArg(y) + return true + } + goto end8ae759893af2b32c6dbcdeeca12ca207 +end8ae759893af2b32c6dbcdeeca12ca207: + ; // 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) @@ -4399,6 +4735,56 @@ endfd9dd9448d726fc7d82274b404cddb67: 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) + { + c := v.AuxInt + s := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto end32327450a43437ef98ffba85d4f64808 + } + d := v.Args[0].AuxInt + x := v.Args[0].Args[0] + y := v.Args[1] + if !(x.Op != OpSB) { + goto end32327450a43437ef98ffba85d4f64808 + } + v.reset(OpAMD64LEAQ2) + v.AuxInt = c + d + v.Aux = s + v.AddArg(x) + v.AddArg(y) + return true + } + goto end32327450a43437ef98ffba85d4f64808 +end32327450a43437ef98ffba85d4f64808: + ; + // match: (LEAQ2 [c] {s} x (ADDQconst [d] y)) + // cond: y.Op != OpSB + // result: (LEAQ2 [c+2*d] {s} x y) + { + c := v.AuxInt + s := v.Aux + x := v.Args[0] + if v.Args[1].Op != OpAMD64ADDQconst { + goto end86e05a0977fd26c884c75b29625c6236 + } + d := v.Args[1].AuxInt + y := v.Args[1].Args[0] + if !(y.Op != OpSB) { + goto end86e05a0977fd26c884c75b29625c6236 + } + v.reset(OpAMD64LEAQ2) + v.AuxInt = c + 2*d + v.Aux = s + v.AddArg(x) + v.AddArg(y) + return true + } + goto end86e05a0977fd26c884c75b29625c6236 +end86e05a0977fd26c884c75b29625c6236: + ; // 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) @@ -4430,14 +4816,64 @@ end2bf3cb6e212c3f62ab83ce10059e672e: func rewriteValueAMD64_OpAMD64LEAQ4(v *Value, config *Config) bool { b := v.Block _ = b - // 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) + // match: (LEAQ4 [c] {s} (ADDQconst [d] x) y) + // cond: x.Op != OpSB + // result: (LEAQ4 [c+d] {s} x y) { - off1 := v.AuxInt - sym1 := v.Aux - if v.Args[0].Op != OpAMD64LEAQ { - goto end066907f169f09e56139e801397316c95 + c := v.AuxInt + s := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto end2225ec635a27f55cd2e4ddaf3bebdf5b + } + d := v.Args[0].AuxInt + x := v.Args[0].Args[0] + y := v.Args[1] + if !(x.Op != OpSB) { + goto end2225ec635a27f55cd2e4ddaf3bebdf5b + } + v.reset(OpAMD64LEAQ4) + v.AuxInt = c + d + v.Aux = s + v.AddArg(x) + v.AddArg(y) + return true + } + goto end2225ec635a27f55cd2e4ddaf3bebdf5b +end2225ec635a27f55cd2e4ddaf3bebdf5b: + ; + // match: (LEAQ4 [c] {s} x (ADDQconst [d] y)) + // cond: y.Op != OpSB + // result: (LEAQ4 [c+4*d] {s} x y) + { + c := v.AuxInt + s := v.Aux + x := v.Args[0] + if v.Args[1].Op != OpAMD64ADDQconst { + goto endd198c6d7b0038f43476fe50d886ed76b + } + d := v.Args[1].AuxInt + y := v.Args[1].Args[0] + if !(y.Op != OpSB) { + goto endd198c6d7b0038f43476fe50d886ed76b + } + v.reset(OpAMD64LEAQ4) + v.AuxInt = c + 4*d + v.Aux = s + v.AddArg(x) + v.AddArg(y) + return true + } + goto endd198c6d7b0038f43476fe50d886ed76b +endd198c6d7b0038f43476fe50d886ed76b: + ; + // 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) + { + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ { + goto end066907f169f09e56139e801397316c95 } off2 := v.Args[0].AuxInt sym2 := v.Args[0].Aux @@ -4461,6 +4897,56 @@ end066907f169f09e56139e801397316c95: 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) + { + c := v.AuxInt + s := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto end26e798ad0167e205b8c670f19cef8122 + } + d := v.Args[0].AuxInt + x := v.Args[0].Args[0] + y := v.Args[1] + if !(x.Op != OpSB) { + goto end26e798ad0167e205b8c670f19cef8122 + } + v.reset(OpAMD64LEAQ8) + v.AuxInt = c + d + v.Aux = s + v.AddArg(x) + v.AddArg(y) + return true + } + goto end26e798ad0167e205b8c670f19cef8122 +end26e798ad0167e205b8c670f19cef8122: + ; + // match: (LEAQ8 [c] {s} x (ADDQconst [d] y)) + // cond: y.Op != OpSB + // result: (LEAQ8 [c+8*d] {s} x y) + { + c := v.AuxInt + s := v.Aux + x := v.Args[0] + if v.Args[1].Op != OpAMD64ADDQconst { + goto end85f87ffff7b951c1d085198e3bee2f09 + } + d := v.Args[1].AuxInt + y := v.Args[1].Args[0] + if !(y.Op != OpSB) { + goto end85f87ffff7b951c1d085198e3bee2f09 + } + v.reset(OpAMD64LEAQ8) + v.AuxInt = c + 8*d + v.Aux = s + v.AddArg(x) + v.AddArg(y) + return true + } + goto end85f87ffff7b951c1d085198e3bee2f09 +end85f87ffff7b951c1d085198e3bee2f09: + ; // 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) @@ -5697,6 +6183,113 @@ end7ec9147ab863c1bd59190fed81f894b6: } goto end3771a59cf66b0df99120d76f4c358fab end3771a59cf66b0df99120d76f4c358fab: + ; + // 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) + { + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ1 { + goto endb5e38220bc6108fb683f1f1e46853bd9 + } + 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)) { + goto endb5e38220bc6108fb683f1f1e46853bd9 + } + v.reset(OpAMD64MOVBloadidx1) + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(ptr) + v.AddArg(idx) + v.AddArg(mem) + return true + } + goto endb5e38220bc6108fb683f1f1e46853bd9 +endb5e38220bc6108fb683f1f1e46853bd9: + ; + // match: (MOVBload [off] {sym} (ADDQ ptr idx) mem) + // cond: ptr.Op != OpSB + // result: (MOVBloadidx1 [off] {sym} ptr idx mem) + { + off := v.AuxInt + sym := v.Aux + if v.Args[0].Op != OpAMD64ADDQ { + goto end2abf84efc0e06ed9cda71fb8a1ffaacd + } + ptr := v.Args[0].Args[0] + idx := v.Args[0].Args[1] + mem := v.Args[1] + if !(ptr.Op != OpSB) { + goto end2abf84efc0e06ed9cda71fb8a1ffaacd + } + v.reset(OpAMD64MOVBloadidx1) + v.AuxInt = off + v.Aux = sym + v.AddArg(ptr) + v.AddArg(idx) + v.AddArg(mem) + return true + } + goto end2abf84efc0e06ed9cda71fb8a1ffaacd +end2abf84efc0e06ed9cda71fb8a1ffaacd: + ; + 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) + { + c := v.AuxInt + sym := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto end287a4eb26a59b5f23efa2c6df34711f7 + } + 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 + } + goto end287a4eb26a59b5f23efa2c6df34711f7 +end287a4eb26a59b5f23efa2c6df34711f7: + ; + // match: (MOVBloadidx1 [c] {sym} ptr (ADDQconst [d] idx) mem) + // cond: + // result: (MOVBloadidx1 [c+d] {sym} ptr idx mem) + { + c := v.AuxInt + sym := v.Aux + ptr := v.Args[0] + if v.Args[1].Op != OpAMD64ADDQconst { + goto end3d2e4e850c5e8129cd71a8693403b6c1 + } + 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 + } + goto end3d2e4e850c5e8129cd71a8693403b6c1 +end3d2e4e850c5e8129cd71a8693403b6c1: ; return false } @@ -5857,18 +6450,21 @@ enda7086cf7f6b8cf81972e2c3d4b12f3fc: ende386ced77f1acdae2e8bbc379803b7cf: ; // match: (MOVBstore [off] {sym} (ADDQ ptr idx) val mem) - // cond: + // cond: ptr.Op != OpSB // result: (MOVBstoreidx1 [off] {sym} ptr idx val mem) { off := v.AuxInt sym := v.Aux if v.Args[0].Op != OpAMD64ADDQ { - goto endc7abfa0b473c622e6d5aa3b1846fb2b7 + goto endb43afe2024f68e41f2538876c4bf49cc } ptr := v.Args[0].Args[0] idx := v.Args[0].Args[1] val := v.Args[1] mem := v.Args[2] + if !(ptr.Op != OpSB) { + goto endb43afe2024f68e41f2538876c4bf49cc + } v.reset(OpAMD64MOVBstoreidx1) v.AuxInt = off v.Aux = sym @@ -5878,8 +6474,8 @@ ende386ced77f1acdae2e8bbc379803b7cf: v.AddArg(mem) return true } - goto endc7abfa0b473c622e6d5aa3b1846fb2b7 -endc7abfa0b473c622e6d5aa3b1846fb2b7: + goto endb43afe2024f68e41f2538876c4bf49cc +endb43afe2024f68e41f2538876c4bf49cc: ; return false } @@ -5942,22 +6538,22 @@ end8deb839acf84818dd8fc827c0338f42c: func rewriteValueAMD64_OpAMD64MOVBstoreidx1(v *Value, config *Config) bool { b := v.Block _ = b - // match: (MOVBstoreidx1 [off1] {sym} (ADDQconst [off2] ptr) idx val mem) + // match: (MOVBstoreidx1 [c] {sym} (ADDQconst [d] ptr) idx val mem) // cond: - // result: (MOVBstoreidx1 [addOff(off1, off2)] {sym} ptr idx val mem) + // result: (MOVBstoreidx1 [c+d] {sym} ptr idx val mem) { - off1 := v.AuxInt + c := v.AuxInt sym := v.Aux if v.Args[0].Op != OpAMD64ADDQconst { - goto endba611397b0dfd416156f29d7bd95b945 + goto end5e07185968f39170e41a237cc6258752 } - off2 := v.Args[0].AuxInt + 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 = addOff(off1, off2) + v.AuxInt = c + d v.Aux = sym v.AddArg(ptr) v.AddArg(idx) @@ -5965,8 +6561,34 @@ func rewriteValueAMD64_OpAMD64MOVBstoreidx1(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto endba611397b0dfd416156f29d7bd95b945 -endba611397b0dfd416156f29d7bd95b945: + goto end5e07185968f39170e41a237cc6258752 +end5e07185968f39170e41a237cc6258752: + ; + // match: (MOVBstoreidx1 [c] {sym} ptr (ADDQconst [d] idx) val mem) + // cond: + // result: (MOVBstoreidx1 [c+d] {sym} ptr idx val mem) + { + c := v.AuxInt + sym := v.Aux + ptr := v.Args[0] + if v.Args[1].Op != OpAMD64ADDQconst { + goto endf1e4b8d5da2530ca81e2c01dc2892875 + } + 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 + } + goto endf1e4b8d5da2530ca81e2c01dc2892875 +endf1e4b8d5da2530ca81e2c01dc2892875: ; return false } @@ -6113,6 +6735,87 @@ end0c8b8a40360c5c581d92723eca04d340: } goto enddb9e59335876d8a565c425731438a1b3 enddb9e59335876d8a565c425731438a1b3: + ; + // 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) + { + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ4 { + goto end6eed46982cfbceace4784afdf29ba2b9 + } + 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)) { + goto end6eed46982cfbceace4784afdf29ba2b9 + } + v.reset(OpAMD64MOVLloadidx4) + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(ptr) + v.AddArg(idx) + v.AddArg(mem) + return true + } + goto end6eed46982cfbceace4784afdf29ba2b9 +end6eed46982cfbceace4784afdf29ba2b9: + ; + 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) + { + c := v.AuxInt + sym := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto endcafad33c3669685fdfee020f111fdcb6 + } + 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 + } + goto endcafad33c3669685fdfee020f111fdcb6 +endcafad33c3669685fdfee020f111fdcb6: + ; + // match: (MOVLloadidx4 [c] {sym} ptr (ADDQconst [d] idx) mem) + // cond: + // result: (MOVLloadidx4 [c+4*d] {sym} ptr idx mem) + { + c := v.AuxInt + sym := v.Aux + ptr := v.Args[0] + if v.Args[1].Op != OpAMD64ADDQconst { + goto endfb8f54bfe07226dcb7d4e2d6df319707 + } + 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 + } + goto endfb8f54bfe07226dcb7d4e2d6df319707 +endfb8f54bfe07226dcb7d4e2d6df319707: ; return false } @@ -6333,22 +7036,22 @@ endd579250954b5df84a77518b36f739e12: func rewriteValueAMD64_OpAMD64MOVLstoreidx4(v *Value, config *Config) bool { b := v.Block _ = b - // match: (MOVLstoreidx4 [off1] {sym} (ADDQconst [off2] ptr) idx val mem) + // match: (MOVLstoreidx4 [c] {sym} (ADDQconst [d] ptr) idx val mem) // cond: - // result: (MOVLstoreidx4 [addOff(off1, off2)] {sym} ptr idx val mem) + // result: (MOVLstoreidx4 [c+d] {sym} ptr idx val mem) { - off1 := v.AuxInt + c := v.AuxInt sym := v.Aux if v.Args[0].Op != OpAMD64ADDQconst { - goto endf4921486b8eca2abd4a92ffadc6cb52d + goto endd72a73ada3e68139d21049bd337bcfd2 } - off2 := v.Args[0].AuxInt + 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 = addOff(off1, off2) + v.AuxInt = c + d v.Aux = sym v.AddArg(ptr) v.AddArg(idx) @@ -6356,8 +7059,34 @@ func rewriteValueAMD64_OpAMD64MOVLstoreidx4(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto endf4921486b8eca2abd4a92ffadc6cb52d -endf4921486b8eca2abd4a92ffadc6cb52d: + goto endd72a73ada3e68139d21049bd337bcfd2 +endd72a73ada3e68139d21049bd337bcfd2: + ; + // match: (MOVLstoreidx4 [c] {sym} ptr (ADDQconst [d] idx) val mem) + // cond: + // result: (MOVLstoreidx4 [c+4*d] {sym} ptr idx val mem) + { + c := v.AuxInt + sym := v.Aux + ptr := v.Args[0] + if v.Args[1].Op != OpAMD64ADDQconst { + goto endea783679ed46542bc48309b9fd2f6054 + } + 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 + } + goto endea783679ed46542bc48309b9fd2f6054 +endea783679ed46542bc48309b9fd2f6054: ; return false } @@ -6555,29 +7284,53 @@ end74a50d810fb3945e809f608cd094a59c: func rewriteValueAMD64_OpAMD64MOVQloadidx8(v *Value, config *Config) bool { b := v.Block _ = b - // match: (MOVQloadidx8 [off1] {sym} (ADDQconst [off2] ptr) idx mem) + // match: (MOVQloadidx8 [c] {sym} (ADDQconst [d] ptr) idx mem) // cond: - // result: (MOVQloadidx8 [addOff(off1, off2)] {sym} ptr idx mem) + // result: (MOVQloadidx8 [c+d] {sym} ptr idx mem) { - off1 := v.AuxInt + c := v.AuxInt sym := v.Aux if v.Args[0].Op != OpAMD64ADDQconst { - goto endb138bf9b0b33ec824bf0aff619f8bafa + goto end012c0c0292dbfd55f520e4d88d9247e4 } - off2 := v.Args[0].AuxInt + d := v.Args[0].AuxInt ptr := v.Args[0].Args[0] idx := v.Args[1] mem := v.Args[2] v.reset(OpAMD64MOVQloadidx8) - v.AuxInt = addOff(off1, off2) + v.AuxInt = c + d v.Aux = sym v.AddArg(ptr) v.AddArg(idx) v.AddArg(mem) return true } - goto endb138bf9b0b33ec824bf0aff619f8bafa -endb138bf9b0b33ec824bf0aff619f8bafa: + goto end012c0c0292dbfd55f520e4d88d9247e4 +end012c0c0292dbfd55f520e4d88d9247e4: + ; + // match: (MOVQloadidx8 [c] {sym} ptr (ADDQconst [d] idx) mem) + // cond: + // result: (MOVQloadidx8 [c+8*d] {sym} ptr idx mem) + { + c := v.AuxInt + sym := v.Aux + ptr := v.Args[0] + if v.Args[1].Op != OpAMD64ADDQconst { + goto endd36e82450f4737c06501b7bc9e881d13 + } + 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 + } + goto endd36e82450f4737c06501b7bc9e881d13 +endd36e82450f4737c06501b7bc9e881d13: ; return false } @@ -6752,22 +7505,22 @@ endf405b27b22dbf76f83abd1b5ad5e53d9: func rewriteValueAMD64_OpAMD64MOVQstoreidx8(v *Value, config *Config) bool { b := v.Block _ = b - // match: (MOVQstoreidx8 [off1] {sym} (ADDQconst [off2] ptr) idx val mem) + // match: (MOVQstoreidx8 [c] {sym} (ADDQconst [d] ptr) idx val mem) // cond: - // result: (MOVQstoreidx8 [addOff(off1, off2)] {sym} ptr idx val mem) + // result: (MOVQstoreidx8 [c+d] {sym} ptr idx val mem) { - off1 := v.AuxInt + c := v.AuxInt sym := v.Aux if v.Args[0].Op != OpAMD64ADDQconst { - goto end50671766fdab364c1edbd2072fb8e525 + goto end775cfe4359adc4bffc346289df14bbc3 } - off2 := v.Args[0].AuxInt + 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 = addOff(off1, off2) + v.AuxInt = c + d v.Aux = sym v.AddArg(ptr) v.AddArg(idx) @@ -6775,8 +7528,34 @@ func rewriteValueAMD64_OpAMD64MOVQstoreidx8(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto end50671766fdab364c1edbd2072fb8e525 -end50671766fdab364c1edbd2072fb8e525: + goto end775cfe4359adc4bffc346289df14bbc3 +end775cfe4359adc4bffc346289df14bbc3: + ; + // match: (MOVQstoreidx8 [c] {sym} ptr (ADDQconst [d] idx) val mem) + // cond: + // result: (MOVQstoreidx8 [c+8*d] {sym} ptr idx val mem) + { + c := v.AuxInt + sym := v.Aux + ptr := v.Args[0] + if v.Args[1].Op != OpAMD64ADDQconst { + goto end20281fb6ccf09a9b56abdba46f443232 + } + 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 + } + goto end20281fb6ccf09a9b56abdba46f443232 +end20281fb6ccf09a9b56abdba46f443232: ; return false } @@ -6864,32 +7643,53 @@ endbcb2ce441824d0e3a4b501018cfa7f60: func rewriteValueAMD64_OpAMD64MOVSDloadidx8(v *Value, config *Config) bool { b := v.Block _ = b - // match: (MOVSDloadidx8 [off1] {sym} (ADDQconst [off2] {sym} ptr) idx mem) + // match: (MOVSDloadidx8 [c] {sym} (ADDQconst [d] ptr) idx mem) // cond: - // result: (MOVSDloadidx8 [addOff(off1, off2)] {sym} ptr idx mem) + // result: (MOVSDloadidx8 [c+d] {sym} ptr idx mem) { - off1 := v.AuxInt + c := v.AuxInt sym := v.Aux if v.Args[0].Op != OpAMD64ADDQconst { - goto end84f0f457e271104a92343e3b1d2804c6 - } - off2 := v.Args[0].AuxInt - if v.Args[0].Aux != v.Aux { - goto end84f0f457e271104a92343e3b1d2804c6 + goto endb313602cfa64c282cc86c27c7183c507 } + d := v.Args[0].AuxInt ptr := v.Args[0].Args[0] idx := v.Args[1] mem := v.Args[2] v.reset(OpAMD64MOVSDloadidx8) - v.AuxInt = addOff(off1, off2) + v.AuxInt = c + d v.Aux = sym v.AddArg(ptr) v.AddArg(idx) v.AddArg(mem) return true } - goto end84f0f457e271104a92343e3b1d2804c6 -end84f0f457e271104a92343e3b1d2804c6: + goto endb313602cfa64c282cc86c27c7183c507 +endb313602cfa64c282cc86c27c7183c507: + ; + // match: (MOVSDloadidx8 [c] {sym} ptr (ADDQconst [d] idx) mem) + // cond: + // result: (MOVSDloadidx8 [c+8*d] {sym} ptr idx mem) + { + c := v.AuxInt + sym := v.Aux + ptr := v.Args[0] + if v.Args[1].Op != OpAMD64ADDQconst { + goto endfb406e2cba383116291b60825765637c + } + 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 + } + goto endfb406e2cba383116291b60825765637c +endfb406e2cba383116291b60825765637c: ; return false } @@ -6983,25 +7783,22 @@ end1ad6fc0c5b59610dabf7f9595a48a230: func rewriteValueAMD64_OpAMD64MOVSDstoreidx8(v *Value, config *Config) bool { b := v.Block _ = b - // match: (MOVSDstoreidx8 [off1] {sym} (ADDQconst [off2] {sym} ptr) idx val mem) + // match: (MOVSDstoreidx8 [c] {sym} (ADDQconst [d] ptr) idx val mem) // cond: - // result: (MOVSDstoreidx8 [addOff(off1, off2)] {sym} ptr idx val mem) + // result: (MOVSDstoreidx8 [c+d] {sym} ptr idx val mem) { - off1 := v.AuxInt + c := v.AuxInt sym := v.Aux if v.Args[0].Op != OpAMD64ADDQconst { - goto endc0e28f57697cb6038d5d09eafe26c947 - } - off2 := v.Args[0].AuxInt - if v.Args[0].Aux != v.Aux { - goto endc0e28f57697cb6038d5d09eafe26c947 + goto end8b8f41236593d5d5e83663cc14350fe8 } + 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 = addOff(off1, off2) + v.AuxInt = c + d v.Aux = sym v.AddArg(ptr) v.AddArg(idx) @@ -7009,8 +7806,34 @@ func rewriteValueAMD64_OpAMD64MOVSDstoreidx8(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto endc0e28f57697cb6038d5d09eafe26c947 -endc0e28f57697cb6038d5d09eafe26c947: + goto end8b8f41236593d5d5e83663cc14350fe8 +end8b8f41236593d5d5e83663cc14350fe8: + ; + // match: (MOVSDstoreidx8 [c] {sym} ptr (ADDQconst [d] idx) val mem) + // cond: + // result: (MOVSDstoreidx8 [c+8*d] {sym} ptr idx val mem) + { + c := v.AuxInt + sym := v.Aux + ptr := v.Args[0] + if v.Args[1].Op != OpAMD64ADDQconst { + goto end94b7159715acb6ebb94b08b3a826f5fe + } + 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 + } + goto end94b7159715acb6ebb94b08b3a826f5fe +end94b7159715acb6ebb94b08b3a826f5fe: ; return false } @@ -7098,32 +7921,53 @@ end49722f4a0adba31bb143601ce1d2aae0: func rewriteValueAMD64_OpAMD64MOVSSloadidx4(v *Value, config *Config) bool { b := v.Block _ = b - // match: (MOVSSloadidx4 [off1] {sym} (ADDQconst [off2] {sym} ptr) idx mem) + // match: (MOVSSloadidx4 [c] {sym} (ADDQconst [d] ptr) idx mem) // cond: - // result: (MOVSSloadidx4 [addOff(off1, off2)] {sym} ptr idx mem) + // result: (MOVSSloadidx4 [c+d] {sym} ptr idx mem) { - off1 := v.AuxInt + c := v.AuxInt sym := v.Aux if v.Args[0].Op != OpAMD64ADDQconst { - goto end7eb5a1ab1e2508683d879ec25286754b - } - off2 := v.Args[0].AuxInt - if v.Args[0].Aux != v.Aux { - goto end7eb5a1ab1e2508683d879ec25286754b + goto end2317614a112d773b1209327d552bb022 } + d := v.Args[0].AuxInt ptr := v.Args[0].Args[0] idx := v.Args[1] mem := v.Args[2] v.reset(OpAMD64MOVSSloadidx4) - v.AuxInt = addOff(off1, off2) + v.AuxInt = c + d v.Aux = sym v.AddArg(ptr) v.AddArg(idx) v.AddArg(mem) return true } - goto end7eb5a1ab1e2508683d879ec25286754b -end7eb5a1ab1e2508683d879ec25286754b: + goto end2317614a112d773b1209327d552bb022 +end2317614a112d773b1209327d552bb022: + ; + // match: (MOVSSloadidx4 [c] {sym} ptr (ADDQconst [d] idx) mem) + // cond: + // result: (MOVSSloadidx4 [c+4*d] {sym} ptr idx mem) + { + c := v.AuxInt + sym := v.Aux + ptr := v.Args[0] + if v.Args[1].Op != OpAMD64ADDQconst { + goto endd3063853eaa3813f3c95eedeba23e391 + } + 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 + } + goto endd3063853eaa3813f3c95eedeba23e391 +endd3063853eaa3813f3c95eedeba23e391: ; return false } @@ -7217,25 +8061,48 @@ end1622dc435e45833eda4d29d44df7cc34: func rewriteValueAMD64_OpAMD64MOVSSstoreidx4(v *Value, config *Config) bool { b := v.Block _ = b - // match: (MOVSSstoreidx4 [off1] {sym} (ADDQconst [off2] {sym} ptr) idx val mem) + // match: (MOVSSstoreidx4 [c] {sym} (ADDQconst [d] ptr) idx val mem) // cond: - // result: (MOVSSstoreidx4 [addOff(off1, off2)] {sym} ptr idx val mem) + // result: (MOVSSstoreidx4 [c+d] {sym} ptr idx val mem) { - off1 := v.AuxInt + c := v.AuxInt sym := v.Aux if v.Args[0].Op != OpAMD64ADDQconst { - goto end66e4853026306cd46f414c22d281254f - } - off2 := v.Args[0].AuxInt - if v.Args[0].Aux != v.Aux { - goto end66e4853026306cd46f414c22d281254f + goto end5995724dec9833993ca0b1c827919b6a } + 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 = addOff(off1, off2) + v.AuxInt = c + d + v.Aux = sym + v.AddArg(ptr) + v.AddArg(idx) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto end5995724dec9833993ca0b1c827919b6a +end5995724dec9833993ca0b1c827919b6a: + ; + // match: (MOVSSstoreidx4 [c] {sym} ptr (ADDQconst [d] idx) val mem) + // cond: + // result: (MOVSSstoreidx4 [c+4*d] {sym} ptr idx val mem) + { + c := v.AuxInt + sym := v.Aux + ptr := v.Args[0] + if v.Args[1].Op != OpAMD64ADDQconst { + goto endad50732309bcc958cffc54992194cdd6 + } + 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) @@ -7243,8 +8110,8 @@ func rewriteValueAMD64_OpAMD64MOVSSstoreidx4(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto end66e4853026306cd46f414c22d281254f -end66e4853026306cd46f414c22d281254f: + goto endad50732309bcc958cffc54992194cdd6 +endad50732309bcc958cffc54992194cdd6: ; return false } @@ -7391,6 +8258,87 @@ endfcb0ce76f96e8b0c2eb19a9b827c1b73: } goto end7a79314cb49bf53d79c38c3077d87457 end7a79314cb49bf53d79c38c3077d87457: + ; + // 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) + { + off1 := v.AuxInt + sym1 := v.Aux + if v.Args[0].Op != OpAMD64LEAQ2 { + goto end1a7be5e27e24f56f760b50d4d2f2a8da + } + 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)) { + goto end1a7be5e27e24f56f760b50d4d2f2a8da + } + v.reset(OpAMD64MOVWloadidx2) + v.AuxInt = addOff(off1, off2) + v.Aux = mergeSym(sym1, sym2) + v.AddArg(ptr) + v.AddArg(idx) + v.AddArg(mem) + return true + } + goto end1a7be5e27e24f56f760b50d4d2f2a8da +end1a7be5e27e24f56f760b50d4d2f2a8da: + ; + 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) + { + c := v.AuxInt + sym := v.Aux + if v.Args[0].Op != OpAMD64ADDQconst { + goto end1a8b9db99bc480ce4f8cc0fa0e6024ea + } + 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 + } + goto end1a8b9db99bc480ce4f8cc0fa0e6024ea +end1a8b9db99bc480ce4f8cc0fa0e6024ea: + ; + // match: (MOVWloadidx2 [c] {sym} ptr (ADDQconst [d] idx) mem) + // cond: + // result: (MOVWloadidx2 [c+2*d] {sym} ptr idx mem) + { + c := v.AuxInt + sym := v.Aux + ptr := v.Args[0] + if v.Args[1].Op != OpAMD64ADDQconst { + goto end38e4b4448cc3c61b0691bc11c61c7098 + } + 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 + } + goto end38e4b4448cc3c61b0691bc11c61c7098 +end38e4b4448cc3c61b0691bc11c61c7098: ; return false } @@ -7611,22 +8559,48 @@ endba47397e07b40a64fa4cad36ac2e32ad: func rewriteValueAMD64_OpAMD64MOVWstoreidx2(v *Value, config *Config) bool { b := v.Block _ = b - // match: (MOVWstoreidx2 [off1] {sym} (ADDQconst [off2] ptr) idx val mem) + // match: (MOVWstoreidx2 [c] {sym} (ADDQconst [d] ptr) idx val mem) // cond: - // result: (MOVWstoreidx2 [addOff(off1, off2)] {sym} ptr idx val mem) + // result: (MOVWstoreidx2 [c+d] {sym} ptr idx val mem) { - off1 := v.AuxInt + c := v.AuxInt sym := v.Aux if v.Args[0].Op != OpAMD64ADDQconst { - goto end7ab3a4fbfc9bac9d46ba72d40f667794 + goto end8e684d397fadfa1c3f0783597ca01cc7 } - off2 := v.Args[0].AuxInt + 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 = addOff(off1, off2) + v.AuxInt = c + d + v.Aux = sym + v.AddArg(ptr) + v.AddArg(idx) + v.AddArg(val) + v.AddArg(mem) + return true + } + goto end8e684d397fadfa1c3f0783597ca01cc7 +end8e684d397fadfa1c3f0783597ca01cc7: + ; + // match: (MOVWstoreidx2 [c] {sym} ptr (ADDQconst [d] idx) val mem) + // cond: + // result: (MOVWstoreidx2 [c+2*d] {sym} ptr idx val mem) + { + c := v.AuxInt + sym := v.Aux + ptr := v.Args[0] + if v.Args[1].Op != OpAMD64ADDQconst { + goto end9701df480a14263338b1d37a15b59eb5 + } + 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) @@ -7634,8 +8608,8 @@ func rewriteValueAMD64_OpAMD64MOVWstoreidx2(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto end7ab3a4fbfc9bac9d46ba72d40f667794 -end7ab3a4fbfc9bac9d46ba72d40f667794: + goto end9701df480a14263338b1d37a15b59eb5 +end9701df480a14263338b1d37a15b59eb5: ; return false } diff --git a/src/cmd/compile/internal/ssa/value.go b/src/cmd/compile/internal/ssa/value.go index d71fd8fb87..0d6c19b80a 100644 --- a/src/cmd/compile/internal/ssa/value.go +++ b/src/cmd/compile/internal/ssa/value.go @@ -117,7 +117,7 @@ func (v *Value) LongString() string { if v.Aux != nil { s += fmt.Sprintf(" {%s}", v.Aux) } - s += fmt.Sprintf(" [%s]", v.AuxInt) + s += fmt.Sprintf(" [%d]", v.AuxInt) case auxSymValAndOff: if v.Aux != nil { s += fmt.Sprintf(" {%s}", v.Aux) -- cgit v1.3 From 0543447597d54de911bd1e02369a0b191849b4bd Mon Sep 17 00:00:00 2001 From: Alexandru Moșoi Date: Thu, 4 Feb 2016 19:52:10 +0100 Subject: [dev.ssa] cmd/compile/internal/ssa/gen: enclose rules' code in a for loop * Enclose each rule's code in a for with no condition * The loop is ran at most once because it's always terminated by a return. * Use break when matching condition fails * Drop rule hashes * Shaves about 3 lines of code per rule The binary size is not afected. Change-Id: I27c3e40dc8cae98dcd50739342dc38db2ef9c247 Reviewed-on: https://go-review.googlesource.com/19220 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/gen/rulegen.go | 57 +- src/cmd/compile/internal/ssa/rewriteAMD64.go | 5378 +++++++----------------- src/cmd/compile/internal/ssa/rewritegeneric.go | 2291 ++++------ 3 files changed, 2253 insertions(+), 5473 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/gen/rulegen.go b/src/cmd/compile/internal/ssa/gen/rulegen.go index c39271eaa6..1a0f5d4b1e 100644 --- a/src/cmd/compile/internal/ssa/gen/rulegen.go +++ b/src/cmd/compile/internal/ssa/gen/rulegen.go @@ -12,7 +12,6 @@ package main import ( "bufio" "bytes" - "crypto/md5" "flag" "fmt" "go/format" @@ -59,10 +58,6 @@ func (r Rule) String() string { return fmt.Sprintf("rule %q at line %d", r.rule, r.lineno) } -func (r Rule) hash() string { - return fmt.Sprintf("%02x", md5.Sum([]byte(r.rule))) -} - // 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, "->") @@ -170,24 +165,16 @@ func genRules(arch arch) { fmt.Fprintln(w, "b := v.Block") fmt.Fprintln(w, "_ = b") for _, rule := range oprules[op] { - // Note: we use a hash to identify the rule so that its - // identity is invariant to adding/removing rules elsewhere - // in the rules file. This is useful to squash spurious - // diffs that would occur if we used rule index. - rulehash := rule.hash() - 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) - fail := fmt.Sprintf("{\ngoto end%s\n}\n", rulehash) - - fmt.Fprintf(w, "{\n") - genMatch(w, arch, match, fail) + fmt.Fprintf(w, "for {\n") + genMatch(w, arch, match) if cond != "" { - fmt.Fprintf(w, "if !(%s) %s", cond, fail) + fmt.Fprintf(w, "if !(%s) {\nbreak\n}\n", cond) } genResult(w, arch, result) @@ -197,8 +184,6 @@ func genRules(arch arch) { fmt.Fprintf(w, "return true\n") fmt.Fprintf(w, "}\n") - fmt.Fprintf(w, "goto end%s\n", rulehash) // use label - fmt.Fprintf(w, "end%s:;\n", rulehash) } fmt.Fprintf(w, "return false\n") fmt.Fprintf(w, "}\n") @@ -216,23 +201,19 @@ func genRules(arch arch) { for _, op := range ops { fmt.Fprintf(w, "case %s:\n", blockName(op, arch)) for _, rule := range blockrules[op] { - rulehash := rule.hash() - 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) - fail := fmt.Sprintf("{\ngoto end%s\n}\n", rulehash) - - fmt.Fprintf(w, "{\n") + 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", fail, map[string]string{}, false) + genMatch0(w, arch, s[1], "v", map[string]string{}, false) } // assign successor names @@ -244,7 +225,7 @@ func genRules(arch arch) { } if cond != "" { - fmt.Fprintf(w, "if !(%s) %s", cond, fail) + fmt.Fprintf(w, "if !(%s) {\nbreak\n}\n", cond) } // Rule matches. Generate result. @@ -306,8 +287,6 @@ func genRules(arch arch) { fmt.Fprintf(w, "return true\n") fmt.Fprintf(w, "}\n") - fmt.Fprintf(w, "goto end%s\n", rulehash) // use label - fmt.Fprintf(w, "end%s:;\n", rulehash) } } fmt.Fprintf(w, "}\n") @@ -329,18 +308,18 @@ func genRules(arch arch) { } } -func genMatch(w io.Writer, arch arch, match, fail string) { - genMatch0(w, arch, match, "v", fail, map[string]string{}, true) +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, fail string, m map[string]string, top bool) { +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 %s", v, match, fail) + fmt.Fprintf(w, "if %s != %s {\nbreak\n}\n", v, match) return } // remember that this variable references the given value @@ -358,7 +337,7 @@ func genMatch0(w io.Writer, arch arch, match, v, fail string, m map[string]strin // check op if !top { - fmt.Fprintf(w, "if %s.Op != %s %s", v, opName(s[0], arch), fail) + fmt.Fprintf(w, "if %s.Op != %s {\nbreak\n}\n", v, opName(s[0], arch)) } // check type/aux/args @@ -369,12 +348,12 @@ func genMatch0(w io.Writer, arch arch, match, v, fail string, m map[string]strin 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 %s", v, t, fail) + 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 %s", v, u, fail) + 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) @@ -385,11 +364,11 @@ func genMatch0(w io.Writer, arch arch, match, v, fail string, m map[string]strin x := a[1 : len(a)-1] // remove [] if !isVariable(x) { // code - fmt.Fprintf(w, "if %s.AuxInt != %s %s", v, x, fail) + 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 %s", v, y, fail) + 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) @@ -400,11 +379,11 @@ func genMatch0(w io.Writer, arch arch, match, v, fail string, m map[string]strin x := a[1 : len(a)-1] // remove {} if !isVariable(x) { // code - fmt.Fprintf(w, "if %s.Aux != %s %s", v, x, fail) + 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 %s", v, y, fail) + 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) @@ -412,7 +391,7 @@ func genMatch0(w io.Writer, arch arch, match, v, fail string, m map[string]strin } } else { // variable or sexpr - genMatch0(w, arch, a, fmt.Sprintf("%s.Args[%d]", v, argnum), fail, m, false) + genMatch0(w, arch, a, fmt.Sprintf("%s.Args[%d]", v, argnum), m, false) argnum++ } } diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index beaf0acc7f..25bbbcdeb1 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -740,10 +740,10 @@ func rewriteValueAMD64_OpAMD64ADDB(v *Value, config *Config) bool { // match: (ADDB x (MOVBconst [c])) // cond: // result: (ADDBconst [c] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVBconst { - goto endab690db69bfd8192eea57a2f9f76bf84 + break } c := v.Args[1].AuxInt v.reset(OpAMD64ADDBconst) @@ -751,15 +751,12 @@ func rewriteValueAMD64_OpAMD64ADDB(v *Value, config *Config) bool { v.AddArg(x) return true } - goto endab690db69bfd8192eea57a2f9f76bf84 -endab690db69bfd8192eea57a2f9f76bf84: - ; // match: (ADDB (MOVBconst [c]) x) // cond: // result: (ADDBconst [c] x) - { + for { if v.Args[0].Op != OpAMD64MOVBconst { - goto end28aa1a4abe7e1abcdd64135e9967d39d + break } c := v.Args[0].AuxInt x := v.Args[1] @@ -768,16 +765,13 @@ endab690db69bfd8192eea57a2f9f76bf84: v.AddArg(x) return true } - goto end28aa1a4abe7e1abcdd64135e9967d39d -end28aa1a4abe7e1abcdd64135e9967d39d: - ; // match: (ADDB x (NEGB y)) // cond: // result: (SUBB x y) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64NEGB { - goto end9464509b8874ffb00b43b843da01f0bc + break } y := v.Args[1].Args[0] v.reset(OpAMD64SUBB) @@ -785,9 +779,6 @@ end28aa1a4abe7e1abcdd64135e9967d39d: v.AddArg(y) return true } - goto end9464509b8874ffb00b43b843da01f0bc -end9464509b8874ffb00b43b843da01f0bc: - ; return false } func rewriteValueAMD64_OpAMD64ADDBconst(v *Value, config *Config) bool { @@ -796,43 +787,37 @@ func rewriteValueAMD64_OpAMD64ADDBconst(v *Value, config *Config) bool { // match: (ADDBconst [c] x) // cond: int8(c)==0 // result: x - { + for { c := v.AuxInt x := v.Args[0] if !(int8(c) == 0) { - goto end3fbe38dfc1de8f48c755862c4c8b6bac + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto end3fbe38dfc1de8f48c755862c4c8b6bac -end3fbe38dfc1de8f48c755862c4c8b6bac: - ; // match: (ADDBconst [c] (MOVBconst [d])) // cond: // result: (MOVBconst [c+d]) - { + for { c := v.AuxInt if v.Args[0].Op != OpAMD64MOVBconst { - goto enda9b1e9e31ccdf0af5f4fe57bf4b1343f + break } d := v.Args[0].AuxInt v.reset(OpAMD64MOVBconst) v.AuxInt = c + d return true } - goto enda9b1e9e31ccdf0af5f4fe57bf4b1343f -enda9b1e9e31ccdf0af5f4fe57bf4b1343f: - ; // match: (ADDBconst [c] (ADDBconst [d] x)) // cond: // result: (ADDBconst [c+d] x) - { + for { c := v.AuxInt if v.Args[0].Op != OpAMD64ADDBconst { - goto end9b1e6890adbf9d9e447d591b4148cbd0 + break } d := v.Args[0].AuxInt x := v.Args[0].Args[0] @@ -841,9 +826,6 @@ enda9b1e9e31ccdf0af5f4fe57bf4b1343f: v.AddArg(x) return true } - goto end9b1e6890adbf9d9e447d591b4148cbd0 -end9b1e6890adbf9d9e447d591b4148cbd0: - ; return false } func rewriteValueAMD64_OpAMD64ADDL(v *Value, config *Config) bool { @@ -852,10 +834,10 @@ func rewriteValueAMD64_OpAMD64ADDL(v *Value, config *Config) bool { // match: (ADDL x (MOVLconst [c])) // cond: // result: (ADDLconst [c] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVLconst { - goto end8d6d3b99a7be8da6b7a254b7e709cc95 + break } c := v.Args[1].AuxInt v.reset(OpAMD64ADDLconst) @@ -863,15 +845,12 @@ func rewriteValueAMD64_OpAMD64ADDL(v *Value, config *Config) bool { v.AddArg(x) return true } - goto end8d6d3b99a7be8da6b7a254b7e709cc95 -end8d6d3b99a7be8da6b7a254b7e709cc95: - ; // match: (ADDL (MOVLconst [c]) x) // cond: // result: (ADDLconst [c] x) - { + for { if v.Args[0].Op != OpAMD64MOVLconst { - goto end739561e08a561e26ce3634dc0d5ec733 + break } c := v.Args[0].AuxInt x := v.Args[1] @@ -880,16 +859,13 @@ end8d6d3b99a7be8da6b7a254b7e709cc95: v.AddArg(x) return true } - goto end739561e08a561e26ce3634dc0d5ec733 -end739561e08a561e26ce3634dc0d5ec733: - ; // match: (ADDL x (NEGL y)) // cond: // result: (SUBL x y) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64NEGL { - goto end9596df31f2685a49df67c6fb912a521d + break } y := v.Args[1].Args[0] v.reset(OpAMD64SUBL) @@ -897,9 +873,6 @@ end739561e08a561e26ce3634dc0d5ec733: v.AddArg(y) return true } - goto end9596df31f2685a49df67c6fb912a521d -end9596df31f2685a49df67c6fb912a521d: - ; return false } func rewriteValueAMD64_OpAMD64ADDLconst(v *Value, config *Config) bool { @@ -908,43 +881,37 @@ func rewriteValueAMD64_OpAMD64ADDLconst(v *Value, config *Config) bool { // match: (ADDLconst [c] x) // cond: int32(c)==0 // result: x - { + for { c := v.AuxInt x := v.Args[0] if !(int32(c) == 0) { - goto endf04fb6232fbd3b460bb0d1bdcdc57d65 + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto endf04fb6232fbd3b460bb0d1bdcdc57d65 -endf04fb6232fbd3b460bb0d1bdcdc57d65: - ; // match: (ADDLconst [c] (MOVLconst [d])) // cond: // result: (MOVLconst [c+d]) - { + for { c := v.AuxInt if v.Args[0].Op != OpAMD64MOVLconst { - goto ende04850e987890abf1d66199042a19c23 + break } d := v.Args[0].AuxInt v.reset(OpAMD64MOVLconst) v.AuxInt = c + d return true } - goto ende04850e987890abf1d66199042a19c23 -ende04850e987890abf1d66199042a19c23: - ; // match: (ADDLconst [c] (ADDLconst [d] x)) // cond: // result: (ADDLconst [c+d] x) - { + for { c := v.AuxInt if v.Args[0].Op != OpAMD64ADDLconst { - goto endf1dd8673b2fef4950aec87aa7523a236 + break } d := v.Args[0].AuxInt x := v.Args[0].Args[0] @@ -953,9 +920,6 @@ ende04850e987890abf1d66199042a19c23: v.AddArg(x) return true } - goto endf1dd8673b2fef4950aec87aa7523a236 -endf1dd8673b2fef4950aec87aa7523a236: - ; return false } func rewriteValueAMD64_OpAMD64ADDQ(v *Value, config *Config) bool { @@ -964,53 +928,47 @@ func rewriteValueAMD64_OpAMD64ADDQ(v *Value, config *Config) bool { // match: (ADDQ x (MOVQconst [c])) // cond: is32Bit(c) // result: (ADDQconst [c] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVQconst { - goto end1de8aeb1d043e0dadcffd169a99ce5c0 + break } c := v.Args[1].AuxInt if !(is32Bit(c)) { - goto end1de8aeb1d043e0dadcffd169a99ce5c0 + break } v.reset(OpAMD64ADDQconst) v.AuxInt = c v.AddArg(x) return true } - goto end1de8aeb1d043e0dadcffd169a99ce5c0 -end1de8aeb1d043e0dadcffd169a99ce5c0: - ; // match: (ADDQ (MOVQconst [c]) x) // cond: is32Bit(c) // result: (ADDQconst [c] x) - { + for { if v.Args[0].Op != OpAMD64MOVQconst { - goto endca635e3bdecd9e3aeb892f841021dfaa + break } c := v.Args[0].AuxInt x := v.Args[1] if !(is32Bit(c)) { - goto endca635e3bdecd9e3aeb892f841021dfaa + break } v.reset(OpAMD64ADDQconst) v.AuxInt = c v.AddArg(x) return true } - goto endca635e3bdecd9e3aeb892f841021dfaa -endca635e3bdecd9e3aeb892f841021dfaa: - ; // match: (ADDQ x (SHLQconst [3] y)) // cond: // result: (LEAQ8 x y) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64SHLQconst { - goto endc02313d35a0525d1d680cd58992e820d + break } if v.Args[1].AuxInt != 3 { - goto endc02313d35a0525d1d680cd58992e820d + break } y := v.Args[1].Args[0] v.reset(OpAMD64LEAQ8) @@ -1018,19 +976,16 @@ endca635e3bdecd9e3aeb892f841021dfaa: v.AddArg(y) return true } - goto endc02313d35a0525d1d680cd58992e820d -endc02313d35a0525d1d680cd58992e820d: - ; // match: (ADDQ x (SHLQconst [2] y)) // cond: // result: (LEAQ4 x y) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64SHLQconst { - goto end153955fe292c5ecb20b76bba7da8f451 + break } if v.Args[1].AuxInt != 2 { - goto end153955fe292c5ecb20b76bba7da8f451 + break } y := v.Args[1].Args[0] v.reset(OpAMD64LEAQ4) @@ -1038,19 +993,16 @@ endc02313d35a0525d1d680cd58992e820d: v.AddArg(y) return true } - goto end153955fe292c5ecb20b76bba7da8f451 -end153955fe292c5ecb20b76bba7da8f451: - ; // match: (ADDQ x (SHLQconst [1] y)) // cond: // result: (LEAQ2 x y) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64SHLQconst { - goto enda863d175a7a59f03d4306df57e8351f6 + break } if v.Args[1].AuxInt != 1 { - goto enda863d175a7a59f03d4306df57e8351f6 + break } y := v.Args[1].Args[0] v.reset(OpAMD64LEAQ2) @@ -1058,39 +1010,33 @@ end153955fe292c5ecb20b76bba7da8f451: v.AddArg(y) return true } - goto enda863d175a7a59f03d4306df57e8351f6 -enda863d175a7a59f03d4306df57e8351f6: - ; // match: (ADDQ x (ADDQ y y)) // cond: // result: (LEAQ2 x y) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64ADDQ { - goto endf7dd9841c41eec66eddd351ee39cfbf3 + break } y := v.Args[1].Args[0] if v.Args[1].Args[1] != y { - goto endf7dd9841c41eec66eddd351ee39cfbf3 + break } v.reset(OpAMD64LEAQ2) v.AddArg(x) v.AddArg(y) return true } - goto endf7dd9841c41eec66eddd351ee39cfbf3 -endf7dd9841c41eec66eddd351ee39cfbf3: - ; // match: (ADDQ x (ADDQ x y)) // cond: // result: (LEAQ2 y x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64ADDQ { - goto end5547794ce29adef7d31260653a56bcb5 + break } if v.Args[1].Args[0] != x { - goto end5547794ce29adef7d31260653a56bcb5 + break } y := v.Args[1].Args[1] v.reset(OpAMD64LEAQ2) @@ -1098,42 +1044,36 @@ endf7dd9841c41eec66eddd351ee39cfbf3: v.AddArg(x) return true } - goto end5547794ce29adef7d31260653a56bcb5 -end5547794ce29adef7d31260653a56bcb5: - ; // match: (ADDQ x (ADDQ y x)) // cond: // result: (LEAQ2 y x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64ADDQ { - goto end0ef5fb7590c377b6274991aaea41fae2 + break } y := v.Args[1].Args[0] if v.Args[1].Args[1] != x { - goto end0ef5fb7590c377b6274991aaea41fae2 + break } v.reset(OpAMD64LEAQ2) v.AddArg(y) v.AddArg(x) return true } - goto end0ef5fb7590c377b6274991aaea41fae2 -end0ef5fb7590c377b6274991aaea41fae2: - ; // 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 { - goto endadc48e1a7f3d0a3505b68ffc771bb086 + break } c := v.Args[1].AuxInt s := v.Args[1].Aux y := v.Args[1].Args[0] if !(x.Op != OpSB && y.Op != OpSB) { - goto endadc48e1a7f3d0a3505b68ffc771bb086 + break } v.reset(OpAMD64LEAQ1) v.AuxInt = c @@ -1142,22 +1082,19 @@ end0ef5fb7590c377b6274991aaea41fae2: v.AddArg(y) return true } - goto endadc48e1a7f3d0a3505b68ffc771bb086 -endadc48e1a7f3d0a3505b68ffc771bb086: - ; // 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 { - goto end2696de9ef8f27dbc96dd4ad5878b0779 + 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) { - goto end2696de9ef8f27dbc96dd4ad5878b0779 + break } v.reset(OpAMD64LEAQ1) v.AuxInt = c @@ -1166,16 +1103,13 @@ endadc48e1a7f3d0a3505b68ffc771bb086: v.AddArg(y) return true } - goto end2696de9ef8f27dbc96dd4ad5878b0779 -end2696de9ef8f27dbc96dd4ad5878b0779: - ; // match: (ADDQ x (NEGQ y)) // cond: // result: (SUBQ x y) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64NEGQ { - goto endec8f899c6e175a0147a90750f9bfe0a2 + break } y := v.Args[1].Args[0] v.reset(OpAMD64SUBQ) @@ -1183,9 +1117,6 @@ end2696de9ef8f27dbc96dd4ad5878b0779: v.AddArg(y) return true } - goto endec8f899c6e175a0147a90750f9bfe0a2 -endec8f899c6e175a0147a90750f9bfe0a2: - ; return false } func rewriteValueAMD64_OpAMD64ADDQconst(v *Value, config *Config) bool { @@ -1194,10 +1125,10 @@ func rewriteValueAMD64_OpAMD64ADDQconst(v *Value, config *Config) bool { // match: (ADDQconst [c] (LEAQ [d] {s} x)) // cond: // result: (LEAQ [c+d] {s} x) - { + for { c := v.AuxInt if v.Args[0].Op != OpAMD64LEAQ { - goto end5bfebc265098e6e57905269bb95daa3f + break } d := v.Args[0].AuxInt s := v.Args[0].Aux @@ -1208,16 +1139,13 @@ func rewriteValueAMD64_OpAMD64ADDQconst(v *Value, config *Config) bool { v.AddArg(x) return true } - goto end5bfebc265098e6e57905269bb95daa3f -end5bfebc265098e6e57905269bb95daa3f: - ; // 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 { - goto end71505b5ee2217f51c50569efc37499e7 + break } d := v.Args[0].AuxInt s := v.Args[0].Aux @@ -1230,16 +1158,13 @@ end5bfebc265098e6e57905269bb95daa3f: v.AddArg(y) return true } - goto end71505b5ee2217f51c50569efc37499e7 -end71505b5ee2217f51c50569efc37499e7: - ; // 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 { - goto end9f155ec07598aec52f602a92a5d719a9 + break } d := v.Args[0].AuxInt s := v.Args[0].Aux @@ -1252,16 +1177,13 @@ end71505b5ee2217f51c50569efc37499e7: v.AddArg(y) return true } - goto end9f155ec07598aec52f602a92a5d719a9 -end9f155ec07598aec52f602a92a5d719a9: - ; // 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 { - goto end95f58aac9e8ea7efaef2bec6400cf7f8 + break } d := v.Args[0].AuxInt s := v.Args[0].Aux @@ -1274,16 +1196,13 @@ end9f155ec07598aec52f602a92a5d719a9: v.AddArg(y) return true } - goto end95f58aac9e8ea7efaef2bec6400cf7f8 -end95f58aac9e8ea7efaef2bec6400cf7f8: - ; // 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 { - goto end9d4328824aff954a1f47f1109500e826 + break } d := v.Args[0].AuxInt s := v.Args[0].Aux @@ -1296,15 +1215,12 @@ end95f58aac9e8ea7efaef2bec6400cf7f8: v.AddArg(y) return true } - goto end9d4328824aff954a1f47f1109500e826 -end9d4328824aff954a1f47f1109500e826: - ; // match: (ADDQconst [0] x) // cond: // result: x - { + for { if v.AuxInt != 0 { - goto end03d9f5a3e153048b0afa781401e2a849 + break } x := v.Args[0] v.reset(OpCopy) @@ -1312,32 +1228,26 @@ end9d4328824aff954a1f47f1109500e826: v.AddArg(x) return true } - goto end03d9f5a3e153048b0afa781401e2a849 -end03d9f5a3e153048b0afa781401e2a849: - ; // match: (ADDQconst [c] (MOVQconst [d])) // cond: // result: (MOVQconst [c+d]) - { + for { c := v.AuxInt if v.Args[0].Op != OpAMD64MOVQconst { - goto end09dc54395b4e96e8332cf8e4e7481c52 + break } d := v.Args[0].AuxInt v.reset(OpAMD64MOVQconst) v.AuxInt = c + d return true } - goto end09dc54395b4e96e8332cf8e4e7481c52 -end09dc54395b4e96e8332cf8e4e7481c52: - ; // match: (ADDQconst [c] (ADDQconst [d] x)) // cond: // result: (ADDQconst [c+d] x) - { + for { c := v.AuxInt if v.Args[0].Op != OpAMD64ADDQconst { - goto endd4cb539641f0dc40bfd0cb7fbb9b0405 + break } d := v.Args[0].AuxInt x := v.Args[0].Args[0] @@ -1346,9 +1256,6 @@ end09dc54395b4e96e8332cf8e4e7481c52: v.AddArg(x) return true } - goto endd4cb539641f0dc40bfd0cb7fbb9b0405 -endd4cb539641f0dc40bfd0cb7fbb9b0405: - ; return false } func rewriteValueAMD64_OpAMD64ADDW(v *Value, config *Config) bool { @@ -1357,10 +1264,10 @@ func rewriteValueAMD64_OpAMD64ADDW(v *Value, config *Config) bool { // match: (ADDW x (MOVWconst [c])) // cond: // result: (ADDWconst [c] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVWconst { - goto end1aabd2317de77c7dfc4876fd7e4c5011 + break } c := v.Args[1].AuxInt v.reset(OpAMD64ADDWconst) @@ -1368,15 +1275,12 @@ func rewriteValueAMD64_OpAMD64ADDW(v *Value, config *Config) bool { v.AddArg(x) return true } - goto end1aabd2317de77c7dfc4876fd7e4c5011 -end1aabd2317de77c7dfc4876fd7e4c5011: - ; // match: (ADDW (MOVWconst [c]) x) // cond: // result: (ADDWconst [c] x) - { + for { if v.Args[0].Op != OpAMD64MOVWconst { - goto ende3aede99966f388afc624f9e86676fd2 + break } c := v.Args[0].AuxInt x := v.Args[1] @@ -1385,16 +1289,13 @@ end1aabd2317de77c7dfc4876fd7e4c5011: v.AddArg(x) return true } - goto ende3aede99966f388afc624f9e86676fd2 -ende3aede99966f388afc624f9e86676fd2: - ; // match: (ADDW x (NEGW y)) // cond: // result: (SUBW x y) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64NEGW { - goto end55cf2af0d75f3ec413528eeb799e94d5 + break } y := v.Args[1].Args[0] v.reset(OpAMD64SUBW) @@ -1402,9 +1303,6 @@ ende3aede99966f388afc624f9e86676fd2: v.AddArg(y) return true } - goto end55cf2af0d75f3ec413528eeb799e94d5 -end55cf2af0d75f3ec413528eeb799e94d5: - ; return false } func rewriteValueAMD64_OpAMD64ADDWconst(v *Value, config *Config) bool { @@ -1413,43 +1311,37 @@ func rewriteValueAMD64_OpAMD64ADDWconst(v *Value, config *Config) bool { // match: (ADDWconst [c] x) // cond: int16(c)==0 // result: x - { + for { c := v.AuxInt x := v.Args[0] if !(int16(c) == 0) { - goto end8564670ff18b2a91eb92d5e5775464cd + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto end8564670ff18b2a91eb92d5e5775464cd -end8564670ff18b2a91eb92d5e5775464cd: - ; // match: (ADDWconst [c] (MOVWconst [d])) // cond: // result: (MOVWconst [c+d]) - { + for { c := v.AuxInt if v.Args[0].Op != OpAMD64MOVWconst { - goto end32541920f2f5a920dfae41d8ebbef00f + break } d := v.Args[0].AuxInt v.reset(OpAMD64MOVWconst) v.AuxInt = c + d return true } - goto end32541920f2f5a920dfae41d8ebbef00f -end32541920f2f5a920dfae41d8ebbef00f: - ; // match: (ADDWconst [c] (ADDWconst [d] x)) // cond: // result: (ADDWconst [c+d] x) - { + for { c := v.AuxInt if v.Args[0].Op != OpAMD64ADDWconst { - goto end73944f6ddda7e4c050f11d17484ff9a5 + break } d := v.Args[0].AuxInt x := v.Args[0].Args[0] @@ -1458,9 +1350,6 @@ end32541920f2f5a920dfae41d8ebbef00f: v.AddArg(x) return true } - goto end73944f6ddda7e4c050f11d17484ff9a5 -end73944f6ddda7e4c050f11d17484ff9a5: - ; return false } func rewriteValueAMD64_OpAMD64ANDB(v *Value, config *Config) bool { @@ -1469,10 +1358,10 @@ func rewriteValueAMD64_OpAMD64ANDB(v *Value, config *Config) bool { // match: (ANDB x (MOVLconst [c])) // cond: // result: (ANDBconst [c] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVLconst { - goto end01100cd255396e29bfdb130f4fbc9bbc + break } c := v.Args[1].AuxInt v.reset(OpAMD64ANDBconst) @@ -1480,15 +1369,12 @@ func rewriteValueAMD64_OpAMD64ANDB(v *Value, config *Config) bool { v.AddArg(x) return true } - goto end01100cd255396e29bfdb130f4fbc9bbc -end01100cd255396e29bfdb130f4fbc9bbc: - ; // match: (ANDB (MOVLconst [c]) x) // cond: // result: (ANDBconst [c] x) - { + for { if v.Args[0].Op != OpAMD64MOVLconst { - goto end70830ce2834dc5f8d786fa6789460926 + break } c := v.Args[0].AuxInt x := v.Args[1] @@ -1497,16 +1383,13 @@ end01100cd255396e29bfdb130f4fbc9bbc: v.AddArg(x) return true } - goto end70830ce2834dc5f8d786fa6789460926 -end70830ce2834dc5f8d786fa6789460926: - ; // match: (ANDB x (MOVBconst [c])) // cond: // result: (ANDBconst [c] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVBconst { - goto endd275ec2e73768cb3d201478fc934e06c + break } c := v.Args[1].AuxInt v.reset(OpAMD64ANDBconst) @@ -1514,15 +1397,12 @@ end70830ce2834dc5f8d786fa6789460926: v.AddArg(x) return true } - goto endd275ec2e73768cb3d201478fc934e06c -endd275ec2e73768cb3d201478fc934e06c: - ; // match: (ANDB (MOVBconst [c]) x) // cond: // result: (ANDBconst [c] x) - { + for { if v.Args[0].Op != OpAMD64MOVBconst { - goto end4068edac2ae0f354cf581db210288b98 + break } c := v.Args[0].AuxInt x := v.Args[1] @@ -1531,25 +1411,19 @@ endd275ec2e73768cb3d201478fc934e06c: v.AddArg(x) return true } - goto end4068edac2ae0f354cf581db210288b98 -end4068edac2ae0f354cf581db210288b98: - ; // match: (ANDB x x) // cond: // result: x - { + for { x := v.Args[0] if v.Args[1] != x { - goto endb8ff272a1456513da708603abe37541c + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto endb8ff272a1456513da708603abe37541c -endb8ff272a1456513da708603abe37541c: - ; return false } func rewriteValueAMD64_OpAMD64ANDBconst(v *Value, config *Config) bool { @@ -1558,51 +1432,42 @@ func rewriteValueAMD64_OpAMD64ANDBconst(v *Value, config *Config) bool { // match: (ANDBconst [c] _) // cond: int8(c)==0 // result: (MOVBconst [0]) - { + for { c := v.AuxInt if !(int8(c) == 0) { - goto end2106d410c949da14d7c00041f40eca76 + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } - goto end2106d410c949da14d7c00041f40eca76 -end2106d410c949da14d7c00041f40eca76: - ; // match: (ANDBconst [c] x) // cond: int8(c)==-1 // result: x - { + for { c := v.AuxInt x := v.Args[0] if !(int8(c) == -1) { - goto enda0b78503c204c8225de1433949a71fe4 + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto enda0b78503c204c8225de1433949a71fe4 -enda0b78503c204c8225de1433949a71fe4: - ; // match: (ANDBconst [c] (MOVBconst [d])) // cond: // result: (MOVBconst [c&d]) - { + for { c := v.AuxInt if v.Args[0].Op != OpAMD64MOVBconst { - goto end946312b1f216933da86febe293eb956f + break } d := v.Args[0].AuxInt v.reset(OpAMD64MOVBconst) v.AuxInt = c & d return true } - goto end946312b1f216933da86febe293eb956f -end946312b1f216933da86febe293eb956f: - ; return false } func rewriteValueAMD64_OpAMD64ANDL(v *Value, config *Config) bool { @@ -1611,10 +1476,10 @@ func rewriteValueAMD64_OpAMD64ANDL(v *Value, config *Config) bool { // match: (ANDL x (MOVLconst [c])) // cond: // result: (ANDLconst [c] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVLconst { - goto end0a4c49d9a26759c0fd21369dafcd7abb + break } c := v.Args[1].AuxInt v.reset(OpAMD64ANDLconst) @@ -1622,15 +1487,12 @@ func rewriteValueAMD64_OpAMD64ANDL(v *Value, config *Config) bool { v.AddArg(x) return true } - goto end0a4c49d9a26759c0fd21369dafcd7abb -end0a4c49d9a26759c0fd21369dafcd7abb: - ; // match: (ANDL (MOVLconst [c]) x) // cond: // result: (ANDLconst [c] x) - { + for { if v.Args[0].Op != OpAMD64MOVLconst { - goto end0529ba323d9b6f15c41add401ef67959 + break } c := v.Args[0].AuxInt x := v.Args[1] @@ -1639,25 +1501,19 @@ end0a4c49d9a26759c0fd21369dafcd7abb: v.AddArg(x) return true } - goto end0529ba323d9b6f15c41add401ef67959 -end0529ba323d9b6f15c41add401ef67959: - ; // match: (ANDL x x) // cond: // result: x - { + for { x := v.Args[0] if v.Args[1] != x { - goto enddfb08a0d0c262854db3905cb323388c7 + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto enddfb08a0d0c262854db3905cb323388c7 -enddfb08a0d0c262854db3905cb323388c7: - ; return false } func rewriteValueAMD64_OpAMD64ANDLconst(v *Value, config *Config) bool { @@ -1666,51 +1522,42 @@ func rewriteValueAMD64_OpAMD64ANDLconst(v *Value, config *Config) bool { // match: (ANDLconst [c] _) // cond: int32(c)==0 // result: (MOVLconst [0]) - { + for { c := v.AuxInt if !(int32(c) == 0) { - goto end5efb241208aef28c950b7bcf8d85d5de + break } v.reset(OpAMD64MOVLconst) v.AuxInt = 0 return true } - goto end5efb241208aef28c950b7bcf8d85d5de -end5efb241208aef28c950b7bcf8d85d5de: - ; // match: (ANDLconst [c] x) // cond: int32(c)==-1 // result: x - { + for { c := v.AuxInt x := v.Args[0] if !(int32(c) == -1) { - goto end0e852ae30bb8289d6ffee0c9267e3e0c + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto end0e852ae30bb8289d6ffee0c9267e3e0c -end0e852ae30bb8289d6ffee0c9267e3e0c: - ; // match: (ANDLconst [c] (MOVLconst [d])) // cond: // result: (MOVLconst [c&d]) - { + for { c := v.AuxInt if v.Args[0].Op != OpAMD64MOVLconst { - goto end7bfd24059369753eadd235f07e2dd7b8 + break } d := v.Args[0].AuxInt v.reset(OpAMD64MOVLconst) v.AuxInt = c & d return true } - goto end7bfd24059369753eadd235f07e2dd7b8 -end7bfd24059369753eadd235f07e2dd7b8: - ; return false } func rewriteValueAMD64_OpAMD64ANDQ(v *Value, config *Config) bool { @@ -1719,59 +1566,50 @@ func rewriteValueAMD64_OpAMD64ANDQ(v *Value, config *Config) bool { // match: (ANDQ x (MOVQconst [c])) // cond: is32Bit(c) // result: (ANDQconst [c] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVQconst { - goto end048fadc69e81103480015b84b9cafff7 + break } c := v.Args[1].AuxInt if !(is32Bit(c)) { - goto end048fadc69e81103480015b84b9cafff7 + break } v.reset(OpAMD64ANDQconst) v.AuxInt = c v.AddArg(x) return true } - goto end048fadc69e81103480015b84b9cafff7 -end048fadc69e81103480015b84b9cafff7: - ; // match: (ANDQ (MOVQconst [c]) x) // cond: is32Bit(c) // result: (ANDQconst [c] x) - { + for { if v.Args[0].Op != OpAMD64MOVQconst { - goto end3035a3bf650b708705fd27dd857ab0a4 + break } c := v.Args[0].AuxInt x := v.Args[1] if !(is32Bit(c)) { - goto end3035a3bf650b708705fd27dd857ab0a4 + break } v.reset(OpAMD64ANDQconst) v.AuxInt = c v.AddArg(x) return true } - goto end3035a3bf650b708705fd27dd857ab0a4 -end3035a3bf650b708705fd27dd857ab0a4: - ; // match: (ANDQ x x) // cond: // result: x - { + for { x := v.Args[0] if v.Args[1] != x { - goto end06b5ec19efdd4e79f03a5e4a2c3c3427 + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto end06b5ec19efdd4e79f03a5e4a2c3c3427 -end06b5ec19efdd4e79f03a5e4a2c3c3427: - ; return false } func rewriteValueAMD64_OpAMD64ANDQconst(v *Value, config *Config) bool { @@ -1780,23 +1618,20 @@ func rewriteValueAMD64_OpAMD64ANDQconst(v *Value, config *Config) bool { // match: (ANDQconst [0] _) // cond: // result: (MOVQconst [0]) - { + for { if v.AuxInt != 0 { - goto end57018c1d0f54fd721521095b4832bab2 + break } v.reset(OpAMD64MOVQconst) v.AuxInt = 0 return true } - goto end57018c1d0f54fd721521095b4832bab2 -end57018c1d0f54fd721521095b4832bab2: - ; // match: (ANDQconst [-1] x) // cond: // result: x - { + for { if v.AuxInt != -1 { - goto endb542c4b42ab94a7bedb32dec8f610d67 + break } x := v.Args[0] v.reset(OpCopy) @@ -1804,25 +1639,19 @@ end57018c1d0f54fd721521095b4832bab2: v.AddArg(x) return true } - goto endb542c4b42ab94a7bedb32dec8f610d67 -endb542c4b42ab94a7bedb32dec8f610d67: - ; // match: (ANDQconst [c] (MOVQconst [d])) // cond: // result: (MOVQconst [c&d]) - { + for { c := v.AuxInt if v.Args[0].Op != OpAMD64MOVQconst { - goto end67ca66494705b0345a5f22c710225292 + break } d := v.Args[0].AuxInt v.reset(OpAMD64MOVQconst) v.AuxInt = c & d return true } - goto end67ca66494705b0345a5f22c710225292 -end67ca66494705b0345a5f22c710225292: - ; return false } func rewriteValueAMD64_OpAMD64ANDW(v *Value, config *Config) bool { @@ -1831,10 +1660,10 @@ func rewriteValueAMD64_OpAMD64ANDW(v *Value, config *Config) bool { // match: (ANDW x (MOVLconst [c])) // cond: // result: (ANDWconst [c] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVLconst { - goto endce6f557823ee2fdd7a8f47b6f925fc7c + break } c := v.Args[1].AuxInt v.reset(OpAMD64ANDWconst) @@ -1842,15 +1671,12 @@ func rewriteValueAMD64_OpAMD64ANDW(v *Value, config *Config) bool { v.AddArg(x) return true } - goto endce6f557823ee2fdd7a8f47b6f925fc7c -endce6f557823ee2fdd7a8f47b6f925fc7c: - ; // match: (ANDW (MOVLconst [c]) x) // cond: // result: (ANDWconst [c] x) - { + for { if v.Args[0].Op != OpAMD64MOVLconst { - goto endc46af0d9265c08b09f1f1fba24feda80 + break } c := v.Args[0].AuxInt x := v.Args[1] @@ -1859,16 +1685,13 @@ endce6f557823ee2fdd7a8f47b6f925fc7c: v.AddArg(x) return true } - goto endc46af0d9265c08b09f1f1fba24feda80 -endc46af0d9265c08b09f1f1fba24feda80: - ; // match: (ANDW x (MOVWconst [c])) // cond: // result: (ANDWconst [c] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVWconst { - goto enda77a39f65a5eb3436a5842eab69a3103 + break } c := v.Args[1].AuxInt v.reset(OpAMD64ANDWconst) @@ -1876,15 +1699,12 @@ endc46af0d9265c08b09f1f1fba24feda80: v.AddArg(x) return true } - goto enda77a39f65a5eb3436a5842eab69a3103 -enda77a39f65a5eb3436a5842eab69a3103: - ; // match: (ANDW (MOVWconst [c]) x) // cond: // result: (ANDWconst [c] x) - { + for { if v.Args[0].Op != OpAMD64MOVWconst { - goto endea2a25eb525a5dbf6d5132d84ea4e7a5 + break } c := v.Args[0].AuxInt x := v.Args[1] @@ -1893,25 +1713,19 @@ enda77a39f65a5eb3436a5842eab69a3103: v.AddArg(x) return true } - goto endea2a25eb525a5dbf6d5132d84ea4e7a5 -endea2a25eb525a5dbf6d5132d84ea4e7a5: - ; // match: (ANDW x x) // cond: // result: x - { + for { x := v.Args[0] if v.Args[1] != x { - goto end3a26cf52dd1b77f07cc9e005760dbb11 + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto end3a26cf52dd1b77f07cc9e005760dbb11 -end3a26cf52dd1b77f07cc9e005760dbb11: - ; return false } func rewriteValueAMD64_OpAMD64ANDWconst(v *Value, config *Config) bool { @@ -1920,51 +1734,42 @@ func rewriteValueAMD64_OpAMD64ANDWconst(v *Value, config *Config) bool { // match: (ANDWconst [c] _) // cond: int16(c)==0 // result: (MOVWconst [0]) - { + for { c := v.AuxInt if !(int16(c) == 0) { - goto end336ece33b4f0fb44dfe1f24981df7b74 + break } v.reset(OpAMD64MOVWconst) v.AuxInt = 0 return true } - goto end336ece33b4f0fb44dfe1f24981df7b74 -end336ece33b4f0fb44dfe1f24981df7b74: - ; // match: (ANDWconst [c] x) // cond: int16(c)==-1 // result: x - { + for { c := v.AuxInt x := v.Args[0] if !(int16(c) == -1) { - goto endfb111c3afa8c5c4040fa6000fadee810 + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto endfb111c3afa8c5c4040fa6000fadee810 -endfb111c3afa8c5c4040fa6000fadee810: - ; // match: (ANDWconst [c] (MOVWconst [d])) // cond: // result: (MOVWconst [c&d]) - { + for { c := v.AuxInt if v.Args[0].Op != OpAMD64MOVWconst { - goto end250eb27fcac10bf6c0d96ce66a21726e + break } d := v.Args[0].AuxInt v.reset(OpAMD64MOVWconst) v.AuxInt = c & d return true } - goto end250eb27fcac10bf6c0d96ce66a21726e -end250eb27fcac10bf6c0d96ce66a21726e: - ; return false } func rewriteValueAMD64_OpAdd16(v *Value, config *Config) bool { @@ -1973,7 +1778,7 @@ func rewriteValueAMD64_OpAdd16(v *Value, config *Config) bool { // match: (Add16 x y) // cond: // result: (ADDW x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64ADDW) @@ -1981,9 +1786,6 @@ func rewriteValueAMD64_OpAdd16(v *Value, config *Config) bool { v.AddArg(y) return true } - goto ende604481c6de9fe4574cb2954ba2ddc67 -ende604481c6de9fe4574cb2954ba2ddc67: - ; return false } func rewriteValueAMD64_OpAdd32(v *Value, config *Config) bool { @@ -1992,7 +1794,7 @@ func rewriteValueAMD64_OpAdd32(v *Value, config *Config) bool { // match: (Add32 x y) // cond: // result: (ADDL x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64ADDL) @@ -2000,9 +1802,6 @@ func rewriteValueAMD64_OpAdd32(v *Value, config *Config) bool { v.AddArg(y) return true } - goto endc445ea2a65385445676cd684ae9a42b5 -endc445ea2a65385445676cd684ae9a42b5: - ; return false } func rewriteValueAMD64_OpAdd32F(v *Value, config *Config) bool { @@ -2011,7 +1810,7 @@ func rewriteValueAMD64_OpAdd32F(v *Value, config *Config) bool { // match: (Add32F x y) // cond: // result: (ADDSS x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64ADDSS) @@ -2019,9 +1818,6 @@ func rewriteValueAMD64_OpAdd32F(v *Value, config *Config) bool { v.AddArg(y) return true } - goto end5d82e1c10823774894c036b7c5b8fed4 -end5d82e1c10823774894c036b7c5b8fed4: - ; return false } func rewriteValueAMD64_OpAdd64(v *Value, config *Config) bool { @@ -2030,7 +1826,7 @@ func rewriteValueAMD64_OpAdd64(v *Value, config *Config) bool { // match: (Add64 x y) // cond: // result: (ADDQ x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64ADDQ) @@ -2038,9 +1834,6 @@ func rewriteValueAMD64_OpAdd64(v *Value, config *Config) bool { v.AddArg(y) return true } - goto endd88f18b3f39e3ccc201477a616f0abc0 -endd88f18b3f39e3ccc201477a616f0abc0: - ; return false } func rewriteValueAMD64_OpAdd64F(v *Value, config *Config) bool { @@ -2049,7 +1842,7 @@ func rewriteValueAMD64_OpAdd64F(v *Value, config *Config) bool { // match: (Add64F x y) // cond: // result: (ADDSD x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64ADDSD) @@ -2057,9 +1850,6 @@ func rewriteValueAMD64_OpAdd64F(v *Value, config *Config) bool { v.AddArg(y) return true } - goto end62f2de6c70abd214e6987ee37976653a -end62f2de6c70abd214e6987ee37976653a: - ; return false } func rewriteValueAMD64_OpAdd8(v *Value, config *Config) bool { @@ -2068,7 +1858,7 @@ func rewriteValueAMD64_OpAdd8(v *Value, config *Config) bool { // match: (Add8 x y) // cond: // result: (ADDB x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64ADDB) @@ -2076,9 +1866,6 @@ func rewriteValueAMD64_OpAdd8(v *Value, config *Config) bool { v.AddArg(y) return true } - goto end6117c84a6b75c1b816b3fb095bc5f656 -end6117c84a6b75c1b816b3fb095bc5f656: - ; return false } func rewriteValueAMD64_OpAddPtr(v *Value, config *Config) bool { @@ -2087,7 +1874,7 @@ func rewriteValueAMD64_OpAddPtr(v *Value, config *Config) bool { // match: (AddPtr x y) // cond: // result: (ADDQ x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64ADDQ) @@ -2095,9 +1882,6 @@ func rewriteValueAMD64_OpAddPtr(v *Value, config *Config) bool { v.AddArg(y) return true } - goto enda1d5640788c7157996f9d4af602dec1c -enda1d5640788c7157996f9d4af602dec1c: - ; return false } func rewriteValueAMD64_OpAddr(v *Value, config *Config) bool { @@ -2106,7 +1890,7 @@ func rewriteValueAMD64_OpAddr(v *Value, config *Config) bool { // match: (Addr {sym} base) // cond: // result: (LEAQ {sym} base) - { + for { sym := v.Aux base := v.Args[0] v.reset(OpAMD64LEAQ) @@ -2114,9 +1898,6 @@ func rewriteValueAMD64_OpAddr(v *Value, config *Config) bool { v.AddArg(base) return true } - goto end53cad0c3c9daa5575680e77c14e05e72 -end53cad0c3c9daa5575680e77c14e05e72: - ; return false } func rewriteValueAMD64_OpAnd16(v *Value, config *Config) bool { @@ -2125,7 +1906,7 @@ func rewriteValueAMD64_OpAnd16(v *Value, config *Config) bool { // match: (And16 x y) // cond: // result: (ANDW x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64ANDW) @@ -2133,9 +1914,6 @@ func rewriteValueAMD64_OpAnd16(v *Value, config *Config) bool { v.AddArg(y) return true } - goto end1c01f04a173d86ce1a6d1ef59e753014 -end1c01f04a173d86ce1a6d1ef59e753014: - ; return false } func rewriteValueAMD64_OpAnd32(v *Value, config *Config) bool { @@ -2144,7 +1922,7 @@ func rewriteValueAMD64_OpAnd32(v *Value, config *Config) bool { // match: (And32 x y) // cond: // result: (ANDL x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64ANDL) @@ -2152,9 +1930,6 @@ func rewriteValueAMD64_OpAnd32(v *Value, config *Config) bool { v.AddArg(y) return true } - goto end6b9eb9375b3a859028a6ba6bf6b8ec88 -end6b9eb9375b3a859028a6ba6bf6b8ec88: - ; return false } func rewriteValueAMD64_OpAnd64(v *Value, config *Config) bool { @@ -2163,7 +1938,7 @@ func rewriteValueAMD64_OpAnd64(v *Value, config *Config) bool { // match: (And64 x y) // cond: // result: (ANDQ x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64ANDQ) @@ -2171,9 +1946,6 @@ func rewriteValueAMD64_OpAnd64(v *Value, config *Config) bool { v.AddArg(y) return true } - goto enda0bde5853819d05fa2b7d3b723629552 -enda0bde5853819d05fa2b7d3b723629552: - ; return false } func rewriteValueAMD64_OpAnd8(v *Value, config *Config) bool { @@ -2182,7 +1954,7 @@ func rewriteValueAMD64_OpAnd8(v *Value, config *Config) bool { // match: (And8 x y) // cond: // result: (ANDB x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64ANDB) @@ -2190,9 +1962,6 @@ func rewriteValueAMD64_OpAnd8(v *Value, config *Config) bool { v.AddArg(y) return true } - goto end0f53bee6291f1229b43aa1b5f977b4f2 -end0f53bee6291f1229b43aa1b5f977b4f2: - ; return false } func rewriteValueAMD64_OpAMD64CMPB(v *Value, config *Config) bool { @@ -2201,10 +1970,10 @@ func rewriteValueAMD64_OpAMD64CMPB(v *Value, config *Config) bool { // match: (CMPB x (MOVBconst [c])) // cond: // result: (CMPBconst x [c]) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVBconst { - goto end52190c0b8759133aa6c540944965c4c0 + break } c := v.Args[1].AuxInt v.reset(OpAMD64CMPBconst) @@ -2212,15 +1981,12 @@ func rewriteValueAMD64_OpAMD64CMPB(v *Value, config *Config) bool { v.AuxInt = c return true } - goto end52190c0b8759133aa6c540944965c4c0 -end52190c0b8759133aa6c540944965c4c0: - ; // match: (CMPB (MOVBconst [c]) x) // cond: // result: (InvertFlags (CMPBconst x [c])) - { + for { if v.Args[0].Op != OpAMD64MOVBconst { - goto end25ab646f9eb8749ea58c8fbbb4bf6bcd + break } c := v.Args[0].AuxInt x := v.Args[1] @@ -2231,9 +1997,6 @@ end52190c0b8759133aa6c540944965c4c0: v.AddArg(v0) return true } - goto end25ab646f9eb8749ea58c8fbbb4bf6bcd -end25ab646f9eb8749ea58c8fbbb4bf6bcd: - ; return false } func rewriteValueAMD64_OpAMD64CMPBconst(v *Value, config *Config) bool { @@ -2242,151 +2005,127 @@ func rewriteValueAMD64_OpAMD64CMPBconst(v *Value, config *Config) bool { // match: (CMPBconst (MOVBconst [x]) [y]) // cond: int8(x)==int8(y) // result: (FlagEQ) - { + for { if v.Args[0].Op != OpAMD64MOVBconst { - goto end1be300bd80b7d8cd0fa37e1907c75a77 + break } x := v.Args[0].AuxInt y := v.AuxInt if !(int8(x) == int8(y)) { - goto end1be300bd80b7d8cd0fa37e1907c75a77 + break } v.reset(OpAMD64FlagEQ) return true } - goto end1be300bd80b7d8cd0fa37e1907c75a77 -end1be300bd80b7d8cd0fa37e1907c75a77: - ; // match: (CMPBconst (MOVBconst [x]) [y]) // cond: int8(x)uint8(y) // result: (FlagLT_UGT) - { + for { if v.Args[0].Op != OpAMD64MOVBconst { - goto endbfa2ca974f69ec9ceb8a24ad6db45efb + break } x := v.Args[0].AuxInt y := v.AuxInt if !(int8(x) < int8(y) && uint8(x) > uint8(y)) { - goto endbfa2ca974f69ec9ceb8a24ad6db45efb + break } v.reset(OpAMD64FlagLT_UGT) return true } - goto endbfa2ca974f69ec9ceb8a24ad6db45efb -endbfa2ca974f69ec9ceb8a24ad6db45efb: - ; // match: (CMPBconst (MOVBconst [x]) [y]) // cond: int8(x)>int8(y) && uint8(x) int8(y) && uint8(x) < uint8(y)) { - goto end68ac2e7dcb3704e235e1c292669320ed + break } v.reset(OpAMD64FlagGT_ULT) return true } - goto end68ac2e7dcb3704e235e1c292669320ed -end68ac2e7dcb3704e235e1c292669320ed: - ; // match: (CMPBconst (MOVBconst [x]) [y]) // cond: int8(x)>int8(y) && uint8(x)>uint8(y) // result: (FlagGT_UGT) - { + for { if v.Args[0].Op != OpAMD64MOVBconst { - goto endac1c49c82fb6b76dd324042c4588973c + break } x := v.Args[0].AuxInt y := v.AuxInt if !(int8(x) > int8(y) && uint8(x) > uint8(y)) { - goto endac1c49c82fb6b76dd324042c4588973c + break } v.reset(OpAMD64FlagGT_UGT) return true } - goto endac1c49c82fb6b76dd324042c4588973c -endac1c49c82fb6b76dd324042c4588973c: - ; // 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 { - goto end82aa9d89330cb5dc58592048bfc16ebc + break } m := v.Args[0].AuxInt n := v.AuxInt if !(int8(m)+1 == int8(n) && isPowerOfTwo(int64(int8(n)))) { - goto end82aa9d89330cb5dc58592048bfc16ebc + break } v.reset(OpAMD64FlagLT_ULT) return true } - goto end82aa9d89330cb5dc58592048bfc16ebc -end82aa9d89330cb5dc58592048bfc16ebc: - ; // match: (CMPBconst (ANDB x y) [0]) // cond: // result: (TESTB x y) - { + for { if v.Args[0].Op != OpAMD64ANDB { - goto endc1dd0adee6d97d0f2644600fa5247db5 + break } x := v.Args[0].Args[0] y := v.Args[0].Args[1] if v.AuxInt != 0 { - goto endc1dd0adee6d97d0f2644600fa5247db5 + break } v.reset(OpAMD64TESTB) v.AddArg(x) v.AddArg(y) return true } - goto endc1dd0adee6d97d0f2644600fa5247db5 -endc1dd0adee6d97d0f2644600fa5247db5: - ; // match: (CMPBconst (ANDBconst [c] x) [0]) // cond: // result: (TESTBconst [c] x) - { + for { if v.Args[0].Op != OpAMD64ANDBconst { - goto end575fd7ac1086d0c37e6946db5bbc7e94 + break } c := v.Args[0].AuxInt x := v.Args[0].Args[0] if v.AuxInt != 0 { - goto end575fd7ac1086d0c37e6946db5bbc7e94 + break } v.reset(OpAMD64TESTBconst) v.AuxInt = c v.AddArg(x) return true } - goto end575fd7ac1086d0c37e6946db5bbc7e94 -end575fd7ac1086d0c37e6946db5bbc7e94: - ; return false } func rewriteValueAMD64_OpAMD64CMPL(v *Value, config *Config) bool { @@ -2395,10 +2134,10 @@ func rewriteValueAMD64_OpAMD64CMPL(v *Value, config *Config) bool { // match: (CMPL x (MOVLconst [c])) // cond: // result: (CMPLconst x [c]) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVLconst { - goto end49ff4559c4bdecb2aef0c905e2d9a6cf + break } c := v.Args[1].AuxInt v.reset(OpAMD64CMPLconst) @@ -2406,15 +2145,12 @@ func rewriteValueAMD64_OpAMD64CMPL(v *Value, config *Config) bool { v.AuxInt = c return true } - goto end49ff4559c4bdecb2aef0c905e2d9a6cf -end49ff4559c4bdecb2aef0c905e2d9a6cf: - ; // match: (CMPL (MOVLconst [c]) x) // cond: // result: (InvertFlags (CMPLconst x [c])) - { + for { if v.Args[0].Op != OpAMD64MOVLconst { - goto end7d89230086678ab4ed5cc96a3ae358d6 + break } c := v.Args[0].AuxInt x := v.Args[1] @@ -2425,9 +2161,6 @@ end49ff4559c4bdecb2aef0c905e2d9a6cf: v.AddArg(v0) return true } - goto end7d89230086678ab4ed5cc96a3ae358d6 -end7d89230086678ab4ed5cc96a3ae358d6: - ; return false } func rewriteValueAMD64_OpAMD64CMPLconst(v *Value, config *Config) bool { @@ -2436,151 +2169,127 @@ func rewriteValueAMD64_OpAMD64CMPLconst(v *Value, config *Config) bool { // match: (CMPLconst (MOVLconst [x]) [y]) // cond: int32(x)==int32(y) // result: (FlagEQ) - { + for { if v.Args[0].Op != OpAMD64MOVLconst { - goto end7c53f3fc20f710e60f327bf63b4c8d4e + break } x := v.Args[0].AuxInt y := v.AuxInt if !(int32(x) == int32(y)) { - goto end7c53f3fc20f710e60f327bf63b4c8d4e + break } v.reset(OpAMD64FlagEQ) return true } - goto end7c53f3fc20f710e60f327bf63b4c8d4e -end7c53f3fc20f710e60f327bf63b4c8d4e: - ; // match: (CMPLconst (MOVLconst [x]) [y]) // cond: int32(x)uint32(y) // result: (FlagLT_UGT) - { + for { if v.Args[0].Op != OpAMD64MOVLconst { - goto end66603988bfeb71e410328b40425c3418 + break } x := v.Args[0].AuxInt y := v.AuxInt if !(int32(x) < int32(y) && uint32(x) > uint32(y)) { - goto end66603988bfeb71e410328b40425c3418 + break } v.reset(OpAMD64FlagLT_UGT) return true } - goto end66603988bfeb71e410328b40425c3418 -end66603988bfeb71e410328b40425c3418: - ; // match: (CMPLconst (MOVLconst [x]) [y]) // cond: int32(x)>int32(y) && uint32(x) int32(y) && uint32(x) < uint32(y)) { - goto endb1b0b14302e765637328dade12e1ce87 + break } v.reset(OpAMD64FlagGT_ULT) return true } - goto endb1b0b14302e765637328dade12e1ce87 -endb1b0b14302e765637328dade12e1ce87: - ; // match: (CMPLconst (MOVLconst [x]) [y]) // cond: int32(x)>int32(y) && uint32(x)>uint32(y) // result: (FlagGT_UGT) - { + for { if v.Args[0].Op != OpAMD64MOVLconst { - goto endc7b8e86e537d6e106e237023dc2c9a7b + break } x := v.Args[0].AuxInt y := v.AuxInt if !(int32(x) > int32(y) && uint32(x) > uint32(y)) { - goto endc7b8e86e537d6e106e237023dc2c9a7b + break } v.reset(OpAMD64FlagGT_UGT) return true } - goto endc7b8e86e537d6e106e237023dc2c9a7b -endc7b8e86e537d6e106e237023dc2c9a7b: - ; // 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 { - goto endf202b9830a1e45f3888f2598c762c702 + break } m := v.Args[0].AuxInt n := v.AuxInt if !(int32(m)+1 == int32(n) && isPowerOfTwo(int64(int32(n)))) { - goto endf202b9830a1e45f3888f2598c762c702 + break } v.reset(OpAMD64FlagLT_ULT) return true } - goto endf202b9830a1e45f3888f2598c762c702 -endf202b9830a1e45f3888f2598c762c702: - ; // match: (CMPLconst (ANDL x y) [0]) // cond: // result: (TESTL x y) - { + for { if v.Args[0].Op != OpAMD64ANDL { - goto endc99c55b2fd4bbe4f6eba9675087f215d + break } x := v.Args[0].Args[0] y := v.Args[0].Args[1] if v.AuxInt != 0 { - goto endc99c55b2fd4bbe4f6eba9675087f215d + break } v.reset(OpAMD64TESTL) v.AddArg(x) v.AddArg(y) return true } - goto endc99c55b2fd4bbe4f6eba9675087f215d -endc99c55b2fd4bbe4f6eba9675087f215d: - ; // match: (CMPLconst (ANDLconst [c] x) [0]) // cond: // result: (TESTLconst [c] x) - { + for { if v.Args[0].Op != OpAMD64ANDLconst { - goto end218077662043c7cfb0b92334ec8d691f + break } c := v.Args[0].AuxInt x := v.Args[0].Args[0] if v.AuxInt != 0 { - goto end218077662043c7cfb0b92334ec8d691f + break } v.reset(OpAMD64TESTLconst) v.AuxInt = c v.AddArg(x) return true } - goto end218077662043c7cfb0b92334ec8d691f -end218077662043c7cfb0b92334ec8d691f: - ; return false } func rewriteValueAMD64_OpAMD64CMPQ(v *Value, config *Config) bool { @@ -2589,34 +2298,31 @@ func rewriteValueAMD64_OpAMD64CMPQ(v *Value, config *Config) bool { // match: (CMPQ x (MOVQconst [c])) // cond: is32Bit(c) // result: (CMPQconst x [c]) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVQconst { - goto end3bbb2c6caa57853a7561738ce3c0c630 + break } c := v.Args[1].AuxInt if !(is32Bit(c)) { - goto end3bbb2c6caa57853a7561738ce3c0c630 + break } v.reset(OpAMD64CMPQconst) v.AddArg(x) v.AuxInt = c return true } - goto end3bbb2c6caa57853a7561738ce3c0c630 -end3bbb2c6caa57853a7561738ce3c0c630: - ; // match: (CMPQ (MOVQconst [c]) x) // cond: is32Bit(c) // result: (InvertFlags (CMPQconst x [c])) - { + for { if v.Args[0].Op != OpAMD64MOVQconst { - goto end153e951c4d9890ee40bf6f189ff6280e + break } c := v.Args[0].AuxInt x := v.Args[1] if !(is32Bit(c)) { - goto end153e951c4d9890ee40bf6f189ff6280e + break } v.reset(OpAMD64InvertFlags) v0 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeFlags) @@ -2625,9 +2331,6 @@ end3bbb2c6caa57853a7561738ce3c0c630: v.AddArg(v0) return true } - goto end153e951c4d9890ee40bf6f189ff6280e -end153e951c4d9890ee40bf6f189ff6280e: - ; return false } func rewriteValueAMD64_OpAMD64CMPQconst(v *Value, config *Config) bool { @@ -2636,151 +2339,127 @@ func rewriteValueAMD64_OpAMD64CMPQconst(v *Value, config *Config) bool { // match: (CMPQconst (MOVQconst [x]) [y]) // cond: x==y // result: (FlagEQ) - { + for { if v.Args[0].Op != OpAMD64MOVQconst { - goto enda7a434ec055a51246d67ff14b48e455d + break } x := v.Args[0].AuxInt y := v.AuxInt if !(x == y) { - goto enda7a434ec055a51246d67ff14b48e455d + break } v.reset(OpAMD64FlagEQ) return true } - goto enda7a434ec055a51246d67ff14b48e455d -enda7a434ec055a51246d67ff14b48e455d: - ; // match: (CMPQconst (MOVQconst [x]) [y]) // cond: xuint64(y) // result: (FlagLT_UGT) - { + for { if v.Args[0].Op != OpAMD64MOVQconst { - goto end38a2207ac4547f3f0cfb2bc48748e033 + break } x := v.Args[0].AuxInt y := v.AuxInt if !(x < y && uint64(x) > uint64(y)) { - goto end38a2207ac4547f3f0cfb2bc48748e033 + break } v.reset(OpAMD64FlagLT_UGT) return true } - goto end38a2207ac4547f3f0cfb2bc48748e033 -end38a2207ac4547f3f0cfb2bc48748e033: - ; // match: (CMPQconst (MOVQconst [x]) [y]) // cond: x>y && uint64(x) y && uint64(x) < uint64(y)) { - goto end0adaa13f82a881b97095d7a210b96f3c + break } v.reset(OpAMD64FlagGT_ULT) return true } - goto end0adaa13f82a881b97095d7a210b96f3c -end0adaa13f82a881b97095d7a210b96f3c: - ; // match: (CMPQconst (MOVQconst [x]) [y]) // cond: x>y && uint64(x)>uint64(y) // result: (FlagGT_UGT) - { + for { if v.Args[0].Op != OpAMD64MOVQconst { - goto end1248b87e4a141c78bc8eff05d3fac70e + break } x := v.Args[0].AuxInt y := v.AuxInt if !(x > y && uint64(x) > uint64(y)) { - goto end1248b87e4a141c78bc8eff05d3fac70e + break } v.reset(OpAMD64FlagGT_UGT) return true } - goto end1248b87e4a141c78bc8eff05d3fac70e -end1248b87e4a141c78bc8eff05d3fac70e: - ; // match: (CMPQconst (ANDQconst _ [m]) [n]) // cond: m+1==n && isPowerOfTwo(n) // result: (FlagLT_ULT) - { + for { if v.Args[0].Op != OpAMD64ANDQconst { - goto end934098fb12e383829b654938269abc12 + break } m := v.Args[0].AuxInt n := v.AuxInt if !(m+1 == n && isPowerOfTwo(n)) { - goto end934098fb12e383829b654938269abc12 + break } v.reset(OpAMD64FlagLT_ULT) return true } - goto end934098fb12e383829b654938269abc12 -end934098fb12e383829b654938269abc12: - ; // match: (CMPQconst (ANDQ x y) [0]) // cond: // result: (TESTQ x y) - { + for { if v.Args[0].Op != OpAMD64ANDQ { - goto endd253b271c624b83def50b061d8a945a1 + break } x := v.Args[0].Args[0] y := v.Args[0].Args[1] if v.AuxInt != 0 { - goto endd253b271c624b83def50b061d8a945a1 + break } v.reset(OpAMD64TESTQ) v.AddArg(x) v.AddArg(y) return true } - goto endd253b271c624b83def50b061d8a945a1 -endd253b271c624b83def50b061d8a945a1: - ; // match: (CMPQconst (ANDQconst [c] x) [0]) // cond: // result: (TESTQconst [c] x) - { + for { if v.Args[0].Op != OpAMD64ANDQconst { - goto endcf00c5ad714d2152d72184b163c8d57c + break } c := v.Args[0].AuxInt x := v.Args[0].Args[0] if v.AuxInt != 0 { - goto endcf00c5ad714d2152d72184b163c8d57c + break } v.reset(OpAMD64TESTQconst) v.AuxInt = c v.AddArg(x) return true } - goto endcf00c5ad714d2152d72184b163c8d57c -endcf00c5ad714d2152d72184b163c8d57c: - ; return false } func rewriteValueAMD64_OpAMD64CMPW(v *Value, config *Config) bool { @@ -2789,10 +2468,10 @@ func rewriteValueAMD64_OpAMD64CMPW(v *Value, config *Config) bool { // match: (CMPW x (MOVWconst [c])) // cond: // result: (CMPWconst x [c]) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVWconst { - goto end310a9ba58ac35c97587e08c63fe8a46c + break } c := v.Args[1].AuxInt v.reset(OpAMD64CMPWconst) @@ -2800,15 +2479,12 @@ func rewriteValueAMD64_OpAMD64CMPW(v *Value, config *Config) bool { v.AuxInt = c return true } - goto end310a9ba58ac35c97587e08c63fe8a46c -end310a9ba58ac35c97587e08c63fe8a46c: - ; // match: (CMPW (MOVWconst [c]) x) // cond: // result: (InvertFlags (CMPWconst x [c])) - { + for { if v.Args[0].Op != OpAMD64MOVWconst { - goto end3c52d0ae6e3d186bf131b41276c21889 + break } c := v.Args[0].AuxInt x := v.Args[1] @@ -2819,9 +2495,6 @@ end310a9ba58ac35c97587e08c63fe8a46c: v.AddArg(v0) return true } - goto end3c52d0ae6e3d186bf131b41276c21889 -end3c52d0ae6e3d186bf131b41276c21889: - ; return false } func rewriteValueAMD64_OpAMD64CMPWconst(v *Value, config *Config) bool { @@ -2830,151 +2503,127 @@ func rewriteValueAMD64_OpAMD64CMPWconst(v *Value, config *Config) bool { // match: (CMPWconst (MOVWconst [x]) [y]) // cond: int16(x)==int16(y) // result: (FlagEQ) - { + for { if v.Args[0].Op != OpAMD64MOVWconst { - goto endff7e81d2095a9997513cae77cd245b43 + break } x := v.Args[0].AuxInt y := v.AuxInt if !(int16(x) == int16(y)) { - goto endff7e81d2095a9997513cae77cd245b43 + break } v.reset(OpAMD64FlagEQ) return true } - goto endff7e81d2095a9997513cae77cd245b43 -endff7e81d2095a9997513cae77cd245b43: - ; // match: (CMPWconst (MOVWconst [x]) [y]) // cond: int16(x)uint16(y) // result: (FlagLT_UGT) - { + for { if v.Args[0].Op != OpAMD64MOVWconst { - goto ended901a2a49e592c431e45ffc17ca213d + break } x := v.Args[0].AuxInt y := v.AuxInt if !(int16(x) < int16(y) && uint16(x) > uint16(y)) { - goto ended901a2a49e592c431e45ffc17ca213d + break } v.reset(OpAMD64FlagLT_UGT) return true } - goto ended901a2a49e592c431e45ffc17ca213d -ended901a2a49e592c431e45ffc17ca213d: - ; // match: (CMPWconst (MOVWconst [x]) [y]) // cond: int16(x)>int16(y) && uint16(x) int16(y) && uint16(x) < uint16(y)) { - goto end66b1d55596a00cdc04ad83bfdeb6be8b + break } v.reset(OpAMD64FlagGT_ULT) return true } - goto end66b1d55596a00cdc04ad83bfdeb6be8b -end66b1d55596a00cdc04ad83bfdeb6be8b: - ; // match: (CMPWconst (MOVWconst [x]) [y]) // cond: int16(x)>int16(y) && uint16(x)>uint16(y) // result: (FlagGT_UGT) - { + for { if v.Args[0].Op != OpAMD64MOVWconst { - goto end4493f5af38d242ebb4bc2f64055a0854 + break } x := v.Args[0].AuxInt y := v.AuxInt if !(int16(x) > int16(y) && uint16(x) > uint16(y)) { - goto end4493f5af38d242ebb4bc2f64055a0854 + break } v.reset(OpAMD64FlagGT_UGT) return true } - goto end4493f5af38d242ebb4bc2f64055a0854 -end4493f5af38d242ebb4bc2f64055a0854: - ; // 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 { - goto endfcea07d93ded49b0e02d5fa0059309a4 + break } m := v.Args[0].AuxInt n := v.AuxInt if !(int16(m)+1 == int16(n) && isPowerOfTwo(int64(int16(n)))) { - goto endfcea07d93ded49b0e02d5fa0059309a4 + break } v.reset(OpAMD64FlagLT_ULT) return true } - goto endfcea07d93ded49b0e02d5fa0059309a4 -endfcea07d93ded49b0e02d5fa0059309a4: - ; // match: (CMPWconst (ANDW x y) [0]) // cond: // result: (TESTW x y) - { + for { if v.Args[0].Op != OpAMD64ANDW { - goto end390cbc150fec59cbf63a209c485ef8b2 + break } x := v.Args[0].Args[0] y := v.Args[0].Args[1] if v.AuxInt != 0 { - goto end390cbc150fec59cbf63a209c485ef8b2 + break } v.reset(OpAMD64TESTW) v.AddArg(x) v.AddArg(y) return true } - goto end390cbc150fec59cbf63a209c485ef8b2 -end390cbc150fec59cbf63a209c485ef8b2: - ; // match: (CMPWconst (ANDWconst [c] x) [0]) // cond: // result: (TESTWconst [c] x) - { + for { if v.Args[0].Op != OpAMD64ANDWconst { - goto end1bde0fea3dcffeb66b314bc6b4c9aae5 + break } c := v.Args[0].AuxInt x := v.Args[0].Args[0] if v.AuxInt != 0 { - goto end1bde0fea3dcffeb66b314bc6b4c9aae5 + break } v.reset(OpAMD64TESTWconst) v.AuxInt = c v.AddArg(x) return true } - goto end1bde0fea3dcffeb66b314bc6b4c9aae5 -end1bde0fea3dcffeb66b314bc6b4c9aae5: - ; return false } func rewriteValueAMD64_OpClosureCall(v *Value, config *Config) bool { @@ -2983,7 +2632,7 @@ func rewriteValueAMD64_OpClosureCall(v *Value, config *Config) bool { // 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] @@ -2995,9 +2644,6 @@ func rewriteValueAMD64_OpClosureCall(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto endfd75d26316012d86cb71d0dd1214259b -endfd75d26316012d86cb71d0dd1214259b: - ; return false } func rewriteValueAMD64_OpCom16(v *Value, config *Config) bool { @@ -3006,15 +2652,12 @@ func rewriteValueAMD64_OpCom16(v *Value, config *Config) bool { // match: (Com16 x) // cond: // result: (NOTW x) - { + for { x := v.Args[0] v.reset(OpAMD64NOTW) v.AddArg(x) return true } - goto end1b14ba8d7d7aa585ec0a211827f280ae -end1b14ba8d7d7aa585ec0a211827f280ae: - ; return false } func rewriteValueAMD64_OpCom32(v *Value, config *Config) bool { @@ -3023,15 +2666,12 @@ func rewriteValueAMD64_OpCom32(v *Value, config *Config) bool { // match: (Com32 x) // cond: // result: (NOTL x) - { + for { x := v.Args[0] v.reset(OpAMD64NOTL) v.AddArg(x) return true } - goto end6eb124ba3bdb3fd6031414370852feb6 -end6eb124ba3bdb3fd6031414370852feb6: - ; return false } func rewriteValueAMD64_OpCom64(v *Value, config *Config) bool { @@ -3040,15 +2680,12 @@ func rewriteValueAMD64_OpCom64(v *Value, config *Config) bool { // match: (Com64 x) // cond: // result: (NOTQ x) - { + for { x := v.Args[0] v.reset(OpAMD64NOTQ) v.AddArg(x) return true } - goto endf5f3b355a87779c347e305719dddda05 -endf5f3b355a87779c347e305719dddda05: - ; return false } func rewriteValueAMD64_OpCom8(v *Value, config *Config) bool { @@ -3057,15 +2694,12 @@ func rewriteValueAMD64_OpCom8(v *Value, config *Config) bool { // match: (Com8 x) // cond: // result: (NOTB x) - { + for { x := v.Args[0] v.reset(OpAMD64NOTB) v.AddArg(x) return true } - goto end1c7c5c055d663ccf1f05fbc4883030c6 -end1c7c5c055d663ccf1f05fbc4883030c6: - ; return false } func rewriteValueAMD64_OpConst16(v *Value, config *Config) bool { @@ -3074,15 +2708,12 @@ func rewriteValueAMD64_OpConst16(v *Value, config *Config) bool { // match: (Const16 [val]) // cond: // result: (MOVWconst [val]) - { + for { val := v.AuxInt v.reset(OpAMD64MOVWconst) v.AuxInt = val return true } - goto end2c6c92f297873b8ac12bd035d56d001e -end2c6c92f297873b8ac12bd035d56d001e: - ; return false } func rewriteValueAMD64_OpConst32(v *Value, config *Config) bool { @@ -3091,15 +2722,12 @@ func rewriteValueAMD64_OpConst32(v *Value, config *Config) bool { // match: (Const32 [val]) // cond: // result: (MOVLconst [val]) - { + for { val := v.AuxInt v.reset(OpAMD64MOVLconst) v.AuxInt = val return true } - goto enddae5807662af67143a3ac3ad9c63bae5 -enddae5807662af67143a3ac3ad9c63bae5: - ; return false } func rewriteValueAMD64_OpConst32F(v *Value, config *Config) bool { @@ -3108,15 +2736,12 @@ func rewriteValueAMD64_OpConst32F(v *Value, config *Config) bool { // match: (Const32F [val]) // cond: // result: (MOVSSconst [val]) - { + for { val := v.AuxInt v.reset(OpAMD64MOVSSconst) v.AuxInt = val return true } - goto endfabcef2d57a8f36eaa6041de6f112b89 -endfabcef2d57a8f36eaa6041de6f112b89: - ; return false } func rewriteValueAMD64_OpConst64(v *Value, config *Config) bool { @@ -3125,15 +2750,12 @@ func rewriteValueAMD64_OpConst64(v *Value, config *Config) bool { // match: (Const64 [val]) // cond: // result: (MOVQconst [val]) - { + for { val := v.AuxInt v.reset(OpAMD64MOVQconst) v.AuxInt = val return true } - goto endc630434ae7f143ab69d5f482a9b52b5f -endc630434ae7f143ab69d5f482a9b52b5f: - ; return false } func rewriteValueAMD64_OpConst64F(v *Value, config *Config) bool { @@ -3142,15 +2764,12 @@ func rewriteValueAMD64_OpConst64F(v *Value, config *Config) bool { // match: (Const64F [val]) // cond: // result: (MOVSDconst [val]) - { + for { val := v.AuxInt v.reset(OpAMD64MOVSDconst) v.AuxInt = val return true } - goto endae6cf7189e464bbde17b98635a20f0ff -endae6cf7189e464bbde17b98635a20f0ff: - ; return false } func rewriteValueAMD64_OpConst8(v *Value, config *Config) bool { @@ -3159,15 +2778,12 @@ func rewriteValueAMD64_OpConst8(v *Value, config *Config) bool { // match: (Const8 [val]) // cond: // result: (MOVBconst [val]) - { + for { val := v.AuxInt v.reset(OpAMD64MOVBconst) v.AuxInt = val return true } - goto end200524c722ed14ca935ba47f8f30327d -end200524c722ed14ca935ba47f8f30327d: - ; return false } func rewriteValueAMD64_OpConstBool(v *Value, config *Config) bool { @@ -3176,15 +2792,12 @@ func rewriteValueAMD64_OpConstBool(v *Value, config *Config) bool { // match: (ConstBool [b]) // cond: // result: (MOVBconst [b]) - { + for { b := v.AuxInt v.reset(OpAMD64MOVBconst) v.AuxInt = b return true } - goto end6d919011283330dcbcb3826f0adc6793 -end6d919011283330dcbcb3826f0adc6793: - ; return false } func rewriteValueAMD64_OpConstNil(v *Value, config *Config) bool { @@ -3193,14 +2806,11 @@ func rewriteValueAMD64_OpConstNil(v *Value, config *Config) bool { // match: (ConstNil) // cond: // result: (MOVQconst [0]) - { + for { v.reset(OpAMD64MOVQconst) v.AuxInt = 0 return true } - goto endea557d921056c25b945a49649e4b9b91 -endea557d921056c25b945a49649e4b9b91: - ; return false } func rewriteValueAMD64_OpConvert(v *Value, config *Config) bool { @@ -3209,7 +2819,7 @@ func rewriteValueAMD64_OpConvert(v *Value, config *Config) bool { // match: (Convert x mem) // cond: // result: (MOVQconvert x mem) - { + for { t := v.Type x := v.Args[0] mem := v.Args[1] @@ -3219,9 +2829,6 @@ func rewriteValueAMD64_OpConvert(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto end0aa5cd28888761ffab21bce45db361c8 -end0aa5cd28888761ffab21bce45db361c8: - ; return false } func rewriteValueAMD64_OpCvt32Fto32(v *Value, config *Config) bool { @@ -3230,15 +2837,12 @@ func rewriteValueAMD64_OpCvt32Fto32(v *Value, config *Config) bool { // match: (Cvt32Fto32 x) // cond: // result: (CVTTSS2SL x) - { + for { x := v.Args[0] v.reset(OpAMD64CVTTSS2SL) v.AddArg(x) return true } - goto enda410209d31804e1bce7bdc235fc62342 -enda410209d31804e1bce7bdc235fc62342: - ; return false } func rewriteValueAMD64_OpCvt32Fto64(v *Value, config *Config) bool { @@ -3247,15 +2851,12 @@ func rewriteValueAMD64_OpCvt32Fto64(v *Value, config *Config) bool { // match: (Cvt32Fto64 x) // cond: // result: (CVTTSS2SQ x) - { + for { x := v.Args[0] v.reset(OpAMD64CVTTSS2SQ) v.AddArg(x) return true } - goto enddb02fa4f3230a14d557d6c90cdadd523 -enddb02fa4f3230a14d557d6c90cdadd523: - ; return false } func rewriteValueAMD64_OpCvt32Fto64F(v *Value, config *Config) bool { @@ -3264,15 +2865,12 @@ func rewriteValueAMD64_OpCvt32Fto64F(v *Value, config *Config) bool { // match: (Cvt32Fto64F x) // cond: // result: (CVTSS2SD x) - { + for { x := v.Args[0] v.reset(OpAMD64CVTSS2SD) v.AddArg(x) return true } - goto end0bf5d6f8d182ee2b3ab7d7c2f8ff7790 -end0bf5d6f8d182ee2b3ab7d7c2f8ff7790: - ; return false } func rewriteValueAMD64_OpCvt32to32F(v *Value, config *Config) bool { @@ -3281,15 +2879,12 @@ func rewriteValueAMD64_OpCvt32to32F(v *Value, config *Config) bool { // match: (Cvt32to32F x) // cond: // result: (CVTSL2SS x) - { + for { x := v.Args[0] v.reset(OpAMD64CVTSL2SS) v.AddArg(x) return true } - goto ende0bdea2b21aecdb8399d6fd80ddc97d6 -ende0bdea2b21aecdb8399d6fd80ddc97d6: - ; return false } func rewriteValueAMD64_OpCvt32to64F(v *Value, config *Config) bool { @@ -3298,15 +2893,12 @@ func rewriteValueAMD64_OpCvt32to64F(v *Value, config *Config) bool { // match: (Cvt32to64F x) // cond: // result: (CVTSL2SD x) - { + for { x := v.Args[0] v.reset(OpAMD64CVTSL2SD) v.AddArg(x) return true } - goto ende06cbe745112bcf0e6612788ef71c958 -ende06cbe745112bcf0e6612788ef71c958: - ; return false } func rewriteValueAMD64_OpCvt64Fto32(v *Value, config *Config) bool { @@ -3315,15 +2907,12 @@ func rewriteValueAMD64_OpCvt64Fto32(v *Value, config *Config) bool { // match: (Cvt64Fto32 x) // cond: // result: (CVTTSD2SL x) - { + for { x := v.Args[0] v.reset(OpAMD64CVTTSD2SL) v.AddArg(x) return true } - goto endc213dd690dfe568607dec717b2c385b7 -endc213dd690dfe568607dec717b2c385b7: - ; return false } func rewriteValueAMD64_OpCvt64Fto32F(v *Value, config *Config) bool { @@ -3332,15 +2921,12 @@ func rewriteValueAMD64_OpCvt64Fto32F(v *Value, config *Config) bool { // match: (Cvt64Fto32F x) // cond: // result: (CVTSD2SS x) - { + for { x := v.Args[0] v.reset(OpAMD64CVTSD2SS) v.AddArg(x) return true } - goto endfd70158a96824ced99712d606c607d94 -endfd70158a96824ced99712d606c607d94: - ; return false } func rewriteValueAMD64_OpCvt64Fto64(v *Value, config *Config) bool { @@ -3349,15 +2935,12 @@ func rewriteValueAMD64_OpCvt64Fto64(v *Value, config *Config) bool { // match: (Cvt64Fto64 x) // cond: // result: (CVTTSD2SQ x) - { + for { x := v.Args[0] v.reset(OpAMD64CVTTSD2SQ) v.AddArg(x) return true } - goto end0bf3e4468047fd20714266ff05797454 -end0bf3e4468047fd20714266ff05797454: - ; return false } func rewriteValueAMD64_OpCvt64to32F(v *Value, config *Config) bool { @@ -3366,15 +2949,12 @@ func rewriteValueAMD64_OpCvt64to32F(v *Value, config *Config) bool { // match: (Cvt64to32F x) // cond: // result: (CVTSQ2SS x) - { + for { x := v.Args[0] v.reset(OpAMD64CVTSQ2SS) v.AddArg(x) return true } - goto endfecc08b8a8cbd2bf3be21a077c4d0d40 -endfecc08b8a8cbd2bf3be21a077c4d0d40: - ; return false } func rewriteValueAMD64_OpCvt64to64F(v *Value, config *Config) bool { @@ -3383,15 +2963,12 @@ func rewriteValueAMD64_OpCvt64to64F(v *Value, config *Config) bool { // match: (Cvt64to64F x) // cond: // result: (CVTSQ2SD x) - { + for { x := v.Args[0] v.reset(OpAMD64CVTSQ2SD) v.AddArg(x) return true } - goto endf74ce5df659f385f75c61187b515a5d0 -endf74ce5df659f385f75c61187b515a5d0: - ; return false } func rewriteValueAMD64_OpDeferCall(v *Value, config *Config) bool { @@ -3400,7 +2977,7 @@ func rewriteValueAMD64_OpDeferCall(v *Value, config *Config) bool { // match: (DeferCall [argwid] mem) // cond: // result: (CALLdefer [argwid] mem) - { + for { argwid := v.AuxInt mem := v.Args[0] v.reset(OpAMD64CALLdefer) @@ -3408,9 +2985,6 @@ func rewriteValueAMD64_OpDeferCall(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto end1c408581037450df959dd1fb7554a022 -end1c408581037450df959dd1fb7554a022: - ; return false } func rewriteValueAMD64_OpDiv16(v *Value, config *Config) bool { @@ -3419,7 +2993,7 @@ func rewriteValueAMD64_OpDiv16(v *Value, config *Config) bool { // match: (Div16 x y) // cond: // result: (DIVW x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64DIVW) @@ -3427,9 +3001,6 @@ func rewriteValueAMD64_OpDiv16(v *Value, config *Config) bool { v.AddArg(y) return true } - goto endb60a86e606726640c84d3e1e5a5ce890 -endb60a86e606726640c84d3e1e5a5ce890: - ; return false } func rewriteValueAMD64_OpDiv16u(v *Value, config *Config) bool { @@ -3438,7 +3009,7 @@ func rewriteValueAMD64_OpDiv16u(v *Value, config *Config) bool { // match: (Div16u x y) // cond: // result: (DIVWU x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64DIVWU) @@ -3446,9 +3017,6 @@ func rewriteValueAMD64_OpDiv16u(v *Value, config *Config) bool { v.AddArg(y) return true } - goto end6af9e212a865593e506bfdf7db67c9ec -end6af9e212a865593e506bfdf7db67c9ec: - ; return false } func rewriteValueAMD64_OpDiv32(v *Value, config *Config) bool { @@ -3457,7 +3025,7 @@ func rewriteValueAMD64_OpDiv32(v *Value, config *Config) bool { // match: (Div32 x y) // cond: // result: (DIVL x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64DIVL) @@ -3465,9 +3033,6 @@ func rewriteValueAMD64_OpDiv32(v *Value, config *Config) bool { v.AddArg(y) return true } - goto endf20ac71407e57c2904684d3cc33cf697 -endf20ac71407e57c2904684d3cc33cf697: - ; return false } func rewriteValueAMD64_OpDiv32F(v *Value, config *Config) bool { @@ -3476,7 +3041,7 @@ func rewriteValueAMD64_OpDiv32F(v *Value, config *Config) bool { // match: (Div32F x y) // cond: // result: (DIVSS x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64DIVSS) @@ -3484,9 +3049,6 @@ func rewriteValueAMD64_OpDiv32F(v *Value, config *Config) bool { v.AddArg(y) return true } - goto enddca0462c7b176c4138854d7d5627ab5b -enddca0462c7b176c4138854d7d5627ab5b: - ; return false } func rewriteValueAMD64_OpDiv32u(v *Value, config *Config) bool { @@ -3495,7 +3057,7 @@ func rewriteValueAMD64_OpDiv32u(v *Value, config *Config) bool { // match: (Div32u x y) // cond: // result: (DIVLU x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64DIVLU) @@ -3503,9 +3065,6 @@ func rewriteValueAMD64_OpDiv32u(v *Value, config *Config) bool { v.AddArg(y) return true } - goto enda22604d23eeb1298008c97b817f60bbd -enda22604d23eeb1298008c97b817f60bbd: - ; return false } func rewriteValueAMD64_OpDiv64(v *Value, config *Config) bool { @@ -3514,7 +3073,7 @@ func rewriteValueAMD64_OpDiv64(v *Value, config *Config) bool { // match: (Div64 x y) // cond: // result: (DIVQ x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64DIVQ) @@ -3522,9 +3081,6 @@ func rewriteValueAMD64_OpDiv64(v *Value, config *Config) bool { v.AddArg(y) return true } - goto end86490d9b337333dfc09a413e1e0120a9 -end86490d9b337333dfc09a413e1e0120a9: - ; return false } func rewriteValueAMD64_OpDiv64F(v *Value, config *Config) bool { @@ -3533,7 +3089,7 @@ func rewriteValueAMD64_OpDiv64F(v *Value, config *Config) bool { // match: (Div64F x y) // cond: // result: (DIVSD x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64DIVSD) @@ -3541,9 +3097,6 @@ func rewriteValueAMD64_OpDiv64F(v *Value, config *Config) bool { v.AddArg(y) return true } - goto end12299d76db5144a60f564d34ba97eb43 -end12299d76db5144a60f564d34ba97eb43: - ; return false } func rewriteValueAMD64_OpDiv64u(v *Value, config *Config) bool { @@ -3552,7 +3105,7 @@ func rewriteValueAMD64_OpDiv64u(v *Value, config *Config) bool { // match: (Div64u x y) // cond: // result: (DIVQU x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64DIVQU) @@ -3560,9 +3113,6 @@ func rewriteValueAMD64_OpDiv64u(v *Value, config *Config) bool { v.AddArg(y) return true } - goto endf871d8b397e5fad6a5b500cc0c759a8d -endf871d8b397e5fad6a5b500cc0c759a8d: - ; return false } func rewriteValueAMD64_OpDiv8(v *Value, config *Config) bool { @@ -3571,7 +3121,7 @@ func rewriteValueAMD64_OpDiv8(v *Value, config *Config) bool { // match: (Div8 x y) // cond: // result: (DIVW (SignExt8to16 x) (SignExt8to16 y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64DIVW) @@ -3583,9 +3133,6 @@ func rewriteValueAMD64_OpDiv8(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto endeee2bc780a73ec2ccb1a66c527816ee0 -endeee2bc780a73ec2ccb1a66c527816ee0: - ; return false } func rewriteValueAMD64_OpDiv8u(v *Value, config *Config) bool { @@ -3594,7 +3141,7 @@ func rewriteValueAMD64_OpDiv8u(v *Value, config *Config) bool { // match: (Div8u x y) // cond: // result: (DIVWU (ZeroExt8to16 x) (ZeroExt8to16 y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64DIVWU) @@ -3606,9 +3153,6 @@ func rewriteValueAMD64_OpDiv8u(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto end39da6664d6434d844303f6924cc875dd -end39da6664d6434d844303f6924cc875dd: - ; return false } func rewriteValueAMD64_OpEq16(v *Value, config *Config) bool { @@ -3617,7 +3161,7 @@ func rewriteValueAMD64_OpEq16(v *Value, config *Config) bool { // match: (Eq16 x y) // cond: // result: (SETEQ (CMPW x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETEQ) @@ -3627,9 +3171,6 @@ func rewriteValueAMD64_OpEq16(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto endd7f668b1d23603b0949953ee8dec8107 -endd7f668b1d23603b0949953ee8dec8107: - ; return false } func rewriteValueAMD64_OpEq32(v *Value, config *Config) bool { @@ -3638,7 +3179,7 @@ func rewriteValueAMD64_OpEq32(v *Value, config *Config) bool { // match: (Eq32 x y) // cond: // result: (SETEQ (CMPL x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETEQ) @@ -3648,9 +3189,6 @@ func rewriteValueAMD64_OpEq32(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto endf28041ae0c73fb341cc0d2f4903fb2fb -endf28041ae0c73fb341cc0d2f4903fb2fb: - ; return false } func rewriteValueAMD64_OpEq32F(v *Value, config *Config) bool { @@ -3659,7 +3197,7 @@ func rewriteValueAMD64_OpEq32F(v *Value, config *Config) bool { // match: (Eq32F x y) // cond: // result: (SETEQF (UCOMISS x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETEQF) @@ -3669,9 +3207,6 @@ func rewriteValueAMD64_OpEq32F(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto endb2c12933769e5faa8fc238048e113dee -endb2c12933769e5faa8fc238048e113dee: - ; return false } func rewriteValueAMD64_OpEq64(v *Value, config *Config) bool { @@ -3680,7 +3215,7 @@ func rewriteValueAMD64_OpEq64(v *Value, config *Config) bool { // match: (Eq64 x y) // cond: // result: (SETEQ (CMPQ x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETEQ) @@ -3690,9 +3225,6 @@ func rewriteValueAMD64_OpEq64(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto ende07a380487b710b51bcd5aa6d3144b8c -ende07a380487b710b51bcd5aa6d3144b8c: - ; return false } func rewriteValueAMD64_OpEq64F(v *Value, config *Config) bool { @@ -3701,7 +3233,7 @@ func rewriteValueAMD64_OpEq64F(v *Value, config *Config) bool { // match: (Eq64F x y) // cond: // result: (SETEQF (UCOMISD x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETEQF) @@ -3711,9 +3243,6 @@ func rewriteValueAMD64_OpEq64F(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end68e20c0c1b3ee62fbd17af07ac100704 -end68e20c0c1b3ee62fbd17af07ac100704: - ; return false } func rewriteValueAMD64_OpEq8(v *Value, config *Config) bool { @@ -3722,7 +3251,7 @@ func rewriteValueAMD64_OpEq8(v *Value, config *Config) bool { // match: (Eq8 x y) // cond: // result: (SETEQ (CMPB x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETEQ) @@ -3732,9 +3261,6 @@ func rewriteValueAMD64_OpEq8(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end359e5a51d2ab928a455f0ae5adb42ab0 -end359e5a51d2ab928a455f0ae5adb42ab0: - ; return false } func rewriteValueAMD64_OpEqPtr(v *Value, config *Config) bool { @@ -3743,7 +3269,7 @@ func rewriteValueAMD64_OpEqPtr(v *Value, config *Config) bool { // match: (EqPtr x y) // cond: // result: (SETEQ (CMPQ x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETEQ) @@ -3753,9 +3279,6 @@ func rewriteValueAMD64_OpEqPtr(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto endf19bd3c0eb99d15718bef4066d62560c -endf19bd3c0eb99d15718bef4066d62560c: - ; return false } func rewriteValueAMD64_OpGeq16(v *Value, config *Config) bool { @@ -3764,7 +3287,7 @@ func rewriteValueAMD64_OpGeq16(v *Value, config *Config) bool { // match: (Geq16 x y) // cond: // result: (SETGE (CMPW x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETGE) @@ -3774,9 +3297,6 @@ func rewriteValueAMD64_OpGeq16(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end0a3f723d5c0b877c473b0043d814867b -end0a3f723d5c0b877c473b0043d814867b: - ; return false } func rewriteValueAMD64_OpGeq16U(v *Value, config *Config) bool { @@ -3785,7 +3305,7 @@ func rewriteValueAMD64_OpGeq16U(v *Value, config *Config) bool { // match: (Geq16U x y) // cond: // result: (SETAE (CMPW x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETAE) @@ -3795,9 +3315,6 @@ func rewriteValueAMD64_OpGeq16U(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end79d754a28ee34eff95140635b26f0248 -end79d754a28ee34eff95140635b26f0248: - ; return false } func rewriteValueAMD64_OpGeq32(v *Value, config *Config) bool { @@ -3806,7 +3323,7 @@ func rewriteValueAMD64_OpGeq32(v *Value, config *Config) bool { // match: (Geq32 x y) // cond: // result: (SETGE (CMPL x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETGE) @@ -3816,9 +3333,6 @@ func rewriteValueAMD64_OpGeq32(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto endfb1f6286a1b153b2a3f5b8548a782c8c -endfb1f6286a1b153b2a3f5b8548a782c8c: - ; return false } func rewriteValueAMD64_OpGeq32F(v *Value, config *Config) bool { @@ -3827,7 +3341,7 @@ func rewriteValueAMD64_OpGeq32F(v *Value, config *Config) bool { // match: (Geq32F x y) // cond: // result: (SETGEF (UCOMISS x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETGEF) @@ -3837,9 +3351,6 @@ func rewriteValueAMD64_OpGeq32F(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end7a8d6107a945410e64db06669a61da97 -end7a8d6107a945410e64db06669a61da97: - ; return false } func rewriteValueAMD64_OpGeq32U(v *Value, config *Config) bool { @@ -3848,7 +3359,7 @@ func rewriteValueAMD64_OpGeq32U(v *Value, config *Config) bool { // match: (Geq32U x y) // cond: // result: (SETAE (CMPL x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETAE) @@ -3858,9 +3369,6 @@ func rewriteValueAMD64_OpGeq32U(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto endc5d3478a626df01ede063564f4cb80d0 -endc5d3478a626df01ede063564f4cb80d0: - ; return false } func rewriteValueAMD64_OpGeq64(v *Value, config *Config) bool { @@ -3869,7 +3377,7 @@ func rewriteValueAMD64_OpGeq64(v *Value, config *Config) bool { // match: (Geq64 x y) // cond: // result: (SETGE (CMPQ x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETGE) @@ -3879,9 +3387,6 @@ func rewriteValueAMD64_OpGeq64(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end74bddb7905ab865de5b041e7e4789911 -end74bddb7905ab865de5b041e7e4789911: - ; return false } func rewriteValueAMD64_OpGeq64F(v *Value, config *Config) bool { @@ -3890,7 +3395,7 @@ func rewriteValueAMD64_OpGeq64F(v *Value, config *Config) bool { // match: (Geq64F x y) // cond: // result: (SETGEF (UCOMISD x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETGEF) @@ -3900,9 +3405,6 @@ func rewriteValueAMD64_OpGeq64F(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end9fac9bd98ef58b7fbbe1a31f84bdcccf -end9fac9bd98ef58b7fbbe1a31f84bdcccf: - ; return false } func rewriteValueAMD64_OpGeq64U(v *Value, config *Config) bool { @@ -3911,7 +3413,7 @@ func rewriteValueAMD64_OpGeq64U(v *Value, config *Config) bool { // match: (Geq64U x y) // cond: // result: (SETAE (CMPQ x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETAE) @@ -3921,9 +3423,6 @@ func rewriteValueAMD64_OpGeq64U(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end95101721fc8f5be9969e50e364143e7f -end95101721fc8f5be9969e50e364143e7f: - ; return false } func rewriteValueAMD64_OpGeq8(v *Value, config *Config) bool { @@ -3932,7 +3431,7 @@ func rewriteValueAMD64_OpGeq8(v *Value, config *Config) bool { // match: (Geq8 x y) // cond: // result: (SETGE (CMPB x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETGE) @@ -3942,9 +3441,6 @@ func rewriteValueAMD64_OpGeq8(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end983070a3db317bdb64b5a0fb104d267c -end983070a3db317bdb64b5a0fb104d267c: - ; return false } func rewriteValueAMD64_OpGeq8U(v *Value, config *Config) bool { @@ -3953,7 +3449,7 @@ func rewriteValueAMD64_OpGeq8U(v *Value, config *Config) bool { // match: (Geq8U x y) // cond: // result: (SETAE (CMPB x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETAE) @@ -3963,9 +3459,6 @@ func rewriteValueAMD64_OpGeq8U(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto enda617119faaccc0f0c2d23548116cf331 -enda617119faaccc0f0c2d23548116cf331: - ; return false } func rewriteValueAMD64_OpGetClosurePtr(v *Value, config *Config) bool { @@ -3974,13 +3467,10 @@ func rewriteValueAMD64_OpGetClosurePtr(v *Value, config *Config) bool { // match: (GetClosurePtr) // cond: // result: (LoweredGetClosurePtr) - { + for { v.reset(OpAMD64LoweredGetClosurePtr) return true } - goto end6fd0b53f0acb4d35e7d7fa78d2ca1392 -end6fd0b53f0acb4d35e7d7fa78d2ca1392: - ; return false } func rewriteValueAMD64_OpGetG(v *Value, config *Config) bool { @@ -3989,15 +3479,12 @@ func rewriteValueAMD64_OpGetG(v *Value, config *Config) bool { // match: (GetG mem) // cond: // result: (LoweredGetG mem) - { + for { mem := v.Args[0] v.reset(OpAMD64LoweredGetG) v.AddArg(mem) return true } - goto endf543eaaf68c4bef1d4cdc8ba19683723 -endf543eaaf68c4bef1d4cdc8ba19683723: - ; return false } func rewriteValueAMD64_OpGoCall(v *Value, config *Config) bool { @@ -4006,7 +3493,7 @@ func rewriteValueAMD64_OpGoCall(v *Value, config *Config) bool { // match: (GoCall [argwid] mem) // cond: // result: (CALLgo [argwid] mem) - { + for { argwid := v.AuxInt mem := v.Args[0] v.reset(OpAMD64CALLgo) @@ -4014,9 +3501,6 @@ func rewriteValueAMD64_OpGoCall(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto end1cef0f92c46e6aaa2c7abdf5f2794baf -end1cef0f92c46e6aaa2c7abdf5f2794baf: - ; return false } func rewriteValueAMD64_OpGreater16(v *Value, config *Config) bool { @@ -4025,7 +3509,7 @@ func rewriteValueAMD64_OpGreater16(v *Value, config *Config) bool { // match: (Greater16 x y) // cond: // result: (SETG (CMPW x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETG) @@ -4035,9 +3519,6 @@ func rewriteValueAMD64_OpGreater16(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end4e4a1307c61240af9a86d8fe4f834ee8 -end4e4a1307c61240af9a86d8fe4f834ee8: - ; return false } func rewriteValueAMD64_OpGreater16U(v *Value, config *Config) bool { @@ -4046,7 +3527,7 @@ func rewriteValueAMD64_OpGreater16U(v *Value, config *Config) bool { // match: (Greater16U x y) // cond: // result: (SETA (CMPW x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETA) @@ -4056,9 +3537,6 @@ func rewriteValueAMD64_OpGreater16U(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end7c66c75f4b8ec1db593f3e60cfba9592 -end7c66c75f4b8ec1db593f3e60cfba9592: - ; return false } func rewriteValueAMD64_OpGreater32(v *Value, config *Config) bool { @@ -4067,7 +3545,7 @@ func rewriteValueAMD64_OpGreater32(v *Value, config *Config) bool { // match: (Greater32 x y) // cond: // result: (SETG (CMPL x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETG) @@ -4077,9 +3555,6 @@ func rewriteValueAMD64_OpGreater32(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end6fb0eae4a0e0e81b4afb085d398d873b -end6fb0eae4a0e0e81b4afb085d398d873b: - ; return false } func rewriteValueAMD64_OpGreater32F(v *Value, config *Config) bool { @@ -4088,7 +3563,7 @@ func rewriteValueAMD64_OpGreater32F(v *Value, config *Config) bool { // match: (Greater32F x y) // cond: // result: (SETGF (UCOMISS x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETGF) @@ -4098,9 +3573,6 @@ func rewriteValueAMD64_OpGreater32F(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end94df0bd5cedad8ce8021df1b24da40c6 -end94df0bd5cedad8ce8021df1b24da40c6: - ; return false } func rewriteValueAMD64_OpGreater32U(v *Value, config *Config) bool { @@ -4109,7 +3581,7 @@ func rewriteValueAMD64_OpGreater32U(v *Value, config *Config) bool { // match: (Greater32U x y) // cond: // result: (SETA (CMPL x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETA) @@ -4119,9 +3591,6 @@ func rewriteValueAMD64_OpGreater32U(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end18da022a28eae8bd0771e0c948aadaf8 -end18da022a28eae8bd0771e0c948aadaf8: - ; return false } func rewriteValueAMD64_OpGreater64(v *Value, config *Config) bool { @@ -4130,7 +3599,7 @@ func rewriteValueAMD64_OpGreater64(v *Value, config *Config) bool { // match: (Greater64 x y) // cond: // result: (SETG (CMPQ x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETG) @@ -4140,9 +3609,6 @@ func rewriteValueAMD64_OpGreater64(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto endc025c908708f939780fba0da0c1148b4 -endc025c908708f939780fba0da0c1148b4: - ; return false } func rewriteValueAMD64_OpGreater64F(v *Value, config *Config) bool { @@ -4151,7 +3617,7 @@ func rewriteValueAMD64_OpGreater64F(v *Value, config *Config) bool { // match: (Greater64F x y) // cond: // result: (SETGF (UCOMISD x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETGF) @@ -4161,9 +3627,6 @@ func rewriteValueAMD64_OpGreater64F(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end033ca5181b18376e7215c02812ef5a6b -end033ca5181b18376e7215c02812ef5a6b: - ; return false } func rewriteValueAMD64_OpGreater64U(v *Value, config *Config) bool { @@ -4172,7 +3635,7 @@ func rewriteValueAMD64_OpGreater64U(v *Value, config *Config) bool { // match: (Greater64U x y) // cond: // result: (SETA (CMPQ x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETA) @@ -4182,9 +3645,6 @@ func rewriteValueAMD64_OpGreater64U(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto endb3e25347041760a04d3fc8321c3f3d00 -endb3e25347041760a04d3fc8321c3f3d00: - ; return false } func rewriteValueAMD64_OpGreater8(v *Value, config *Config) bool { @@ -4193,7 +3653,7 @@ func rewriteValueAMD64_OpGreater8(v *Value, config *Config) bool { // match: (Greater8 x y) // cond: // result: (SETG (CMPB x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETG) @@ -4203,9 +3663,6 @@ func rewriteValueAMD64_OpGreater8(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto enda3eeb5da2e69cb54a1515601d4b360d4 -enda3eeb5da2e69cb54a1515601d4b360d4: - ; return false } func rewriteValueAMD64_OpGreater8U(v *Value, config *Config) bool { @@ -4214,7 +3671,7 @@ func rewriteValueAMD64_OpGreater8U(v *Value, config *Config) bool { // match: (Greater8U x y) // cond: // result: (SETA (CMPB x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETA) @@ -4224,9 +3681,6 @@ func rewriteValueAMD64_OpGreater8U(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto endd2027f3b6471262f42b90c8cc0413667 -endd2027f3b6471262f42b90c8cc0413667: - ; return false } func rewriteValueAMD64_OpHmul16(v *Value, config *Config) bool { @@ -4235,7 +3689,7 @@ func rewriteValueAMD64_OpHmul16(v *Value, config *Config) bool { // match: (Hmul16 x y) // cond: // result: (HMULW x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64HMULW) @@ -4243,9 +3697,6 @@ func rewriteValueAMD64_OpHmul16(v *Value, config *Config) bool { v.AddArg(y) return true } - goto end1b9ff394bb3b06fc109637656b6875f5 -end1b9ff394bb3b06fc109637656b6875f5: - ; return false } func rewriteValueAMD64_OpHmul16u(v *Value, config *Config) bool { @@ -4254,7 +3705,7 @@ func rewriteValueAMD64_OpHmul16u(v *Value, config *Config) bool { // match: (Hmul16u x y) // cond: // result: (HMULWU x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64HMULWU) @@ -4262,9 +3713,6 @@ func rewriteValueAMD64_OpHmul16u(v *Value, config *Config) bool { v.AddArg(y) return true } - goto endee9089e794a43f2ce1619a6ef61670f4 -endee9089e794a43f2ce1619a6ef61670f4: - ; return false } func rewriteValueAMD64_OpHmul32(v *Value, config *Config) bool { @@ -4273,7 +3721,7 @@ func rewriteValueAMD64_OpHmul32(v *Value, config *Config) bool { // match: (Hmul32 x y) // cond: // result: (HMULL x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64HMULL) @@ -4281,9 +3729,6 @@ func rewriteValueAMD64_OpHmul32(v *Value, config *Config) bool { v.AddArg(y) return true } - goto end7c83c91ef2634f0b1da4f49350b437b1 -end7c83c91ef2634f0b1da4f49350b437b1: - ; return false } func rewriteValueAMD64_OpHmul32u(v *Value, config *Config) bool { @@ -4292,7 +3737,7 @@ func rewriteValueAMD64_OpHmul32u(v *Value, config *Config) bool { // match: (Hmul32u x y) // cond: // result: (HMULLU x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64HMULLU) @@ -4300,9 +3745,6 @@ func rewriteValueAMD64_OpHmul32u(v *Value, config *Config) bool { v.AddArg(y) return true } - goto end3c4f36611dc8815aa2a63d4ec0eaa06d -end3c4f36611dc8815aa2a63d4ec0eaa06d: - ; return false } func rewriteValueAMD64_OpHmul8(v *Value, config *Config) bool { @@ -4311,7 +3753,7 @@ func rewriteValueAMD64_OpHmul8(v *Value, config *Config) bool { // match: (Hmul8 x y) // cond: // result: (HMULB x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64HMULB) @@ -4319,9 +3761,6 @@ func rewriteValueAMD64_OpHmul8(v *Value, config *Config) bool { v.AddArg(y) return true } - goto end51b2cc9f1ed15314e68fc81024f281a7 -end51b2cc9f1ed15314e68fc81024f281a7: - ; return false } func rewriteValueAMD64_OpHmul8u(v *Value, config *Config) bool { @@ -4330,7 +3769,7 @@ func rewriteValueAMD64_OpHmul8u(v *Value, config *Config) bool { // match: (Hmul8u x y) // cond: // result: (HMULBU x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64HMULBU) @@ -4338,9 +3777,6 @@ func rewriteValueAMD64_OpHmul8u(v *Value, config *Config) bool { v.AddArg(y) return true } - goto ende68d7b3a3c774cedc3522af9d635c39d -ende68d7b3a3c774cedc3522af9d635c39d: - ; return false } func rewriteValueAMD64_OpITab(v *Value, config *Config) bool { @@ -4349,9 +3785,9 @@ func rewriteValueAMD64_OpITab(v *Value, config *Config) bool { // match: (ITab (Load ptr mem)) // cond: // result: (MOVQload ptr mem) - { + for { if v.Args[0].Op != OpLoad { - goto enda49fcae3630a097c78aa58189c90a97a + break } ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] @@ -4360,9 +3796,6 @@ func rewriteValueAMD64_OpITab(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto enda49fcae3630a097c78aa58189c90a97a -enda49fcae3630a097c78aa58189c90a97a: - ; return false } func rewriteValueAMD64_OpInterCall(v *Value, config *Config) bool { @@ -4371,7 +3804,7 @@ func rewriteValueAMD64_OpInterCall(v *Value, config *Config) bool { // match: (InterCall [argwid] entry mem) // cond: // result: (CALLinter [argwid] entry mem) - { + for { argwid := v.AuxInt entry := v.Args[0] mem := v.Args[1] @@ -4381,9 +3814,6 @@ func rewriteValueAMD64_OpInterCall(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto endc04351e492ed362efc6aa75121bca305 -endc04351e492ed362efc6aa75121bca305: - ; return false } func rewriteValueAMD64_OpIsInBounds(v *Value, config *Config) bool { @@ -4392,7 +3822,7 @@ func rewriteValueAMD64_OpIsInBounds(v *Value, config *Config) bool { // match: (IsInBounds idx len) // cond: // result: (SETB (CMPQ idx len)) - { + for { idx := v.Args[0] len := v.Args[1] v.reset(OpAMD64SETB) @@ -4402,9 +3832,6 @@ func rewriteValueAMD64_OpIsInBounds(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto endfff988d5f1912886d73be3bb563c37d9 -endfff988d5f1912886d73be3bb563c37d9: - ; return false } func rewriteValueAMD64_OpIsNonNil(v *Value, config *Config) bool { @@ -4413,7 +3840,7 @@ func rewriteValueAMD64_OpIsNonNil(v *Value, config *Config) bool { // match: (IsNonNil p) // cond: // result: (SETNE (TESTQ p p)) - { + for { p := v.Args[0] v.reset(OpAMD64SETNE) v0 := b.NewValue0(v.Line, OpAMD64TESTQ, TypeFlags) @@ -4422,9 +3849,6 @@ func rewriteValueAMD64_OpIsNonNil(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end0af5ec868ede9ea73fb0602d54b863e9 -end0af5ec868ede9ea73fb0602d54b863e9: - ; return false } func rewriteValueAMD64_OpIsSliceInBounds(v *Value, config *Config) bool { @@ -4433,7 +3857,7 @@ func rewriteValueAMD64_OpIsSliceInBounds(v *Value, config *Config) bool { // match: (IsSliceInBounds idx len) // cond: // result: (SETBE (CMPQ idx len)) - { + for { idx := v.Args[0] len := v.Args[1] v.reset(OpAMD64SETBE) @@ -4443,9 +3867,6 @@ func rewriteValueAMD64_OpIsSliceInBounds(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end02799ad95fe7fb5ce3c2c8ab313b737c -end02799ad95fe7fb5ce3c2c8ab313b737c: - ; return false } func rewriteValueAMD64_OpAMD64LEAQ(v *Value, config *Config) bool { @@ -4454,11 +3875,11 @@ func rewriteValueAMD64_OpAMD64LEAQ(v *Value, config *Config) bool { // 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 { - goto endb764d049517eb7c125b442ec9246c2c6 + break } d := v.Args[0].AuxInt x := v.Args[0].Args[0] @@ -4468,22 +3889,19 @@ func rewriteValueAMD64_OpAMD64LEAQ(v *Value, config *Config) bool { v.AddArg(x) return true } - goto endb764d049517eb7c125b442ec9246c2c6 -endb764d049517eb7c125b442ec9246c2c6: - ; // 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 { - goto end8ee88dfb1a197184ebe10e479fafd322 + break } x := v.Args[0].Args[0] y := v.Args[0].Args[1] if !(x.Op != OpSB && y.Op != OpSB) { - goto end8ee88dfb1a197184ebe10e479fafd322 + break } v.reset(OpAMD64LEAQ1) v.AuxInt = c @@ -4492,23 +3910,20 @@ endb764d049517eb7c125b442ec9246c2c6: v.AddArg(y) return true } - goto end8ee88dfb1a197184ebe10e479fafd322 -end8ee88dfb1a197184ebe10e479fafd322: - ; // 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 { - goto end2e2249051d6776a92bcb0d83107e0d82 + break } off2 := v.Args[0].AuxInt sym2 := v.Args[0].Aux x := v.Args[0].Args[0] if !(canMergeSym(sym1, sym2)) { - goto end2e2249051d6776a92bcb0d83107e0d82 + break } v.reset(OpAMD64LEAQ) v.AuxInt = addOff(off1, off2) @@ -4516,24 +3931,21 @@ end8ee88dfb1a197184ebe10e479fafd322: v.AddArg(x) return true } - goto end2e2249051d6776a92bcb0d83107e0d82 -end2e2249051d6776a92bcb0d83107e0d82: - ; // 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 { - goto end4e2502574680cc8e02dcc07561e96ef9 + 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)) { - goto end4e2502574680cc8e02dcc07561e96ef9 + break } v.reset(OpAMD64LEAQ1) v.AuxInt = addOff(off1, off2) @@ -4542,24 +3954,21 @@ end2e2249051d6776a92bcb0d83107e0d82: v.AddArg(y) return true } - goto end4e2502574680cc8e02dcc07561e96ef9 -end4e2502574680cc8e02dcc07561e96ef9: - ; // 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 { - goto end92e54b1fbb5ba0b17a6006fe56b4d57b + 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)) { - goto end92e54b1fbb5ba0b17a6006fe56b4d57b + break } v.reset(OpAMD64LEAQ2) v.AuxInt = addOff(off1, off2) @@ -4568,24 +3977,21 @@ end4e2502574680cc8e02dcc07561e96ef9: v.AddArg(y) return true } - goto end92e54b1fbb5ba0b17a6006fe56b4d57b -end92e54b1fbb5ba0b17a6006fe56b4d57b: - ; // 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 { - goto end5da4c89d542d34d0d7f8848c3ea0fead + 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)) { - goto end5da4c89d542d34d0d7f8848c3ea0fead + break } v.reset(OpAMD64LEAQ4) v.AuxInt = addOff(off1, off2) @@ -4594,24 +4000,21 @@ end92e54b1fbb5ba0b17a6006fe56b4d57b: v.AddArg(y) return true } - goto end5da4c89d542d34d0d7f8848c3ea0fead -end5da4c89d542d34d0d7f8848c3ea0fead: - ; // 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 { - goto endc051937df5f12598e76c0923b5a60a39 + 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)) { - goto endc051937df5f12598e76c0923b5a60a39 + break } v.reset(OpAMD64LEAQ8) v.AuxInt = addOff(off1, off2) @@ -4620,9 +4023,6 @@ end5da4c89d542d34d0d7f8848c3ea0fead: v.AddArg(y) return true } - goto endc051937df5f12598e76c0923b5a60a39 -endc051937df5f12598e76c0923b5a60a39: - ; return false } func rewriteValueAMD64_OpAMD64LEAQ1(v *Value, config *Config) bool { @@ -4631,17 +4031,17 @@ func rewriteValueAMD64_OpAMD64LEAQ1(v *Value, config *Config) bool { // 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 { - goto endcee67e6c005f58a521fc4f33a98b11c6 + break } d := v.Args[0].AuxInt x := v.Args[0].Args[0] y := v.Args[1] if !(x.Op != OpSB) { - goto endcee67e6c005f58a521fc4f33a98b11c6 + break } v.reset(OpAMD64LEAQ1) v.AuxInt = c + d @@ -4650,23 +4050,20 @@ func rewriteValueAMD64_OpAMD64LEAQ1(v *Value, config *Config) bool { v.AddArg(y) return true } - goto endcee67e6c005f58a521fc4f33a98b11c6 -endcee67e6c005f58a521fc4f33a98b11c6: - ; // 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 { - goto end8ae759893af2b32c6dbcdeeca12ca207 + break } d := v.Args[1].AuxInt y := v.Args[1].Args[0] if !(y.Op != OpSB) { - goto end8ae759893af2b32c6dbcdeeca12ca207 + break } v.reset(OpAMD64LEAQ1) v.AuxInt = c + d @@ -4675,24 +4072,21 @@ endcee67e6c005f58a521fc4f33a98b11c6: v.AddArg(y) return true } - goto end8ae759893af2b32c6dbcdeeca12ca207 -end8ae759893af2b32c6dbcdeeca12ca207: - ; // 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 { - goto end3b837b0ce1bd6a79804a28ee529fc65b + 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) { - goto end3b837b0ce1bd6a79804a28ee529fc65b + break } v.reset(OpAMD64LEAQ1) v.AuxInt = addOff(off1, off2) @@ -4701,24 +4095,21 @@ end8ae759893af2b32c6dbcdeeca12ca207: v.AddArg(y) return true } - goto end3b837b0ce1bd6a79804a28ee529fc65b -end3b837b0ce1bd6a79804a28ee529fc65b: - ; // 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 { - goto endfd9dd9448d726fc7d82274b404cddb67 + break } off2 := v.Args[1].AuxInt sym2 := v.Args[1].Aux y := v.Args[1].Args[0] if !(canMergeSym(sym1, sym2) && y.Op != OpSB) { - goto endfd9dd9448d726fc7d82274b404cddb67 + break } v.reset(OpAMD64LEAQ1) v.AuxInt = addOff(off1, off2) @@ -4727,9 +4118,6 @@ end3b837b0ce1bd6a79804a28ee529fc65b: v.AddArg(y) return true } - goto endfd9dd9448d726fc7d82274b404cddb67 -endfd9dd9448d726fc7d82274b404cddb67: - ; return false } func rewriteValueAMD64_OpAMD64LEAQ2(v *Value, config *Config) bool { @@ -4738,17 +4126,17 @@ func rewriteValueAMD64_OpAMD64LEAQ2(v *Value, config *Config) bool { // 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 { - goto end32327450a43437ef98ffba85d4f64808 + break } d := v.Args[0].AuxInt x := v.Args[0].Args[0] y := v.Args[1] if !(x.Op != OpSB) { - goto end32327450a43437ef98ffba85d4f64808 + break } v.reset(OpAMD64LEAQ2) v.AuxInt = c + d @@ -4757,23 +4145,20 @@ func rewriteValueAMD64_OpAMD64LEAQ2(v *Value, config *Config) bool { v.AddArg(y) return true } - goto end32327450a43437ef98ffba85d4f64808 -end32327450a43437ef98ffba85d4f64808: - ; // 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 { - goto end86e05a0977fd26c884c75b29625c6236 + break } d := v.Args[1].AuxInt y := v.Args[1].Args[0] if !(y.Op != OpSB) { - goto end86e05a0977fd26c884c75b29625c6236 + break } v.reset(OpAMD64LEAQ2) v.AuxInt = c + 2*d @@ -4782,24 +4167,21 @@ end32327450a43437ef98ffba85d4f64808: v.AddArg(y) return true } - goto end86e05a0977fd26c884c75b29625c6236 -end86e05a0977fd26c884c75b29625c6236: - ; // 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 { - goto end2bf3cb6e212c3f62ab83ce10059e672e + 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) { - goto end2bf3cb6e212c3f62ab83ce10059e672e + break } v.reset(OpAMD64LEAQ2) v.AuxInt = addOff(off1, off2) @@ -4808,9 +4190,6 @@ end86e05a0977fd26c884c75b29625c6236: v.AddArg(y) return true } - goto end2bf3cb6e212c3f62ab83ce10059e672e -end2bf3cb6e212c3f62ab83ce10059e672e: - ; return false } func rewriteValueAMD64_OpAMD64LEAQ4(v *Value, config *Config) bool { @@ -4819,17 +4198,17 @@ func rewriteValueAMD64_OpAMD64LEAQ4(v *Value, config *Config) bool { // 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 { - goto end2225ec635a27f55cd2e4ddaf3bebdf5b + break } d := v.Args[0].AuxInt x := v.Args[0].Args[0] y := v.Args[1] if !(x.Op != OpSB) { - goto end2225ec635a27f55cd2e4ddaf3bebdf5b + break } v.reset(OpAMD64LEAQ4) v.AuxInt = c + d @@ -4838,23 +4217,20 @@ func rewriteValueAMD64_OpAMD64LEAQ4(v *Value, config *Config) bool { v.AddArg(y) return true } - goto end2225ec635a27f55cd2e4ddaf3bebdf5b -end2225ec635a27f55cd2e4ddaf3bebdf5b: - ; // 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 { - goto endd198c6d7b0038f43476fe50d886ed76b + break } d := v.Args[1].AuxInt y := v.Args[1].Args[0] if !(y.Op != OpSB) { - goto endd198c6d7b0038f43476fe50d886ed76b + break } v.reset(OpAMD64LEAQ4) v.AuxInt = c + 4*d @@ -4863,24 +4239,21 @@ end2225ec635a27f55cd2e4ddaf3bebdf5b: v.AddArg(y) return true } - goto endd198c6d7b0038f43476fe50d886ed76b -endd198c6d7b0038f43476fe50d886ed76b: - ; // 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 { - goto end066907f169f09e56139e801397316c95 + 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) { - goto end066907f169f09e56139e801397316c95 + break } v.reset(OpAMD64LEAQ4) v.AuxInt = addOff(off1, off2) @@ -4889,9 +4262,6 @@ endd198c6d7b0038f43476fe50d886ed76b: v.AddArg(y) return true } - goto end066907f169f09e56139e801397316c95 -end066907f169f09e56139e801397316c95: - ; return false } func rewriteValueAMD64_OpAMD64LEAQ8(v *Value, config *Config) bool { @@ -4900,17 +4270,17 @@ func rewriteValueAMD64_OpAMD64LEAQ8(v *Value, config *Config) bool { // 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 { - goto end26e798ad0167e205b8c670f19cef8122 + break } d := v.Args[0].AuxInt x := v.Args[0].Args[0] y := v.Args[1] if !(x.Op != OpSB) { - goto end26e798ad0167e205b8c670f19cef8122 + break } v.reset(OpAMD64LEAQ8) v.AuxInt = c + d @@ -4919,23 +4289,20 @@ func rewriteValueAMD64_OpAMD64LEAQ8(v *Value, config *Config) bool { v.AddArg(y) return true } - goto end26e798ad0167e205b8c670f19cef8122 -end26e798ad0167e205b8c670f19cef8122: - ; // 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 { - goto end85f87ffff7b951c1d085198e3bee2f09 + break } d := v.Args[1].AuxInt y := v.Args[1].Args[0] if !(y.Op != OpSB) { - goto end85f87ffff7b951c1d085198e3bee2f09 + break } v.reset(OpAMD64LEAQ8) v.AuxInt = c + 8*d @@ -4944,24 +4311,21 @@ end26e798ad0167e205b8c670f19cef8122: v.AddArg(y) return true } - goto end85f87ffff7b951c1d085198e3bee2f09 -end85f87ffff7b951c1d085198e3bee2f09: - ; // 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 { - goto end6bde9448027690b01bbf30dee061ce23 + 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) { - goto end6bde9448027690b01bbf30dee061ce23 + break } v.reset(OpAMD64LEAQ8) v.AuxInt = addOff(off1, off2) @@ -4970,9 +4334,6 @@ end85f87ffff7b951c1d085198e3bee2f09: v.AddArg(y) return true } - goto end6bde9448027690b01bbf30dee061ce23 -end6bde9448027690b01bbf30dee061ce23: - ; return false } func rewriteValueAMD64_OpLeq16(v *Value, config *Config) bool { @@ -4981,7 +4342,7 @@ func rewriteValueAMD64_OpLeq16(v *Value, config *Config) bool { // match: (Leq16 x y) // cond: // result: (SETLE (CMPW x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETLE) @@ -4991,9 +4352,6 @@ func rewriteValueAMD64_OpLeq16(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end586c647ca6bb8ec725eea917c743d1ea -end586c647ca6bb8ec725eea917c743d1ea: - ; return false } func rewriteValueAMD64_OpLeq16U(v *Value, config *Config) bool { @@ -5002,7 +4360,7 @@ func rewriteValueAMD64_OpLeq16U(v *Value, config *Config) bool { // match: (Leq16U x y) // cond: // result: (SETBE (CMPW x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETBE) @@ -5012,9 +4370,6 @@ func rewriteValueAMD64_OpLeq16U(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end9c24a81bc6a4a92267bd6638362dfbfc -end9c24a81bc6a4a92267bd6638362dfbfc: - ; return false } func rewriteValueAMD64_OpLeq32(v *Value, config *Config) bool { @@ -5023,7 +4378,7 @@ func rewriteValueAMD64_OpLeq32(v *Value, config *Config) bool { // match: (Leq32 x y) // cond: // result: (SETLE (CMPL x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETLE) @@ -5033,9 +4388,6 @@ func rewriteValueAMD64_OpLeq32(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end595ee99a9fc3460b2748b9129b139f88 -end595ee99a9fc3460b2748b9129b139f88: - ; return false } func rewriteValueAMD64_OpLeq32F(v *Value, config *Config) bool { @@ -5044,7 +4396,7 @@ func rewriteValueAMD64_OpLeq32F(v *Value, config *Config) bool { // match: (Leq32F x y) // cond: // result: (SETGEF (UCOMISS y x)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETGEF) @@ -5054,9 +4406,6 @@ func rewriteValueAMD64_OpLeq32F(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto endfee4b989a80cc43328b24f7017e80a17 -endfee4b989a80cc43328b24f7017e80a17: - ; return false } func rewriteValueAMD64_OpLeq32U(v *Value, config *Config) bool { @@ -5065,7 +4414,7 @@ func rewriteValueAMD64_OpLeq32U(v *Value, config *Config) bool { // match: (Leq32U x y) // cond: // result: (SETBE (CMPL x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETBE) @@ -5075,9 +4424,6 @@ func rewriteValueAMD64_OpLeq32U(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end1a59850aad6cb17c295d0dc359013420 -end1a59850aad6cb17c295d0dc359013420: - ; return false } func rewriteValueAMD64_OpLeq64(v *Value, config *Config) bool { @@ -5086,7 +4432,7 @@ func rewriteValueAMD64_OpLeq64(v *Value, config *Config) bool { // match: (Leq64 x y) // cond: // result: (SETLE (CMPQ x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETLE) @@ -5096,9 +4442,6 @@ func rewriteValueAMD64_OpLeq64(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end406def83fcbf29cd8fa306170b512de2 -end406def83fcbf29cd8fa306170b512de2: - ; return false } func rewriteValueAMD64_OpLeq64F(v *Value, config *Config) bool { @@ -5107,7 +4450,7 @@ func rewriteValueAMD64_OpLeq64F(v *Value, config *Config) bool { // match: (Leq64F x y) // cond: // result: (SETGEF (UCOMISD y x)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETGEF) @@ -5117,9 +4460,6 @@ func rewriteValueAMD64_OpLeq64F(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end6e3de6d4b5668f673e3822d5947edbd0 -end6e3de6d4b5668f673e3822d5947edbd0: - ; return false } func rewriteValueAMD64_OpLeq64U(v *Value, config *Config) bool { @@ -5128,7 +4468,7 @@ func rewriteValueAMD64_OpLeq64U(v *Value, config *Config) bool { // match: (Leq64U x y) // cond: // result: (SETBE (CMPQ x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETBE) @@ -5138,9 +4478,6 @@ func rewriteValueAMD64_OpLeq64U(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end52f23c145b80639c8d60420ad4057bc7 -end52f23c145b80639c8d60420ad4057bc7: - ; return false } func rewriteValueAMD64_OpLeq8(v *Value, config *Config) bool { @@ -5149,7 +4486,7 @@ func rewriteValueAMD64_OpLeq8(v *Value, config *Config) bool { // match: (Leq8 x y) // cond: // result: (SETLE (CMPB x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETLE) @@ -5159,9 +4496,6 @@ func rewriteValueAMD64_OpLeq8(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end72ecba6f2a7062cb266923dfec811f79 -end72ecba6f2a7062cb266923dfec811f79: - ; return false } func rewriteValueAMD64_OpLeq8U(v *Value, config *Config) bool { @@ -5170,7 +4504,7 @@ func rewriteValueAMD64_OpLeq8U(v *Value, config *Config) bool { // match: (Leq8U x y) // cond: // result: (SETBE (CMPB x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETBE) @@ -5180,9 +4514,6 @@ func rewriteValueAMD64_OpLeq8U(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto endb043b338cced4f15400d8d6e584ebea7 -endb043b338cced4f15400d8d6e584ebea7: - ; return false } func rewriteValueAMD64_OpLess16(v *Value, config *Config) bool { @@ -5191,7 +4522,7 @@ func rewriteValueAMD64_OpLess16(v *Value, config *Config) bool { // match: (Less16 x y) // cond: // result: (SETL (CMPW x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETL) @@ -5201,9 +4532,6 @@ func rewriteValueAMD64_OpLess16(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end2f6c6ba80eda8d68e77a58cba13d3f16 -end2f6c6ba80eda8d68e77a58cba13d3f16: - ; return false } func rewriteValueAMD64_OpLess16U(v *Value, config *Config) bool { @@ -5212,7 +4540,7 @@ func rewriteValueAMD64_OpLess16U(v *Value, config *Config) bool { // match: (Less16U x y) // cond: // result: (SETB (CMPW x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETB) @@ -5222,9 +4550,6 @@ func rewriteValueAMD64_OpLess16U(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end9f65eefe7b83a3c436b5c16664c93703 -end9f65eefe7b83a3c436b5c16664c93703: - ; return false } func rewriteValueAMD64_OpLess32(v *Value, config *Config) bool { @@ -5233,7 +4558,7 @@ func rewriteValueAMD64_OpLess32(v *Value, config *Config) bool { // match: (Less32 x y) // cond: // result: (SETL (CMPL x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETL) @@ -5243,9 +4568,6 @@ func rewriteValueAMD64_OpLess32(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end6632ff4ee994eb5b14cdf60c99ac3798 -end6632ff4ee994eb5b14cdf60c99ac3798: - ; return false } func rewriteValueAMD64_OpLess32F(v *Value, config *Config) bool { @@ -5254,7 +4576,7 @@ func rewriteValueAMD64_OpLess32F(v *Value, config *Config) bool { // match: (Less32F x y) // cond: // result: (SETGF (UCOMISS y x)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETGF) @@ -5264,9 +4586,6 @@ func rewriteValueAMD64_OpLess32F(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end5b3b0c96a7fc2ede81bc89c9abaac9d0 -end5b3b0c96a7fc2ede81bc89c9abaac9d0: - ; return false } func rewriteValueAMD64_OpLess32U(v *Value, config *Config) bool { @@ -5275,7 +4594,7 @@ func rewriteValueAMD64_OpLess32U(v *Value, config *Config) bool { // match: (Less32U x y) // cond: // result: (SETB (CMPL x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETB) @@ -5285,9 +4604,6 @@ func rewriteValueAMD64_OpLess32U(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end39e5a513c7fb0a42817a6cf9c6143b60 -end39e5a513c7fb0a42817a6cf9c6143b60: - ; return false } func rewriteValueAMD64_OpLess64(v *Value, config *Config) bool { @@ -5296,7 +4612,7 @@ func rewriteValueAMD64_OpLess64(v *Value, config *Config) bool { // match: (Less64 x y) // cond: // result: (SETL (CMPQ x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETL) @@ -5306,9 +4622,6 @@ func rewriteValueAMD64_OpLess64(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto enddce827d3e922e8487b61a88c2b1510f2 -enddce827d3e922e8487b61a88c2b1510f2: - ; return false } func rewriteValueAMD64_OpLess64F(v *Value, config *Config) bool { @@ -5317,7 +4630,7 @@ func rewriteValueAMD64_OpLess64F(v *Value, config *Config) bool { // match: (Less64F x y) // cond: // result: (SETGF (UCOMISD y x)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETGF) @@ -5327,9 +4640,6 @@ func rewriteValueAMD64_OpLess64F(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto endf2be3d2dcb6543d2159e7fff5ccbbb55 -endf2be3d2dcb6543d2159e7fff5ccbbb55: - ; return false } func rewriteValueAMD64_OpLess64U(v *Value, config *Config) bool { @@ -5338,7 +4648,7 @@ func rewriteValueAMD64_OpLess64U(v *Value, config *Config) bool { // match: (Less64U x y) // cond: // result: (SETB (CMPQ x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETB) @@ -5348,9 +4658,6 @@ func rewriteValueAMD64_OpLess64U(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto endb76d7768f175a44baf6d63d12ab6e81d -endb76d7768f175a44baf6d63d12ab6e81d: - ; return false } func rewriteValueAMD64_OpLess8(v *Value, config *Config) bool { @@ -5359,7 +4666,7 @@ func rewriteValueAMD64_OpLess8(v *Value, config *Config) bool { // match: (Less8 x y) // cond: // result: (SETL (CMPB x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETL) @@ -5369,9 +4676,6 @@ func rewriteValueAMD64_OpLess8(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end314fbffe99f3bd4b07857a80c0b914cd -end314fbffe99f3bd4b07857a80c0b914cd: - ; return false } func rewriteValueAMD64_OpLess8U(v *Value, config *Config) bool { @@ -5380,7 +4684,7 @@ func rewriteValueAMD64_OpLess8U(v *Value, config *Config) bool { // match: (Less8U x y) // cond: // result: (SETB (CMPB x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETB) @@ -5390,9 +4694,6 @@ func rewriteValueAMD64_OpLess8U(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto endadccc5d80fd053a33004ed0759f64d93 -endadccc5d80fd053a33004ed0759f64d93: - ; return false } func rewriteValueAMD64_OpLoad(v *Value, config *Config) bool { @@ -5401,111 +4702,93 @@ func rewriteValueAMD64_OpLoad(v *Value, config *Config) bool { // match: (Load 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)) { - goto end7c4c53acf57ebc5f03273652ba1d5934 + break } v.reset(OpAMD64MOVQload) v.AddArg(ptr) v.AddArg(mem) return true } - goto end7c4c53acf57ebc5f03273652ba1d5934 -end7c4c53acf57ebc5f03273652ba1d5934: - ; // match: (Load ptr mem) // cond: is32BitInt(t) // result: (MOVLload ptr mem) - { + for { t := v.Type ptr := v.Args[0] mem := v.Args[1] if !(is32BitInt(t)) { - goto ende1cfcb15bfbcfd448ce303d0882a4057 + break } v.reset(OpAMD64MOVLload) v.AddArg(ptr) v.AddArg(mem) return true } - goto ende1cfcb15bfbcfd448ce303d0882a4057 -ende1cfcb15bfbcfd448ce303d0882a4057: - ; // match: (Load ptr mem) // cond: is16BitInt(t) // result: (MOVWload ptr mem) - { + for { t := v.Type ptr := v.Args[0] mem := v.Args[1] if !(is16BitInt(t)) { - goto end2d0a1304501ed9f4e9e2d288505a9c7c + break } v.reset(OpAMD64MOVWload) v.AddArg(ptr) v.AddArg(mem) return true } - goto end2d0a1304501ed9f4e9e2d288505a9c7c -end2d0a1304501ed9f4e9e2d288505a9c7c: - ; // match: (Load 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)) { - goto end8f83bf72293670e75b22d6627bd13f0b + break } v.reset(OpAMD64MOVBload) v.AddArg(ptr) v.AddArg(mem) return true } - goto end8f83bf72293670e75b22d6627bd13f0b -end8f83bf72293670e75b22d6627bd13f0b: - ; // match: (Load ptr mem) // cond: is32BitFloat(t) // result: (MOVSSload ptr mem) - { + for { t := v.Type ptr := v.Args[0] mem := v.Args[1] if !(is32BitFloat(t)) { - goto end63383c4895805881aabceebea3c4c533 + break } v.reset(OpAMD64MOVSSload) v.AddArg(ptr) v.AddArg(mem) return true } - goto end63383c4895805881aabceebea3c4c533 -end63383c4895805881aabceebea3c4c533: - ; // match: (Load ptr mem) // cond: is64BitFloat(t) // result: (MOVSDload ptr mem) - { + for { t := v.Type ptr := v.Args[0] mem := v.Args[1] if !(is64BitFloat(t)) { - goto end99d0858c0a5bb72f0fe4decc748da812 + break } v.reset(OpAMD64MOVSDload) v.AddArg(ptr) v.AddArg(mem) return true } - goto end99d0858c0a5bb72f0fe4decc748da812 -end99d0858c0a5bb72f0fe4decc748da812: - ; return false } func rewriteValueAMD64_OpLrot16(v *Value, config *Config) bool { @@ -5514,7 +4797,7 @@ func rewriteValueAMD64_OpLrot16(v *Value, config *Config) bool { // match: (Lrot16 x [c]) // cond: // result: (ROLWconst [c&15] x) - { + for { t := v.Type x := v.Args[0] c := v.AuxInt @@ -5524,9 +4807,6 @@ func rewriteValueAMD64_OpLrot16(v *Value, config *Config) bool { v.AddArg(x) return true } - goto endb23dfa24c619d0068f925899d53ee7fd -endb23dfa24c619d0068f925899d53ee7fd: - ; return false } func rewriteValueAMD64_OpLrot32(v *Value, config *Config) bool { @@ -5535,7 +4815,7 @@ func rewriteValueAMD64_OpLrot32(v *Value, config *Config) bool { // match: (Lrot32 x [c]) // cond: // result: (ROLLconst [c&31] x) - { + for { t := v.Type x := v.Args[0] c := v.AuxInt @@ -5545,9 +4825,6 @@ func rewriteValueAMD64_OpLrot32(v *Value, config *Config) bool { v.AddArg(x) return true } - goto end38b2215c011896c36845f72ecb72b1b0 -end38b2215c011896c36845f72ecb72b1b0: - ; return false } func rewriteValueAMD64_OpLrot64(v *Value, config *Config) bool { @@ -5556,7 +4833,7 @@ func rewriteValueAMD64_OpLrot64(v *Value, config *Config) bool { // match: (Lrot64 x [c]) // cond: // result: (ROLQconst [c&63] x) - { + for { t := v.Type x := v.Args[0] c := v.AuxInt @@ -5566,9 +4843,6 @@ func rewriteValueAMD64_OpLrot64(v *Value, config *Config) bool { v.AddArg(x) return true } - goto end5cb355e4f3ca387f252ef4f6a55f9f68 -end5cb355e4f3ca387f252ef4f6a55f9f68: - ; return false } func rewriteValueAMD64_OpLrot8(v *Value, config *Config) bool { @@ -5577,7 +4851,7 @@ func rewriteValueAMD64_OpLrot8(v *Value, config *Config) bool { // match: (Lrot8 x [c]) // cond: // result: (ROLBconst [c&7] x) - { + for { t := v.Type x := v.Args[0] c := v.AuxInt @@ -5587,9 +4861,6 @@ func rewriteValueAMD64_OpLrot8(v *Value, config *Config) bool { v.AddArg(x) return true } - goto end26bfb3dd5b537cf13ac9f2978d94ed71 -end26bfb3dd5b537cf13ac9f2978d94ed71: - ; return false } func rewriteValueAMD64_OpLsh16x16(v *Value, config *Config) bool { @@ -5598,7 +4869,7 @@ func rewriteValueAMD64_OpLsh16x16(v *Value, config *Config) bool { // match: (Lsh16x16 x y) // cond: // result: (ANDW (SHLW x y) (SBBLcarrymask (CMPWconst y [16]))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -5615,9 +4886,6 @@ func rewriteValueAMD64_OpLsh16x16(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto ende1a6e1781dd669bd74d66fc34c97218f -ende1a6e1781dd669bd74d66fc34c97218f: - ; return false } func rewriteValueAMD64_OpLsh16x32(v *Value, config *Config) bool { @@ -5626,7 +4894,7 @@ func rewriteValueAMD64_OpLsh16x32(v *Value, config *Config) bool { // match: (Lsh16x32 x y) // cond: // result: (ANDW (SHLW x y) (SBBLcarrymask (CMPLconst y [16]))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -5643,9 +4911,6 @@ func rewriteValueAMD64_OpLsh16x32(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto end711e661a5b6682f98e7993c2dfa72f45 -end711e661a5b6682f98e7993c2dfa72f45: - ; return false } func rewriteValueAMD64_OpLsh16x64(v *Value, config *Config) bool { @@ -5654,7 +4919,7 @@ func rewriteValueAMD64_OpLsh16x64(v *Value, config *Config) bool { // match: (Lsh16x64 x y) // cond: // result: (ANDW (SHLW x y) (SBBLcarrymask (CMPQconst y [16]))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -5671,9 +4936,6 @@ func rewriteValueAMD64_OpLsh16x64(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto end4800d2b7d4f0e5acafcdf4e765941570 -end4800d2b7d4f0e5acafcdf4e765941570: - ; return false } func rewriteValueAMD64_OpLsh16x8(v *Value, config *Config) bool { @@ -5682,7 +4944,7 @@ func rewriteValueAMD64_OpLsh16x8(v *Value, config *Config) bool { // match: (Lsh16x8 x y) // cond: // result: (ANDW (SHLW x y) (SBBLcarrymask (CMPBconst y [16]))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -5699,9 +4961,6 @@ func rewriteValueAMD64_OpLsh16x8(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto endbe15f4a70f6c490f30f12a5db0f24ec4 -endbe15f4a70f6c490f30f12a5db0f24ec4: - ; return false } func rewriteValueAMD64_OpLsh32x16(v *Value, config *Config) bool { @@ -5710,7 +4969,7 @@ func rewriteValueAMD64_OpLsh32x16(v *Value, config *Config) bool { // match: (Lsh32x16 x y) // cond: // result: (ANDL (SHLL x y) (SBBLcarrymask (CMPWconst y [32]))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -5727,9 +4986,6 @@ func rewriteValueAMD64_OpLsh32x16(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto end6e9dfb6e850fc86393b2f6b1d509287f -end6e9dfb6e850fc86393b2f6b1d509287f: - ; return false } func rewriteValueAMD64_OpLsh32x32(v *Value, config *Config) bool { @@ -5738,7 +4994,7 @@ func rewriteValueAMD64_OpLsh32x32(v *Value, config *Config) bool { // match: (Lsh32x32 x y) // cond: // result: (ANDL (SHLL x y) (SBBLcarrymask (CMPLconst y [32]))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -5755,9 +5011,6 @@ func rewriteValueAMD64_OpLsh32x32(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto end9a4d057653a8fdad133aaf4a6b4f2b74 -end9a4d057653a8fdad133aaf4a6b4f2b74: - ; return false } func rewriteValueAMD64_OpLsh32x64(v *Value, config *Config) bool { @@ -5766,7 +5019,7 @@ func rewriteValueAMD64_OpLsh32x64(v *Value, config *Config) bool { // match: (Lsh32x64 x y) // cond: // result: (ANDL (SHLL x y) (SBBLcarrymask (CMPQconst y [32]))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -5783,9 +5036,6 @@ func rewriteValueAMD64_OpLsh32x64(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto endae1486be93eb21ebac539419b5a109cb -endae1486be93eb21ebac539419b5a109cb: - ; return false } func rewriteValueAMD64_OpLsh32x8(v *Value, config *Config) bool { @@ -5794,7 +5044,7 @@ func rewriteValueAMD64_OpLsh32x8(v *Value, config *Config) bool { // match: (Lsh32x8 x y) // cond: // result: (ANDL (SHLL x y) (SBBLcarrymask (CMPBconst y [32]))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -5811,9 +5061,6 @@ func rewriteValueAMD64_OpLsh32x8(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto endede3d7bbbb6e7ac26b598b75409703f5 -endede3d7bbbb6e7ac26b598b75409703f5: - ; return false } func rewriteValueAMD64_OpLsh64x16(v *Value, config *Config) bool { @@ -5822,7 +5069,7 @@ func rewriteValueAMD64_OpLsh64x16(v *Value, config *Config) bool { // match: (Lsh64x16 x y) // cond: // result: (ANDQ (SHLQ x y) (SBBQcarrymask (CMPWconst y [64]))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -5839,9 +5086,6 @@ func rewriteValueAMD64_OpLsh64x16(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto end4dc49d47e1079e618e480ee95c20df6d -end4dc49d47e1079e618e480ee95c20df6d: - ; return false } func rewriteValueAMD64_OpLsh64x32(v *Value, config *Config) bool { @@ -5850,7 +5094,7 @@ func rewriteValueAMD64_OpLsh64x32(v *Value, config *Config) bool { // match: (Lsh64x32 x y) // cond: // result: (ANDQ (SHLQ x y) (SBBQcarrymask (CMPLconst y [64]))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -5867,9 +5111,6 @@ func rewriteValueAMD64_OpLsh64x32(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto end52a5e8c44a38fe265cf0619081d1723b -end52a5e8c44a38fe265cf0619081d1723b: - ; return false } func rewriteValueAMD64_OpLsh64x64(v *Value, config *Config) bool { @@ -5878,7 +5119,7 @@ func rewriteValueAMD64_OpLsh64x64(v *Value, config *Config) bool { // match: (Lsh64x64 x y) // cond: // result: (ANDQ (SHLQ x y) (SBBQcarrymask (CMPQconst y [64]))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -5895,9 +5136,6 @@ func rewriteValueAMD64_OpLsh64x64(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto enda2931f1f1a64c3e0251febeb894666b0 -enda2931f1f1a64c3e0251febeb894666b0: - ; return false } func rewriteValueAMD64_OpLsh64x8(v *Value, config *Config) bool { @@ -5906,7 +5144,7 @@ func rewriteValueAMD64_OpLsh64x8(v *Value, config *Config) bool { // match: (Lsh64x8 x y) // cond: // result: (ANDQ (SHLQ x y) (SBBQcarrymask (CMPBconst y [64]))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -5923,9 +5161,6 @@ func rewriteValueAMD64_OpLsh64x8(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto end8535fcd7c1fc28bbc53844b29ffbdb22 -end8535fcd7c1fc28bbc53844b29ffbdb22: - ; return false } func rewriteValueAMD64_OpLsh8x16(v *Value, config *Config) bool { @@ -5934,7 +5169,7 @@ func rewriteValueAMD64_OpLsh8x16(v *Value, config *Config) bool { // match: (Lsh8x16 x y) // cond: // result: (ANDB (SHLB x y) (SBBLcarrymask (CMPWconst y [8]))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -5951,9 +5186,6 @@ func rewriteValueAMD64_OpLsh8x16(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto endc4b0328ed4d6943ac1af3662b93ad8e2 -endc4b0328ed4d6943ac1af3662b93ad8e2: - ; return false } func rewriteValueAMD64_OpLsh8x32(v *Value, config *Config) bool { @@ -5962,7 +5194,7 @@ func rewriteValueAMD64_OpLsh8x32(v *Value, config *Config) bool { // match: (Lsh8x32 x y) // cond: // result: (ANDB (SHLB x y) (SBBLcarrymask (CMPLconst y [8]))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -5979,9 +5211,6 @@ func rewriteValueAMD64_OpLsh8x32(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto end1e6cfcdb7439ccc73f4f59874f3559b2 -end1e6cfcdb7439ccc73f4f59874f3559b2: - ; return false } func rewriteValueAMD64_OpLsh8x64(v *Value, config *Config) bool { @@ -5990,7 +5219,7 @@ func rewriteValueAMD64_OpLsh8x64(v *Value, config *Config) bool { // match: (Lsh8x64 x y) // cond: // result: (ANDB (SHLB x y) (SBBLcarrymask (CMPQconst y [8]))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -6007,9 +5236,6 @@ func rewriteValueAMD64_OpLsh8x64(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto endf3ea2e740c7fd7ea2caa24357b0bf798 -endf3ea2e740c7fd7ea2caa24357b0bf798: - ; return false } func rewriteValueAMD64_OpLsh8x8(v *Value, config *Config) bool { @@ -6018,7 +5244,7 @@ func rewriteValueAMD64_OpLsh8x8(v *Value, config *Config) bool { // match: (Lsh8x8 x y) // cond: // result: (ANDB (SHLB x y) (SBBLcarrymask (CMPBconst y [8]))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -6035,9 +5261,6 @@ func rewriteValueAMD64_OpLsh8x8(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto end5d557e41670b7ac83d122eeb4029363d -end5d557e41670b7ac83d122eeb4029363d: - ; return false } func rewriteValueAMD64_OpAMD64MOVBQSX(v *Value, config *Config) bool { @@ -6046,9 +5269,9 @@ func rewriteValueAMD64_OpAMD64MOVBQSX(v *Value, config *Config) bool { // match: (MOVBQSX (MOVBload [off] {sym} ptr mem)) // cond: // result: @v.Args[0].Block (MOVBQSXload [off] {sym} ptr mem) - { + for { if v.Args[0].Op != OpAMD64MOVBload { - goto end19c38f3a1a37dca50637c917fa26e4f7 + break } off := v.Args[0].AuxInt sym := v.Args[0].Aux @@ -6063,29 +5286,23 @@ func rewriteValueAMD64_OpAMD64MOVBQSX(v *Value, config *Config) bool { v0.AddArg(mem) return true } - goto end19c38f3a1a37dca50637c917fa26e4f7 -end19c38f3a1a37dca50637c917fa26e4f7: - ; // match: (MOVBQSX (ANDBconst [c] x)) // cond: c & 0x80 == 0 // result: (ANDQconst [c & 0x7f] x) - { + for { if v.Args[0].Op != OpAMD64ANDBconst { - goto endf998318725c3cc6c701ebb69a2473650 + break } c := v.Args[0].AuxInt x := v.Args[0].Args[0] if !(c&0x80 == 0) { - goto endf998318725c3cc6c701ebb69a2473650 + break } v.reset(OpAMD64ANDQconst) v.AuxInt = c & 0x7f v.AddArg(x) return true } - goto endf998318725c3cc6c701ebb69a2473650 -endf998318725c3cc6c701ebb69a2473650: - ; return false } func rewriteValueAMD64_OpAMD64MOVBQZX(v *Value, config *Config) bool { @@ -6094,9 +5311,9 @@ func rewriteValueAMD64_OpAMD64MOVBQZX(v *Value, config *Config) bool { // match: (MOVBQZX (MOVBload [off] {sym} ptr mem)) // cond: // result: @v.Args[0].Block (MOVBQZXload [off] {sym} ptr mem) - { + for { if v.Args[0].Op != OpAMD64MOVBload { - goto end1169bcf3d56fa24321b002eaebd5a62d + break } off := v.Args[0].AuxInt sym := v.Args[0].Aux @@ -6111,15 +5328,12 @@ func rewriteValueAMD64_OpAMD64MOVBQZX(v *Value, config *Config) bool { v0.AddArg(mem) return true } - goto end1169bcf3d56fa24321b002eaebd5a62d -end1169bcf3d56fa24321b002eaebd5a62d: - ; // match: (MOVBQZX (ANDBconst [c] x)) // cond: // result: (ANDQconst [c & 0xff] x) - { + for { if v.Args[0].Op != OpAMD64ANDBconst { - goto enddca0c0e20f19210fe65677bfd758b24e + break } c := v.Args[0].AuxInt x := v.Args[0].Args[0] @@ -6128,9 +5342,6 @@ end1169bcf3d56fa24321b002eaebd5a62d: v.AddArg(x) return true } - goto enddca0c0e20f19210fe65677bfd758b24e -enddca0c0e20f19210fe65677bfd758b24e: - ; return false } func rewriteValueAMD64_OpAMD64MOVBload(v *Value, config *Config) bool { @@ -6139,11 +5350,11 @@ func rewriteValueAMD64_OpAMD64MOVBload(v *Value, config *Config) bool { // 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 { - goto end7ec9147ab863c1bd59190fed81f894b6 + break } off2 := v.Args[0].AuxInt ptr := v.Args[0].Args[0] @@ -6155,24 +5366,21 @@ func rewriteValueAMD64_OpAMD64MOVBload(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto end7ec9147ab863c1bd59190fed81f894b6 -end7ec9147ab863c1bd59190fed81f894b6: - ; // 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 { - goto end3771a59cf66b0df99120d76f4c358fab + 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)) { - goto end3771a59cf66b0df99120d76f4c358fab + break } v.reset(OpAMD64MOVBload) v.AuxInt = addOff(off1, off2) @@ -6181,17 +5389,14 @@ end7ec9147ab863c1bd59190fed81f894b6: v.AddArg(mem) return true } - goto end3771a59cf66b0df99120d76f4c358fab -end3771a59cf66b0df99120d76f4c358fab: - ; // 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 { - goto endb5e38220bc6108fb683f1f1e46853bd9 + break } off2 := v.Args[0].AuxInt sym2 := v.Args[0].Aux @@ -6199,7 +5404,7 @@ end3771a59cf66b0df99120d76f4c358fab: idx := v.Args[0].Args[1] mem := v.Args[1] if !(canMergeSym(sym1, sym2)) { - goto endb5e38220bc6108fb683f1f1e46853bd9 + break } v.reset(OpAMD64MOVBloadidx1) v.AuxInt = addOff(off1, off2) @@ -6209,23 +5414,20 @@ end3771a59cf66b0df99120d76f4c358fab: v.AddArg(mem) return true } - goto endb5e38220bc6108fb683f1f1e46853bd9 -endb5e38220bc6108fb683f1f1e46853bd9: - ; // 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 { - goto end2abf84efc0e06ed9cda71fb8a1ffaacd + break } ptr := v.Args[0].Args[0] idx := v.Args[0].Args[1] mem := v.Args[1] if !(ptr.Op != OpSB) { - goto end2abf84efc0e06ed9cda71fb8a1ffaacd + break } v.reset(OpAMD64MOVBloadidx1) v.AuxInt = off @@ -6235,9 +5437,6 @@ endb5e38220bc6108fb683f1f1e46853bd9: v.AddArg(mem) return true } - goto end2abf84efc0e06ed9cda71fb8a1ffaacd -end2abf84efc0e06ed9cda71fb8a1ffaacd: - ; return false } func rewriteValueAMD64_OpAMD64MOVBloadidx1(v *Value, config *Config) bool { @@ -6246,11 +5445,11 @@ func rewriteValueAMD64_OpAMD64MOVBloadidx1(v *Value, config *Config) bool { // 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 { - goto end287a4eb26a59b5f23efa2c6df34711f7 + break } d := v.Args[0].AuxInt ptr := v.Args[0].Args[0] @@ -6264,18 +5463,15 @@ func rewriteValueAMD64_OpAMD64MOVBloadidx1(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto end287a4eb26a59b5f23efa2c6df34711f7 -end287a4eb26a59b5f23efa2c6df34711f7: - ; // 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 { - goto end3d2e4e850c5e8129cd71a8693403b6c1 + break } d := v.Args[1].AuxInt idx := v.Args[1].Args[0] @@ -6288,9 +5484,6 @@ end287a4eb26a59b5f23efa2c6df34711f7: v.AddArg(mem) return true } - goto end3d2e4e850c5e8129cd71a8693403b6c1 -end3d2e4e850c5e8129cd71a8693403b6c1: - ; return false } func rewriteValueAMD64_OpAMD64MOVBstore(v *Value, config *Config) bool { @@ -6299,12 +5492,12 @@ func rewriteValueAMD64_OpAMD64MOVBstore(v *Value, config *Config) bool { // 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 { - goto end5b3f41f0770d566ff1647dea1d4a40e8 + break } x := v.Args[1].Args[0] mem := v.Args[2] @@ -6316,18 +5509,15 @@ func rewriteValueAMD64_OpAMD64MOVBstore(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto end5b3f41f0770d566ff1647dea1d4a40e8 -end5b3f41f0770d566ff1647dea1d4a40e8: - ; // 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 { - goto end3a2e55db7e03920700c4875f6a55de3b + break } x := v.Args[1].Args[0] mem := v.Args[2] @@ -6339,17 +5529,14 @@ end5b3f41f0770d566ff1647dea1d4a40e8: v.AddArg(mem) return true } - goto end3a2e55db7e03920700c4875f6a55de3b -end3a2e55db7e03920700c4875f6a55de3b: - ; // 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 { - goto ende6347ac19d0469ee59d2e7f2e18d1070 + break } off2 := v.Args[0].AuxInt ptr := v.Args[0].Args[0] @@ -6363,23 +5550,20 @@ end3a2e55db7e03920700c4875f6a55de3b: v.AddArg(mem) return true } - goto ende6347ac19d0469ee59d2e7f2e18d1070 -ende6347ac19d0469ee59d2e7f2e18d1070: - ; // 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 { - goto endfdf24c49923451a076f1868988b8c9d9 + break } c := v.Args[1].AuxInt mem := v.Args[2] if !(validOff(off)) { - goto endfdf24c49923451a076f1868988b8c9d9 + break } v.reset(OpAMD64MOVBstoreconst) v.AuxInt = makeValAndOff(int64(int8(c)), off) @@ -6388,17 +5572,14 @@ ende6347ac19d0469ee59d2e7f2e18d1070: v.AddArg(mem) return true } - goto endfdf24c49923451a076f1868988b8c9d9 -endfdf24c49923451a076f1868988b8c9d9: - ; // 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 { - goto enda7086cf7f6b8cf81972e2c3d4b12f3fc + break } off2 := v.Args[0].AuxInt sym2 := v.Args[0].Aux @@ -6406,7 +5587,7 @@ endfdf24c49923451a076f1868988b8c9d9: val := v.Args[1] mem := v.Args[2] if !(canMergeSym(sym1, sym2)) { - goto enda7086cf7f6b8cf81972e2c3d4b12f3fc + break } v.reset(OpAMD64MOVBstore) v.AuxInt = addOff(off1, off2) @@ -6416,17 +5597,14 @@ endfdf24c49923451a076f1868988b8c9d9: v.AddArg(mem) return true } - goto enda7086cf7f6b8cf81972e2c3d4b12f3fc -enda7086cf7f6b8cf81972e2c3d4b12f3fc: - ; // 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 { - goto ende386ced77f1acdae2e8bbc379803b7cf + break } off2 := v.Args[0].AuxInt sym2 := v.Args[0].Aux @@ -6435,7 +5613,7 @@ enda7086cf7f6b8cf81972e2c3d4b12f3fc: val := v.Args[1] mem := v.Args[2] if !(canMergeSym(sym1, sym2)) { - goto ende386ced77f1acdae2e8bbc379803b7cf + break } v.reset(OpAMD64MOVBstoreidx1) v.AuxInt = addOff(off1, off2) @@ -6446,24 +5624,21 @@ enda7086cf7f6b8cf81972e2c3d4b12f3fc: v.AddArg(mem) return true } - goto ende386ced77f1acdae2e8bbc379803b7cf -ende386ced77f1acdae2e8bbc379803b7cf: - ; // 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 { - goto endb43afe2024f68e41f2538876c4bf49cc + 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) { - goto endb43afe2024f68e41f2538876c4bf49cc + break } v.reset(OpAMD64MOVBstoreidx1) v.AuxInt = off @@ -6474,9 +5649,6 @@ ende386ced77f1acdae2e8bbc379803b7cf: v.AddArg(mem) return true } - goto endb43afe2024f68e41f2538876c4bf49cc -endb43afe2024f68e41f2538876c4bf49cc: - ; return false } func rewriteValueAMD64_OpAMD64MOVBstoreconst(v *Value, config *Config) bool { @@ -6485,17 +5657,17 @@ func rewriteValueAMD64_OpAMD64MOVBstoreconst(v *Value, config *Config) bool { // 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 { - goto end8d35ca650b7c40bc43984d3f5925a052 + break } off := v.Args[0].AuxInt ptr := v.Args[0].Args[0] mem := v.Args[1] if !(ValAndOff(sc).canAdd(off)) { - goto end8d35ca650b7c40bc43984d3f5925a052 + break } v.reset(OpAMD64MOVBstoreconst) v.AuxInt = ValAndOff(sc).add(off) @@ -6504,24 +5676,21 @@ func rewriteValueAMD64_OpAMD64MOVBstoreconst(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto end8d35ca650b7c40bc43984d3f5925a052 -end8d35ca650b7c40bc43984d3f5925a052: - ; // 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 { - goto end8deb839acf84818dd8fc827c0338f42c + 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)) { - goto end8deb839acf84818dd8fc827c0338f42c + break } v.reset(OpAMD64MOVBstoreconst) v.AuxInt = ValAndOff(sc).add(off) @@ -6530,9 +5699,6 @@ end8d35ca650b7c40bc43984d3f5925a052: v.AddArg(mem) return true } - goto end8deb839acf84818dd8fc827c0338f42c -end8deb839acf84818dd8fc827c0338f42c: - ; return false } func rewriteValueAMD64_OpAMD64MOVBstoreidx1(v *Value, config *Config) bool { @@ -6541,11 +5707,11 @@ func rewriteValueAMD64_OpAMD64MOVBstoreidx1(v *Value, config *Config) bool { // 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 { - goto end5e07185968f39170e41a237cc6258752 + break } d := v.Args[0].AuxInt ptr := v.Args[0].Args[0] @@ -6561,18 +5727,15 @@ func rewriteValueAMD64_OpAMD64MOVBstoreidx1(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto end5e07185968f39170e41a237cc6258752 -end5e07185968f39170e41a237cc6258752: - ; // 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 { - goto endf1e4b8d5da2530ca81e2c01dc2892875 + break } d := v.Args[1].AuxInt idx := v.Args[1].Args[0] @@ -6587,9 +5750,6 @@ end5e07185968f39170e41a237cc6258752: v.AddArg(mem) return true } - goto endf1e4b8d5da2530ca81e2c01dc2892875 -endf1e4b8d5da2530ca81e2c01dc2892875: - ; return false } func rewriteValueAMD64_OpAMD64MOVLQSX(v *Value, config *Config) bool { @@ -6598,9 +5758,9 @@ func rewriteValueAMD64_OpAMD64MOVLQSX(v *Value, config *Config) bool { // match: (MOVLQSX (MOVLload [off] {sym} ptr mem)) // cond: // result: @v.Args[0].Block (MOVLQSXload [off] {sym} ptr mem) - { + for { if v.Args[0].Op != OpAMD64MOVLload { - goto end9498ad52d5051e8e3ee9b0ed7af68d01 + break } off := v.Args[0].AuxInt sym := v.Args[0].Aux @@ -6615,29 +5775,23 @@ func rewriteValueAMD64_OpAMD64MOVLQSX(v *Value, config *Config) bool { v0.AddArg(mem) return true } - goto end9498ad52d5051e8e3ee9b0ed7af68d01 -end9498ad52d5051e8e3ee9b0ed7af68d01: - ; // match: (MOVLQSX (ANDLconst [c] x)) // cond: c & 0x80000000 == 0 // result: (ANDQconst [c & 0x7fffffff] x) - { + for { if v.Args[0].Op != OpAMD64ANDLconst { - goto end286a5aa0d10b04039cbe6e09307b4cbe + break } c := v.Args[0].AuxInt x := v.Args[0].Args[0] if !(c&0x80000000 == 0) { - goto end286a5aa0d10b04039cbe6e09307b4cbe + break } v.reset(OpAMD64ANDQconst) v.AuxInt = c & 0x7fffffff v.AddArg(x) return true } - goto end286a5aa0d10b04039cbe6e09307b4cbe -end286a5aa0d10b04039cbe6e09307b4cbe: - ; return false } func rewriteValueAMD64_OpAMD64MOVLQZX(v *Value, config *Config) bool { @@ -6646,9 +5800,9 @@ func rewriteValueAMD64_OpAMD64MOVLQZX(v *Value, config *Config) bool { // match: (MOVLQZX (MOVLload [off] {sym} ptr mem)) // cond: // result: @v.Args[0].Block (MOVLQZXload [off] {sym} ptr mem) - { + for { if v.Args[0].Op != OpAMD64MOVLload { - goto endb00602ccd4180bd749a3b01914264fbc + break } off := v.Args[0].AuxInt sym := v.Args[0].Aux @@ -6663,15 +5817,12 @@ func rewriteValueAMD64_OpAMD64MOVLQZX(v *Value, config *Config) bool { v0.AddArg(mem) return true } - goto endb00602ccd4180bd749a3b01914264fbc -endb00602ccd4180bd749a3b01914264fbc: - ; // match: (MOVLQZX (ANDLconst [c] x)) // cond: // result: (ANDQconst [c & 0xffffffff] x) - { + for { if v.Args[0].Op != OpAMD64ANDLconst { - goto end71446f0e4f530fbbc6b25a3d07761c06 + break } c := v.Args[0].AuxInt x := v.Args[0].Args[0] @@ -6680,9 +5831,6 @@ endb00602ccd4180bd749a3b01914264fbc: v.AddArg(x) return true } - goto end71446f0e4f530fbbc6b25a3d07761c06 -end71446f0e4f530fbbc6b25a3d07761c06: - ; return false } func rewriteValueAMD64_OpAMD64MOVLload(v *Value, config *Config) bool { @@ -6691,11 +5839,11 @@ func rewriteValueAMD64_OpAMD64MOVLload(v *Value, config *Config) bool { // 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 { - goto end0c8b8a40360c5c581d92723eca04d340 + break } off2 := v.Args[0].AuxInt ptr := v.Args[0].Args[0] @@ -6707,24 +5855,21 @@ func rewriteValueAMD64_OpAMD64MOVLload(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto end0c8b8a40360c5c581d92723eca04d340 -end0c8b8a40360c5c581d92723eca04d340: - ; // 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 { - goto enddb9e59335876d8a565c425731438a1b3 + 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)) { - goto enddb9e59335876d8a565c425731438a1b3 + break } v.reset(OpAMD64MOVLload) v.AuxInt = addOff(off1, off2) @@ -6733,17 +5878,14 @@ end0c8b8a40360c5c581d92723eca04d340: v.AddArg(mem) return true } - goto enddb9e59335876d8a565c425731438a1b3 -enddb9e59335876d8a565c425731438a1b3: - ; // 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 { - goto end6eed46982cfbceace4784afdf29ba2b9 + break } off2 := v.Args[0].AuxInt sym2 := v.Args[0].Aux @@ -6751,7 +5893,7 @@ enddb9e59335876d8a565c425731438a1b3: idx := v.Args[0].Args[1] mem := v.Args[1] if !(canMergeSym(sym1, sym2)) { - goto end6eed46982cfbceace4784afdf29ba2b9 + break } v.reset(OpAMD64MOVLloadidx4) v.AuxInt = addOff(off1, off2) @@ -6761,9 +5903,6 @@ enddb9e59335876d8a565c425731438a1b3: v.AddArg(mem) return true } - goto end6eed46982cfbceace4784afdf29ba2b9 -end6eed46982cfbceace4784afdf29ba2b9: - ; return false } func rewriteValueAMD64_OpAMD64MOVLloadidx4(v *Value, config *Config) bool { @@ -6772,11 +5911,11 @@ func rewriteValueAMD64_OpAMD64MOVLloadidx4(v *Value, config *Config) bool { // 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 { - goto endcafad33c3669685fdfee020f111fdcb6 + break } d := v.Args[0].AuxInt ptr := v.Args[0].Args[0] @@ -6790,18 +5929,15 @@ func rewriteValueAMD64_OpAMD64MOVLloadidx4(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto endcafad33c3669685fdfee020f111fdcb6 -endcafad33c3669685fdfee020f111fdcb6: - ; // 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 { - goto endfb8f54bfe07226dcb7d4e2d6df319707 + break } d := v.Args[1].AuxInt idx := v.Args[1].Args[0] @@ -6814,9 +5950,6 @@ endcafad33c3669685fdfee020f111fdcb6: v.AddArg(mem) return true } - goto endfb8f54bfe07226dcb7d4e2d6df319707 -endfb8f54bfe07226dcb7d4e2d6df319707: - ; return false } func rewriteValueAMD64_OpAMD64MOVLstore(v *Value, config *Config) bool { @@ -6825,12 +5958,12 @@ func rewriteValueAMD64_OpAMD64MOVLstore(v *Value, config *Config) bool { // 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 { - goto end1fb7b2ae707c76d30927c21f85d77472 + break } x := v.Args[1].Args[0] mem := v.Args[2] @@ -6842,18 +5975,15 @@ func rewriteValueAMD64_OpAMD64MOVLstore(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto end1fb7b2ae707c76d30927c21f85d77472 -end1fb7b2ae707c76d30927c21f85d77472: - ; // 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 { - goto end199e8c23a5e7e99728a43d6a83b2c2cf + break } x := v.Args[1].Args[0] mem := v.Args[2] @@ -6865,17 +5995,14 @@ end1fb7b2ae707c76d30927c21f85d77472: v.AddArg(mem) return true } - goto end199e8c23a5e7e99728a43d6a83b2c2cf -end199e8c23a5e7e99728a43d6a83b2c2cf: - ; // 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 { - goto end43bffdb8d9c1fc85a95778d4911955f1 + break } off2 := v.Args[0].AuxInt ptr := v.Args[0].Args[0] @@ -6889,23 +6016,20 @@ end199e8c23a5e7e99728a43d6a83b2c2cf: v.AddArg(mem) return true } - goto end43bffdb8d9c1fc85a95778d4911955f1 -end43bffdb8d9c1fc85a95778d4911955f1: - ; // 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 { - goto enda62a54c45bf42db801af4095d27faccd + break } c := v.Args[1].AuxInt mem := v.Args[2] if !(validOff(off)) { - goto enda62a54c45bf42db801af4095d27faccd + break } v.reset(OpAMD64MOVLstoreconst) v.AuxInt = makeValAndOff(int64(int32(c)), off) @@ -6914,17 +6038,14 @@ end43bffdb8d9c1fc85a95778d4911955f1: v.AddArg(mem) return true } - goto enda62a54c45bf42db801af4095d27faccd -enda62a54c45bf42db801af4095d27faccd: - ; // 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 { - goto endd57b1e4313fc7a3331340a9af00ba116 + break } off2 := v.Args[0].AuxInt sym2 := v.Args[0].Aux @@ -6932,7 +6053,7 @@ enda62a54c45bf42db801af4095d27faccd: val := v.Args[1] mem := v.Args[2] if !(canMergeSym(sym1, sym2)) { - goto endd57b1e4313fc7a3331340a9af00ba116 + break } v.reset(OpAMD64MOVLstore) v.AuxInt = addOff(off1, off2) @@ -6942,17 +6063,14 @@ enda62a54c45bf42db801af4095d27faccd: v.AddArg(mem) return true } - goto endd57b1e4313fc7a3331340a9af00ba116 -endd57b1e4313fc7a3331340a9af00ba116: - ; // 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 { - goto end6d2bbe089d6de8d261fcdeef263d2f7c + break } off2 := v.Args[0].AuxInt sym2 := v.Args[0].Aux @@ -6961,7 +6079,7 @@ endd57b1e4313fc7a3331340a9af00ba116: val := v.Args[1] mem := v.Args[2] if !(canMergeSym(sym1, sym2)) { - goto end6d2bbe089d6de8d261fcdeef263d2f7c + break } v.reset(OpAMD64MOVLstoreidx4) v.AuxInt = addOff(off1, off2) @@ -6972,9 +6090,6 @@ endd57b1e4313fc7a3331340a9af00ba116: v.AddArg(mem) return true } - goto end6d2bbe089d6de8d261fcdeef263d2f7c -end6d2bbe089d6de8d261fcdeef263d2f7c: - ; return false } func rewriteValueAMD64_OpAMD64MOVLstoreconst(v *Value, config *Config) bool { @@ -6983,17 +6098,17 @@ func rewriteValueAMD64_OpAMD64MOVLstoreconst(v *Value, config *Config) bool { // 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 { - goto end4981598152dd0763f1d735810a7d34e8 + break } off := v.Args[0].AuxInt ptr := v.Args[0].Args[0] mem := v.Args[1] if !(ValAndOff(sc).canAdd(off)) { - goto end4981598152dd0763f1d735810a7d34e8 + break } v.reset(OpAMD64MOVLstoreconst) v.AuxInt = ValAndOff(sc).add(off) @@ -7002,24 +6117,21 @@ func rewriteValueAMD64_OpAMD64MOVLstoreconst(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto end4981598152dd0763f1d735810a7d34e8 -end4981598152dd0763f1d735810a7d34e8: - ; // 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 { - goto endd579250954b5df84a77518b36f739e12 + 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)) { - goto endd579250954b5df84a77518b36f739e12 + break } v.reset(OpAMD64MOVLstoreconst) v.AuxInt = ValAndOff(sc).add(off) @@ -7028,9 +6140,6 @@ end4981598152dd0763f1d735810a7d34e8: v.AddArg(mem) return true } - goto endd579250954b5df84a77518b36f739e12 -endd579250954b5df84a77518b36f739e12: - ; return false } func rewriteValueAMD64_OpAMD64MOVLstoreidx4(v *Value, config *Config) bool { @@ -7039,11 +6148,11 @@ func rewriteValueAMD64_OpAMD64MOVLstoreidx4(v *Value, config *Config) bool { // 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 { - goto endd72a73ada3e68139d21049bd337bcfd2 + break } d := v.Args[0].AuxInt ptr := v.Args[0].Args[0] @@ -7059,18 +6168,15 @@ func rewriteValueAMD64_OpAMD64MOVLstoreidx4(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto endd72a73ada3e68139d21049bd337bcfd2 -endd72a73ada3e68139d21049bd337bcfd2: - ; // 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 { - goto endea783679ed46542bc48309b9fd2f6054 + break } d := v.Args[1].AuxInt idx := v.Args[1].Args[0] @@ -7085,9 +6191,6 @@ endd72a73ada3e68139d21049bd337bcfd2: v.AddArg(mem) return true } - goto endea783679ed46542bc48309b9fd2f6054 -endea783679ed46542bc48309b9fd2f6054: - ; return false } func rewriteValueAMD64_OpAMD64MOVOload(v *Value, config *Config) bool { @@ -7096,11 +6199,11 @@ func rewriteValueAMD64_OpAMD64MOVOload(v *Value, config *Config) bool { // 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 { - goto endf1e8fcf569ddd8b3f7a2f61696971913 + break } off2 := v.Args[0].AuxInt ptr := v.Args[0].Args[0] @@ -7112,24 +6215,21 @@ func rewriteValueAMD64_OpAMD64MOVOload(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto endf1e8fcf569ddd8b3f7a2f61696971913 -endf1e8fcf569ddd8b3f7a2f61696971913: - ; // 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 { - goto endd36cf9b00af7a8f44fb8c60067a8efb2 + 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)) { - goto endd36cf9b00af7a8f44fb8c60067a8efb2 + break } v.reset(OpAMD64MOVOload) v.AuxInt = addOff(off1, off2) @@ -7138,9 +6238,6 @@ endf1e8fcf569ddd8b3f7a2f61696971913: v.AddArg(mem) return true } - goto endd36cf9b00af7a8f44fb8c60067a8efb2 -endd36cf9b00af7a8f44fb8c60067a8efb2: - ; return false } func rewriteValueAMD64_OpAMD64MOVOstore(v *Value, config *Config) bool { @@ -7149,11 +6246,11 @@ func rewriteValueAMD64_OpAMD64MOVOstore(v *Value, config *Config) bool { // 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 { - goto end2be573aa1bd919e567e6156a4ee36517 + break } off2 := v.Args[0].AuxInt ptr := v.Args[0].Args[0] @@ -7167,17 +6264,14 @@ func rewriteValueAMD64_OpAMD64MOVOstore(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto end2be573aa1bd919e567e6156a4ee36517 -end2be573aa1bd919e567e6156a4ee36517: - ; // 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 { - goto endc28b9b3efe9eb235e1586c4555280c20 + break } off2 := v.Args[0].AuxInt sym2 := v.Args[0].Aux @@ -7185,7 +6279,7 @@ end2be573aa1bd919e567e6156a4ee36517: val := v.Args[1] mem := v.Args[2] if !(canMergeSym(sym1, sym2)) { - goto endc28b9b3efe9eb235e1586c4555280c20 + break } v.reset(OpAMD64MOVOstore) v.AuxInt = addOff(off1, off2) @@ -7195,9 +6289,6 @@ end2be573aa1bd919e567e6156a4ee36517: v.AddArg(mem) return true } - goto endc28b9b3efe9eb235e1586c4555280c20 -endc28b9b3efe9eb235e1586c4555280c20: - ; return false } func rewriteValueAMD64_OpAMD64MOVQload(v *Value, config *Config) bool { @@ -7206,11 +6297,11 @@ func rewriteValueAMD64_OpAMD64MOVQload(v *Value, config *Config) bool { // 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 { - goto end0b8c50dd7faefb7d046f9a27e054df77 + break } off2 := v.Args[0].AuxInt ptr := v.Args[0].Args[0] @@ -7222,24 +6313,21 @@ func rewriteValueAMD64_OpAMD64MOVQload(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto end0b8c50dd7faefb7d046f9a27e054df77 -end0b8c50dd7faefb7d046f9a27e054df77: - ; // 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 { - goto endd0c093adc4f05f2037005734c77d3cc4 + 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)) { - goto endd0c093adc4f05f2037005734c77d3cc4 + break } v.reset(OpAMD64MOVQload) v.AuxInt = addOff(off1, off2) @@ -7248,17 +6336,14 @@ end0b8c50dd7faefb7d046f9a27e054df77: v.AddArg(mem) return true } - goto endd0c093adc4f05f2037005734c77d3cc4 -endd0c093adc4f05f2037005734c77d3cc4: - ; // 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 { - goto end74a50d810fb3945e809f608cd094a59c + break } off2 := v.Args[0].AuxInt sym2 := v.Args[0].Aux @@ -7266,7 +6351,7 @@ endd0c093adc4f05f2037005734c77d3cc4: idx := v.Args[0].Args[1] mem := v.Args[1] if !(canMergeSym(sym1, sym2)) { - goto end74a50d810fb3945e809f608cd094a59c + break } v.reset(OpAMD64MOVQloadidx8) v.AuxInt = addOff(off1, off2) @@ -7276,9 +6361,6 @@ endd0c093adc4f05f2037005734c77d3cc4: v.AddArg(mem) return true } - goto end74a50d810fb3945e809f608cd094a59c -end74a50d810fb3945e809f608cd094a59c: - ; return false } func rewriteValueAMD64_OpAMD64MOVQloadidx8(v *Value, config *Config) bool { @@ -7287,11 +6369,11 @@ func rewriteValueAMD64_OpAMD64MOVQloadidx8(v *Value, config *Config) bool { // 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 { - goto end012c0c0292dbfd55f520e4d88d9247e4 + break } d := v.Args[0].AuxInt ptr := v.Args[0].Args[0] @@ -7305,18 +6387,15 @@ func rewriteValueAMD64_OpAMD64MOVQloadidx8(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto end012c0c0292dbfd55f520e4d88d9247e4 -end012c0c0292dbfd55f520e4d88d9247e4: - ; // 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 { - goto endd36e82450f4737c06501b7bc9e881d13 + break } d := v.Args[1].AuxInt idx := v.Args[1].Args[0] @@ -7329,9 +6408,6 @@ end012c0c0292dbfd55f520e4d88d9247e4: v.AddArg(mem) return true } - goto endd36e82450f4737c06501b7bc9e881d13 -endd36e82450f4737c06501b7bc9e881d13: - ; return false } func rewriteValueAMD64_OpAMD64MOVQstore(v *Value, config *Config) bool { @@ -7340,11 +6416,11 @@ func rewriteValueAMD64_OpAMD64MOVQstore(v *Value, config *Config) bool { // 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 { - goto end0a110b5e42a4576c32fda50590092848 + break } off2 := v.Args[0].AuxInt ptr := v.Args[0].Args[0] @@ -7358,23 +6434,20 @@ func rewriteValueAMD64_OpAMD64MOVQstore(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto end0a110b5e42a4576c32fda50590092848 -end0a110b5e42a4576c32fda50590092848: - ; // 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 { - goto endda0f4b36e19753762dbd1c6ee05e4c81 + break } c := v.Args[1].AuxInt mem := v.Args[2] if !(validValAndOff(c, off)) { - goto endda0f4b36e19753762dbd1c6ee05e4c81 + break } v.reset(OpAMD64MOVQstoreconst) v.AuxInt = makeValAndOff(c, off) @@ -7383,17 +6456,14 @@ end0a110b5e42a4576c32fda50590092848: v.AddArg(mem) return true } - goto endda0f4b36e19753762dbd1c6ee05e4c81 -endda0f4b36e19753762dbd1c6ee05e4c81: - ; // 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 { - goto end9a0cfe20b3b0f587e252760907c1b5c0 + break } off2 := v.Args[0].AuxInt sym2 := v.Args[0].Aux @@ -7401,7 +6471,7 @@ endda0f4b36e19753762dbd1c6ee05e4c81: val := v.Args[1] mem := v.Args[2] if !(canMergeSym(sym1, sym2)) { - goto end9a0cfe20b3b0f587e252760907c1b5c0 + break } v.reset(OpAMD64MOVQstore) v.AuxInt = addOff(off1, off2) @@ -7411,17 +6481,14 @@ endda0f4b36e19753762dbd1c6ee05e4c81: v.AddArg(mem) return true } - goto end9a0cfe20b3b0f587e252760907c1b5c0 -end9a0cfe20b3b0f587e252760907c1b5c0: - ; // 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 { - goto end442c322e6719e280b6be1c12858e49d7 + break } off2 := v.Args[0].AuxInt sym2 := v.Args[0].Aux @@ -7430,7 +6497,7 @@ end9a0cfe20b3b0f587e252760907c1b5c0: val := v.Args[1] mem := v.Args[2] if !(canMergeSym(sym1, sym2)) { - goto end442c322e6719e280b6be1c12858e49d7 + break } v.reset(OpAMD64MOVQstoreidx8) v.AuxInt = addOff(off1, off2) @@ -7441,9 +6508,6 @@ end9a0cfe20b3b0f587e252760907c1b5c0: v.AddArg(mem) return true } - goto end442c322e6719e280b6be1c12858e49d7 -end442c322e6719e280b6be1c12858e49d7: - ; return false } func rewriteValueAMD64_OpAMD64MOVQstoreconst(v *Value, config *Config) bool { @@ -7452,17 +6516,17 @@ func rewriteValueAMD64_OpAMD64MOVQstoreconst(v *Value, config *Config) bool { // 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 { - goto end3694207cd20e8e1cc719e179bdfe0c74 + break } off := v.Args[0].AuxInt ptr := v.Args[0].Args[0] mem := v.Args[1] if !(ValAndOff(sc).canAdd(off)) { - goto end3694207cd20e8e1cc719e179bdfe0c74 + break } v.reset(OpAMD64MOVQstoreconst) v.AuxInt = ValAndOff(sc).add(off) @@ -7471,24 +6535,21 @@ func rewriteValueAMD64_OpAMD64MOVQstoreconst(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto end3694207cd20e8e1cc719e179bdfe0c74 -end3694207cd20e8e1cc719e179bdfe0c74: - ; // 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 { - goto endf405b27b22dbf76f83abd1b5ad5e53d9 + 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)) { - goto endf405b27b22dbf76f83abd1b5ad5e53d9 + break } v.reset(OpAMD64MOVQstoreconst) v.AuxInt = ValAndOff(sc).add(off) @@ -7497,9 +6558,6 @@ end3694207cd20e8e1cc719e179bdfe0c74: v.AddArg(mem) return true } - goto endf405b27b22dbf76f83abd1b5ad5e53d9 -endf405b27b22dbf76f83abd1b5ad5e53d9: - ; return false } func rewriteValueAMD64_OpAMD64MOVQstoreidx8(v *Value, config *Config) bool { @@ -7508,11 +6566,11 @@ func rewriteValueAMD64_OpAMD64MOVQstoreidx8(v *Value, config *Config) bool { // 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 { - goto end775cfe4359adc4bffc346289df14bbc3 + break } d := v.Args[0].AuxInt ptr := v.Args[0].Args[0] @@ -7528,18 +6586,15 @@ func rewriteValueAMD64_OpAMD64MOVQstoreidx8(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto end775cfe4359adc4bffc346289df14bbc3 -end775cfe4359adc4bffc346289df14bbc3: - ; // 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 { - goto end20281fb6ccf09a9b56abdba46f443232 + break } d := v.Args[1].AuxInt idx := v.Args[1].Args[0] @@ -7554,9 +6609,6 @@ end775cfe4359adc4bffc346289df14bbc3: v.AddArg(mem) return true } - goto end20281fb6ccf09a9b56abdba46f443232 -end20281fb6ccf09a9b56abdba46f443232: - ; return false } func rewriteValueAMD64_OpAMD64MOVSDload(v *Value, config *Config) bool { @@ -7565,11 +6617,11 @@ func rewriteValueAMD64_OpAMD64MOVSDload(v *Value, config *Config) bool { // 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 { - goto end6dad9bf78e7368bb095eb2dfba7e244a + break } off2 := v.Args[0].AuxInt ptr := v.Args[0].Args[0] @@ -7581,24 +6633,21 @@ func rewriteValueAMD64_OpAMD64MOVSDload(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto end6dad9bf78e7368bb095eb2dfba7e244a -end6dad9bf78e7368bb095eb2dfba7e244a: - ; // 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 { - goto end96fa9c439e31050aa91582bc2a9f2c20 + 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)) { - goto end96fa9c439e31050aa91582bc2a9f2c20 + break } v.reset(OpAMD64MOVSDload) v.AuxInt = addOff(off1, off2) @@ -7607,17 +6656,14 @@ end6dad9bf78e7368bb095eb2dfba7e244a: v.AddArg(mem) return true } - goto end96fa9c439e31050aa91582bc2a9f2c20 -end96fa9c439e31050aa91582bc2a9f2c20: - ; // 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 { - goto endbcb2ce441824d0e3a4b501018cfa7f60 + break } off2 := v.Args[0].AuxInt sym2 := v.Args[0].Aux @@ -7625,7 +6671,7 @@ end96fa9c439e31050aa91582bc2a9f2c20: idx := v.Args[0].Args[1] mem := v.Args[1] if !(canMergeSym(sym1, sym2)) { - goto endbcb2ce441824d0e3a4b501018cfa7f60 + break } v.reset(OpAMD64MOVSDloadidx8) v.AuxInt = addOff(off1, off2) @@ -7635,9 +6681,6 @@ end96fa9c439e31050aa91582bc2a9f2c20: v.AddArg(mem) return true } - goto endbcb2ce441824d0e3a4b501018cfa7f60 -endbcb2ce441824d0e3a4b501018cfa7f60: - ; return false } func rewriteValueAMD64_OpAMD64MOVSDloadidx8(v *Value, config *Config) bool { @@ -7646,11 +6689,11 @@ func rewriteValueAMD64_OpAMD64MOVSDloadidx8(v *Value, config *Config) bool { // 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 { - goto endb313602cfa64c282cc86c27c7183c507 + break } d := v.Args[0].AuxInt ptr := v.Args[0].Args[0] @@ -7664,18 +6707,15 @@ func rewriteValueAMD64_OpAMD64MOVSDloadidx8(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto endb313602cfa64c282cc86c27c7183c507 -endb313602cfa64c282cc86c27c7183c507: - ; // 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 { - goto endfb406e2cba383116291b60825765637c + break } d := v.Args[1].AuxInt idx := v.Args[1].Args[0] @@ -7688,9 +6728,6 @@ endb313602cfa64c282cc86c27c7183c507: v.AddArg(mem) return true } - goto endfb406e2cba383116291b60825765637c -endfb406e2cba383116291b60825765637c: - ; return false } func rewriteValueAMD64_OpAMD64MOVSDstore(v *Value, config *Config) bool { @@ -7699,11 +6736,11 @@ func rewriteValueAMD64_OpAMD64MOVSDstore(v *Value, config *Config) bool { // 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 { - goto end6c6160664143cc66e63e67b9aa43a7ef + break } off2 := v.Args[0].AuxInt ptr := v.Args[0].Args[0] @@ -7717,17 +6754,14 @@ func rewriteValueAMD64_OpAMD64MOVSDstore(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto end6c6160664143cc66e63e67b9aa43a7ef -end6c6160664143cc66e63e67b9aa43a7ef: - ; // 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 { - goto end415dde14f3400bec1b2756174a5d7179 + break } off2 := v.Args[0].AuxInt sym2 := v.Args[0].Aux @@ -7735,7 +6769,7 @@ end6c6160664143cc66e63e67b9aa43a7ef: val := v.Args[1] mem := v.Args[2] if !(canMergeSym(sym1, sym2)) { - goto end415dde14f3400bec1b2756174a5d7179 + break } v.reset(OpAMD64MOVSDstore) v.AuxInt = addOff(off1, off2) @@ -7745,17 +6779,14 @@ end6c6160664143cc66e63e67b9aa43a7ef: v.AddArg(mem) return true } - goto end415dde14f3400bec1b2756174a5d7179 -end415dde14f3400bec1b2756174a5d7179: - ; // 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 { - goto end1ad6fc0c5b59610dabf7f9595a48a230 + break } off2 := v.Args[0].AuxInt sym2 := v.Args[0].Aux @@ -7764,7 +6795,7 @@ end415dde14f3400bec1b2756174a5d7179: val := v.Args[1] mem := v.Args[2] if !(canMergeSym(sym1, sym2)) { - goto end1ad6fc0c5b59610dabf7f9595a48a230 + break } v.reset(OpAMD64MOVSDstoreidx8) v.AuxInt = addOff(off1, off2) @@ -7775,9 +6806,6 @@ end415dde14f3400bec1b2756174a5d7179: v.AddArg(mem) return true } - goto end1ad6fc0c5b59610dabf7f9595a48a230 -end1ad6fc0c5b59610dabf7f9595a48a230: - ; return false } func rewriteValueAMD64_OpAMD64MOVSDstoreidx8(v *Value, config *Config) bool { @@ -7786,11 +6814,11 @@ func rewriteValueAMD64_OpAMD64MOVSDstoreidx8(v *Value, config *Config) bool { // 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 { - goto end8b8f41236593d5d5e83663cc14350fe8 + break } d := v.Args[0].AuxInt ptr := v.Args[0].Args[0] @@ -7806,18 +6834,15 @@ func rewriteValueAMD64_OpAMD64MOVSDstoreidx8(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto end8b8f41236593d5d5e83663cc14350fe8 -end8b8f41236593d5d5e83663cc14350fe8: - ; // 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 { - goto end94b7159715acb6ebb94b08b3a826f5fe + break } d := v.Args[1].AuxInt idx := v.Args[1].Args[0] @@ -7832,9 +6857,6 @@ end8b8f41236593d5d5e83663cc14350fe8: v.AddArg(mem) return true } - goto end94b7159715acb6ebb94b08b3a826f5fe -end94b7159715acb6ebb94b08b3a826f5fe: - ; return false } func rewriteValueAMD64_OpAMD64MOVSSload(v *Value, config *Config) bool { @@ -7843,11 +6865,11 @@ func rewriteValueAMD64_OpAMD64MOVSSload(v *Value, config *Config) bool { // 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 { - goto end96d63dbb64b0adfa944684c9e939c972 + break } off2 := v.Args[0].AuxInt ptr := v.Args[0].Args[0] @@ -7859,24 +6881,21 @@ func rewriteValueAMD64_OpAMD64MOVSSload(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto end96d63dbb64b0adfa944684c9e939c972 -end96d63dbb64b0adfa944684c9e939c972: - ; // 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 { - goto end15f2583bd72ad7fc077b3952634a1c85 + 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)) { - goto end15f2583bd72ad7fc077b3952634a1c85 + break } v.reset(OpAMD64MOVSSload) v.AuxInt = addOff(off1, off2) @@ -7885,17 +6904,14 @@ end96d63dbb64b0adfa944684c9e939c972: v.AddArg(mem) return true } - goto end15f2583bd72ad7fc077b3952634a1c85 -end15f2583bd72ad7fc077b3952634a1c85: - ; // 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 { - goto end49722f4a0adba31bb143601ce1d2aae0 + break } off2 := v.Args[0].AuxInt sym2 := v.Args[0].Aux @@ -7903,7 +6919,7 @@ end15f2583bd72ad7fc077b3952634a1c85: idx := v.Args[0].Args[1] mem := v.Args[1] if !(canMergeSym(sym1, sym2)) { - goto end49722f4a0adba31bb143601ce1d2aae0 + break } v.reset(OpAMD64MOVSSloadidx4) v.AuxInt = addOff(off1, off2) @@ -7913,9 +6929,6 @@ end15f2583bd72ad7fc077b3952634a1c85: v.AddArg(mem) return true } - goto end49722f4a0adba31bb143601ce1d2aae0 -end49722f4a0adba31bb143601ce1d2aae0: - ; return false } func rewriteValueAMD64_OpAMD64MOVSSloadidx4(v *Value, config *Config) bool { @@ -7924,11 +6937,11 @@ func rewriteValueAMD64_OpAMD64MOVSSloadidx4(v *Value, config *Config) bool { // 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 { - goto end2317614a112d773b1209327d552bb022 + break } d := v.Args[0].AuxInt ptr := v.Args[0].Args[0] @@ -7942,18 +6955,15 @@ func rewriteValueAMD64_OpAMD64MOVSSloadidx4(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto end2317614a112d773b1209327d552bb022 -end2317614a112d773b1209327d552bb022: - ; // 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 { - goto endd3063853eaa3813f3c95eedeba23e391 + break } d := v.Args[1].AuxInt idx := v.Args[1].Args[0] @@ -7966,9 +6976,6 @@ end2317614a112d773b1209327d552bb022: v.AddArg(mem) return true } - goto endd3063853eaa3813f3c95eedeba23e391 -endd3063853eaa3813f3c95eedeba23e391: - ; return false } func rewriteValueAMD64_OpAMD64MOVSSstore(v *Value, config *Config) bool { @@ -7977,11 +6984,11 @@ func rewriteValueAMD64_OpAMD64MOVSSstore(v *Value, config *Config) bool { // 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 { - goto endf711aa4081a9b2924b55387d4f70cfd6 + break } off2 := v.Args[0].AuxInt ptr := v.Args[0].Args[0] @@ -7995,17 +7002,14 @@ func rewriteValueAMD64_OpAMD64MOVSSstore(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto endf711aa4081a9b2924b55387d4f70cfd6 -endf711aa4081a9b2924b55387d4f70cfd6: - ; // 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 { - goto end70ebc170131920e515e3f416a6b952c5 + break } off2 := v.Args[0].AuxInt sym2 := v.Args[0].Aux @@ -8013,7 +7017,7 @@ endf711aa4081a9b2924b55387d4f70cfd6: val := v.Args[1] mem := v.Args[2] if !(canMergeSym(sym1, sym2)) { - goto end70ebc170131920e515e3f416a6b952c5 + break } v.reset(OpAMD64MOVSSstore) v.AuxInt = addOff(off1, off2) @@ -8023,17 +7027,14 @@ endf711aa4081a9b2924b55387d4f70cfd6: v.AddArg(mem) return true } - goto end70ebc170131920e515e3f416a6b952c5 -end70ebc170131920e515e3f416a6b952c5: - ; // 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 { - goto end1622dc435e45833eda4d29d44df7cc34 + break } off2 := v.Args[0].AuxInt sym2 := v.Args[0].Aux @@ -8042,7 +7043,7 @@ end70ebc170131920e515e3f416a6b952c5: val := v.Args[1] mem := v.Args[2] if !(canMergeSym(sym1, sym2)) { - goto end1622dc435e45833eda4d29d44df7cc34 + break } v.reset(OpAMD64MOVSSstoreidx4) v.AuxInt = addOff(off1, off2) @@ -8053,9 +7054,6 @@ end70ebc170131920e515e3f416a6b952c5: v.AddArg(mem) return true } - goto end1622dc435e45833eda4d29d44df7cc34 -end1622dc435e45833eda4d29d44df7cc34: - ; return false } func rewriteValueAMD64_OpAMD64MOVSSstoreidx4(v *Value, config *Config) bool { @@ -8064,11 +7062,11 @@ func rewriteValueAMD64_OpAMD64MOVSSstoreidx4(v *Value, config *Config) bool { // 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 { - goto end5995724dec9833993ca0b1c827919b6a + break } d := v.Args[0].AuxInt ptr := v.Args[0].Args[0] @@ -8084,18 +7082,15 @@ func rewriteValueAMD64_OpAMD64MOVSSstoreidx4(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto end5995724dec9833993ca0b1c827919b6a -end5995724dec9833993ca0b1c827919b6a: - ; // 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 { - goto endad50732309bcc958cffc54992194cdd6 + break } d := v.Args[1].AuxInt idx := v.Args[1].Args[0] @@ -8110,9 +7105,6 @@ end5995724dec9833993ca0b1c827919b6a: v.AddArg(mem) return true } - goto endad50732309bcc958cffc54992194cdd6 -endad50732309bcc958cffc54992194cdd6: - ; return false } func rewriteValueAMD64_OpAMD64MOVWQSX(v *Value, config *Config) bool { @@ -8121,9 +7113,9 @@ func rewriteValueAMD64_OpAMD64MOVWQSX(v *Value, config *Config) bool { // match: (MOVWQSX (MOVWload [off] {sym} ptr mem)) // cond: // result: @v.Args[0].Block (MOVWQSXload [off] {sym} ptr mem) - { + for { if v.Args[0].Op != OpAMD64MOVWload { - goto endef39da125e2794cdafd008426ecc91eb + break } off := v.Args[0].AuxInt sym := v.Args[0].Aux @@ -8138,29 +7130,23 @@ func rewriteValueAMD64_OpAMD64MOVWQSX(v *Value, config *Config) bool { v0.AddArg(mem) return true } - goto endef39da125e2794cdafd008426ecc91eb -endef39da125e2794cdafd008426ecc91eb: - ; // match: (MOVWQSX (ANDWconst [c] x)) // cond: c & 0x8000 == 0 // result: (ANDQconst [c & 0x7fff] x) - { + for { if v.Args[0].Op != OpAMD64ANDWconst { - goto end8581b4c4dfd1278e97aa536308519e68 + break } c := v.Args[0].AuxInt x := v.Args[0].Args[0] if !(c&0x8000 == 0) { - goto end8581b4c4dfd1278e97aa536308519e68 + break } v.reset(OpAMD64ANDQconst) v.AuxInt = c & 0x7fff v.AddArg(x) return true } - goto end8581b4c4dfd1278e97aa536308519e68 -end8581b4c4dfd1278e97aa536308519e68: - ; return false } func rewriteValueAMD64_OpAMD64MOVWQZX(v *Value, config *Config) bool { @@ -8169,9 +7155,9 @@ func rewriteValueAMD64_OpAMD64MOVWQZX(v *Value, config *Config) bool { // match: (MOVWQZX (MOVWload [off] {sym} ptr mem)) // cond: // result: @v.Args[0].Block (MOVWQZXload [off] {sym} ptr mem) - { + for { if v.Args[0].Op != OpAMD64MOVWload { - goto end348d59b382c9d0c64896811facbe4c5e + break } off := v.Args[0].AuxInt sym := v.Args[0].Aux @@ -8186,15 +7172,12 @@ func rewriteValueAMD64_OpAMD64MOVWQZX(v *Value, config *Config) bool { v0.AddArg(mem) return true } - goto end348d59b382c9d0c64896811facbe4c5e -end348d59b382c9d0c64896811facbe4c5e: - ; // match: (MOVWQZX (ANDWconst [c] x)) // cond: // result: (ANDQconst [c & 0xffff] x) - { + for { if v.Args[0].Op != OpAMD64ANDWconst { - goto end15c2a3b0ade49892e79289e562bac52f + break } c := v.Args[0].AuxInt x := v.Args[0].Args[0] @@ -8203,9 +7186,6 @@ end348d59b382c9d0c64896811facbe4c5e: v.AddArg(x) return true } - goto end15c2a3b0ade49892e79289e562bac52f -end15c2a3b0ade49892e79289e562bac52f: - ; return false } func rewriteValueAMD64_OpAMD64MOVWload(v *Value, config *Config) bool { @@ -8214,11 +7194,11 @@ func rewriteValueAMD64_OpAMD64MOVWload(v *Value, config *Config) bool { // 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 { - goto endfcb0ce76f96e8b0c2eb19a9b827c1b73 + break } off2 := v.Args[0].AuxInt ptr := v.Args[0].Args[0] @@ -8230,24 +7210,21 @@ func rewriteValueAMD64_OpAMD64MOVWload(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto endfcb0ce76f96e8b0c2eb19a9b827c1b73 -endfcb0ce76f96e8b0c2eb19a9b827c1b73: - ; // 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 { - goto end7a79314cb49bf53d79c38c3077d87457 + 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)) { - goto end7a79314cb49bf53d79c38c3077d87457 + break } v.reset(OpAMD64MOVWload) v.AuxInt = addOff(off1, off2) @@ -8256,17 +7233,14 @@ endfcb0ce76f96e8b0c2eb19a9b827c1b73: v.AddArg(mem) return true } - goto end7a79314cb49bf53d79c38c3077d87457 -end7a79314cb49bf53d79c38c3077d87457: - ; // 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 { - goto end1a7be5e27e24f56f760b50d4d2f2a8da + break } off2 := v.Args[0].AuxInt sym2 := v.Args[0].Aux @@ -8274,7 +7248,7 @@ end7a79314cb49bf53d79c38c3077d87457: idx := v.Args[0].Args[1] mem := v.Args[1] if !(canMergeSym(sym1, sym2)) { - goto end1a7be5e27e24f56f760b50d4d2f2a8da + break } v.reset(OpAMD64MOVWloadidx2) v.AuxInt = addOff(off1, off2) @@ -8284,9 +7258,6 @@ end7a79314cb49bf53d79c38c3077d87457: v.AddArg(mem) return true } - goto end1a7be5e27e24f56f760b50d4d2f2a8da -end1a7be5e27e24f56f760b50d4d2f2a8da: - ; return false } func rewriteValueAMD64_OpAMD64MOVWloadidx2(v *Value, config *Config) bool { @@ -8295,11 +7266,11 @@ func rewriteValueAMD64_OpAMD64MOVWloadidx2(v *Value, config *Config) bool { // 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 { - goto end1a8b9db99bc480ce4f8cc0fa0e6024ea + break } d := v.Args[0].AuxInt ptr := v.Args[0].Args[0] @@ -8313,18 +7284,15 @@ func rewriteValueAMD64_OpAMD64MOVWloadidx2(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto end1a8b9db99bc480ce4f8cc0fa0e6024ea -end1a8b9db99bc480ce4f8cc0fa0e6024ea: - ; // 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 { - goto end38e4b4448cc3c61b0691bc11c61c7098 + break } d := v.Args[1].AuxInt idx := v.Args[1].Args[0] @@ -8337,9 +7305,6 @@ end1a8b9db99bc480ce4f8cc0fa0e6024ea: v.AddArg(mem) return true } - goto end38e4b4448cc3c61b0691bc11c61c7098 -end38e4b4448cc3c61b0691bc11c61c7098: - ; return false } func rewriteValueAMD64_OpAMD64MOVWstore(v *Value, config *Config) bool { @@ -8348,12 +7313,12 @@ func rewriteValueAMD64_OpAMD64MOVWstore(v *Value, config *Config) bool { // 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 { - goto endca90c534e75c7f5cb803504d119a853f + break } x := v.Args[1].Args[0] mem := v.Args[2] @@ -8365,18 +7330,15 @@ func rewriteValueAMD64_OpAMD64MOVWstore(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto endca90c534e75c7f5cb803504d119a853f -endca90c534e75c7f5cb803504d119a853f: - ; // 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 { - goto end187fe73dfaf9cf5f4c349283b4dfd9d1 + break } x := v.Args[1].Args[0] mem := v.Args[2] @@ -8388,17 +7350,14 @@ endca90c534e75c7f5cb803504d119a853f: v.AddArg(mem) return true } - goto end187fe73dfaf9cf5f4c349283b4dfd9d1 -end187fe73dfaf9cf5f4c349283b4dfd9d1: - ; // 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 { - goto endda15fdd59aa956ded0440188f38de1aa + break } off2 := v.Args[0].AuxInt ptr := v.Args[0].Args[0] @@ -8412,23 +7371,20 @@ end187fe73dfaf9cf5f4c349283b4dfd9d1: v.AddArg(mem) return true } - goto endda15fdd59aa956ded0440188f38de1aa -endda15fdd59aa956ded0440188f38de1aa: - ; // 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 { - goto end60327daf9965d73a8c1971d098e1e31d + break } c := v.Args[1].AuxInt mem := v.Args[2] if !(validOff(off)) { - goto end60327daf9965d73a8c1971d098e1e31d + break } v.reset(OpAMD64MOVWstoreconst) v.AuxInt = makeValAndOff(int64(int16(c)), off) @@ -8437,17 +7393,14 @@ endda15fdd59aa956ded0440188f38de1aa: v.AddArg(mem) return true } - goto end60327daf9965d73a8c1971d098e1e31d -end60327daf9965d73a8c1971d098e1e31d: - ; // 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 { - goto end4cc466ede8e64e415c899ccac81c0f27 + break } off2 := v.Args[0].AuxInt sym2 := v.Args[0].Aux @@ -8455,7 +7408,7 @@ end60327daf9965d73a8c1971d098e1e31d: val := v.Args[1] mem := v.Args[2] if !(canMergeSym(sym1, sym2)) { - goto end4cc466ede8e64e415c899ccac81c0f27 + break } v.reset(OpAMD64MOVWstore) v.AuxInt = addOff(off1, off2) @@ -8465,17 +7418,14 @@ end60327daf9965d73a8c1971d098e1e31d: v.AddArg(mem) return true } - goto end4cc466ede8e64e415c899ccac81c0f27 -end4cc466ede8e64e415c899ccac81c0f27: - ; // 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 { - goto endecfc76d1ba8fcce5d4110a452cd39752 + break } off2 := v.Args[0].AuxInt sym2 := v.Args[0].Aux @@ -8484,7 +7434,7 @@ end4cc466ede8e64e415c899ccac81c0f27: val := v.Args[1] mem := v.Args[2] if !(canMergeSym(sym1, sym2)) { - goto endecfc76d1ba8fcce5d4110a452cd39752 + break } v.reset(OpAMD64MOVWstoreidx2) v.AuxInt = addOff(off1, off2) @@ -8495,9 +7445,6 @@ end4cc466ede8e64e415c899ccac81c0f27: v.AddArg(mem) return true } - goto endecfc76d1ba8fcce5d4110a452cd39752 -endecfc76d1ba8fcce5d4110a452cd39752: - ; return false } func rewriteValueAMD64_OpAMD64MOVWstoreconst(v *Value, config *Config) bool { @@ -8506,17 +7453,17 @@ func rewriteValueAMD64_OpAMD64MOVWstoreconst(v *Value, config *Config) bool { // 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 { - goto end8825edac065f0e1c615ca5e6ba40e2de + break } off := v.Args[0].AuxInt ptr := v.Args[0].Args[0] mem := v.Args[1] if !(ValAndOff(sc).canAdd(off)) { - goto end8825edac065f0e1c615ca5e6ba40e2de + break } v.reset(OpAMD64MOVWstoreconst) v.AuxInt = ValAndOff(sc).add(off) @@ -8525,24 +7472,21 @@ func rewriteValueAMD64_OpAMD64MOVWstoreconst(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto end8825edac065f0e1c615ca5e6ba40e2de -end8825edac065f0e1c615ca5e6ba40e2de: - ; // 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 { - goto endba47397e07b40a64fa4cad36ac2e32ad + 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)) { - goto endba47397e07b40a64fa4cad36ac2e32ad + break } v.reset(OpAMD64MOVWstoreconst) v.AuxInt = ValAndOff(sc).add(off) @@ -8551,9 +7495,6 @@ end8825edac065f0e1c615ca5e6ba40e2de: v.AddArg(mem) return true } - goto endba47397e07b40a64fa4cad36ac2e32ad -endba47397e07b40a64fa4cad36ac2e32ad: - ; return false } func rewriteValueAMD64_OpAMD64MOVWstoreidx2(v *Value, config *Config) bool { @@ -8562,11 +7503,11 @@ func rewriteValueAMD64_OpAMD64MOVWstoreidx2(v *Value, config *Config) bool { // 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 { - goto end8e684d397fadfa1c3f0783597ca01cc7 + break } d := v.Args[0].AuxInt ptr := v.Args[0].Args[0] @@ -8582,18 +7523,15 @@ func rewriteValueAMD64_OpAMD64MOVWstoreidx2(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto end8e684d397fadfa1c3f0783597ca01cc7 -end8e684d397fadfa1c3f0783597ca01cc7: - ; // 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 { - goto end9701df480a14263338b1d37a15b59eb5 + break } d := v.Args[1].AuxInt idx := v.Args[1].Args[0] @@ -8608,9 +7546,6 @@ end8e684d397fadfa1c3f0783597ca01cc7: v.AddArg(mem) return true } - goto end9701df480a14263338b1d37a15b59eb5 -end9701df480a14263338b1d37a15b59eb5: - ; return false } func rewriteValueAMD64_OpAMD64MULB(v *Value, config *Config) bool { @@ -8619,10 +7554,10 @@ func rewriteValueAMD64_OpAMD64MULB(v *Value, config *Config) bool { // match: (MULB x (MOVBconst [c])) // cond: // result: (MULBconst [c] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVBconst { - goto end66c6419213ddeb52b1c53fb589a70e5f + break } c := v.Args[1].AuxInt v.reset(OpAMD64MULBconst) @@ -8630,15 +7565,12 @@ func rewriteValueAMD64_OpAMD64MULB(v *Value, config *Config) bool { v.AddArg(x) return true } - goto end66c6419213ddeb52b1c53fb589a70e5f -end66c6419213ddeb52b1c53fb589a70e5f: - ; // match: (MULB (MOVBconst [c]) x) // cond: // result: (MULBconst [c] x) - { + for { if v.Args[0].Op != OpAMD64MOVBconst { - goto end7e82c8dbbba265b78035ca7df394bb06 + break } c := v.Args[0].AuxInt x := v.Args[1] @@ -8647,9 +7579,6 @@ end66c6419213ddeb52b1c53fb589a70e5f: v.AddArg(x) return true } - goto end7e82c8dbbba265b78035ca7df394bb06 -end7e82c8dbbba265b78035ca7df394bb06: - ; return false } func rewriteValueAMD64_OpAMD64MULBconst(v *Value, config *Config) bool { @@ -8658,19 +7587,16 @@ func rewriteValueAMD64_OpAMD64MULBconst(v *Value, config *Config) bool { // match: (MULBconst [c] (MOVBconst [d])) // cond: // result: (MOVBconst [c*d]) - { + for { c := v.AuxInt if v.Args[0].Op != OpAMD64MOVBconst { - goto endf2db9f96016085f8cb4082b4af01b2aa + break } d := v.Args[0].AuxInt v.reset(OpAMD64MOVBconst) v.AuxInt = c * d return true } - goto endf2db9f96016085f8cb4082b4af01b2aa -endf2db9f96016085f8cb4082b4af01b2aa: - ; return false } func rewriteValueAMD64_OpAMD64MULL(v *Value, config *Config) bool { @@ -8679,10 +7605,10 @@ func rewriteValueAMD64_OpAMD64MULL(v *Value, config *Config) bool { // match: (MULL x (MOVLconst [c])) // cond: // result: (MULLconst [c] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVLconst { - goto end893477a261bcad6c2821b77c83075c6c + break } c := v.Args[1].AuxInt v.reset(OpAMD64MULLconst) @@ -8690,15 +7616,12 @@ func rewriteValueAMD64_OpAMD64MULL(v *Value, config *Config) bool { v.AddArg(x) return true } - goto end893477a261bcad6c2821b77c83075c6c -end893477a261bcad6c2821b77c83075c6c: - ; // match: (MULL (MOVLconst [c]) x) // cond: // result: (MULLconst [c] x) - { + for { if v.Args[0].Op != OpAMD64MOVLconst { - goto end8a0f957c528a54eecb0dbfc5d96e017a + break } c := v.Args[0].AuxInt x := v.Args[1] @@ -8707,9 +7630,6 @@ end893477a261bcad6c2821b77c83075c6c: v.AddArg(x) return true } - goto end8a0f957c528a54eecb0dbfc5d96e017a -end8a0f957c528a54eecb0dbfc5d96e017a: - ; return false } func rewriteValueAMD64_OpAMD64MULLconst(v *Value, config *Config) bool { @@ -8718,19 +7638,16 @@ func rewriteValueAMD64_OpAMD64MULLconst(v *Value, config *Config) bool { // match: (MULLconst [c] (MOVLconst [d])) // cond: // result: (MOVLconst [c*d]) - { + for { c := v.AuxInt if v.Args[0].Op != OpAMD64MOVLconst { - goto endd5732835ed1276ef8b728bcfc1289f73 + break } d := v.Args[0].AuxInt v.reset(OpAMD64MOVLconst) v.AuxInt = c * d return true } - goto endd5732835ed1276ef8b728bcfc1289f73 -endd5732835ed1276ef8b728bcfc1289f73: - ; return false } func rewriteValueAMD64_OpAMD64MULQ(v *Value, config *Config) bool { @@ -8739,43 +7656,37 @@ func rewriteValueAMD64_OpAMD64MULQ(v *Value, config *Config) bool { // match: (MULQ x (MOVQconst [c])) // cond: is32Bit(c) // result: (MULQconst [c] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVQconst { - goto endb38c6e3e0ddfa25ba0ef9684ac1528c0 + break } c := v.Args[1].AuxInt if !(is32Bit(c)) { - goto endb38c6e3e0ddfa25ba0ef9684ac1528c0 + break } v.reset(OpAMD64MULQconst) v.AuxInt = c v.AddArg(x) return true } - goto endb38c6e3e0ddfa25ba0ef9684ac1528c0 -endb38c6e3e0ddfa25ba0ef9684ac1528c0: - ; // match: (MULQ (MOVQconst [c]) x) // cond: is32Bit(c) // result: (MULQconst [c] x) - { + for { if v.Args[0].Op != OpAMD64MOVQconst { - goto end9cb4f29b0bd7141639416735dcbb3b87 + break } c := v.Args[0].AuxInt x := v.Args[1] if !(is32Bit(c)) { - goto end9cb4f29b0bd7141639416735dcbb3b87 + break } v.reset(OpAMD64MULQconst) v.AuxInt = c v.AddArg(x) return true } - goto end9cb4f29b0bd7141639416735dcbb3b87 -end9cb4f29b0bd7141639416735dcbb3b87: - ; return false } func rewriteValueAMD64_OpAMD64MULQconst(v *Value, config *Config) bool { @@ -8784,38 +7695,32 @@ func rewriteValueAMD64_OpAMD64MULQconst(v *Value, config *Config) bool { // match: (MULQconst [-1] x) // cond: // result: (NEGQ x) - { + for { if v.AuxInt != -1 { - goto end82501cca6b5fb121a7f8b197e55f2fec + break } x := v.Args[0] v.reset(OpAMD64NEGQ) v.AddArg(x) return true } - goto end82501cca6b5fb121a7f8b197e55f2fec -end82501cca6b5fb121a7f8b197e55f2fec: - ; // match: (MULQconst [0] _) // cond: // result: (MOVQconst [0]) - { + for { if v.AuxInt != 0 { - goto endcb9faa068e3558ff44daaf1d47d091b5 + break } v.reset(OpAMD64MOVQconst) v.AuxInt = 0 return true } - goto endcb9faa068e3558ff44daaf1d47d091b5 -endcb9faa068e3558ff44daaf1d47d091b5: - ; // match: (MULQconst [1] x) // cond: // result: x - { + for { if v.AuxInt != 1 { - goto end0b527e71db2b288b2841a1f757aa580d + break } x := v.Args[0] v.reset(OpCopy) @@ -8823,15 +7728,12 @@ endcb9faa068e3558ff44daaf1d47d091b5: v.AddArg(x) return true } - goto end0b527e71db2b288b2841a1f757aa580d -end0b527e71db2b288b2841a1f757aa580d: - ; // match: (MULQconst [3] x) // cond: // result: (LEAQ2 x x) - { + for { if v.AuxInt != 3 { - goto end34a86f261671b5852bec6c57155fe0da + break } x := v.Args[0] v.reset(OpAMD64LEAQ2) @@ -8839,15 +7741,12 @@ end0b527e71db2b288b2841a1f757aa580d: v.AddArg(x) return true } - goto end34a86f261671b5852bec6c57155fe0da -end34a86f261671b5852bec6c57155fe0da: - ; // match: (MULQconst [5] x) // cond: // result: (LEAQ4 x x) - { + for { if v.AuxInt != 5 { - goto end534601906c45a9171a9fec3e4b82b189 + break } x := v.Args[0] v.reset(OpAMD64LEAQ4) @@ -8855,15 +7754,12 @@ end34a86f261671b5852bec6c57155fe0da: v.AddArg(x) return true } - goto end534601906c45a9171a9fec3e4b82b189 -end534601906c45a9171a9fec3e4b82b189: - ; // match: (MULQconst [9] x) // cond: // result: (LEAQ8 x x) - { + for { if v.AuxInt != 9 { - goto end48a2280b6459821289c56073b8354997 + break } x := v.Args[0] v.reset(OpAMD64LEAQ8) @@ -8871,42 +7767,33 @@ end534601906c45a9171a9fec3e4b82b189: v.AddArg(x) return true } - goto end48a2280b6459821289c56073b8354997 -end48a2280b6459821289c56073b8354997: - ; // match: (MULQconst [c] x) // cond: isPowerOfTwo(c) // result: (SHLQconst [log2(c)] x) - { + for { c := v.AuxInt x := v.Args[0] if !(isPowerOfTwo(c)) { - goto end75076953dbfe022526a153eda99b39b2 + break } v.reset(OpAMD64SHLQconst) v.AuxInt = log2(c) v.AddArg(x) return true } - goto end75076953dbfe022526a153eda99b39b2 -end75076953dbfe022526a153eda99b39b2: - ; // match: (MULQconst [c] (MOVQconst [d])) // cond: // result: (MOVQconst [c*d]) - { + for { c := v.AuxInt if v.Args[0].Op != OpAMD64MOVQconst { - goto end55c38c5c405101e610d7ba7fc702ddc0 + break } d := v.Args[0].AuxInt v.reset(OpAMD64MOVQconst) v.AuxInt = c * d return true } - goto end55c38c5c405101e610d7ba7fc702ddc0 -end55c38c5c405101e610d7ba7fc702ddc0: - ; return false } func rewriteValueAMD64_OpAMD64MULW(v *Value, config *Config) bool { @@ -8915,10 +7802,10 @@ func rewriteValueAMD64_OpAMD64MULW(v *Value, config *Config) bool { // match: (MULW x (MOVWconst [c])) // cond: // result: (MULWconst [c] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVWconst { - goto end542112cc08217d4bdffc1a645d290ffb + break } c := v.Args[1].AuxInt v.reset(OpAMD64MULWconst) @@ -8926,15 +7813,12 @@ func rewriteValueAMD64_OpAMD64MULW(v *Value, config *Config) bool { v.AddArg(x) return true } - goto end542112cc08217d4bdffc1a645d290ffb -end542112cc08217d4bdffc1a645d290ffb: - ; // match: (MULW (MOVWconst [c]) x) // cond: // result: (MULWconst [c] x) - { + for { if v.Args[0].Op != OpAMD64MOVWconst { - goto endd97b4245ced2b3d27d8c555b06281de4 + break } c := v.Args[0].AuxInt x := v.Args[1] @@ -8943,9 +7827,6 @@ end542112cc08217d4bdffc1a645d290ffb: v.AddArg(x) return true } - goto endd97b4245ced2b3d27d8c555b06281de4 -endd97b4245ced2b3d27d8c555b06281de4: - ; return false } func rewriteValueAMD64_OpAMD64MULWconst(v *Value, config *Config) bool { @@ -8954,19 +7835,16 @@ func rewriteValueAMD64_OpAMD64MULWconst(v *Value, config *Config) bool { // match: (MULWconst [c] (MOVWconst [d])) // cond: // result: (MOVWconst [c*d]) - { + for { c := v.AuxInt if v.Args[0].Op != OpAMD64MOVWconst { - goto end61dbc9d9e93dd6946a20a1f475b3f74b + break } d := v.Args[0].AuxInt v.reset(OpAMD64MOVWconst) v.AuxInt = c * d return true } - goto end61dbc9d9e93dd6946a20a1f475b3f74b -end61dbc9d9e93dd6946a20a1f475b3f74b: - ; return false } func rewriteValueAMD64_OpMod16(v *Value, config *Config) bool { @@ -8975,7 +7853,7 @@ func rewriteValueAMD64_OpMod16(v *Value, config *Config) bool { // match: (Mod16 x y) // cond: // result: (MODW x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64MODW) @@ -8983,9 +7861,6 @@ func rewriteValueAMD64_OpMod16(v *Value, config *Config) bool { v.AddArg(y) return true } - goto end036bac694be9fe0d6b00b86c2e625990 -end036bac694be9fe0d6b00b86c2e625990: - ; return false } func rewriteValueAMD64_OpMod16u(v *Value, config *Config) bool { @@ -8994,7 +7869,7 @@ func rewriteValueAMD64_OpMod16u(v *Value, config *Config) bool { // match: (Mod16u x y) // cond: // result: (MODWU x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64MODWU) @@ -9002,9 +7877,6 @@ func rewriteValueAMD64_OpMod16u(v *Value, config *Config) bool { v.AddArg(y) return true } - goto enda75d900097f1510ca1c6df786bef0c24 -enda75d900097f1510ca1c6df786bef0c24: - ; return false } func rewriteValueAMD64_OpMod32(v *Value, config *Config) bool { @@ -9013,7 +7885,7 @@ func rewriteValueAMD64_OpMod32(v *Value, config *Config) bool { // match: (Mod32 x y) // cond: // result: (MODL x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64MODL) @@ -9021,9 +7893,6 @@ func rewriteValueAMD64_OpMod32(v *Value, config *Config) bool { v.AddArg(y) return true } - goto end12c8c0ecf3296810b8217cd4e40f7707 -end12c8c0ecf3296810b8217cd4e40f7707: - ; return false } func rewriteValueAMD64_OpMod32u(v *Value, config *Config) bool { @@ -9032,7 +7901,7 @@ func rewriteValueAMD64_OpMod32u(v *Value, config *Config) bool { // match: (Mod32u x y) // cond: // result: (MODLU x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64MODLU) @@ -9040,9 +7909,6 @@ func rewriteValueAMD64_OpMod32u(v *Value, config *Config) bool { v.AddArg(y) return true } - goto end1f0892076cfd58733a08d3ab175a3c1c -end1f0892076cfd58733a08d3ab175a3c1c: - ; return false } func rewriteValueAMD64_OpMod64(v *Value, config *Config) bool { @@ -9051,7 +7917,7 @@ func rewriteValueAMD64_OpMod64(v *Value, config *Config) bool { // match: (Mod64 x y) // cond: // result: (MODQ x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64MODQ) @@ -9059,9 +7925,6 @@ func rewriteValueAMD64_OpMod64(v *Value, config *Config) bool { v.AddArg(y) return true } - goto endaae75f449baf5dc108be4e0439af97f2 -endaae75f449baf5dc108be4e0439af97f2: - ; return false } func rewriteValueAMD64_OpMod64u(v *Value, config *Config) bool { @@ -9070,7 +7933,7 @@ func rewriteValueAMD64_OpMod64u(v *Value, config *Config) bool { // match: (Mod64u x y) // cond: // result: (MODQU x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64MODQU) @@ -9078,9 +7941,6 @@ func rewriteValueAMD64_OpMod64u(v *Value, config *Config) bool { v.AddArg(y) return true } - goto end0d4c8b9df77e59289fb14e2496559d1d -end0d4c8b9df77e59289fb14e2496559d1d: - ; return false } func rewriteValueAMD64_OpMod8(v *Value, config *Config) bool { @@ -9089,7 +7949,7 @@ func rewriteValueAMD64_OpMod8(v *Value, config *Config) bool { // match: (Mod8 x y) // cond: // result: (MODW (SignExt8to16 x) (SignExt8to16 y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64MODW) @@ -9101,9 +7961,6 @@ func rewriteValueAMD64_OpMod8(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto endf959fc16e72bc6dc47ab7c9ee3778901 -endf959fc16e72bc6dc47ab7c9ee3778901: - ; return false } func rewriteValueAMD64_OpMod8u(v *Value, config *Config) bool { @@ -9112,7 +7969,7 @@ func rewriteValueAMD64_OpMod8u(v *Value, config *Config) bool { // match: (Mod8u x y) // cond: // result: (MODWU (ZeroExt8to16 x) (ZeroExt8to16 y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64MODWU) @@ -9124,9 +7981,6 @@ func rewriteValueAMD64_OpMod8u(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto end9b3274d9dd7f1e91c75ce5e7b548fe97 -end9b3274d9dd7f1e91c75ce5e7b548fe97: - ; return false } func rewriteValueAMD64_OpMove(v *Value, config *Config) bool { @@ -9135,9 +7989,9 @@ func rewriteValueAMD64_OpMove(v *Value, config *Config) bool { // match: (Move [0] _ _ mem) // cond: // result: mem - { + for { if v.AuxInt != 0 { - goto end0961cbfe144a616cba75190d07d65e41 + break } mem := v.Args[2] v.reset(OpCopy) @@ -9145,15 +7999,12 @@ func rewriteValueAMD64_OpMove(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto end0961cbfe144a616cba75190d07d65e41 -end0961cbfe144a616cba75190d07d65e41: - ; // match: (Move [1] dst src mem) // cond: // result: (MOVBstore dst (MOVBload src mem) mem) - { + for { if v.AuxInt != 1 { - goto end72e5dd27e999493b67ea3af4ecc60d48 + break } dst := v.Args[0] src := v.Args[1] @@ -9167,15 +8018,12 @@ end0961cbfe144a616cba75190d07d65e41: v.AddArg(mem) return true } - goto end72e5dd27e999493b67ea3af4ecc60d48 -end72e5dd27e999493b67ea3af4ecc60d48: - ; // match: (Move [2] dst src mem) // cond: // result: (MOVWstore dst (MOVWload src mem) mem) - { + for { if v.AuxInt != 2 { - goto end017f774e406d4578b4bcefcd8db8ec1e + break } dst := v.Args[0] src := v.Args[1] @@ -9189,15 +8037,12 @@ end72e5dd27e999493b67ea3af4ecc60d48: v.AddArg(mem) return true } - goto end017f774e406d4578b4bcefcd8db8ec1e -end017f774e406d4578b4bcefcd8db8ec1e: - ; // match: (Move [4] dst src mem) // cond: // result: (MOVLstore dst (MOVLload src mem) mem) - { + for { if v.AuxInt != 4 { - goto end938ec47a2ddf8e9b4bf71ffade6e5b3f + break } dst := v.Args[0] src := v.Args[1] @@ -9211,15 +8056,12 @@ end017f774e406d4578b4bcefcd8db8ec1e: v.AddArg(mem) return true } - goto end938ec47a2ddf8e9b4bf71ffade6e5b3f -end938ec47a2ddf8e9b4bf71ffade6e5b3f: - ; // match: (Move [8] dst src mem) // cond: // result: (MOVQstore dst (MOVQload src mem) mem) - { + for { if v.AuxInt != 8 { - goto end696b3498f5fee17f49ae0f708d3dfe4b + break } dst := v.Args[0] src := v.Args[1] @@ -9233,15 +8075,12 @@ end938ec47a2ddf8e9b4bf71ffade6e5b3f: v.AddArg(mem) return true } - goto end696b3498f5fee17f49ae0f708d3dfe4b -end696b3498f5fee17f49ae0f708d3dfe4b: - ; // match: (Move [16] dst src mem) // cond: // result: (MOVOstore dst (MOVOload src mem) mem) - { + for { if v.AuxInt != 16 { - goto end4894ace925d468c10a5b0c5b91fc4c1c + break } dst := v.Args[0] src := v.Args[1] @@ -9255,15 +8094,12 @@ end696b3498f5fee17f49ae0f708d3dfe4b: v.AddArg(mem) return true } - goto end4894ace925d468c10a5b0c5b91fc4c1c -end4894ace925d468c10a5b0c5b91fc4c1c: - ; // 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 { - goto end76ce0004999139fe4608c3c5356eb364 + break } dst := v.Args[0] src := v.Args[1] @@ -9286,15 +8122,12 @@ end4894ace925d468c10a5b0c5b91fc4c1c: v.AddArg(v1) return true } - goto end76ce0004999139fe4608c3c5356eb364 -end76ce0004999139fe4608c3c5356eb364: - ; // 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 { - goto end21378690c0f39bdd6b46566d57da34e3 + break } dst := v.Args[0] src := v.Args[1] @@ -9317,15 +8150,12 @@ end76ce0004999139fe4608c3c5356eb364: v.AddArg(v1) return true } - goto end21378690c0f39bdd6b46566d57da34e3 -end21378690c0f39bdd6b46566d57da34e3: - ; // 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 { - goto endcb6e509881d8638d8cae3af4f2b19a8e + break } dst := v.Args[0] src := v.Args[1] @@ -9348,15 +8178,12 @@ end21378690c0f39bdd6b46566d57da34e3: v.AddArg(v1) return true } - goto endcb6e509881d8638d8cae3af4f2b19a8e -endcb6e509881d8638d8cae3af4f2b19a8e: - ; // 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 { - goto end3429ae54bc071c0856ad366c79b7ab97 + break } dst := v.Args[0] src := v.Args[1] @@ -9379,19 +8206,16 @@ endcb6e509881d8638d8cae3af4f2b19a8e: v.AddArg(v1) return true } - goto end3429ae54bc071c0856ad366c79b7ab97 -end3429ae54bc071c0856ad366c79b7ab97: - ; // 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) { - goto endc90f121709d5411d389649dea89a2251 + break } v.reset(OpAMD64MOVQstore) v.AuxInt = size - 8 @@ -9411,19 +8235,16 @@ end3429ae54bc071c0856ad366c79b7ab97: v.AddArg(v1) return true } - goto endc90f121709d5411d389649dea89a2251 -endc90f121709d5411d389649dea89a2251: - ; // match: (Move [size] dst src mem) // cond: size > 16 && size%16 != 0 && size%16 <= 8 // result: (Move [size-size%16] (ADDQconst dst [size%16]) (ADDQconst 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) { - goto end376c57db23b866866f23677c6cde43ba + break } v.reset(OpMove) v.AuxInt = size - size%16 @@ -9445,19 +8266,16 @@ endc90f121709d5411d389649dea89a2251: v.AddArg(v2) return true } - goto end376c57db23b866866f23677c6cde43ba -end376c57db23b866866f23677c6cde43ba: - ; // match: (Move [size] dst src mem) // cond: size > 16 && size%16 != 0 && size%16 > 8 // result: (Move [size-size%16] (ADDQconst dst [size%16]) (ADDQconst 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) { - goto end2f82f76766a21f8802768380cf10a497 + break } v.reset(OpMove) v.AuxInt = size - size%16 @@ -9479,19 +8297,16 @@ end376c57db23b866866f23677c6cde43ba: v.AddArg(v2) return true } - goto end2f82f76766a21f8802768380cf10a497 -end2f82f76766a21f8802768380cf10a497: - ; // 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) { - goto endcb66da6685f0079ee1f84d10fa561f22 + break } v.reset(OpAMD64DUFFCOPY) v.AuxInt = 14 * (64 - size/16) @@ -9500,19 +8315,16 @@ end2f82f76766a21f8802768380cf10a497: v.AddArg(mem) return true } - goto endcb66da6685f0079ee1f84d10fa561f22 -endcb66da6685f0079ee1f84d10fa561f22: - ; // 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) { - goto end7ae25ff1bbdcf34efef09613745e9d6e + break } v.reset(OpAMD64REPMOVSQ) v.AddArg(dst) @@ -9523,9 +8335,6 @@ endcb66da6685f0079ee1f84d10fa561f22: v.AddArg(mem) return true } - goto end7ae25ff1bbdcf34efef09613745e9d6e -end7ae25ff1bbdcf34efef09613745e9d6e: - ; return false } func rewriteValueAMD64_OpMul16(v *Value, config *Config) bool { @@ -9534,7 +8343,7 @@ func rewriteValueAMD64_OpMul16(v *Value, config *Config) bool { // match: (Mul16 x y) // cond: // result: (MULW x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64MULW) @@ -9542,9 +8351,6 @@ func rewriteValueAMD64_OpMul16(v *Value, config *Config) bool { v.AddArg(y) return true } - goto end1addf5ea2c885aa1729b8f944859d00c -end1addf5ea2c885aa1729b8f944859d00c: - ; return false } func rewriteValueAMD64_OpMul32(v *Value, config *Config) bool { @@ -9553,7 +8359,7 @@ func rewriteValueAMD64_OpMul32(v *Value, config *Config) bool { // match: (Mul32 x y) // cond: // result: (MULL x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64MULL) @@ -9561,9 +8367,6 @@ func rewriteValueAMD64_OpMul32(v *Value, config *Config) bool { v.AddArg(y) return true } - goto ende144381f85808e5144782804768e2859 -ende144381f85808e5144782804768e2859: - ; return false } func rewriteValueAMD64_OpMul32F(v *Value, config *Config) bool { @@ -9572,7 +8375,7 @@ func rewriteValueAMD64_OpMul32F(v *Value, config *Config) bool { // match: (Mul32F x y) // cond: // result: (MULSS x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64MULSS) @@ -9580,9 +8383,6 @@ func rewriteValueAMD64_OpMul32F(v *Value, config *Config) bool { v.AddArg(y) return true } - goto end32105a3bfe0237b799b69d83b3f171ca -end32105a3bfe0237b799b69d83b3f171ca: - ; return false } func rewriteValueAMD64_OpMul64(v *Value, config *Config) bool { @@ -9591,7 +8391,7 @@ func rewriteValueAMD64_OpMul64(v *Value, config *Config) bool { // match: (Mul64 x y) // cond: // result: (MULQ x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64MULQ) @@ -9599,9 +8399,6 @@ func rewriteValueAMD64_OpMul64(v *Value, config *Config) bool { v.AddArg(y) return true } - goto end38da21e77ac329eb643b20e7d97d5853 -end38da21e77ac329eb643b20e7d97d5853: - ; return false } func rewriteValueAMD64_OpMul64F(v *Value, config *Config) bool { @@ -9610,7 +8407,7 @@ func rewriteValueAMD64_OpMul64F(v *Value, config *Config) bool { // match: (Mul64F x y) // cond: // result: (MULSD x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64MULSD) @@ -9618,9 +8415,6 @@ func rewriteValueAMD64_OpMul64F(v *Value, config *Config) bool { v.AddArg(y) return true } - goto end0ff6e1919fb0a3e549eb82b43edf1f52 -end0ff6e1919fb0a3e549eb82b43edf1f52: - ; return false } func rewriteValueAMD64_OpMul8(v *Value, config *Config) bool { @@ -9629,7 +8423,7 @@ func rewriteValueAMD64_OpMul8(v *Value, config *Config) bool { // match: (Mul8 x y) // cond: // result: (MULB x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64MULB) @@ -9637,9 +8431,6 @@ func rewriteValueAMD64_OpMul8(v *Value, config *Config) bool { v.AddArg(y) return true } - goto endd876d6bc42a2285b801f42dadbd8757c -endd876d6bc42a2285b801f42dadbd8757c: - ; return false } func rewriteValueAMD64_OpAMD64NEGB(v *Value, config *Config) bool { @@ -9648,18 +8439,15 @@ func rewriteValueAMD64_OpAMD64NEGB(v *Value, config *Config) bool { // match: (NEGB (MOVBconst [c])) // cond: // result: (MOVBconst [-c]) - { + for { if v.Args[0].Op != OpAMD64MOVBconst { - goto end36d0300ba9eab8c9da86246ff653ca96 + break } c := v.Args[0].AuxInt v.reset(OpAMD64MOVBconst) v.AuxInt = -c return true } - goto end36d0300ba9eab8c9da86246ff653ca96 -end36d0300ba9eab8c9da86246ff653ca96: - ; return false } func rewriteValueAMD64_OpAMD64NEGL(v *Value, config *Config) bool { @@ -9668,18 +8456,15 @@ func rewriteValueAMD64_OpAMD64NEGL(v *Value, config *Config) bool { // match: (NEGL (MOVLconst [c])) // cond: // result: (MOVLconst [-c]) - { + for { if v.Args[0].Op != OpAMD64MOVLconst { - goto end7a245ec67e56bd51911e5ba2d0aa0a16 + break } c := v.Args[0].AuxInt v.reset(OpAMD64MOVLconst) v.AuxInt = -c return true } - goto end7a245ec67e56bd51911e5ba2d0aa0a16 -end7a245ec67e56bd51911e5ba2d0aa0a16: - ; return false } func rewriteValueAMD64_OpAMD64NEGQ(v *Value, config *Config) bool { @@ -9688,18 +8473,15 @@ func rewriteValueAMD64_OpAMD64NEGQ(v *Value, config *Config) bool { // match: (NEGQ (MOVQconst [c])) // cond: // result: (MOVQconst [-c]) - { + for { if v.Args[0].Op != OpAMD64MOVQconst { - goto end04ddd98bc6724ecb85c80c2a4e2bca5a + break } c := v.Args[0].AuxInt v.reset(OpAMD64MOVQconst) v.AuxInt = -c return true } - goto end04ddd98bc6724ecb85c80c2a4e2bca5a -end04ddd98bc6724ecb85c80c2a4e2bca5a: - ; return false } func rewriteValueAMD64_OpAMD64NEGW(v *Value, config *Config) bool { @@ -9708,18 +8490,15 @@ func rewriteValueAMD64_OpAMD64NEGW(v *Value, config *Config) bool { // match: (NEGW (MOVWconst [c])) // cond: // result: (MOVWconst [-c]) - { + for { if v.Args[0].Op != OpAMD64MOVWconst { - goto end1db6636f0a51848d8a34f6561ecfe7ae + break } c := v.Args[0].AuxInt v.reset(OpAMD64MOVWconst) v.AuxInt = -c return true } - goto end1db6636f0a51848d8a34f6561ecfe7ae -end1db6636f0a51848d8a34f6561ecfe7ae: - ; return false } func rewriteValueAMD64_OpAMD64NOTB(v *Value, config *Config) bool { @@ -9728,18 +8507,15 @@ func rewriteValueAMD64_OpAMD64NOTB(v *Value, config *Config) bool { // match: (NOTB (MOVBconst [c])) // cond: // result: (MOVBconst [^c]) - { + for { if v.Args[0].Op != OpAMD64MOVBconst { - goto end9e383a9ceb29a9e2bf890ec6a67212a8 + break } c := v.Args[0].AuxInt v.reset(OpAMD64MOVBconst) v.AuxInt = ^c return true } - goto end9e383a9ceb29a9e2bf890ec6a67212a8 -end9e383a9ceb29a9e2bf890ec6a67212a8: - ; return false } func rewriteValueAMD64_OpAMD64NOTL(v *Value, config *Config) bool { @@ -9748,18 +8524,15 @@ func rewriteValueAMD64_OpAMD64NOTL(v *Value, config *Config) bool { // match: (NOTL (MOVLconst [c])) // cond: // result: (MOVLconst [^c]) - { + for { if v.Args[0].Op != OpAMD64MOVLconst { - goto endcc73972c088d5e652a1370a96e56502d + break } c := v.Args[0].AuxInt v.reset(OpAMD64MOVLconst) v.AuxInt = ^c return true } - goto endcc73972c088d5e652a1370a96e56502d -endcc73972c088d5e652a1370a96e56502d: - ; return false } func rewriteValueAMD64_OpAMD64NOTQ(v *Value, config *Config) bool { @@ -9768,18 +8541,15 @@ func rewriteValueAMD64_OpAMD64NOTQ(v *Value, config *Config) bool { // match: (NOTQ (MOVQconst [c])) // cond: // result: (MOVQconst [^c]) - { + for { if v.Args[0].Op != OpAMD64MOVQconst { - goto endb39ddb6bf7339d46f74114baad4333b6 + break } c := v.Args[0].AuxInt v.reset(OpAMD64MOVQconst) v.AuxInt = ^c return true } - goto endb39ddb6bf7339d46f74114baad4333b6 -endb39ddb6bf7339d46f74114baad4333b6: - ; return false } func rewriteValueAMD64_OpAMD64NOTW(v *Value, config *Config) bool { @@ -9788,18 +8558,15 @@ func rewriteValueAMD64_OpAMD64NOTW(v *Value, config *Config) bool { // match: (NOTW (MOVWconst [c])) // cond: // result: (MOVWconst [^c]) - { + for { if v.Args[0].Op != OpAMD64MOVWconst { - goto end35848095ebcf894c6957ad3be5f82c43 + break } c := v.Args[0].AuxInt v.reset(OpAMD64MOVWconst) v.AuxInt = ^c return true } - goto end35848095ebcf894c6957ad3be5f82c43 -end35848095ebcf894c6957ad3be5f82c43: - ; return false } func rewriteValueAMD64_OpNeg16(v *Value, config *Config) bool { @@ -9808,15 +8575,12 @@ func rewriteValueAMD64_OpNeg16(v *Value, config *Config) bool { // match: (Neg16 x) // cond: // result: (NEGW x) - { + for { x := v.Args[0] v.reset(OpAMD64NEGW) v.AddArg(x) return true } - goto end7a8c652f4ffeb49656119af69512edb2 -end7a8c652f4ffeb49656119af69512edb2: - ; return false } func rewriteValueAMD64_OpNeg32(v *Value, config *Config) bool { @@ -9825,15 +8589,12 @@ func rewriteValueAMD64_OpNeg32(v *Value, config *Config) bool { // match: (Neg32 x) // cond: // result: (NEGL x) - { + for { x := v.Args[0] v.reset(OpAMD64NEGL) v.AddArg(x) return true } - goto endce1f7e17fc193f6c076e47d5e401e126 -endce1f7e17fc193f6c076e47d5e401e126: - ; return false } func rewriteValueAMD64_OpNeg32F(v *Value, config *Config) bool { @@ -9842,7 +8603,7 @@ func rewriteValueAMD64_OpNeg32F(v *Value, config *Config) bool { // match: (Neg32F x) // cond: // result: (PXOR x (MOVSSconst [f2i(math.Copysign(0, -1))])) - { + for { x := v.Args[0] v.reset(OpAMD64PXOR) v.AddArg(x) @@ -9851,9 +8612,6 @@ func rewriteValueAMD64_OpNeg32F(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end685a5fc899e195b9091afbe2a7146051 -end685a5fc899e195b9091afbe2a7146051: - ; return false } func rewriteValueAMD64_OpNeg64(v *Value, config *Config) bool { @@ -9862,15 +8620,12 @@ func rewriteValueAMD64_OpNeg64(v *Value, config *Config) bool { // match: (Neg64 x) // cond: // result: (NEGQ x) - { + for { x := v.Args[0] v.reset(OpAMD64NEGQ) v.AddArg(x) return true } - goto enda06c5b1718f2b96aba10bf5a5c437c6c -enda06c5b1718f2b96aba10bf5a5c437c6c: - ; return false } func rewriteValueAMD64_OpNeg64F(v *Value, config *Config) bool { @@ -9879,7 +8634,7 @@ func rewriteValueAMD64_OpNeg64F(v *Value, config *Config) bool { // match: (Neg64F x) // cond: // result: (PXOR x (MOVSDconst [f2i(math.Copysign(0, -1))])) - { + for { x := v.Args[0] v.reset(OpAMD64PXOR) v.AddArg(x) @@ -9888,9 +8643,6 @@ func rewriteValueAMD64_OpNeg64F(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto ende85ae82b7a51e75000eb9158d584acb2 -ende85ae82b7a51e75000eb9158d584acb2: - ; return false } func rewriteValueAMD64_OpNeg8(v *Value, config *Config) bool { @@ -9899,15 +8651,12 @@ func rewriteValueAMD64_OpNeg8(v *Value, config *Config) bool { // match: (Neg8 x) // cond: // result: (NEGB x) - { + for { x := v.Args[0] v.reset(OpAMD64NEGB) v.AddArg(x) return true } - goto end1e5f495a2ac6cdea47b1ae5ba62aa95d -end1e5f495a2ac6cdea47b1ae5ba62aa95d: - ; return false } func rewriteValueAMD64_OpNeq16(v *Value, config *Config) bool { @@ -9916,7 +8665,7 @@ func rewriteValueAMD64_OpNeq16(v *Value, config *Config) bool { // match: (Neq16 x y) // cond: // result: (SETNE (CMPW x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETNE) @@ -9926,9 +8675,6 @@ func rewriteValueAMD64_OpNeq16(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end6413ee42d523a005cce9e3372ff2c8e9 -end6413ee42d523a005cce9e3372ff2c8e9: - ; return false } func rewriteValueAMD64_OpNeq32(v *Value, config *Config) bool { @@ -9937,7 +8683,7 @@ func rewriteValueAMD64_OpNeq32(v *Value, config *Config) bool { // match: (Neq32 x y) // cond: // result: (SETNE (CMPL x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETNE) @@ -9947,9 +8693,6 @@ func rewriteValueAMD64_OpNeq32(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto endb1a3ad499a09d8262952e6cbc47a23a8 -endb1a3ad499a09d8262952e6cbc47a23a8: - ; return false } func rewriteValueAMD64_OpNeq32F(v *Value, config *Config) bool { @@ -9958,7 +8701,7 @@ func rewriteValueAMD64_OpNeq32F(v *Value, config *Config) bool { // match: (Neq32F x y) // cond: // result: (SETNEF (UCOMISS x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETNEF) @@ -9968,9 +8711,6 @@ func rewriteValueAMD64_OpNeq32F(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end2a001b2774f58aaf8c1e9efce6ae59e7 -end2a001b2774f58aaf8c1e9efce6ae59e7: - ; return false } func rewriteValueAMD64_OpNeq64(v *Value, config *Config) bool { @@ -9979,7 +8719,7 @@ func rewriteValueAMD64_OpNeq64(v *Value, config *Config) bool { // match: (Neq64 x y) // cond: // result: (SETNE (CMPQ x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETNE) @@ -9989,9 +8729,6 @@ func rewriteValueAMD64_OpNeq64(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end092b9159bce08d2ef7896f7d3da5a595 -end092b9159bce08d2ef7896f7d3da5a595: - ; return false } func rewriteValueAMD64_OpNeq64F(v *Value, config *Config) bool { @@ -10000,7 +8737,7 @@ func rewriteValueAMD64_OpNeq64F(v *Value, config *Config) bool { // match: (Neq64F x y) // cond: // result: (SETNEF (UCOMISD x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETNEF) @@ -10010,9 +8747,6 @@ func rewriteValueAMD64_OpNeq64F(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto endb9c010023c38bd2fee7800fbefc85d98 -endb9c010023c38bd2fee7800fbefc85d98: - ; return false } func rewriteValueAMD64_OpNeq8(v *Value, config *Config) bool { @@ -10021,7 +8755,7 @@ func rewriteValueAMD64_OpNeq8(v *Value, config *Config) bool { // match: (Neq8 x y) // cond: // result: (SETNE (CMPB x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETNE) @@ -10031,9 +8765,6 @@ func rewriteValueAMD64_OpNeq8(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end89e59f45e068c89458cc4db1692bf3bb -end89e59f45e068c89458cc4db1692bf3bb: - ; return false } func rewriteValueAMD64_OpNeqPtr(v *Value, config *Config) bool { @@ -10042,7 +8773,7 @@ func rewriteValueAMD64_OpNeqPtr(v *Value, config *Config) bool { // match: (NeqPtr x y) // cond: // result: (SETNE (CMPQ x y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SETNE) @@ -10052,9 +8783,6 @@ func rewriteValueAMD64_OpNeqPtr(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end3b8bb3b4952011d1d40f993d8717cf16 -end3b8bb3b4952011d1d40f993d8717cf16: - ; return false } func rewriteValueAMD64_OpNilCheck(v *Value, config *Config) bool { @@ -10063,7 +8791,7 @@ func rewriteValueAMD64_OpNilCheck(v *Value, config *Config) bool { // match: (NilCheck ptr mem) // cond: // result: (LoweredNilCheck ptr mem) - { + for { ptr := v.Args[0] mem := v.Args[1] v.reset(OpAMD64LoweredNilCheck) @@ -10071,9 +8799,6 @@ func rewriteValueAMD64_OpNilCheck(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto end75520e60179564948a625707b84e8a8d -end75520e60179564948a625707b84e8a8d: - ; return false } func rewriteValueAMD64_OpNot(v *Value, config *Config) bool { @@ -10082,16 +8807,13 @@ func rewriteValueAMD64_OpNot(v *Value, config *Config) bool { // match: (Not x) // cond: // result: (XORBconst [1] x) - { + for { x := v.Args[0] v.reset(OpAMD64XORBconst) v.AuxInt = 1 v.AddArg(x) return true } - goto end73973101aad60079c62fa64624e21db1 -end73973101aad60079c62fa64624e21db1: - ; return false } func rewriteValueAMD64_OpAMD64ORB(v *Value, config *Config) bool { @@ -10100,10 +8822,10 @@ func rewriteValueAMD64_OpAMD64ORB(v *Value, config *Config) bool { // match: (ORB x (MOVBconst [c])) // cond: // result: (ORBconst [c] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVBconst { - goto end7b63870decde2515cb77ec4f8f76817c + break } c := v.Args[1].AuxInt v.reset(OpAMD64ORBconst) @@ -10111,15 +8833,12 @@ func rewriteValueAMD64_OpAMD64ORB(v *Value, config *Config) bool { v.AddArg(x) return true } - goto end7b63870decde2515cb77ec4f8f76817c -end7b63870decde2515cb77ec4f8f76817c: - ; // match: (ORB (MOVBconst [c]) x) // cond: // result: (ORBconst [c] x) - { + for { if v.Args[0].Op != OpAMD64MOVBconst { - goto end70b43d531e2097a4f6293f66256a642e + break } c := v.Args[0].AuxInt x := v.Args[1] @@ -10128,25 +8847,19 @@ end7b63870decde2515cb77ec4f8f76817c: v.AddArg(x) return true } - goto end70b43d531e2097a4f6293f66256a642e -end70b43d531e2097a4f6293f66256a642e: - ; // match: (ORB x x) // cond: // result: x - { + for { x := v.Args[0] if v.Args[1] != x { - goto enddca5ce800a9eca157f243cb2fdb1408a + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto enddca5ce800a9eca157f243cb2fdb1408a -enddca5ce800a9eca157f243cb2fdb1408a: - ; return false } func rewriteValueAMD64_OpAMD64ORBconst(v *Value, config *Config) bool { @@ -10155,51 +8868,42 @@ func rewriteValueAMD64_OpAMD64ORBconst(v *Value, config *Config) bool { // match: (ORBconst [c] x) // cond: int8(c)==0 // result: x - { + for { c := v.AuxInt x := v.Args[0] if !(int8(c) == 0) { - goto end565f78e3a843dc73943b59227b39a1b3 + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto end565f78e3a843dc73943b59227b39a1b3 -end565f78e3a843dc73943b59227b39a1b3: - ; // match: (ORBconst [c] _) // cond: int8(c)==-1 // result: (MOVBconst [-1]) - { + for { c := v.AuxInt if !(int8(c) == -1) { - goto end6033c7910d8cd536b31446e179e4610d + break } v.reset(OpAMD64MOVBconst) v.AuxInt = -1 return true } - goto end6033c7910d8cd536b31446e179e4610d -end6033c7910d8cd536b31446e179e4610d: - ; // match: (ORBconst [c] (MOVBconst [d])) // cond: // result: (MOVBconst [c|d]) - { + for { c := v.AuxInt if v.Args[0].Op != OpAMD64MOVBconst { - goto endbe5263f022dc10a5cf53c118937d79dd + break } d := v.Args[0].AuxInt v.reset(OpAMD64MOVBconst) v.AuxInt = c | d return true } - goto endbe5263f022dc10a5cf53c118937d79dd -endbe5263f022dc10a5cf53c118937d79dd: - ; return false } func rewriteValueAMD64_OpAMD64ORL(v *Value, config *Config) bool { @@ -10208,10 +8912,10 @@ func rewriteValueAMD64_OpAMD64ORL(v *Value, config *Config) bool { // match: (ORL x (MOVLconst [c])) // cond: // result: (ORLconst [c] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVLconst { - goto end1b883e30d860b6fac14ae98462c4f61a + break } c := v.Args[1].AuxInt v.reset(OpAMD64ORLconst) @@ -10219,15 +8923,12 @@ func rewriteValueAMD64_OpAMD64ORL(v *Value, config *Config) bool { v.AddArg(x) return true } - goto end1b883e30d860b6fac14ae98462c4f61a -end1b883e30d860b6fac14ae98462c4f61a: - ; // match: (ORL (MOVLconst [c]) x) // cond: // result: (ORLconst [c] x) - { + for { if v.Args[0].Op != OpAMD64MOVLconst { - goto enda5bc49524a0cbd2241f792837d0a48a8 + break } c := v.Args[0].AuxInt x := v.Args[1] @@ -10236,25 +8937,19 @@ end1b883e30d860b6fac14ae98462c4f61a: v.AddArg(x) return true } - goto enda5bc49524a0cbd2241f792837d0a48a8 -enda5bc49524a0cbd2241f792837d0a48a8: - ; // match: (ORL x x) // cond: // result: x - { + for { x := v.Args[0] if v.Args[1] != x { - goto end2dd719b68f4938777ef0d820aab93659 + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto end2dd719b68f4938777ef0d820aab93659 -end2dd719b68f4938777ef0d820aab93659: - ; return false } func rewriteValueAMD64_OpAMD64ORLconst(v *Value, config *Config) bool { @@ -10263,51 +8958,42 @@ func rewriteValueAMD64_OpAMD64ORLconst(v *Value, config *Config) bool { // match: (ORLconst [c] x) // cond: int32(c)==0 // result: x - { + for { c := v.AuxInt x := v.Args[0] if !(int32(c) == 0) { - goto end5b52623a724e8a7167c71289fb7192f1 + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto end5b52623a724e8a7167c71289fb7192f1 -end5b52623a724e8a7167c71289fb7192f1: - ; // match: (ORLconst [c] _) // cond: int32(c)==-1 // result: (MOVLconst [-1]) - { + for { c := v.AuxInt if !(int32(c) == -1) { - goto end345a8ea439ef2ef54bd84fc8a0f73e97 + break } v.reset(OpAMD64MOVLconst) v.AuxInt = -1 return true } - goto end345a8ea439ef2ef54bd84fc8a0f73e97 -end345a8ea439ef2ef54bd84fc8a0f73e97: - ; // match: (ORLconst [c] (MOVLconst [d])) // cond: // result: (MOVLconst [c|d]) - { + for { c := v.AuxInt if v.Args[0].Op != OpAMD64MOVLconst { - goto ende9ca05024248f782c88084715f81d727 + break } d := v.Args[0].AuxInt v.reset(OpAMD64MOVLconst) v.AuxInt = c | d return true } - goto ende9ca05024248f782c88084715f81d727 -ende9ca05024248f782c88084715f81d727: - ; return false } func rewriteValueAMD64_OpAMD64ORQ(v *Value, config *Config) bool { @@ -10316,59 +9002,50 @@ func rewriteValueAMD64_OpAMD64ORQ(v *Value, config *Config) bool { // match: (ORQ x (MOVQconst [c])) // cond: is32Bit(c) // result: (ORQconst [c] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVQconst { - goto end601f2bb3ccda102e484ff60adeaf6d26 + break } c := v.Args[1].AuxInt if !(is32Bit(c)) { - goto end601f2bb3ccda102e484ff60adeaf6d26 + break } v.reset(OpAMD64ORQconst) v.AuxInt = c v.AddArg(x) return true } - goto end601f2bb3ccda102e484ff60adeaf6d26 -end601f2bb3ccda102e484ff60adeaf6d26: - ; // match: (ORQ (MOVQconst [c]) x) // cond: is32Bit(c) // result: (ORQconst [c] x) - { + for { if v.Args[0].Op != OpAMD64MOVQconst { - goto end010afbebcd314e288509d79a16a6d5cc + break } c := v.Args[0].AuxInt x := v.Args[1] if !(is32Bit(c)) { - goto end010afbebcd314e288509d79a16a6d5cc + break } v.reset(OpAMD64ORQconst) v.AuxInt = c v.AddArg(x) return true } - goto end010afbebcd314e288509d79a16a6d5cc -end010afbebcd314e288509d79a16a6d5cc: - ; // match: (ORQ x x) // cond: // result: x - { + for { x := v.Args[0] if v.Args[1] != x { - goto end47a27d30b82db576978c5a3a57b520fb + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto end47a27d30b82db576978c5a3a57b520fb -end47a27d30b82db576978c5a3a57b520fb: - ; return false } func rewriteValueAMD64_OpAMD64ORQconst(v *Value, config *Config) bool { @@ -10377,9 +9054,9 @@ func rewriteValueAMD64_OpAMD64ORQconst(v *Value, config *Config) bool { // match: (ORQconst [0] x) // cond: // result: x - { + for { if v.AuxInt != 0 { - goto end44534da6b9ce98d33fad7e20f0be1fbd + break } x := v.Args[0] v.reset(OpCopy) @@ -10387,39 +9064,30 @@ func rewriteValueAMD64_OpAMD64ORQconst(v *Value, config *Config) bool { v.AddArg(x) return true } - goto end44534da6b9ce98d33fad7e20f0be1fbd -end44534da6b9ce98d33fad7e20f0be1fbd: - ; // match: (ORQconst [-1] _) // cond: // result: (MOVQconst [-1]) - { + for { if v.AuxInt != -1 { - goto endcde9b9d7c4527eaa5d50b252f50b43c1 + break } v.reset(OpAMD64MOVQconst) v.AuxInt = -1 return true } - goto endcde9b9d7c4527eaa5d50b252f50b43c1 -endcde9b9d7c4527eaa5d50b252f50b43c1: - ; // match: (ORQconst [c] (MOVQconst [d])) // cond: // result: (MOVQconst [c|d]) - { + for { c := v.AuxInt if v.Args[0].Op != OpAMD64MOVQconst { - goto enda2488509b71db9abcb06a5115c4ddc2c + break } d := v.Args[0].AuxInt v.reset(OpAMD64MOVQconst) v.AuxInt = c | d return true } - goto enda2488509b71db9abcb06a5115c4ddc2c -enda2488509b71db9abcb06a5115c4ddc2c: - ; return false } func rewriteValueAMD64_OpAMD64ORW(v *Value, config *Config) bool { @@ -10428,10 +9096,10 @@ func rewriteValueAMD64_OpAMD64ORW(v *Value, config *Config) bool { // match: (ORW x (MOVWconst [c])) // cond: // result: (ORWconst [c] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVWconst { - goto end9f98df10892dbf170b49aace86ee0d7f + break } c := v.Args[1].AuxInt v.reset(OpAMD64ORWconst) @@ -10439,15 +9107,12 @@ func rewriteValueAMD64_OpAMD64ORW(v *Value, config *Config) bool { v.AddArg(x) return true } - goto end9f98df10892dbf170b49aace86ee0d7f -end9f98df10892dbf170b49aace86ee0d7f: - ; // match: (ORW (MOVWconst [c]) x) // cond: // result: (ORWconst [c] x) - { + for { if v.Args[0].Op != OpAMD64MOVWconst { - goto end96405942c9ceb5fcb0ddb85a8709d015 + break } c := v.Args[0].AuxInt x := v.Args[1] @@ -10456,25 +9121,19 @@ end9f98df10892dbf170b49aace86ee0d7f: v.AddArg(x) return true } - goto end96405942c9ceb5fcb0ddb85a8709d015 -end96405942c9ceb5fcb0ddb85a8709d015: - ; // match: (ORW x x) // cond: // result: x - { + for { x := v.Args[0] if v.Args[1] != x { - goto endc6a23b64e541dc9cfc6a90fd7028e8c1 + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto endc6a23b64e541dc9cfc6a90fd7028e8c1 -endc6a23b64e541dc9cfc6a90fd7028e8c1: - ; return false } func rewriteValueAMD64_OpAMD64ORWconst(v *Value, config *Config) bool { @@ -10483,51 +9142,42 @@ func rewriteValueAMD64_OpAMD64ORWconst(v *Value, config *Config) bool { // match: (ORWconst [c] x) // cond: int16(c)==0 // result: x - { + for { c := v.AuxInt x := v.Args[0] if !(int16(c) == 0) { - goto endbbbdec9091c8b4c58e587eac8a43402d + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto endbbbdec9091c8b4c58e587eac8a43402d -endbbbdec9091c8b4c58e587eac8a43402d: - ; // match: (ORWconst [c] _) // cond: int16(c)==-1 // result: (MOVWconst [-1]) - { + for { c := v.AuxInt if !(int16(c) == -1) { - goto ended87a5775f5e04b2d2a117a63d82dd9b + break } v.reset(OpAMD64MOVWconst) v.AuxInt = -1 return true } - goto ended87a5775f5e04b2d2a117a63d82dd9b -ended87a5775f5e04b2d2a117a63d82dd9b: - ; // match: (ORWconst [c] (MOVWconst [d])) // cond: // result: (MOVWconst [c|d]) - { + for { c := v.AuxInt if v.Args[0].Op != OpAMD64MOVWconst { - goto endba9221a8462b5c62e8d7c686f64c2778 + break } d := v.Args[0].AuxInt v.reset(OpAMD64MOVWconst) v.AuxInt = c | d return true } - goto endba9221a8462b5c62e8d7c686f64c2778 -endba9221a8462b5c62e8d7c686f64c2778: - ; return false } func rewriteValueAMD64_OpOffPtr(v *Value, config *Config) bool { @@ -10536,7 +9186,7 @@ func rewriteValueAMD64_OpOffPtr(v *Value, config *Config) bool { // match: (OffPtr [off] ptr) // cond: // result: (ADDQconst [off] ptr) - { + for { off := v.AuxInt ptr := v.Args[0] v.reset(OpAMD64ADDQconst) @@ -10544,9 +9194,6 @@ func rewriteValueAMD64_OpOffPtr(v *Value, config *Config) bool { v.AddArg(ptr) return true } - goto end0429f947ee7ac49ff45a243e461a5290 -end0429f947ee7ac49ff45a243e461a5290: - ; return false } func rewriteValueAMD64_OpOr16(v *Value, config *Config) bool { @@ -10555,7 +9202,7 @@ func rewriteValueAMD64_OpOr16(v *Value, config *Config) bool { // match: (Or16 x y) // cond: // result: (ORW x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64ORW) @@ -10563,9 +9210,6 @@ func rewriteValueAMD64_OpOr16(v *Value, config *Config) bool { v.AddArg(y) return true } - goto end8fedf2c79d5607b7056b0ff015199cbd -end8fedf2c79d5607b7056b0ff015199cbd: - ; return false } func rewriteValueAMD64_OpOr32(v *Value, config *Config) bool { @@ -10574,7 +9218,7 @@ func rewriteValueAMD64_OpOr32(v *Value, config *Config) bool { // match: (Or32 x y) // cond: // result: (ORL x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64ORL) @@ -10582,9 +9226,6 @@ func rewriteValueAMD64_OpOr32(v *Value, config *Config) bool { v.AddArg(y) return true } - goto endea45bed9ca97d2995b68b53e6012d384 -endea45bed9ca97d2995b68b53e6012d384: - ; return false } func rewriteValueAMD64_OpOr64(v *Value, config *Config) bool { @@ -10593,7 +9234,7 @@ func rewriteValueAMD64_OpOr64(v *Value, config *Config) bool { // match: (Or64 x y) // cond: // result: (ORQ x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64ORQ) @@ -10601,9 +9242,6 @@ func rewriteValueAMD64_OpOr64(v *Value, config *Config) bool { v.AddArg(y) return true } - goto end3a446becaf2461f4f1a41faeef313f41 -end3a446becaf2461f4f1a41faeef313f41: - ; return false } func rewriteValueAMD64_OpOr8(v *Value, config *Config) bool { @@ -10612,7 +9250,7 @@ func rewriteValueAMD64_OpOr8(v *Value, config *Config) bool { // match: (Or8 x y) // cond: // result: (ORB x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64ORB) @@ -10620,9 +9258,6 @@ func rewriteValueAMD64_OpOr8(v *Value, config *Config) bool { v.AddArg(y) return true } - goto end6f8a8c559a167d1f0a5901d09a1fb248 -end6f8a8c559a167d1f0a5901d09a1fb248: - ; return false } func rewriteValueAMD64_OpRsh16Ux16(v *Value, config *Config) bool { @@ -10631,7 +9266,7 @@ func rewriteValueAMD64_OpRsh16Ux16(v *Value, config *Config) bool { // match: (Rsh16Ux16 x y) // cond: // result: (ANDW (SHRW x y) (SBBLcarrymask (CMPWconst y [16]))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -10648,9 +9283,6 @@ func rewriteValueAMD64_OpRsh16Ux16(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto end291acf0117b46a676e5e1fe524459800 -end291acf0117b46a676e5e1fe524459800: - ; return false } func rewriteValueAMD64_OpRsh16Ux32(v *Value, config *Config) bool { @@ -10659,7 +9291,7 @@ func rewriteValueAMD64_OpRsh16Ux32(v *Value, config *Config) bool { // match: (Rsh16Ux32 x y) // cond: // result: (ANDW (SHRW x y) (SBBLcarrymask (CMPLconst y [16]))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -10676,9 +9308,6 @@ func rewriteValueAMD64_OpRsh16Ux32(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto endea051fe538151b144cd630ce63d35bf7 -endea051fe538151b144cd630ce63d35bf7: - ; return false } func rewriteValueAMD64_OpRsh16Ux64(v *Value, config *Config) bool { @@ -10687,7 +9316,7 @@ func rewriteValueAMD64_OpRsh16Ux64(v *Value, config *Config) bool { // match: (Rsh16Ux64 x y) // cond: // result: (ANDW (SHRW x y) (SBBLcarrymask (CMPQconst y [16]))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -10704,9 +9333,6 @@ func rewriteValueAMD64_OpRsh16Ux64(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto endd1a8f3aa91391fbd13c2dcd03a75283a -endd1a8f3aa91391fbd13c2dcd03a75283a: - ; return false } func rewriteValueAMD64_OpRsh16Ux8(v *Value, config *Config) bool { @@ -10715,7 +9341,7 @@ func rewriteValueAMD64_OpRsh16Ux8(v *Value, config *Config) bool { // match: (Rsh16Ux8 x y) // cond: // result: (ANDW (SHRW x y) (SBBLcarrymask (CMPBconst y [16]))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -10732,9 +9358,6 @@ func rewriteValueAMD64_OpRsh16Ux8(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto end9de32652fceccadca5a6206066bcbb10 -end9de32652fceccadca5a6206066bcbb10: - ; return false } func rewriteValueAMD64_OpRsh16x16(v *Value, config *Config) bool { @@ -10743,7 +9366,7 @@ func rewriteValueAMD64_OpRsh16x16(v *Value, config *Config) bool { // match: (Rsh16x16 x y) // cond: // result: (SARW x (ORW y (NOTL (SBBLcarrymask (CMPWconst y [16]))))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -10763,9 +9386,6 @@ func rewriteValueAMD64_OpRsh16x16(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end71e3cf43426d4351f7fac15145ca6cd9 -end71e3cf43426d4351f7fac15145ca6cd9: - ; return false } func rewriteValueAMD64_OpRsh16x32(v *Value, config *Config) bool { @@ -10774,7 +9394,7 @@ func rewriteValueAMD64_OpRsh16x32(v *Value, config *Config) bool { // match: (Rsh16x32 x y) // cond: // result: (SARW x (ORL y (NOTL (SBBLcarrymask (CMPLconst y [16]))))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -10794,9 +9414,6 @@ func rewriteValueAMD64_OpRsh16x32(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto endfc3bf56711046c6b29b676b155af7c98 -endfc3bf56711046c6b29b676b155af7c98: - ; return false } func rewriteValueAMD64_OpRsh16x64(v *Value, config *Config) bool { @@ -10805,7 +9422,7 @@ func rewriteValueAMD64_OpRsh16x64(v *Value, config *Config) bool { // match: (Rsh16x64 x y) // cond: // result: (SARW x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst y [16]))))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -10825,9 +9442,6 @@ func rewriteValueAMD64_OpRsh16x64(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto endeaf40562fd3394586c63adceca4d9559 -endeaf40562fd3394586c63adceca4d9559: - ; return false } func rewriteValueAMD64_OpRsh16x8(v *Value, config *Config) bool { @@ -10836,7 +9450,7 @@ func rewriteValueAMD64_OpRsh16x8(v *Value, config *Config) bool { // match: (Rsh16x8 x y) // cond: // result: (SARW x (ORB y (NOTL (SBBLcarrymask (CMPBconst y [16]))))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -10856,9 +9470,6 @@ func rewriteValueAMD64_OpRsh16x8(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto endc6cd0d3ecc71bc1830e01c07f274ff7b -endc6cd0d3ecc71bc1830e01c07f274ff7b: - ; return false } func rewriteValueAMD64_OpRsh32Ux16(v *Value, config *Config) bool { @@ -10867,7 +9478,7 @@ func rewriteValueAMD64_OpRsh32Ux16(v *Value, config *Config) bool { // match: (Rsh32Ux16 x y) // cond: // result: (ANDL (SHRL x y) (SBBLcarrymask (CMPWconst y [32]))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -10884,9 +9495,6 @@ func rewriteValueAMD64_OpRsh32Ux16(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto end74ddc1443f6ffb1fe911f455ff982bfb -end74ddc1443f6ffb1fe911f455ff982bfb: - ; return false } func rewriteValueAMD64_OpRsh32Ux32(v *Value, config *Config) bool { @@ -10895,7 +9503,7 @@ func rewriteValueAMD64_OpRsh32Ux32(v *Value, config *Config) bool { // match: (Rsh32Ux32 x y) // cond: // result: (ANDL (SHRL x y) (SBBLcarrymask (CMPLconst y [32]))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -10912,9 +9520,6 @@ func rewriteValueAMD64_OpRsh32Ux32(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto enda93828d8aa54be68080640034f94ed96 -enda93828d8aa54be68080640034f94ed96: - ; return false } func rewriteValueAMD64_OpRsh32Ux64(v *Value, config *Config) bool { @@ -10923,7 +9528,7 @@ func rewriteValueAMD64_OpRsh32Ux64(v *Value, config *Config) bool { // match: (Rsh32Ux64 x y) // cond: // result: (ANDL (SHRL x y) (SBBLcarrymask (CMPQconst y [32]))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -10940,9 +9545,6 @@ func rewriteValueAMD64_OpRsh32Ux64(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto end4f644f3f89ef842f4b0567fc385a58e3 -end4f644f3f89ef842f4b0567fc385a58e3: - ; return false } func rewriteValueAMD64_OpRsh32Ux8(v *Value, config *Config) bool { @@ -10951,7 +9553,7 @@ func rewriteValueAMD64_OpRsh32Ux8(v *Value, config *Config) bool { // match: (Rsh32Ux8 x y) // cond: // result: (ANDL (SHRL x y) (SBBLcarrymask (CMPBconst y [32]))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -10968,9 +9570,6 @@ func rewriteValueAMD64_OpRsh32Ux8(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto end2a8f279bb4900b9bf3846378f36d7994 -end2a8f279bb4900b9bf3846378f36d7994: - ; return false } func rewriteValueAMD64_OpRsh32x16(v *Value, config *Config) bool { @@ -10979,7 +9578,7 @@ func rewriteValueAMD64_OpRsh32x16(v *Value, config *Config) bool { // match: (Rsh32x16 x y) // cond: // result: (SARL x (ORW y (NOTL (SBBLcarrymask (CMPWconst y [32]))))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -10999,9 +9598,6 @@ func rewriteValueAMD64_OpRsh32x16(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end1b3a698a50c89c656aa6f7acd72e3f5e -end1b3a698a50c89c656aa6f7acd72e3f5e: - ; return false } func rewriteValueAMD64_OpRsh32x32(v *Value, config *Config) bool { @@ -11010,7 +9606,7 @@ func rewriteValueAMD64_OpRsh32x32(v *Value, config *Config) bool { // match: (Rsh32x32 x y) // cond: // result: (SARL x (ORL y (NOTL (SBBLcarrymask (CMPLconst y [32]))))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -11030,9 +9626,6 @@ func rewriteValueAMD64_OpRsh32x32(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto endc6596de1c198fd84c4076aaa3c6486e5 -endc6596de1c198fd84c4076aaa3c6486e5: - ; return false } func rewriteValueAMD64_OpRsh32x64(v *Value, config *Config) bool { @@ -11041,7 +9634,7 @@ func rewriteValueAMD64_OpRsh32x64(v *Value, config *Config) bool { // match: (Rsh32x64 x y) // cond: // result: (SARL x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst y [32]))))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -11061,9 +9654,6 @@ func rewriteValueAMD64_OpRsh32x64(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto enddda2e730607e2d13b18f1006316e0ebb -enddda2e730607e2d13b18f1006316e0ebb: - ; return false } func rewriteValueAMD64_OpRsh32x8(v *Value, config *Config) bool { @@ -11072,7 +9662,7 @@ func rewriteValueAMD64_OpRsh32x8(v *Value, config *Config) bool { // match: (Rsh32x8 x y) // cond: // result: (SARL x (ORB y (NOTL (SBBLcarrymask (CMPBconst y [32]))))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -11092,9 +9682,6 @@ func rewriteValueAMD64_OpRsh32x8(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto endd9cb28c7e3a43fbd7a877750f34df72a -endd9cb28c7e3a43fbd7a877750f34df72a: - ; return false } func rewriteValueAMD64_OpRsh64Ux16(v *Value, config *Config) bool { @@ -11103,7 +9690,7 @@ func rewriteValueAMD64_OpRsh64Ux16(v *Value, config *Config) bool { // match: (Rsh64Ux16 x y) // cond: // result: (ANDQ (SHRQ x y) (SBBQcarrymask (CMPWconst y [64]))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -11120,9 +9707,6 @@ func rewriteValueAMD64_OpRsh64Ux16(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto end04dfdfa8a2dcffaf7ab1ee93a96b8677 -end04dfdfa8a2dcffaf7ab1ee93a96b8677: - ; return false } func rewriteValueAMD64_OpRsh64Ux32(v *Value, config *Config) bool { @@ -11131,7 +9715,7 @@ func rewriteValueAMD64_OpRsh64Ux32(v *Value, config *Config) bool { // match: (Rsh64Ux32 x y) // cond: // result: (ANDQ (SHRQ x y) (SBBQcarrymask (CMPLconst y [64]))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -11148,9 +9732,6 @@ func rewriteValueAMD64_OpRsh64Ux32(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto end2b2f03d14fb01fd490115a96d893ddb3 -end2b2f03d14fb01fd490115a96d893ddb3: - ; return false } func rewriteValueAMD64_OpRsh64Ux64(v *Value, config *Config) bool { @@ -11159,7 +9740,7 @@ func rewriteValueAMD64_OpRsh64Ux64(v *Value, config *Config) bool { // match: (Rsh64Ux64 x y) // cond: // result: (ANDQ (SHRQ x y) (SBBQcarrymask (CMPQconst y [64]))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -11176,9 +9757,6 @@ func rewriteValueAMD64_OpRsh64Ux64(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto endb24ca32f261a5c799d3e5a572f7cdcff -endb24ca32f261a5c799d3e5a572f7cdcff: - ; return false } func rewriteValueAMD64_OpRsh64Ux8(v *Value, config *Config) bool { @@ -11187,7 +9765,7 @@ func rewriteValueAMD64_OpRsh64Ux8(v *Value, config *Config) bool { // match: (Rsh64Ux8 x y) // cond: // result: (ANDQ (SHRQ x y) (SBBQcarrymask (CMPBconst y [64]))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -11204,9 +9782,6 @@ func rewriteValueAMD64_OpRsh64Ux8(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto end05a9a99310c9e282df012d5c48b58475 -end05a9a99310c9e282df012d5c48b58475: - ; return false } func rewriteValueAMD64_OpRsh64x16(v *Value, config *Config) bool { @@ -11215,7 +9790,7 @@ func rewriteValueAMD64_OpRsh64x16(v *Value, config *Config) bool { // match: (Rsh64x16 x y) // cond: // result: (SARQ x (ORW y (NOTL (SBBLcarrymask (CMPWconst y [64]))))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -11235,9 +9810,6 @@ func rewriteValueAMD64_OpRsh64x16(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto endb97b88b7c4e431bd64ced5690f0e85c4 -endb97b88b7c4e431bd64ced5690f0e85c4: - ; return false } func rewriteValueAMD64_OpRsh64x32(v *Value, config *Config) bool { @@ -11246,7 +9818,7 @@ func rewriteValueAMD64_OpRsh64x32(v *Value, config *Config) bool { // match: (Rsh64x32 x y) // cond: // result: (SARQ x (ORL y (NOTL (SBBLcarrymask (CMPLconst y [64]))))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -11266,9 +9838,6 @@ func rewriteValueAMD64_OpRsh64x32(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end95f72c0d315e6b1d70015b31a0f5f4ca -end95f72c0d315e6b1d70015b31a0f5f4ca: - ; return false } func rewriteValueAMD64_OpRsh64x64(v *Value, config *Config) bool { @@ -11277,7 +9846,7 @@ func rewriteValueAMD64_OpRsh64x64(v *Value, config *Config) bool { // match: (Rsh64x64 x y) // cond: // result: (SARQ x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst y [64]))))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -11297,9 +9866,6 @@ func rewriteValueAMD64_OpRsh64x64(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto enda8ddfaa8e519c0ed70c344a136ba9126 -enda8ddfaa8e519c0ed70c344a136ba9126: - ; return false } func rewriteValueAMD64_OpRsh64x8(v *Value, config *Config) bool { @@ -11308,7 +9874,7 @@ func rewriteValueAMD64_OpRsh64x8(v *Value, config *Config) bool { // match: (Rsh64x8 x y) // cond: // result: (SARQ x (ORB y (NOTL (SBBLcarrymask (CMPBconst y [64]))))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -11328,9 +9894,6 @@ func rewriteValueAMD64_OpRsh64x8(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end62f4adae0bbd0c4d5d6eb7d5eda6a5e3 -end62f4adae0bbd0c4d5d6eb7d5eda6a5e3: - ; return false } func rewriteValueAMD64_OpRsh8Ux16(v *Value, config *Config) bool { @@ -11339,7 +9902,7 @@ func rewriteValueAMD64_OpRsh8Ux16(v *Value, config *Config) bool { // match: (Rsh8Ux16 x y) // cond: // result: (ANDB (SHRB x y) (SBBLcarrymask (CMPWconst y [8]))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -11356,9 +9919,6 @@ func rewriteValueAMD64_OpRsh8Ux16(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto endb791c8283bd486da9809520a7262d5ba -endb791c8283bd486da9809520a7262d5ba: - ; return false } func rewriteValueAMD64_OpRsh8Ux32(v *Value, config *Config) bool { @@ -11367,7 +9927,7 @@ func rewriteValueAMD64_OpRsh8Ux32(v *Value, config *Config) bool { // match: (Rsh8Ux32 x y) // cond: // result: (ANDB (SHRB x y) (SBBLcarrymask (CMPLconst y [8]))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -11384,9 +9944,6 @@ func rewriteValueAMD64_OpRsh8Ux32(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto end5f360ab34942dc218e8f75624c86bbb2 -end5f360ab34942dc218e8f75624c86bbb2: - ; return false } func rewriteValueAMD64_OpRsh8Ux64(v *Value, config *Config) bool { @@ -11395,7 +9952,7 @@ func rewriteValueAMD64_OpRsh8Ux64(v *Value, config *Config) bool { // match: (Rsh8Ux64 x y) // cond: // result: (ANDB (SHRB x y) (SBBLcarrymask (CMPQconst y [8]))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -11412,9 +9969,6 @@ func rewriteValueAMD64_OpRsh8Ux64(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto end7138df590f00234cd21cf02da8ed109e -end7138df590f00234cd21cf02da8ed109e: - ; return false } func rewriteValueAMD64_OpRsh8Ux8(v *Value, config *Config) bool { @@ -11423,7 +9977,7 @@ func rewriteValueAMD64_OpRsh8Ux8(v *Value, config *Config) bool { // match: (Rsh8Ux8 x y) // cond: // result: (ANDB (SHRB x y) (SBBLcarrymask (CMPBconst y [8]))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -11440,9 +9994,6 @@ func rewriteValueAMD64_OpRsh8Ux8(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto end3aab873310bf7b2f3f90705fbd082b93 -end3aab873310bf7b2f3f90705fbd082b93: - ; return false } func rewriteValueAMD64_OpRsh8x16(v *Value, config *Config) bool { @@ -11451,7 +10002,7 @@ func rewriteValueAMD64_OpRsh8x16(v *Value, config *Config) bool { // match: (Rsh8x16 x y) // cond: // result: (SARB x (ORW y (NOTL (SBBLcarrymask (CMPWconst y [8]))))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -11471,9 +10022,6 @@ func rewriteValueAMD64_OpRsh8x16(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto ende275bad06ac788b484b038f1bb3afc8d -ende275bad06ac788b484b038f1bb3afc8d: - ; return false } func rewriteValueAMD64_OpRsh8x32(v *Value, config *Config) bool { @@ -11482,7 +10030,7 @@ func rewriteValueAMD64_OpRsh8x32(v *Value, config *Config) bool { // match: (Rsh8x32 x y) // cond: // result: (SARB x (ORL y (NOTL (SBBLcarrymask (CMPLconst y [8]))))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -11502,9 +10050,6 @@ func rewriteValueAMD64_OpRsh8x32(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end00833cba5173dc390952b6c4644af376 -end00833cba5173dc390952b6c4644af376: - ; return false } func rewriteValueAMD64_OpRsh8x64(v *Value, config *Config) bool { @@ -11513,7 +10058,7 @@ func rewriteValueAMD64_OpRsh8x64(v *Value, config *Config) bool { // match: (Rsh8x64 x y) // cond: // result: (SARB x (ORQ y (NOTQ (SBBQcarrymask (CMPQconst y [8]))))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -11533,9 +10078,6 @@ func rewriteValueAMD64_OpRsh8x64(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end039cf4d3a939b89164b058d09f532fb5 -end039cf4d3a939b89164b058d09f532fb5: - ; return false } func rewriteValueAMD64_OpRsh8x8(v *Value, config *Config) bool { @@ -11544,7 +10086,7 @@ func rewriteValueAMD64_OpRsh8x8(v *Value, config *Config) bool { // match: (Rsh8x8 x y) // cond: // result: (SARB x (ORB y (NOTL (SBBLcarrymask (CMPBconst y [8]))))) - { + for { t := v.Type x := v.Args[0] y := v.Args[1] @@ -11564,9 +10106,6 @@ func rewriteValueAMD64_OpRsh8x8(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end6453a48c573d0dc7c8b0163a266c6218 -end6453a48c573d0dc7c8b0163a266c6218: - ; return false } func rewriteValueAMD64_OpAMD64SARB(v *Value, config *Config) bool { @@ -11575,10 +10114,10 @@ func rewriteValueAMD64_OpAMD64SARB(v *Value, config *Config) bool { // match: (SARB x (MOVQconst [c])) // cond: // result: (SARBconst [c&31] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVQconst { - goto end03194336f801b91c1423aed6f39247f0 + break } c := v.Args[1].AuxInt v.reset(OpAMD64SARBconst) @@ -11586,16 +10125,13 @@ func rewriteValueAMD64_OpAMD64SARB(v *Value, config *Config) bool { v.AddArg(x) return true } - goto end03194336f801b91c1423aed6f39247f0 -end03194336f801b91c1423aed6f39247f0: - ; // match: (SARB x (MOVLconst [c])) // cond: // result: (SARBconst [c&31] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVLconst { - goto end3f623e78dd789403b299106625e0d6df + break } c := v.Args[1].AuxInt v.reset(OpAMD64SARBconst) @@ -11603,16 +10139,13 @@ end03194336f801b91c1423aed6f39247f0: v.AddArg(x) return true } - goto end3f623e78dd789403b299106625e0d6df -end3f623e78dd789403b299106625e0d6df: - ; // match: (SARB x (MOVWconst [c])) // cond: // result: (SARBconst [c&31] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVWconst { - goto end4393e26c64e39342a0634d9a5706cb10 + break } c := v.Args[1].AuxInt v.reset(OpAMD64SARBconst) @@ -11620,16 +10153,13 @@ end3f623e78dd789403b299106625e0d6df: v.AddArg(x) return true } - goto end4393e26c64e39342a0634d9a5706cb10 -end4393e26c64e39342a0634d9a5706cb10: - ; // match: (SARB x (MOVBconst [c])) // cond: // result: (SARBconst [c&31] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVBconst { - goto end3bf3d17717aa6c04462e56d1c87902ce + break } c := v.Args[1].AuxInt v.reset(OpAMD64SARBconst) @@ -11637,9 +10167,6 @@ end4393e26c64e39342a0634d9a5706cb10: v.AddArg(x) return true } - goto end3bf3d17717aa6c04462e56d1c87902ce -end3bf3d17717aa6c04462e56d1c87902ce: - ; return false } func rewriteValueAMD64_OpAMD64SARBconst(v *Value, config *Config) bool { @@ -11648,19 +10175,16 @@ func rewriteValueAMD64_OpAMD64SARBconst(v *Value, config *Config) bool { // match: (SARBconst [c] (MOVQconst [d])) // cond: // result: (MOVQconst [d>>uint64(c)]) - { + for { c := v.AuxInt if v.Args[0].Op != OpAMD64MOVQconst { - goto end06e0e38775f0650ed672427d19cd8fff + break } d := v.Args[0].AuxInt v.reset(OpAMD64MOVQconst) v.AuxInt = d >> uint64(c) return true } - goto end06e0e38775f0650ed672427d19cd8fff -end06e0e38775f0650ed672427d19cd8fff: - ; return false } func rewriteValueAMD64_OpAMD64SARL(v *Value, config *Config) bool { @@ -11669,10 +10193,10 @@ func rewriteValueAMD64_OpAMD64SARL(v *Value, config *Config) bool { // match: (SARL x (MOVQconst [c])) // cond: // result: (SARLconst [c&31] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVQconst { - goto end8fb4e77be1f4d21d0f2a0facf9a60add + break } c := v.Args[1].AuxInt v.reset(OpAMD64SARLconst) @@ -11680,16 +10204,13 @@ func rewriteValueAMD64_OpAMD64SARL(v *Value, config *Config) bool { v.AddArg(x) return true } - goto end8fb4e77be1f4d21d0f2a0facf9a60add -end8fb4e77be1f4d21d0f2a0facf9a60add: - ; // match: (SARL x (MOVLconst [c])) // cond: // result: (SARLconst [c&31] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVLconst { - goto ende586a72c1b232ee0b63e37c71eeb8470 + break } c := v.Args[1].AuxInt v.reset(OpAMD64SARLconst) @@ -11697,16 +10218,13 @@ end8fb4e77be1f4d21d0f2a0facf9a60add: v.AddArg(x) return true } - goto ende586a72c1b232ee0b63e37c71eeb8470 -ende586a72c1b232ee0b63e37c71eeb8470: - ; // match: (SARL x (MOVWconst [c])) // cond: // result: (SARLconst [c&31] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVWconst { - goto end37389c13b9fb94c44bd10b1143809afb + break } c := v.Args[1].AuxInt v.reset(OpAMD64SARLconst) @@ -11714,16 +10232,13 @@ ende586a72c1b232ee0b63e37c71eeb8470: v.AddArg(x) return true } - goto end37389c13b9fb94c44bd10b1143809afb -end37389c13b9fb94c44bd10b1143809afb: - ; // match: (SARL x (MOVBconst [c])) // cond: // result: (SARLconst [c&31] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVBconst { - goto end72550eb8c44c45e76e40888bce753160 + break } c := v.Args[1].AuxInt v.reset(OpAMD64SARLconst) @@ -11731,9 +10246,6 @@ end37389c13b9fb94c44bd10b1143809afb: v.AddArg(x) return true } - goto end72550eb8c44c45e76e40888bce753160 -end72550eb8c44c45e76e40888bce753160: - ; return false } func rewriteValueAMD64_OpAMD64SARLconst(v *Value, config *Config) bool { @@ -11742,19 +10254,16 @@ func rewriteValueAMD64_OpAMD64SARLconst(v *Value, config *Config) bool { // match: (SARLconst [c] (MOVQconst [d])) // cond: // result: (MOVQconst [d>>uint64(c)]) - { + for { c := v.AuxInt if v.Args[0].Op != OpAMD64MOVQconst { - goto end8f34dc94323303e75b7bcc8e731cf1db + break } d := v.Args[0].AuxInt v.reset(OpAMD64MOVQconst) v.AuxInt = d >> uint64(c) return true } - goto end8f34dc94323303e75b7bcc8e731cf1db -end8f34dc94323303e75b7bcc8e731cf1db: - ; return false } func rewriteValueAMD64_OpAMD64SARQ(v *Value, config *Config) bool { @@ -11763,10 +10272,10 @@ func rewriteValueAMD64_OpAMD64SARQ(v *Value, config *Config) bool { // match: (SARQ x (MOVQconst [c])) // cond: // result: (SARQconst [c&63] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVQconst { - goto end25e720ab203be2745dded5550e6d8a7c + break } c := v.Args[1].AuxInt v.reset(OpAMD64SARQconst) @@ -11774,16 +10283,13 @@ func rewriteValueAMD64_OpAMD64SARQ(v *Value, config *Config) bool { v.AddArg(x) return true } - goto end25e720ab203be2745dded5550e6d8a7c -end25e720ab203be2745dded5550e6d8a7c: - ; // match: (SARQ x (MOVLconst [c])) // cond: // result: (SARQconst [c&63] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVLconst { - goto endd04cf826c5db444107cf4e0bf789bcda + break } c := v.Args[1].AuxInt v.reset(OpAMD64SARQconst) @@ -11791,16 +10297,13 @@ end25e720ab203be2745dded5550e6d8a7c: v.AddArg(x) return true } - goto endd04cf826c5db444107cf4e0bf789bcda -endd04cf826c5db444107cf4e0bf789bcda: - ; // match: (SARQ x (MOVWconst [c])) // cond: // result: (SARQconst [c&63] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVWconst { - goto end6266051b3a126922286c298594535622 + break } c := v.Args[1].AuxInt v.reset(OpAMD64SARQconst) @@ -11808,16 +10311,13 @@ endd04cf826c5db444107cf4e0bf789bcda: v.AddArg(x) return true } - goto end6266051b3a126922286c298594535622 -end6266051b3a126922286c298594535622: - ; // match: (SARQ x (MOVBconst [c])) // cond: // result: (SARQconst [c&63] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVBconst { - goto endcf2a1bdfeda535fc96ae1e7f5c54d531 + break } c := v.Args[1].AuxInt v.reset(OpAMD64SARQconst) @@ -11825,9 +10325,6 @@ end6266051b3a126922286c298594535622: v.AddArg(x) return true } - goto endcf2a1bdfeda535fc96ae1e7f5c54d531 -endcf2a1bdfeda535fc96ae1e7f5c54d531: - ; return false } func rewriteValueAMD64_OpAMD64SARQconst(v *Value, config *Config) bool { @@ -11836,19 +10333,16 @@ func rewriteValueAMD64_OpAMD64SARQconst(v *Value, config *Config) bool { // match: (SARQconst [c] (MOVQconst [d])) // cond: // result: (MOVQconst [d>>uint64(c)]) - { + for { c := v.AuxInt if v.Args[0].Op != OpAMD64MOVQconst { - goto endd949ba69a1ff71ba62c49b39c68f269e + break } d := v.Args[0].AuxInt v.reset(OpAMD64MOVQconst) v.AuxInt = d >> uint64(c) return true } - goto endd949ba69a1ff71ba62c49b39c68f269e -endd949ba69a1ff71ba62c49b39c68f269e: - ; return false } func rewriteValueAMD64_OpAMD64SARW(v *Value, config *Config) bool { @@ -11857,10 +10351,10 @@ func rewriteValueAMD64_OpAMD64SARW(v *Value, config *Config) bool { // match: (SARW x (MOVQconst [c])) // cond: // result: (SARWconst [c&31] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVQconst { - goto endec8cafea5ff91b2a1b5cf5a169be924f + break } c := v.Args[1].AuxInt v.reset(OpAMD64SARWconst) @@ -11868,16 +10362,13 @@ func rewriteValueAMD64_OpAMD64SARW(v *Value, config *Config) bool { v.AddArg(x) return true } - goto endec8cafea5ff91b2a1b5cf5a169be924f -endec8cafea5ff91b2a1b5cf5a169be924f: - ; // match: (SARW x (MOVLconst [c])) // cond: // result: (SARWconst [c&31] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVLconst { - goto end9303d0edeebdc8a2a7e93fecf0fff61c + break } c := v.Args[1].AuxInt v.reset(OpAMD64SARWconst) @@ -11885,16 +10376,13 @@ endec8cafea5ff91b2a1b5cf5a169be924f: v.AddArg(x) return true } - goto end9303d0edeebdc8a2a7e93fecf0fff61c -end9303d0edeebdc8a2a7e93fecf0fff61c: - ; // match: (SARW x (MOVWconst [c])) // cond: // result: (SARWconst [c&31] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVWconst { - goto endc46e3f211f94238f9a0aec3c498af490 + break } c := v.Args[1].AuxInt v.reset(OpAMD64SARWconst) @@ -11902,16 +10390,13 @@ end9303d0edeebdc8a2a7e93fecf0fff61c: v.AddArg(x) return true } - goto endc46e3f211f94238f9a0aec3c498af490 -endc46e3f211f94238f9a0aec3c498af490: - ; // match: (SARW x (MOVBconst [c])) // cond: // result: (SARWconst [c&31] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVBconst { - goto end0bf07ce9cd2c536c07768f8dfbe13c62 + break } c := v.Args[1].AuxInt v.reset(OpAMD64SARWconst) @@ -11919,9 +10404,6 @@ endc46e3f211f94238f9a0aec3c498af490: v.AddArg(x) return true } - goto end0bf07ce9cd2c536c07768f8dfbe13c62 -end0bf07ce9cd2c536c07768f8dfbe13c62: - ; return false } func rewriteValueAMD64_OpAMD64SARWconst(v *Value, config *Config) bool { @@ -11930,19 +10412,16 @@ func rewriteValueAMD64_OpAMD64SARWconst(v *Value, config *Config) bool { // match: (SARWconst [c] (MOVQconst [d])) // cond: // result: (MOVQconst [d>>uint64(c)]) - { + for { c := v.AuxInt if v.Args[0].Op != OpAMD64MOVQconst { - goto endca23e80dba22ab574f843c7a4cef24ab + break } d := v.Args[0].AuxInt v.reset(OpAMD64MOVQconst) v.AuxInt = d >> uint64(c) return true } - goto endca23e80dba22ab574f843c7a4cef24ab -endca23e80dba22ab574f843c7a4cef24ab: - ; return false } func rewriteValueAMD64_OpAMD64SBBLcarrymask(v *Value, config *Config) bool { @@ -11951,73 +10430,58 @@ func rewriteValueAMD64_OpAMD64SBBLcarrymask(v *Value, config *Config) bool { // match: (SBBLcarrymask (FlagEQ)) // cond: // result: (MOVLconst [0]) - { + for { if v.Args[0].Op != OpAMD64FlagEQ { - goto end49bb4f49864044e2cd06c9c8e2c05f12 + break } v.reset(OpAMD64MOVLconst) v.AuxInt = 0 return true } - goto end49bb4f49864044e2cd06c9c8e2c05f12 -end49bb4f49864044e2cd06c9c8e2c05f12: - ; // match: (SBBLcarrymask (FlagLT_ULT)) // cond: // result: (MOVLconst [-1]) - { + for { if v.Args[0].Op != OpAMD64FlagLT_ULT { - goto ende534d42c655e8b95b051e7ec44d4fdf9 + break } v.reset(OpAMD64MOVLconst) v.AuxInt = -1 return true } - goto ende534d42c655e8b95b051e7ec44d4fdf9 -ende534d42c655e8b95b051e7ec44d4fdf9: - ; // match: (SBBLcarrymask (FlagLT_UGT)) // cond: // result: (MOVLconst [0]) - { + for { if v.Args[0].Op != OpAMD64FlagLT_UGT { - goto end212628069f217f165eaf49dcfd9e8c76 + break } v.reset(OpAMD64MOVLconst) v.AuxInt = 0 return true } - goto end212628069f217f165eaf49dcfd9e8c76 -end212628069f217f165eaf49dcfd9e8c76: - ; // match: (SBBLcarrymask (FlagGT_ULT)) // cond: // result: (MOVLconst [-1]) - { + for { if v.Args[0].Op != OpAMD64FlagGT_ULT { - goto end4df0bf7db9772a6011ed89bd3ce95f1d + break } v.reset(OpAMD64MOVLconst) v.AuxInt = -1 return true } - goto end4df0bf7db9772a6011ed89bd3ce95f1d -end4df0bf7db9772a6011ed89bd3ce95f1d: - ; // match: (SBBLcarrymask (FlagGT_UGT)) // cond: // result: (MOVLconst [0]) - { + for { if v.Args[0].Op != OpAMD64FlagGT_UGT { - goto end4d9d1509d6d260332f0a345332ce89e2 + break } v.reset(OpAMD64MOVLconst) v.AuxInt = 0 return true } - goto end4d9d1509d6d260332f0a345332ce89e2 -end4d9d1509d6d260332f0a345332ce89e2: - ; return false } func rewriteValueAMD64_OpAMD64SBBQcarrymask(v *Value, config *Config) bool { @@ -12026,73 +10490,58 @@ func rewriteValueAMD64_OpAMD64SBBQcarrymask(v *Value, config *Config) bool { // match: (SBBQcarrymask (FlagEQ)) // cond: // result: (MOVQconst [0]) - { + for { if v.Args[0].Op != OpAMD64FlagEQ { - goto end6b4a6f105b53df8063846a528bab0abb + break } v.reset(OpAMD64MOVQconst) v.AuxInt = 0 return true } - goto end6b4a6f105b53df8063846a528bab0abb -end6b4a6f105b53df8063846a528bab0abb: - ; // match: (SBBQcarrymask (FlagLT_ULT)) // cond: // result: (MOVQconst [-1]) - { + for { if v.Args[0].Op != OpAMD64FlagLT_ULT { - goto endbfed0a1a93d6d8570f304898550d9558 + break } v.reset(OpAMD64MOVQconst) v.AuxInt = -1 return true } - goto endbfed0a1a93d6d8570f304898550d9558 -endbfed0a1a93d6d8570f304898550d9558: - ; // match: (SBBQcarrymask (FlagLT_UGT)) // cond: // result: (MOVQconst [0]) - { + for { if v.Args[0].Op != OpAMD64FlagLT_UGT { - goto end8edf88458891c571a6ea6e52e0267b40 + break } v.reset(OpAMD64MOVQconst) v.AuxInt = 0 return true } - goto end8edf88458891c571a6ea6e52e0267b40 -end8edf88458891c571a6ea6e52e0267b40: - ; // match: (SBBQcarrymask (FlagGT_ULT)) // cond: // result: (MOVQconst [-1]) - { + for { if v.Args[0].Op != OpAMD64FlagGT_ULT { - goto end4663340439f2fa7a666e81f0ebc68436 + break } v.reset(OpAMD64MOVQconst) v.AuxInt = -1 return true } - goto end4663340439f2fa7a666e81f0ebc68436 -end4663340439f2fa7a666e81f0ebc68436: - ; // match: (SBBQcarrymask (FlagGT_UGT)) // cond: // result: (MOVQconst [0]) - { + for { if v.Args[0].Op != OpAMD64FlagGT_UGT { - goto end7262400b0380a163bd65b88e0c3db985 + break } v.reset(OpAMD64MOVQconst) v.AuxInt = 0 return true } - goto end7262400b0380a163bd65b88e0c3db985 -end7262400b0380a163bd65b88e0c3db985: - ; return false } func rewriteValueAMD64_OpAMD64SETA(v *Value, config *Config) bool { @@ -12101,88 +10550,70 @@ func rewriteValueAMD64_OpAMD64SETA(v *Value, config *Config) bool { // match: (SETA (InvertFlags x)) // cond: // result: (SETB x) - { + for { if v.Args[0].Op != OpAMD64InvertFlags { - goto enda4ac36e94fc279d762b5a6c7c6cc665d + break } x := v.Args[0].Args[0] v.reset(OpAMD64SETB) v.AddArg(x) return true } - goto enda4ac36e94fc279d762b5a6c7c6cc665d -enda4ac36e94fc279d762b5a6c7c6cc665d: - ; // match: (SETA (FlagEQ)) // cond: // result: (MOVBconst [0]) - { + for { if v.Args[0].Op != OpAMD64FlagEQ { - goto end1521942d06b7f0caba92883aee0bb90e + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } - goto end1521942d06b7f0caba92883aee0bb90e -end1521942d06b7f0caba92883aee0bb90e: - ; // match: (SETA (FlagLT_ULT)) // cond: // result: (MOVBconst [0]) - { + for { if v.Args[0].Op != OpAMD64FlagLT_ULT { - goto endf79d69b18a140d5c6669216ad65f60f0 + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } - goto endf79d69b18a140d5c6669216ad65f60f0 -endf79d69b18a140d5c6669216ad65f60f0: - ; // match: (SETA (FlagLT_UGT)) // cond: // result: (MOVBconst [1]) - { + for { if v.Args[0].Op != OpAMD64FlagLT_UGT { - goto end272c1e5fca714e319fb1c335023826db + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } - goto end272c1e5fca714e319fb1c335023826db -end272c1e5fca714e319fb1c335023826db: - ; // match: (SETA (FlagGT_ULT)) // cond: // result: (MOVBconst [0]) - { + for { if v.Args[0].Op != OpAMD64FlagGT_ULT { - goto ende0cf0104de1315266d93ded9a092302c + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } - goto ende0cf0104de1315266d93ded9a092302c -ende0cf0104de1315266d93ded9a092302c: - ; // match: (SETA (FlagGT_UGT)) // cond: // result: (MOVBconst [1]) - { + for { if v.Args[0].Op != OpAMD64FlagGT_UGT { - goto end85507f7549319577f9994826ee379f3b + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } - goto end85507f7549319577f9994826ee379f3b -end85507f7549319577f9994826ee379f3b: - ; return false } func rewriteValueAMD64_OpAMD64SETAE(v *Value, config *Config) bool { @@ -12191,88 +10622,70 @@ func rewriteValueAMD64_OpAMD64SETAE(v *Value, config *Config) bool { // match: (SETAE (InvertFlags x)) // cond: // result: (SETBE x) - { + for { if v.Args[0].Op != OpAMD64InvertFlags { - goto end0468f5be6caf682fdea6b91d6648991e + break } x := v.Args[0].Args[0] v.reset(OpAMD64SETBE) v.AddArg(x) return true } - goto end0468f5be6caf682fdea6b91d6648991e -end0468f5be6caf682fdea6b91d6648991e: - ; // match: (SETAE (FlagEQ)) // cond: // result: (MOVBconst [1]) - { + for { if v.Args[0].Op != OpAMD64FlagEQ { - goto endc6396df3825db703a99be0e624c6396f + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } - goto endc6396df3825db703a99be0e624c6396f -endc6396df3825db703a99be0e624c6396f: - ; // match: (SETAE (FlagLT_ULT)) // cond: // result: (MOVBconst [0]) - { + for { if v.Args[0].Op != OpAMD64FlagLT_ULT { - goto end2392c77d6746969c65a422c68ad193bc + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } - goto end2392c77d6746969c65a422c68ad193bc -end2392c77d6746969c65a422c68ad193bc: - ; // match: (SETAE (FlagLT_UGT)) // cond: // result: (MOVBconst [1]) - { + for { if v.Args[0].Op != OpAMD64FlagLT_UGT { - goto end081f3b2b98d3a990739d2a5562d4f254 + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } - goto end081f3b2b98d3a990739d2a5562d4f254 -end081f3b2b98d3a990739d2a5562d4f254: - ; // match: (SETAE (FlagGT_ULT)) // cond: // result: (MOVBconst [0]) - { + for { if v.Args[0].Op != OpAMD64FlagGT_ULT { - goto end47a6cc5efdd00e349c5e23be3624d719 + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } - goto end47a6cc5efdd00e349c5e23be3624d719 -end47a6cc5efdd00e349c5e23be3624d719: - ; // match: (SETAE (FlagGT_UGT)) // cond: // result: (MOVBconst [1]) - { + for { if v.Args[0].Op != OpAMD64FlagGT_UGT { - goto endd47bb51035b00c560b5347b3be19e20e + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } - goto endd47bb51035b00c560b5347b3be19e20e -endd47bb51035b00c560b5347b3be19e20e: - ; return false } func rewriteValueAMD64_OpAMD64SETB(v *Value, config *Config) bool { @@ -12281,88 +10694,70 @@ func rewriteValueAMD64_OpAMD64SETB(v *Value, config *Config) bool { // match: (SETB (InvertFlags x)) // cond: // result: (SETA x) - { + for { if v.Args[0].Op != OpAMD64InvertFlags { - goto endc9eba7aa1e54a228570d2f5cc96f3565 + break } x := v.Args[0].Args[0] v.reset(OpAMD64SETA) v.AddArg(x) return true } - goto endc9eba7aa1e54a228570d2f5cc96f3565 -endc9eba7aa1e54a228570d2f5cc96f3565: - ; // match: (SETB (FlagEQ)) // cond: // result: (MOVBconst [0]) - { + for { if v.Args[0].Op != OpAMD64FlagEQ { - goto endaf8a2c61689b00c8ad90dd090e634c81 + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } - goto endaf8a2c61689b00c8ad90dd090e634c81 -endaf8a2c61689b00c8ad90dd090e634c81: - ; // match: (SETB (FlagLT_ULT)) // cond: // result: (MOVBconst [1]) - { + for { if v.Args[0].Op != OpAMD64FlagLT_ULT { - goto endab96387d5f049ab9c87863473a5d6510 + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } - goto endab96387d5f049ab9c87863473a5d6510 -endab96387d5f049ab9c87863473a5d6510: - ; // match: (SETB (FlagLT_UGT)) // cond: // result: (MOVBconst [0]) - { + for { if v.Args[0].Op != OpAMD64FlagLT_UGT { - goto endbf7af56278add8851974cd1a538b3b7f + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } - goto endbf7af56278add8851974cd1a538b3b7f -endbf7af56278add8851974cd1a538b3b7f: - ; // match: (SETB (FlagGT_ULT)) // cond: // result: (MOVBconst [1]) - { + for { if v.Args[0].Op != OpAMD64FlagGT_ULT { - goto end2d07a10db28e5160fccf66ee44c4823e + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } - goto end2d07a10db28e5160fccf66ee44c4823e -end2d07a10db28e5160fccf66ee44c4823e: - ; // match: (SETB (FlagGT_UGT)) // cond: // result: (MOVBconst [0]) - { + for { if v.Args[0].Op != OpAMD64FlagGT_UGT { - goto end87ec5187683c0ee498c0a2c4de59f4c0 + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } - goto end87ec5187683c0ee498c0a2c4de59f4c0 -end87ec5187683c0ee498c0a2c4de59f4c0: - ; return false } func rewriteValueAMD64_OpAMD64SETBE(v *Value, config *Config) bool { @@ -12371,88 +10766,70 @@ func rewriteValueAMD64_OpAMD64SETBE(v *Value, config *Config) bool { // match: (SETBE (InvertFlags x)) // cond: // result: (SETAE x) - { + for { if v.Args[0].Op != OpAMD64InvertFlags { - goto end9d9031643469798b14b8cad1f5a7a1ba + break } x := v.Args[0].Args[0] v.reset(OpAMD64SETAE) v.AddArg(x) return true } - goto end9d9031643469798b14b8cad1f5a7a1ba -end9d9031643469798b14b8cad1f5a7a1ba: - ; // match: (SETBE (FlagEQ)) // cond: // result: (MOVBconst [1]) - { + for { if v.Args[0].Op != OpAMD64FlagEQ { - goto ende6a02d3ce0e1584e806c7861de97eb5b + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } - goto ende6a02d3ce0e1584e806c7861de97eb5b -ende6a02d3ce0e1584e806c7861de97eb5b: - ; // match: (SETBE (FlagLT_ULT)) // cond: // result: (MOVBconst [1]) - { + for { if v.Args[0].Op != OpAMD64FlagLT_ULT { - goto end7ea0208cd10e6311655d09e8aa354169 + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } - goto end7ea0208cd10e6311655d09e8aa354169 -end7ea0208cd10e6311655d09e8aa354169: - ; // match: (SETBE (FlagLT_UGT)) // cond: // result: (MOVBconst [0]) - { + for { if v.Args[0].Op != OpAMD64FlagLT_UGT { - goto enddbfa0595802c67348d3a3bd22b198231 + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } - goto enddbfa0595802c67348d3a3bd22b198231 -enddbfa0595802c67348d3a3bd22b198231: - ; // match: (SETBE (FlagGT_ULT)) // cond: // result: (MOVBconst [1]) - { + for { if v.Args[0].Op != OpAMD64FlagGT_ULT { - goto end5b26e1d28d6a517ed004b0f9b80df27b + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } - goto end5b26e1d28d6a517ed004b0f9b80df27b -end5b26e1d28d6a517ed004b0f9b80df27b: - ; // match: (SETBE (FlagGT_UGT)) // cond: // result: (MOVBconst [0]) - { + for { if v.Args[0].Op != OpAMD64FlagGT_UGT { - goto end679e2e0ccd0dd526ea781fc64102cb88 + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } - goto end679e2e0ccd0dd526ea781fc64102cb88 -end679e2e0ccd0dd526ea781fc64102cb88: - ; return false } func rewriteValueAMD64_OpAMD64SETEQ(v *Value, config *Config) bool { @@ -12461,88 +10838,70 @@ func rewriteValueAMD64_OpAMD64SETEQ(v *Value, config *Config) bool { // match: (SETEQ (InvertFlags x)) // cond: // result: (SETEQ x) - { + for { if v.Args[0].Op != OpAMD64InvertFlags { - goto end5d2039c9368d8c0cfba23b5a85b459e1 + break } x := v.Args[0].Args[0] v.reset(OpAMD64SETEQ) v.AddArg(x) return true } - goto end5d2039c9368d8c0cfba23b5a85b459e1 -end5d2039c9368d8c0cfba23b5a85b459e1: - ; // match: (SETEQ (FlagEQ)) // cond: // result: (MOVBconst [1]) - { + for { if v.Args[0].Op != OpAMD64FlagEQ { - goto end74e09087ca9d4bdf7740f4f052d2b9d3 + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } - goto end74e09087ca9d4bdf7740f4f052d2b9d3 -end74e09087ca9d4bdf7740f4f052d2b9d3: - ; // match: (SETEQ (FlagLT_ULT)) // cond: // result: (MOVBconst [0]) - { + for { if v.Args[0].Op != OpAMD64FlagLT_ULT { - goto ende5d3756d09e616648de68d364b2c308f + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } - goto ende5d3756d09e616648de68d364b2c308f -ende5d3756d09e616648de68d364b2c308f: - ; // match: (SETEQ (FlagLT_UGT)) // cond: // result: (MOVBconst [0]) - { + for { if v.Args[0].Op != OpAMD64FlagLT_UGT { - goto end1a86a603a5c6e0f328f63b9279137bcc + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } - goto end1a86a603a5c6e0f328f63b9279137bcc -end1a86a603a5c6e0f328f63b9279137bcc: - ; // match: (SETEQ (FlagGT_ULT)) // cond: // result: (MOVBconst [0]) - { + for { if v.Args[0].Op != OpAMD64FlagGT_ULT { - goto endbf907332cd6004c73b88f43b5e20275f + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } - goto endbf907332cd6004c73b88f43b5e20275f -endbf907332cd6004c73b88f43b5e20275f: - ; // match: (SETEQ (FlagGT_UGT)) // cond: // result: (MOVBconst [0]) - { + for { if v.Args[0].Op != OpAMD64FlagGT_UGT { - goto end707540a9904307c186884f60e425ca62 + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } - goto end707540a9904307c186884f60e425ca62 -end707540a9904307c186884f60e425ca62: - ; return false } func rewriteValueAMD64_OpAMD64SETG(v *Value, config *Config) bool { @@ -12551,88 +10910,70 @@ func rewriteValueAMD64_OpAMD64SETG(v *Value, config *Config) bool { // match: (SETG (InvertFlags x)) // cond: // result: (SETL x) - { + for { if v.Args[0].Op != OpAMD64InvertFlags { - goto endf7586738694c9cd0b74ae28bbadb649f + break } x := v.Args[0].Args[0] v.reset(OpAMD64SETL) v.AddArg(x) return true } - goto endf7586738694c9cd0b74ae28bbadb649f -endf7586738694c9cd0b74ae28bbadb649f: - ; // match: (SETG (FlagEQ)) // cond: // result: (MOVBconst [0]) - { + for { if v.Args[0].Op != OpAMD64FlagEQ { - goto endc952db8883f26126822bac29276b0690 + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } - goto endc952db8883f26126822bac29276b0690 -endc952db8883f26126822bac29276b0690: - ; // match: (SETG (FlagLT_ULT)) // cond: // result: (MOVBconst [0]) - { + for { if v.Args[0].Op != OpAMD64FlagLT_ULT { - goto end3b6d659c9285d30eba022a85c6c6f1c9 + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } - goto end3b6d659c9285d30eba022a85c6c6f1c9 -end3b6d659c9285d30eba022a85c6c6f1c9: - ; // match: (SETG (FlagLT_UGT)) // cond: // result: (MOVBconst [0]) - { + for { if v.Args[0].Op != OpAMD64FlagLT_UGT { - goto end2eabfc908ca06e7d5d217142dd48af33 + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } - goto end2eabfc908ca06e7d5d217142dd48af33 -end2eabfc908ca06e7d5d217142dd48af33: - ; // match: (SETG (FlagGT_ULT)) // cond: // result: (MOVBconst [1]) - { + for { if v.Args[0].Op != OpAMD64FlagGT_ULT { - goto end7c059e63a98776c77bb8e43759d2d864 + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } - goto end7c059e63a98776c77bb8e43759d2d864 -end7c059e63a98776c77bb8e43759d2d864: - ; // match: (SETG (FlagGT_UGT)) // cond: // result: (MOVBconst [1]) - { + for { if v.Args[0].Op != OpAMD64FlagGT_UGT { - goto enddcb3196491c82060bcb90da722ffa8bd + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } - goto enddcb3196491c82060bcb90da722ffa8bd -enddcb3196491c82060bcb90da722ffa8bd: - ; return false } func rewriteValueAMD64_OpAMD64SETGE(v *Value, config *Config) bool { @@ -12641,88 +10982,70 @@ func rewriteValueAMD64_OpAMD64SETGE(v *Value, config *Config) bool { // match: (SETGE (InvertFlags x)) // cond: // result: (SETLE x) - { + for { if v.Args[0].Op != OpAMD64InvertFlags { - goto end82c11eff6f842159f564f2dad3d2eedc + break } x := v.Args[0].Args[0] v.reset(OpAMD64SETLE) v.AddArg(x) return true } - goto end82c11eff6f842159f564f2dad3d2eedc -end82c11eff6f842159f564f2dad3d2eedc: - ; // match: (SETGE (FlagEQ)) // cond: // result: (MOVBconst [1]) - { + for { if v.Args[0].Op != OpAMD64FlagEQ { - goto end1152b03b15fb4ea1822b2cc1c6815887 + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } - goto end1152b03b15fb4ea1822b2cc1c6815887 -end1152b03b15fb4ea1822b2cc1c6815887: - ; // match: (SETGE (FlagLT_ULT)) // cond: // result: (MOVBconst [0]) - { + for { if v.Args[0].Op != OpAMD64FlagLT_ULT { - goto endd55763184b306cc32397b421df6fc994 + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } - goto endd55763184b306cc32397b421df6fc994 -endd55763184b306cc32397b421df6fc994: - ; // match: (SETGE (FlagLT_UGT)) // cond: // result: (MOVBconst [0]) - { + for { if v.Args[0].Op != OpAMD64FlagLT_UGT { - goto end209fbc531c4d6696b0b226c1ac016add + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } - goto end209fbc531c4d6696b0b226c1ac016add -end209fbc531c4d6696b0b226c1ac016add: - ; // match: (SETGE (FlagGT_ULT)) // cond: // result: (MOVBconst [1]) - { + for { if v.Args[0].Op != OpAMD64FlagGT_ULT { - goto end41600cc6b5af1497fc534af49eaf60a2 + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } - goto end41600cc6b5af1497fc534af49eaf60a2 -end41600cc6b5af1497fc534af49eaf60a2: - ; // match: (SETGE (FlagGT_UGT)) // cond: // result: (MOVBconst [1]) - { + for { if v.Args[0].Op != OpAMD64FlagGT_UGT { - goto endaa33fb1204dba90a141a9a945a9643a2 + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } - goto endaa33fb1204dba90a141a9a945a9643a2 -endaa33fb1204dba90a141a9a945a9643a2: - ; return false } func rewriteValueAMD64_OpAMD64SETL(v *Value, config *Config) bool { @@ -12731,88 +11054,70 @@ func rewriteValueAMD64_OpAMD64SETL(v *Value, config *Config) bool { // match: (SETL (InvertFlags x)) // cond: // result: (SETG x) - { + for { if v.Args[0].Op != OpAMD64InvertFlags { - goto ende33160cd86b9d4d3b77e02fb4658d5d3 + break } x := v.Args[0].Args[0] v.reset(OpAMD64SETG) v.AddArg(x) return true } - goto ende33160cd86b9d4d3b77e02fb4658d5d3 -ende33160cd86b9d4d3b77e02fb4658d5d3: - ; // match: (SETL (FlagEQ)) // cond: // result: (MOVBconst [0]) - { + for { if v.Args[0].Op != OpAMD64FlagEQ { - goto end52e421ca76fa5dfba6b9bc35b220c0bf + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } - goto end52e421ca76fa5dfba6b9bc35b220c0bf -end52e421ca76fa5dfba6b9bc35b220c0bf: - ; // match: (SETL (FlagLT_ULT)) // cond: // result: (MOVBconst [1]) - { + for { if v.Args[0].Op != OpAMD64FlagLT_ULT { - goto end4d9781536010887bcf6f6ffd563e6aac + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } - goto end4d9781536010887bcf6f6ffd563e6aac -end4d9781536010887bcf6f6ffd563e6aac: - ; // match: (SETL (FlagLT_UGT)) // cond: // result: (MOVBconst [1]) - { + for { if v.Args[0].Op != OpAMD64FlagLT_UGT { - goto end9d0dd525ca800cb3ec73e94d60c3cbf1 + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } - goto end9d0dd525ca800cb3ec73e94d60c3cbf1 -end9d0dd525ca800cb3ec73e94d60c3cbf1: - ; // match: (SETL (FlagGT_ULT)) // cond: // result: (MOVBconst [0]) - { + for { if v.Args[0].Op != OpAMD64FlagGT_ULT { - goto end6d77da1539ee0ebebee0e162c55e8f6e + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } - goto end6d77da1539ee0ebebee0e162c55e8f6e -end6d77da1539ee0ebebee0e162c55e8f6e: - ; // match: (SETL (FlagGT_UGT)) // cond: // result: (MOVBconst [0]) - { + for { if v.Args[0].Op != OpAMD64FlagGT_UGT { - goto end6c129bef0cc197325a338d17720516d1 + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } - goto end6c129bef0cc197325a338d17720516d1 -end6c129bef0cc197325a338d17720516d1: - ; return false } func rewriteValueAMD64_OpAMD64SETLE(v *Value, config *Config) bool { @@ -12821,88 +11126,70 @@ func rewriteValueAMD64_OpAMD64SETLE(v *Value, config *Config) bool { // match: (SETLE (InvertFlags x)) // cond: // result: (SETGE x) - { + for { if v.Args[0].Op != OpAMD64InvertFlags { - goto end9307d96753efbeb888d1c98a6aba7a29 + break } x := v.Args[0].Args[0] v.reset(OpAMD64SETGE) v.AddArg(x) return true } - goto end9307d96753efbeb888d1c98a6aba7a29 -end9307d96753efbeb888d1c98a6aba7a29: - ; // match: (SETLE (FlagEQ)) // cond: // result: (MOVBconst [1]) - { + for { if v.Args[0].Op != OpAMD64FlagEQ { - goto end43f998d2f9524fcdf45bab9fe672aa7c + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } - goto end43f998d2f9524fcdf45bab9fe672aa7c -end43f998d2f9524fcdf45bab9fe672aa7c: - ; // match: (SETLE (FlagLT_ULT)) // cond: // result: (MOVBconst [1]) - { + for { if v.Args[0].Op != OpAMD64FlagLT_ULT { - goto end80212f1ca6a01bccdf4bbd5aa15d5aab + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } - goto end80212f1ca6a01bccdf4bbd5aa15d5aab -end80212f1ca6a01bccdf4bbd5aa15d5aab: - ; // match: (SETLE (FlagLT_UGT)) // cond: // result: (MOVBconst [1]) - { + for { if v.Args[0].Op != OpAMD64FlagLT_UGT { - goto endd5ab2a8df7344cd7c8e1092d78bfd871 + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } - goto endd5ab2a8df7344cd7c8e1092d78bfd871 -endd5ab2a8df7344cd7c8e1092d78bfd871: - ; // match: (SETLE (FlagGT_ULT)) // cond: // result: (MOVBconst [0]) - { + for { if v.Args[0].Op != OpAMD64FlagGT_ULT { - goto enda74997e85c6f82ff1c530e6051d01e21 + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } - goto enda74997e85c6f82ff1c530e6051d01e21 -enda74997e85c6f82ff1c530e6051d01e21: - ; // match: (SETLE (FlagGT_UGT)) // cond: // result: (MOVBconst [0]) - { + for { if v.Args[0].Op != OpAMD64FlagGT_UGT { - goto end7694b41632545d10fcc6339063c53f07 + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } - goto end7694b41632545d10fcc6339063c53f07 -end7694b41632545d10fcc6339063c53f07: - ; return false } func rewriteValueAMD64_OpAMD64SETNE(v *Value, config *Config) bool { @@ -12911,88 +11198,70 @@ func rewriteValueAMD64_OpAMD64SETNE(v *Value, config *Config) bool { // match: (SETNE (InvertFlags x)) // cond: // result: (SETNE x) - { + for { if v.Args[0].Op != OpAMD64InvertFlags { - goto endbc71811b789475308014550f638026eb + break } x := v.Args[0].Args[0] v.reset(OpAMD64SETNE) v.AddArg(x) return true } - goto endbc71811b789475308014550f638026eb -endbc71811b789475308014550f638026eb: - ; // match: (SETNE (FlagEQ)) // cond: // result: (MOVBconst [0]) - { + for { if v.Args[0].Op != OpAMD64FlagEQ { - goto end6b66ea2ed518a926a071fe0d3dce46d8 + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } - goto end6b66ea2ed518a926a071fe0d3dce46d8 -end6b66ea2ed518a926a071fe0d3dce46d8: - ; // match: (SETNE (FlagLT_ULT)) // cond: // result: (MOVBconst [1]) - { + for { if v.Args[0].Op != OpAMD64FlagLT_ULT { - goto ende4d3b99f9dff014be3067a577ba0b016 + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } - goto ende4d3b99f9dff014be3067a577ba0b016 -ende4d3b99f9dff014be3067a577ba0b016: - ; // match: (SETNE (FlagLT_UGT)) // cond: // result: (MOVBconst [1]) - { + for { if v.Args[0].Op != OpAMD64FlagLT_UGT { - goto endb98d73ed6e5d3d21c2ea33840ab2a21c + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } - goto endb98d73ed6e5d3d21c2ea33840ab2a21c -endb98d73ed6e5d3d21c2ea33840ab2a21c: - ; // match: (SETNE (FlagGT_ULT)) // cond: // result: (MOVBconst [1]) - { + for { if v.Args[0].Op != OpAMD64FlagGT_ULT { - goto end3bceb5cece8d0112cc8cd53435d64ef4 + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } - goto end3bceb5cece8d0112cc8cd53435d64ef4 -end3bceb5cece8d0112cc8cd53435d64ef4: - ; // match: (SETNE (FlagGT_UGT)) // cond: // result: (MOVBconst [1]) - { + for { if v.Args[0].Op != OpAMD64FlagGT_UGT { - goto end9249b3ed3e1e582dd5435fb73cbc13ac + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 1 return true } - goto end9249b3ed3e1e582dd5435fb73cbc13ac -end9249b3ed3e1e582dd5435fb73cbc13ac: - ; return false } func rewriteValueAMD64_OpAMD64SHLB(v *Value, config *Config) bool { @@ -13001,10 +11270,10 @@ func rewriteValueAMD64_OpAMD64SHLB(v *Value, config *Config) bool { // match: (SHLB x (MOVQconst [c])) // cond: // result: (SHLBconst [c&31] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVQconst { - goto endb1f377b81b6f4c1864893934230ecbd1 + break } c := v.Args[1].AuxInt v.reset(OpAMD64SHLBconst) @@ -13012,16 +11281,13 @@ func rewriteValueAMD64_OpAMD64SHLB(v *Value, config *Config) bool { v.AddArg(x) return true } - goto endb1f377b81b6f4c1864893934230ecbd1 -endb1f377b81b6f4c1864893934230ecbd1: - ; // match: (SHLB x (MOVLconst [c])) // cond: // result: (SHLBconst [c&31] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVLconst { - goto end434bc4ee26d93bf1c734be760d7a1aa6 + break } c := v.Args[1].AuxInt v.reset(OpAMD64SHLBconst) @@ -13029,16 +11295,13 @@ endb1f377b81b6f4c1864893934230ecbd1: v.AddArg(x) return true } - goto end434bc4ee26d93bf1c734be760d7a1aa6 -end434bc4ee26d93bf1c734be760d7a1aa6: - ; // match: (SHLB x (MOVWconst [c])) // cond: // result: (SHLBconst [c&31] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVWconst { - goto end2c4fe4cce2ae24e0bc5c7d209d22e9d9 + break } c := v.Args[1].AuxInt v.reset(OpAMD64SHLBconst) @@ -13046,16 +11309,13 @@ end434bc4ee26d93bf1c734be760d7a1aa6: v.AddArg(x) return true } - goto end2c4fe4cce2ae24e0bc5c7d209d22e9d9 -end2c4fe4cce2ae24e0bc5c7d209d22e9d9: - ; // match: (SHLB x (MOVBconst [c])) // cond: // result: (SHLBconst [c&31] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVBconst { - goto end2d0d0111d831d8a575b5627284a6337a + break } c := v.Args[1].AuxInt v.reset(OpAMD64SHLBconst) @@ -13063,9 +11323,6 @@ end2c4fe4cce2ae24e0bc5c7d209d22e9d9: v.AddArg(x) return true } - goto end2d0d0111d831d8a575b5627284a6337a -end2d0d0111d831d8a575b5627284a6337a: - ; return false } func rewriteValueAMD64_OpAMD64SHLL(v *Value, config *Config) bool { @@ -13074,10 +11331,10 @@ func rewriteValueAMD64_OpAMD64SHLL(v *Value, config *Config) bool { // match: (SHLL x (MOVQconst [c])) // cond: // result: (SHLLconst [c&31] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVQconst { - goto end1b4f8b8d62445fdcb3cf9cd5036b559b + break } c := v.Args[1].AuxInt v.reset(OpAMD64SHLLconst) @@ -13085,16 +11342,13 @@ func rewriteValueAMD64_OpAMD64SHLL(v *Value, config *Config) bool { v.AddArg(x) return true } - goto end1b4f8b8d62445fdcb3cf9cd5036b559b -end1b4f8b8d62445fdcb3cf9cd5036b559b: - ; // match: (SHLL x (MOVLconst [c])) // cond: // result: (SHLLconst [c&31] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVLconst { - goto end633f9ddcfbb63374c895a5f78da75d25 + break } c := v.Args[1].AuxInt v.reset(OpAMD64SHLLconst) @@ -13102,16 +11356,13 @@ end1b4f8b8d62445fdcb3cf9cd5036b559b: v.AddArg(x) return true } - goto end633f9ddcfbb63374c895a5f78da75d25 -end633f9ddcfbb63374c895a5f78da75d25: - ; // match: (SHLL x (MOVWconst [c])) // cond: // result: (SHLLconst [c&31] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVWconst { - goto enda4f59495061db6cfe796b6dba8d3cad8 + break } c := v.Args[1].AuxInt v.reset(OpAMD64SHLLconst) @@ -13119,16 +11370,13 @@ end633f9ddcfbb63374c895a5f78da75d25: v.AddArg(x) return true } - goto enda4f59495061db6cfe796b6dba8d3cad8 -enda4f59495061db6cfe796b6dba8d3cad8: - ; // match: (SHLL x (MOVBconst [c])) // cond: // result: (SHLLconst [c&31] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVBconst { - goto endd6f39b5f3174ca738ae1c48a96d837a6 + break } c := v.Args[1].AuxInt v.reset(OpAMD64SHLLconst) @@ -13136,9 +11384,6 @@ enda4f59495061db6cfe796b6dba8d3cad8: v.AddArg(x) return true } - goto endd6f39b5f3174ca738ae1c48a96d837a6 -endd6f39b5f3174ca738ae1c48a96d837a6: - ; return false } func rewriteValueAMD64_OpAMD64SHLQ(v *Value, config *Config) bool { @@ -13147,10 +11392,10 @@ func rewriteValueAMD64_OpAMD64SHLQ(v *Value, config *Config) bool { // match: (SHLQ x (MOVQconst [c])) // cond: // result: (SHLQconst [c&63] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVQconst { - goto end4d7e3a945cacdd6b6c8c0de6f465d4ae + break } c := v.Args[1].AuxInt v.reset(OpAMD64SHLQconst) @@ -13158,16 +11403,13 @@ func rewriteValueAMD64_OpAMD64SHLQ(v *Value, config *Config) bool { v.AddArg(x) return true } - goto end4d7e3a945cacdd6b6c8c0de6f465d4ae -end4d7e3a945cacdd6b6c8c0de6f465d4ae: - ; // match: (SHLQ x (MOVLconst [c])) // cond: // result: (SHLQconst [c&63] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVLconst { - goto end394bae2652a3e4bc4b70a6fc193949f8 + break } c := v.Args[1].AuxInt v.reset(OpAMD64SHLQconst) @@ -13175,16 +11417,13 @@ end4d7e3a945cacdd6b6c8c0de6f465d4ae: v.AddArg(x) return true } - goto end394bae2652a3e4bc4b70a6fc193949f8 -end394bae2652a3e4bc4b70a6fc193949f8: - ; // match: (SHLQ x (MOVWconst [c])) // cond: // result: (SHLQconst [c&63] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVWconst { - goto end358be4078efa15ceb443ccda7ce592a0 + break } c := v.Args[1].AuxInt v.reset(OpAMD64SHLQconst) @@ -13192,16 +11431,13 @@ end394bae2652a3e4bc4b70a6fc193949f8: v.AddArg(x) return true } - goto end358be4078efa15ceb443ccda7ce592a0 -end358be4078efa15ceb443ccda7ce592a0: - ; // match: (SHLQ x (MOVBconst [c])) // cond: // result: (SHLQconst [c&63] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVBconst { - goto end032e0efd085f37a12322dbc63795a1b2 + break } c := v.Args[1].AuxInt v.reset(OpAMD64SHLQconst) @@ -13209,9 +11445,6 @@ end358be4078efa15ceb443ccda7ce592a0: v.AddArg(x) return true } - goto end032e0efd085f37a12322dbc63795a1b2 -end032e0efd085f37a12322dbc63795a1b2: - ; return false } func rewriteValueAMD64_OpAMD64SHLW(v *Value, config *Config) bool { @@ -13220,10 +11453,10 @@ func rewriteValueAMD64_OpAMD64SHLW(v *Value, config *Config) bool { // match: (SHLW x (MOVQconst [c])) // cond: // result: (SHLWconst [c&31] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVQconst { - goto enda29aa85ce58b1fdb63d71e2632efd6db + break } c := v.Args[1].AuxInt v.reset(OpAMD64SHLWconst) @@ -13231,16 +11464,13 @@ func rewriteValueAMD64_OpAMD64SHLW(v *Value, config *Config) bool { v.AddArg(x) return true } - goto enda29aa85ce58b1fdb63d71e2632efd6db -enda29aa85ce58b1fdb63d71e2632efd6db: - ; // match: (SHLW x (MOVLconst [c])) // cond: // result: (SHLWconst [c&31] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVLconst { - goto end59ce264ffde0ef9af8ea1a25db7173b6 + break } c := v.Args[1].AuxInt v.reset(OpAMD64SHLWconst) @@ -13248,16 +11478,13 @@ enda29aa85ce58b1fdb63d71e2632efd6db: v.AddArg(x) return true } - goto end59ce264ffde0ef9af8ea1a25db7173b6 -end59ce264ffde0ef9af8ea1a25db7173b6: - ; // match: (SHLW x (MOVWconst [c])) // cond: // result: (SHLWconst [c&31] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVWconst { - goto endba96a52aa58d28b3357828051e0e695c + break } c := v.Args[1].AuxInt v.reset(OpAMD64SHLWconst) @@ -13265,16 +11492,13 @@ end59ce264ffde0ef9af8ea1a25db7173b6: v.AddArg(x) return true } - goto endba96a52aa58d28b3357828051e0e695c -endba96a52aa58d28b3357828051e0e695c: - ; // match: (SHLW x (MOVBconst [c])) // cond: // result: (SHLWconst [c&31] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVBconst { - goto endf9c2165ea24ac7bbdd46cdf0e084104f + break } c := v.Args[1].AuxInt v.reset(OpAMD64SHLWconst) @@ -13282,9 +11506,6 @@ endba96a52aa58d28b3357828051e0e695c: v.AddArg(x) return true } - goto endf9c2165ea24ac7bbdd46cdf0e084104f -endf9c2165ea24ac7bbdd46cdf0e084104f: - ; return false } func rewriteValueAMD64_OpAMD64SHRB(v *Value, config *Config) bool { @@ -13293,10 +11514,10 @@ func rewriteValueAMD64_OpAMD64SHRB(v *Value, config *Config) bool { // match: (SHRB x (MOVQconst [c])) // cond: // result: (SHRBconst [c&31] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVQconst { - goto end2e7fb7a5406cbf51c69a0d04dc73d16a + break } c := v.Args[1].AuxInt v.reset(OpAMD64SHRBconst) @@ -13304,16 +11525,13 @@ func rewriteValueAMD64_OpAMD64SHRB(v *Value, config *Config) bool { v.AddArg(x) return true } - goto end2e7fb7a5406cbf51c69a0d04dc73d16a -end2e7fb7a5406cbf51c69a0d04dc73d16a: - ; // match: (SHRB x (MOVLconst [c])) // cond: // result: (SHRBconst [c&31] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVLconst { - goto end69603cc51e4f244388f368dd188a526a + break } c := v.Args[1].AuxInt v.reset(OpAMD64SHRBconst) @@ -13321,16 +11539,13 @@ end2e7fb7a5406cbf51c69a0d04dc73d16a: v.AddArg(x) return true } - goto end69603cc51e4f244388f368dd188a526a -end69603cc51e4f244388f368dd188a526a: - ; // match: (SHRB x (MOVWconst [c])) // cond: // result: (SHRBconst [c&31] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVWconst { - goto endd96421647299a1bb1b68ad0a90fa0be3 + break } c := v.Args[1].AuxInt v.reset(OpAMD64SHRBconst) @@ -13338,16 +11553,13 @@ end69603cc51e4f244388f368dd188a526a: v.AddArg(x) return true } - goto endd96421647299a1bb1b68ad0a90fa0be3 -endd96421647299a1bb1b68ad0a90fa0be3: - ; // match: (SHRB x (MOVBconst [c])) // cond: // result: (SHRBconst [c&31] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVBconst { - goto enddb1cd5aaa826d43fa4f6d1b2b8795e58 + break } c := v.Args[1].AuxInt v.reset(OpAMD64SHRBconst) @@ -13355,9 +11567,6 @@ endd96421647299a1bb1b68ad0a90fa0be3: v.AddArg(x) return true } - goto enddb1cd5aaa826d43fa4f6d1b2b8795e58 -enddb1cd5aaa826d43fa4f6d1b2b8795e58: - ; return false } func rewriteValueAMD64_OpAMD64SHRL(v *Value, config *Config) bool { @@ -13366,10 +11575,10 @@ func rewriteValueAMD64_OpAMD64SHRL(v *Value, config *Config) bool { // match: (SHRL x (MOVQconst [c])) // cond: // result: (SHRLconst [c&31] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVQconst { - goto end893880cdc59697295c1849a250163e59 + break } c := v.Args[1].AuxInt v.reset(OpAMD64SHRLconst) @@ -13377,16 +11586,13 @@ func rewriteValueAMD64_OpAMD64SHRL(v *Value, config *Config) bool { v.AddArg(x) return true } - goto end893880cdc59697295c1849a250163e59 -end893880cdc59697295c1849a250163e59: - ; // match: (SHRL x (MOVLconst [c])) // cond: // result: (SHRLconst [c&31] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVLconst { - goto end344b8b9202e1925e8d0561f1c21412fc + break } c := v.Args[1].AuxInt v.reset(OpAMD64SHRLconst) @@ -13394,16 +11600,13 @@ end893880cdc59697295c1849a250163e59: v.AddArg(x) return true } - goto end344b8b9202e1925e8d0561f1c21412fc -end344b8b9202e1925e8d0561f1c21412fc: - ; // match: (SHRL x (MOVWconst [c])) // cond: // result: (SHRLconst [c&31] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVWconst { - goto end561280f746f9983f4a4b4a5119b53028 + break } c := v.Args[1].AuxInt v.reset(OpAMD64SHRLconst) @@ -13411,16 +11614,13 @@ end344b8b9202e1925e8d0561f1c21412fc: v.AddArg(x) return true } - goto end561280f746f9983f4a4b4a5119b53028 -end561280f746f9983f4a4b4a5119b53028: - ; // match: (SHRL x (MOVBconst [c])) // cond: // result: (SHRLconst [c&31] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVBconst { - goto enda339271c59d274b73c04ba1f2c44c2b9 + break } c := v.Args[1].AuxInt v.reset(OpAMD64SHRLconst) @@ -13428,9 +11628,6 @@ end561280f746f9983f4a4b4a5119b53028: v.AddArg(x) return true } - goto enda339271c59d274b73c04ba1f2c44c2b9 -enda339271c59d274b73c04ba1f2c44c2b9: - ; return false } func rewriteValueAMD64_OpAMD64SHRQ(v *Value, config *Config) bool { @@ -13439,10 +11636,10 @@ func rewriteValueAMD64_OpAMD64SHRQ(v *Value, config *Config) bool { // match: (SHRQ x (MOVQconst [c])) // cond: // result: (SHRQconst [c&63] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVQconst { - goto end699d35e2d5cfa08b8a3b1c8a183ddcf3 + break } c := v.Args[1].AuxInt v.reset(OpAMD64SHRQconst) @@ -13450,16 +11647,13 @@ func rewriteValueAMD64_OpAMD64SHRQ(v *Value, config *Config) bool { v.AddArg(x) return true } - goto end699d35e2d5cfa08b8a3b1c8a183ddcf3 -end699d35e2d5cfa08b8a3b1c8a183ddcf3: - ; // match: (SHRQ x (MOVLconst [c])) // cond: // result: (SHRQconst [c&63] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVLconst { - goto end3189f4abaac8028d9191c9ba64124999 + break } c := v.Args[1].AuxInt v.reset(OpAMD64SHRQconst) @@ -13467,16 +11661,13 @@ end699d35e2d5cfa08b8a3b1c8a183ddcf3: v.AddArg(x) return true } - goto end3189f4abaac8028d9191c9ba64124999 -end3189f4abaac8028d9191c9ba64124999: - ; // match: (SHRQ x (MOVWconst [c])) // cond: // result: (SHRQconst [c&63] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVWconst { - goto end0cbc86ae04a355c0e2a96400242f4633 + break } c := v.Args[1].AuxInt v.reset(OpAMD64SHRQconst) @@ -13484,16 +11675,13 @@ end3189f4abaac8028d9191c9ba64124999: v.AddArg(x) return true } - goto end0cbc86ae04a355c0e2a96400242f4633 -end0cbc86ae04a355c0e2a96400242f4633: - ; // match: (SHRQ x (MOVBconst [c])) // cond: // result: (SHRQconst [c&63] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVBconst { - goto endb9c003612674e7a1ea7c13e463c229d2 + break } c := v.Args[1].AuxInt v.reset(OpAMD64SHRQconst) @@ -13501,9 +11689,6 @@ end0cbc86ae04a355c0e2a96400242f4633: v.AddArg(x) return true } - goto endb9c003612674e7a1ea7c13e463c229d2 -endb9c003612674e7a1ea7c13e463c229d2: - ; return false } func rewriteValueAMD64_OpAMD64SHRW(v *Value, config *Config) bool { @@ -13512,10 +11697,10 @@ func rewriteValueAMD64_OpAMD64SHRW(v *Value, config *Config) bool { // match: (SHRW x (MOVQconst [c])) // cond: // result: (SHRWconst [c&31] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVQconst { - goto endc5c82eea9a6b51b1d6b76e57f21f46ff + break } c := v.Args[1].AuxInt v.reset(OpAMD64SHRWconst) @@ -13523,16 +11708,13 @@ func rewriteValueAMD64_OpAMD64SHRW(v *Value, config *Config) bool { v.AddArg(x) return true } - goto endc5c82eea9a6b51b1d6b76e57f21f46ff -endc5c82eea9a6b51b1d6b76e57f21f46ff: - ; // match: (SHRW x (MOVLconst [c])) // cond: // result: (SHRWconst [c&31] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVLconst { - goto end773e94c857256ae9a31eb5b3d667e64b + break } c := v.Args[1].AuxInt v.reset(OpAMD64SHRWconst) @@ -13540,16 +11722,13 @@ endc5c82eea9a6b51b1d6b76e57f21f46ff: v.AddArg(x) return true } - goto end773e94c857256ae9a31eb5b3d667e64b -end773e94c857256ae9a31eb5b3d667e64b: - ; // match: (SHRW x (MOVWconst [c])) // cond: // result: (SHRWconst [c&31] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVWconst { - goto endd75ff1f9b3e9ec9c942a39b6179da1b3 + break } c := v.Args[1].AuxInt v.reset(OpAMD64SHRWconst) @@ -13557,16 +11736,13 @@ end773e94c857256ae9a31eb5b3d667e64b: v.AddArg(x) return true } - goto endd75ff1f9b3e9ec9c942a39b6179da1b3 -endd75ff1f9b3e9ec9c942a39b6179da1b3: - ; // match: (SHRW x (MOVBconst [c])) // cond: // result: (SHRWconst [c&31] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVBconst { - goto end6761530cd742ad00057c19a6a3c38ada + break } c := v.Args[1].AuxInt v.reset(OpAMD64SHRWconst) @@ -13574,9 +11750,6 @@ endd75ff1f9b3e9ec9c942a39b6179da1b3: v.AddArg(x) return true } - goto end6761530cd742ad00057c19a6a3c38ada -end6761530cd742ad00057c19a6a3c38ada: - ; return false } func rewriteValueAMD64_OpAMD64SUBB(v *Value, config *Config) bool { @@ -13585,10 +11758,10 @@ func rewriteValueAMD64_OpAMD64SUBB(v *Value, config *Config) bool { // match: (SUBB x (MOVBconst [c])) // cond: // result: (SUBBconst x [c]) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVBconst { - goto end9ca5d2a70e2df1a5a3ed6786bce1f7b2 + break } c := v.Args[1].AuxInt v.reset(OpAMD64SUBBconst) @@ -13596,15 +11769,12 @@ func rewriteValueAMD64_OpAMD64SUBB(v *Value, config *Config) bool { v.AuxInt = c return true } - goto end9ca5d2a70e2df1a5a3ed6786bce1f7b2 -end9ca5d2a70e2df1a5a3ed6786bce1f7b2: - ; // match: (SUBB (MOVBconst [c]) x) // cond: // result: (NEGB (SUBBconst x [c])) - { + for { if v.Args[0].Op != OpAMD64MOVBconst { - goto endc288755d69b04d24a6aac32a73956411 + break } c := v.Args[0].AuxInt x := v.Args[1] @@ -13615,24 +11785,18 @@ end9ca5d2a70e2df1a5a3ed6786bce1f7b2: v.AddArg(v0) return true } - goto endc288755d69b04d24a6aac32a73956411 -endc288755d69b04d24a6aac32a73956411: - ; // match: (SUBB x x) // cond: // result: (MOVBconst [0]) - { + for { x := v.Args[0] if v.Args[1] != x { - goto ende8904403d937d95b0d6133d3ec92bb45 + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } - goto ende8904403d937d95b0d6133d3ec92bb45 -ende8904403d937d95b0d6133d3ec92bb45: - ; return false } func rewriteValueAMD64_OpAMD64SUBBconst(v *Value, config *Config) bool { @@ -13641,43 +11805,37 @@ func rewriteValueAMD64_OpAMD64SUBBconst(v *Value, config *Config) bool { // match: (SUBBconst [c] x) // cond: int8(c) == 0 // result: x - { + for { c := v.AuxInt x := v.Args[0] if !(int8(c) == 0) { - goto end974a26e947badc62fc104581f49138e6 + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto end974a26e947badc62fc104581f49138e6 -end974a26e947badc62fc104581f49138e6: - ; // match: (SUBBconst [c] (MOVBconst [d])) // cond: // result: (MOVBconst [d-c]) - { + for { c := v.AuxInt if v.Args[0].Op != OpAMD64MOVBconst { - goto enddc5383558e2f3eae507afcb94eada964 + break } d := v.Args[0].AuxInt v.reset(OpAMD64MOVBconst) v.AuxInt = d - c return true } - goto enddc5383558e2f3eae507afcb94eada964 -enddc5383558e2f3eae507afcb94eada964: - ; // match: (SUBBconst [c] (SUBBconst [d] x)) // cond: // result: (ADDBconst [-c-d] x) - { + for { c := v.AuxInt if v.Args[0].Op != OpAMD64SUBBconst { - goto end035c57413a46eb347ecb3736d1510915 + break } d := v.Args[0].AuxInt x := v.Args[0].Args[0] @@ -13686,9 +11844,6 @@ enddc5383558e2f3eae507afcb94eada964: v.AddArg(x) return true } - goto end035c57413a46eb347ecb3736d1510915 -end035c57413a46eb347ecb3736d1510915: - ; return false } func rewriteValueAMD64_OpAMD64SUBL(v *Value, config *Config) bool { @@ -13697,10 +11852,10 @@ func rewriteValueAMD64_OpAMD64SUBL(v *Value, config *Config) bool { // match: (SUBL x (MOVLconst [c])) // cond: // result: (SUBLconst x [c]) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVLconst { - goto end178c1d6c86f9c16f6497586c2f7d8625 + break } c := v.Args[1].AuxInt v.reset(OpAMD64SUBLconst) @@ -13708,15 +11863,12 @@ func rewriteValueAMD64_OpAMD64SUBL(v *Value, config *Config) bool { v.AuxInt = c return true } - goto end178c1d6c86f9c16f6497586c2f7d8625 -end178c1d6c86f9c16f6497586c2f7d8625: - ; // match: (SUBL (MOVLconst [c]) x) // cond: // result: (NEGL (SUBLconst x [c])) - { + for { if v.Args[0].Op != OpAMD64MOVLconst { - goto endb0efe6e15ec20486b849534a00483ae2 + break } c := v.Args[0].AuxInt x := v.Args[1] @@ -13727,24 +11879,18 @@ end178c1d6c86f9c16f6497586c2f7d8625: v.AddArg(v0) return true } - goto endb0efe6e15ec20486b849534a00483ae2 -endb0efe6e15ec20486b849534a00483ae2: - ; // match: (SUBL x x) // cond: // result: (MOVLconst [0]) - { + for { x := v.Args[0] if v.Args[1] != x { - goto end332f1f641f875c69bea7289191e69133 + break } v.reset(OpAMD64MOVLconst) v.AuxInt = 0 return true } - goto end332f1f641f875c69bea7289191e69133 -end332f1f641f875c69bea7289191e69133: - ; return false } func rewriteValueAMD64_OpAMD64SUBLconst(v *Value, config *Config) bool { @@ -13753,43 +11899,37 @@ func rewriteValueAMD64_OpAMD64SUBLconst(v *Value, config *Config) bool { // match: (SUBLconst [c] x) // cond: int32(c) == 0 // result: x - { + for { c := v.AuxInt x := v.Args[0] if !(int32(c) == 0) { - goto end3fa10eaa42f9e283cf1757e1b2d3cac2 + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto end3fa10eaa42f9e283cf1757e1b2d3cac2 -end3fa10eaa42f9e283cf1757e1b2d3cac2: - ; // match: (SUBLconst [c] (MOVLconst [d])) // cond: // result: (MOVLconst [d-c]) - { + for { c := v.AuxInt if v.Args[0].Op != OpAMD64MOVLconst { - goto end6c5c6d58d4bdd0a5c2f7bf10b343b41e + break } d := v.Args[0].AuxInt v.reset(OpAMD64MOVLconst) v.AuxInt = d - c return true } - goto end6c5c6d58d4bdd0a5c2f7bf10b343b41e -end6c5c6d58d4bdd0a5c2f7bf10b343b41e: - ; // match: (SUBLconst [c] (SUBLconst [d] x)) // cond: // result: (ADDLconst [-c-d] x) - { + for { c := v.AuxInt if v.Args[0].Op != OpAMD64SUBLconst { - goto end0c9ffb11e8a56ced1b14dbf6bf9a6737 + break } d := v.Args[0].AuxInt x := v.Args[0].Args[0] @@ -13798,9 +11938,6 @@ end6c5c6d58d4bdd0a5c2f7bf10b343b41e: v.AddArg(x) return true } - goto end0c9ffb11e8a56ced1b14dbf6bf9a6737 -end0c9ffb11e8a56ced1b14dbf6bf9a6737: - ; return false } func rewriteValueAMD64_OpAMD64SUBQ(v *Value, config *Config) bool { @@ -13809,34 +11946,31 @@ func rewriteValueAMD64_OpAMD64SUBQ(v *Value, config *Config) bool { // match: (SUBQ x (MOVQconst [c])) // cond: is32Bit(c) // result: (SUBQconst x [c]) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVQconst { - goto end9bbb7b20824a498752c605942fad89c2 + break } c := v.Args[1].AuxInt if !(is32Bit(c)) { - goto end9bbb7b20824a498752c605942fad89c2 + break } v.reset(OpAMD64SUBQconst) v.AddArg(x) v.AuxInt = c return true } - goto end9bbb7b20824a498752c605942fad89c2 -end9bbb7b20824a498752c605942fad89c2: - ; // match: (SUBQ (MOVQconst [c]) x) // cond: is32Bit(c) // result: (NEGQ (SUBQconst x [c])) - { + for { if v.Args[0].Op != OpAMD64MOVQconst { - goto end8beb96de3efee9206d1bd4b7d777d2cb + break } c := v.Args[0].AuxInt x := v.Args[1] if !(is32Bit(c)) { - goto end8beb96de3efee9206d1bd4b7d777d2cb + break } v.reset(OpAMD64NEGQ) v0 := b.NewValue0(v.Line, OpAMD64SUBQconst, v.Type) @@ -13845,24 +11979,18 @@ end9bbb7b20824a498752c605942fad89c2: v.AddArg(v0) return true } - goto end8beb96de3efee9206d1bd4b7d777d2cb -end8beb96de3efee9206d1bd4b7d777d2cb: - ; // match: (SUBQ x x) // cond: // result: (MOVQconst [0]) - { + for { x := v.Args[0] if v.Args[1] != x { - goto endd87d1d839d2dc54d9c90fa4f73383480 + break } v.reset(OpAMD64MOVQconst) v.AuxInt = 0 return true } - goto endd87d1d839d2dc54d9c90fa4f73383480 -endd87d1d839d2dc54d9c90fa4f73383480: - ; return false } func rewriteValueAMD64_OpAMD64SUBQconst(v *Value, config *Config) bool { @@ -13871,9 +11999,9 @@ func rewriteValueAMD64_OpAMD64SUBQconst(v *Value, config *Config) bool { // match: (SUBQconst [0] x) // cond: // result: x - { + for { if v.AuxInt != 0 { - goto endfce1d3cec7c543c9dd80a27d944eb09e + break } x := v.Args[0] v.reset(OpCopy) @@ -13881,32 +12009,26 @@ func rewriteValueAMD64_OpAMD64SUBQconst(v *Value, config *Config) bool { v.AddArg(x) return true } - goto endfce1d3cec7c543c9dd80a27d944eb09e -endfce1d3cec7c543c9dd80a27d944eb09e: - ; // match: (SUBQconst [c] (MOVQconst [d])) // cond: // result: (MOVQconst [d-c]) - { + for { c := v.AuxInt if v.Args[0].Op != OpAMD64MOVQconst { - goto endb0daebe6831cf381377c3e4248070f25 + break } d := v.Args[0].AuxInt v.reset(OpAMD64MOVQconst) v.AuxInt = d - c return true } - goto endb0daebe6831cf381377c3e4248070f25 -endb0daebe6831cf381377c3e4248070f25: - ; // match: (SUBQconst [c] (SUBQconst [d] x)) // cond: // result: (ADDQconst [-c-d] x) - { + for { c := v.AuxInt if v.Args[0].Op != OpAMD64SUBQconst { - goto end2d40ddb5ae9e90679456254c61858d9d + break } d := v.Args[0].AuxInt x := v.Args[0].Args[0] @@ -13915,9 +12037,6 @@ endb0daebe6831cf381377c3e4248070f25: v.AddArg(x) return true } - goto end2d40ddb5ae9e90679456254c61858d9d -end2d40ddb5ae9e90679456254c61858d9d: - ; return false } func rewriteValueAMD64_OpAMD64SUBW(v *Value, config *Config) bool { @@ -13926,10 +12045,10 @@ func rewriteValueAMD64_OpAMD64SUBW(v *Value, config *Config) bool { // match: (SUBW x (MOVWconst [c])) // cond: // result: (SUBWconst x [c]) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVWconst { - goto end135aa9100b2f61d58b37cede37b63731 + break } c := v.Args[1].AuxInt v.reset(OpAMD64SUBWconst) @@ -13937,15 +12056,12 @@ func rewriteValueAMD64_OpAMD64SUBW(v *Value, config *Config) bool { v.AuxInt = c return true } - goto end135aa9100b2f61d58b37cede37b63731 -end135aa9100b2f61d58b37cede37b63731: - ; // match: (SUBW (MOVWconst [c]) x) // cond: // result: (NEGW (SUBWconst x [c])) - { + for { if v.Args[0].Op != OpAMD64MOVWconst { - goto end44d23f7e65a4b1c42d0e6463f8e493b6 + break } c := v.Args[0].AuxInt x := v.Args[1] @@ -13956,24 +12072,18 @@ end135aa9100b2f61d58b37cede37b63731: v.AddArg(v0) return true } - goto end44d23f7e65a4b1c42d0e6463f8e493b6 -end44d23f7e65a4b1c42d0e6463f8e493b6: - ; // match: (SUBW x x) // cond: // result: (MOVWconst [0]) - { + for { x := v.Args[0] if v.Args[1] != x { - goto endb970e7c318d04a1afe1dfe08a7ca0d9c + break } v.reset(OpAMD64MOVWconst) v.AuxInt = 0 return true } - goto endb970e7c318d04a1afe1dfe08a7ca0d9c -endb970e7c318d04a1afe1dfe08a7ca0d9c: - ; return false } func rewriteValueAMD64_OpAMD64SUBWconst(v *Value, config *Config) bool { @@ -13982,43 +12092,37 @@ func rewriteValueAMD64_OpAMD64SUBWconst(v *Value, config *Config) bool { // match: (SUBWconst [c] x) // cond: int16(c) == 0 // result: x - { + for { c := v.AuxInt x := v.Args[0] if !(int16(c) == 0) { - goto end1e7a493992465c9cc8314e3256ed6394 + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto end1e7a493992465c9cc8314e3256ed6394 -end1e7a493992465c9cc8314e3256ed6394: - ; // match: (SUBWconst [c] (MOVWconst [d])) // cond: // result: (MOVWconst [d-c]) - { + for { c := v.AuxInt if v.Args[0].Op != OpAMD64MOVWconst { - goto endae629a229c399eaed7dbb95b1b0e6f8a + break } d := v.Args[0].AuxInt v.reset(OpAMD64MOVWconst) v.AuxInt = d - c return true } - goto endae629a229c399eaed7dbb95b1b0e6f8a -endae629a229c399eaed7dbb95b1b0e6f8a: - ; // match: (SUBWconst [c] (SUBWconst [d] x)) // cond: // result: (ADDWconst [-c-d] x) - { + for { c := v.AuxInt if v.Args[0].Op != OpAMD64SUBWconst { - goto enda59f08d12aa08717b0443b7bb1b71374 + break } d := v.Args[0].AuxInt x := v.Args[0].Args[0] @@ -14027,9 +12131,6 @@ endae629a229c399eaed7dbb95b1b0e6f8a: v.AddArg(x) return true } - goto enda59f08d12aa08717b0443b7bb1b71374 -enda59f08d12aa08717b0443b7bb1b71374: - ; return false } func rewriteValueAMD64_OpSignExt16to32(v *Value, config *Config) bool { @@ -14038,15 +12139,12 @@ func rewriteValueAMD64_OpSignExt16to32(v *Value, config *Config) bool { // match: (SignExt16to32 x) // cond: // result: (MOVWQSX x) - { + for { x := v.Args[0] v.reset(OpAMD64MOVWQSX) v.AddArg(x) return true } - goto end21e4271c2b48a5aa3561ccfa8fa67cd9 -end21e4271c2b48a5aa3561ccfa8fa67cd9: - ; return false } func rewriteValueAMD64_OpSignExt16to64(v *Value, config *Config) bool { @@ -14055,15 +12153,12 @@ func rewriteValueAMD64_OpSignExt16to64(v *Value, config *Config) bool { // match: (SignExt16to64 x) // cond: // result: (MOVWQSX x) - { + for { x := v.Args[0] v.reset(OpAMD64MOVWQSX) v.AddArg(x) return true } - goto endc6d242ee3a3e195ef0f9e8dae47ada75 -endc6d242ee3a3e195ef0f9e8dae47ada75: - ; return false } func rewriteValueAMD64_OpSignExt32to64(v *Value, config *Config) bool { @@ -14072,15 +12167,12 @@ func rewriteValueAMD64_OpSignExt32to64(v *Value, config *Config) bool { // match: (SignExt32to64 x) // cond: // result: (MOVLQSX x) - { + for { x := v.Args[0] v.reset(OpAMD64MOVLQSX) v.AddArg(x) return true } - goto endb9f1a8b2d01eee44964a71a01bca165c -endb9f1a8b2d01eee44964a71a01bca165c: - ; return false } func rewriteValueAMD64_OpSignExt8to16(v *Value, config *Config) bool { @@ -14089,15 +12181,12 @@ func rewriteValueAMD64_OpSignExt8to16(v *Value, config *Config) bool { // match: (SignExt8to16 x) // cond: // result: (MOVBQSX x) - { + for { x := v.Args[0] v.reset(OpAMD64MOVBQSX) v.AddArg(x) return true } - goto end372869f08e147404b80634e5f83fd506 -end372869f08e147404b80634e5f83fd506: - ; return false } func rewriteValueAMD64_OpSignExt8to32(v *Value, config *Config) bool { @@ -14106,15 +12195,12 @@ func rewriteValueAMD64_OpSignExt8to32(v *Value, config *Config) bool { // match: (SignExt8to32 x) // cond: // result: (MOVBQSX x) - { + for { x := v.Args[0] v.reset(OpAMD64MOVBQSX) v.AddArg(x) return true } - goto end913e3575e5b4cf7f60585c108db40464 -end913e3575e5b4cf7f60585c108db40464: - ; return false } func rewriteValueAMD64_OpSignExt8to64(v *Value, config *Config) bool { @@ -14123,15 +12209,12 @@ func rewriteValueAMD64_OpSignExt8to64(v *Value, config *Config) bool { // match: (SignExt8to64 x) // cond: // result: (MOVBQSX x) - { + for { x := v.Args[0] v.reset(OpAMD64MOVBQSX) v.AddArg(x) return true } - goto endcef6d6001d3f25cf5dacee11a46e5c8c -endcef6d6001d3f25cf5dacee11a46e5c8c: - ; return false } func rewriteValueAMD64_OpSqrt(v *Value, config *Config) bool { @@ -14140,15 +12223,12 @@ func rewriteValueAMD64_OpSqrt(v *Value, config *Config) bool { // match: (Sqrt x) // cond: // result: (SQRTSD x) - { + for { x := v.Args[0] v.reset(OpAMD64SQRTSD) v.AddArg(x) return true } - goto end72f79ca9ec139e15856aaa03338cf543 -end72f79ca9ec139e15856aaa03338cf543: - ; return false } func rewriteValueAMD64_OpStaticCall(v *Value, config *Config) bool { @@ -14157,7 +12237,7 @@ func rewriteValueAMD64_OpStaticCall(v *Value, config *Config) bool { // match: (StaticCall [argwid] {target} mem) // cond: // result: (CALLstatic [argwid] {target} mem) - { + for { argwid := v.AuxInt target := v.Aux mem := v.Args[0] @@ -14167,9 +12247,6 @@ func rewriteValueAMD64_OpStaticCall(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto end32c5cbec813d1c2ae94fc9b1090e4b2a -end32c5cbec813d1c2ae94fc9b1090e4b2a: - ; return false } func rewriteValueAMD64_OpStore(v *Value, config *Config) bool { @@ -14178,15 +12255,15 @@ func rewriteValueAMD64_OpStore(v *Value, config *Config) bool { // match: (Store [8] ptr val mem) // cond: is64BitFloat(val.Type) // result: (MOVSDstore ptr val mem) - { + for { if v.AuxInt != 8 { - goto endaeec4f61bc8e67dbf3fa2f79fe4c2b9e + break } ptr := v.Args[0] val := v.Args[1] mem := v.Args[2] if !(is64BitFloat(val.Type)) { - goto endaeec4f61bc8e67dbf3fa2f79fe4c2b9e + break } v.reset(OpAMD64MOVSDstore) v.AddArg(ptr) @@ -14194,21 +12271,18 @@ func rewriteValueAMD64_OpStore(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto endaeec4f61bc8e67dbf3fa2f79fe4c2b9e -endaeec4f61bc8e67dbf3fa2f79fe4c2b9e: - ; // match: (Store [4] ptr val mem) // cond: is32BitFloat(val.Type) // result: (MOVSSstore ptr val mem) - { + for { if v.AuxInt != 4 { - goto endf638ca0a75871b5062da15324d0e0384 + break } ptr := v.Args[0] val := v.Args[1] mem := v.Args[2] if !(is32BitFloat(val.Type)) { - goto endf638ca0a75871b5062da15324d0e0384 + break } v.reset(OpAMD64MOVSSstore) v.AddArg(ptr) @@ -14216,15 +12290,12 @@ endaeec4f61bc8e67dbf3fa2f79fe4c2b9e: v.AddArg(mem) return true } - goto endf638ca0a75871b5062da15324d0e0384 -endf638ca0a75871b5062da15324d0e0384: - ; // match: (Store [8] ptr val mem) // cond: // result: (MOVQstore ptr val mem) - { + for { if v.AuxInt != 8 { - goto endd1eb7c3ea0c806e7a53ff3be86186eb7 + break } ptr := v.Args[0] val := v.Args[1] @@ -14235,15 +12306,12 @@ endf638ca0a75871b5062da15324d0e0384: v.AddArg(mem) return true } - goto endd1eb7c3ea0c806e7a53ff3be86186eb7 -endd1eb7c3ea0c806e7a53ff3be86186eb7: - ; // match: (Store [4] ptr val mem) // cond: // result: (MOVLstore ptr val mem) - { + for { if v.AuxInt != 4 { - goto end44e3b22360da76ecd59be9a8c2dd1347 + break } ptr := v.Args[0] val := v.Args[1] @@ -14254,15 +12322,12 @@ endd1eb7c3ea0c806e7a53ff3be86186eb7: v.AddArg(mem) return true } - goto end44e3b22360da76ecd59be9a8c2dd1347 -end44e3b22360da76ecd59be9a8c2dd1347: - ; // match: (Store [2] ptr val mem) // cond: // result: (MOVWstore ptr val mem) - { + for { if v.AuxInt != 2 { - goto endd0342b7fd3d0713f3e26922660047c71 + break } ptr := v.Args[0] val := v.Args[1] @@ -14273,15 +12338,12 @@ end44e3b22360da76ecd59be9a8c2dd1347: v.AddArg(mem) return true } - goto endd0342b7fd3d0713f3e26922660047c71 -endd0342b7fd3d0713f3e26922660047c71: - ; // match: (Store [1] ptr val mem) // cond: // result: (MOVBstore ptr val mem) - { + for { if v.AuxInt != 1 { - goto end8e76e20031197ca875889d2b4d0eb1d1 + break } ptr := v.Args[0] val := v.Args[1] @@ -14292,9 +12354,6 @@ endd0342b7fd3d0713f3e26922660047c71: v.AddArg(mem) return true } - goto end8e76e20031197ca875889d2b4d0eb1d1 -end8e76e20031197ca875889d2b4d0eb1d1: - ; return false } func rewriteValueAMD64_OpSub16(v *Value, config *Config) bool { @@ -14303,7 +12362,7 @@ func rewriteValueAMD64_OpSub16(v *Value, config *Config) bool { // match: (Sub16 x y) // cond: // result: (SUBW x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SUBW) @@ -14311,9 +12370,6 @@ func rewriteValueAMD64_OpSub16(v *Value, config *Config) bool { v.AddArg(y) return true } - goto end54adc5de883c0460ca71c6ee464d4244 -end54adc5de883c0460ca71c6ee464d4244: - ; return false } func rewriteValueAMD64_OpSub32(v *Value, config *Config) bool { @@ -14322,7 +12378,7 @@ func rewriteValueAMD64_OpSub32(v *Value, config *Config) bool { // match: (Sub32 x y) // cond: // result: (SUBL x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SUBL) @@ -14330,9 +12386,6 @@ func rewriteValueAMD64_OpSub32(v *Value, config *Config) bool { v.AddArg(y) return true } - goto enddc3a2a488bda8c5856f93343e5ffe5f8 -enddc3a2a488bda8c5856f93343e5ffe5f8: - ; return false } func rewriteValueAMD64_OpSub32F(v *Value, config *Config) bool { @@ -14341,7 +12394,7 @@ func rewriteValueAMD64_OpSub32F(v *Value, config *Config) bool { // match: (Sub32F x y) // cond: // result: (SUBSS x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SUBSS) @@ -14349,9 +12402,6 @@ func rewriteValueAMD64_OpSub32F(v *Value, config *Config) bool { v.AddArg(y) return true } - goto end20193c1804b0e707702a884fb8abd60d -end20193c1804b0e707702a884fb8abd60d: - ; return false } func rewriteValueAMD64_OpSub64(v *Value, config *Config) bool { @@ -14360,7 +12410,7 @@ func rewriteValueAMD64_OpSub64(v *Value, config *Config) bool { // match: (Sub64 x y) // cond: // result: (SUBQ x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SUBQ) @@ -14368,9 +12418,6 @@ func rewriteValueAMD64_OpSub64(v *Value, config *Config) bool { v.AddArg(y) return true } - goto endd88d5646309fd9174584888ecc8aca2c -endd88d5646309fd9174584888ecc8aca2c: - ; return false } func rewriteValueAMD64_OpSub64F(v *Value, config *Config) bool { @@ -14379,7 +12426,7 @@ func rewriteValueAMD64_OpSub64F(v *Value, config *Config) bool { // match: (Sub64F x y) // cond: // result: (SUBSD x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SUBSD) @@ -14387,9 +12434,6 @@ func rewriteValueAMD64_OpSub64F(v *Value, config *Config) bool { v.AddArg(y) return true } - goto end5d5af7b8a3326bf9151f00a0013b73d7 -end5d5af7b8a3326bf9151f00a0013b73d7: - ; return false } func rewriteValueAMD64_OpSub8(v *Value, config *Config) bool { @@ -14398,7 +12442,7 @@ func rewriteValueAMD64_OpSub8(v *Value, config *Config) bool { // match: (Sub8 x y) // cond: // result: (SUBB x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SUBB) @@ -14406,9 +12450,6 @@ func rewriteValueAMD64_OpSub8(v *Value, config *Config) bool { v.AddArg(y) return true } - goto end7d33bf9bdfa505f96b930563eca7955f -end7d33bf9bdfa505f96b930563eca7955f: - ; return false } func rewriteValueAMD64_OpSubPtr(v *Value, config *Config) bool { @@ -14417,7 +12458,7 @@ func rewriteValueAMD64_OpSubPtr(v *Value, config *Config) bool { // match: (SubPtr x y) // cond: // result: (SUBQ x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64SUBQ) @@ -14425,9 +12466,6 @@ func rewriteValueAMD64_OpSubPtr(v *Value, config *Config) bool { v.AddArg(y) return true } - goto end748f63f755afe0b97a8f3cf7e4d9cbfe -end748f63f755afe0b97a8f3cf7e4d9cbfe: - ; return false } func rewriteValueAMD64_OpTrunc16to8(v *Value, config *Config) bool { @@ -14436,16 +12474,13 @@ func rewriteValueAMD64_OpTrunc16to8(v *Value, config *Config) bool { // match: (Trunc16to8 x) // cond: // result: x - { + for { x := v.Args[0] v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto end8e2f5e0a6e3a06423c077747de6c2bdd -end8e2f5e0a6e3a06423c077747de6c2bdd: - ; return false } func rewriteValueAMD64_OpTrunc32to16(v *Value, config *Config) bool { @@ -14454,16 +12489,13 @@ func rewriteValueAMD64_OpTrunc32to16(v *Value, config *Config) bool { // match: (Trunc32to16 x) // cond: // result: x - { + for { x := v.Args[0] v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto end5bed0e3a3c1c6374d86beb5a4397708c -end5bed0e3a3c1c6374d86beb5a4397708c: - ; return false } func rewriteValueAMD64_OpTrunc32to8(v *Value, config *Config) bool { @@ -14472,16 +12504,13 @@ func rewriteValueAMD64_OpTrunc32to8(v *Value, config *Config) bool { // match: (Trunc32to8 x) // cond: // result: x - { + for { x := v.Args[0] v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto endef0b8032ce91979ce6cd0004260c04ee -endef0b8032ce91979ce6cd0004260c04ee: - ; return false } func rewriteValueAMD64_OpTrunc64to16(v *Value, config *Config) bool { @@ -14490,16 +12519,13 @@ func rewriteValueAMD64_OpTrunc64to16(v *Value, config *Config) bool { // match: (Trunc64to16 x) // cond: // result: x - { + for { x := v.Args[0] v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto endd32fd6e0ce970c212835e6f71c3dcbfd -endd32fd6e0ce970c212835e6f71c3dcbfd: - ; return false } func rewriteValueAMD64_OpTrunc64to32(v *Value, config *Config) bool { @@ -14508,16 +12534,13 @@ func rewriteValueAMD64_OpTrunc64to32(v *Value, config *Config) bool { // match: (Trunc64to32 x) // cond: // result: x - { + for { x := v.Args[0] v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto end1212c4e84153210aff7fd630fb3e1883 -end1212c4e84153210aff7fd630fb3e1883: - ; return false } func rewriteValueAMD64_OpTrunc64to8(v *Value, config *Config) bool { @@ -14526,16 +12549,13 @@ func rewriteValueAMD64_OpTrunc64to8(v *Value, config *Config) bool { // match: (Trunc64to8 x) // cond: // result: x - { + for { x := v.Args[0] v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto end734f017d4b2810ca2288f7037365824c -end734f017d4b2810ca2288f7037365824c: - ; return false } func rewriteValueAMD64_OpAMD64XORB(v *Value, config *Config) bool { @@ -14544,10 +12564,10 @@ func rewriteValueAMD64_OpAMD64XORB(v *Value, config *Config) bool { // match: (XORB x (MOVBconst [c])) // cond: // result: (XORBconst [c] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVBconst { - goto enda9ed9fdd115ffdffa8127c007c34d7b7 + break } c := v.Args[1].AuxInt v.reset(OpAMD64XORBconst) @@ -14555,15 +12575,12 @@ func rewriteValueAMD64_OpAMD64XORB(v *Value, config *Config) bool { v.AddArg(x) return true } - goto enda9ed9fdd115ffdffa8127c007c34d7b7 -enda9ed9fdd115ffdffa8127c007c34d7b7: - ; // match: (XORB (MOVBconst [c]) x) // cond: // result: (XORBconst [c] x) - { + for { if v.Args[0].Op != OpAMD64MOVBconst { - goto endb02a07d9dc7b802c59f013116e952f3f + break } c := v.Args[0].AuxInt x := v.Args[1] @@ -14572,24 +12589,18 @@ enda9ed9fdd115ffdffa8127c007c34d7b7: v.AddArg(x) return true } - goto endb02a07d9dc7b802c59f013116e952f3f -endb02a07d9dc7b802c59f013116e952f3f: - ; // match: (XORB x x) // cond: // result: (MOVBconst [0]) - { + for { x := v.Args[0] if v.Args[1] != x { - goto end2afddc39503d04d572a3a07878f6c9c9 + break } v.reset(OpAMD64MOVBconst) v.AuxInt = 0 return true } - goto end2afddc39503d04d572a3a07878f6c9c9 -end2afddc39503d04d572a3a07878f6c9c9: - ; return false } func rewriteValueAMD64_OpAMD64XORBconst(v *Value, config *Config) bool { @@ -14598,36 +12609,30 @@ func rewriteValueAMD64_OpAMD64XORBconst(v *Value, config *Config) bool { // match: (XORBconst [c] x) // cond: int8(c)==0 // result: x - { + for { c := v.AuxInt x := v.Args[0] if !(int8(c) == 0) { - goto end14b03b70e5579dfe3f9b243e02a887c3 + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto end14b03b70e5579dfe3f9b243e02a887c3 -end14b03b70e5579dfe3f9b243e02a887c3: - ; // match: (XORBconst [c] (MOVBconst [d])) // cond: // result: (MOVBconst [c^d]) - { + for { c := v.AuxInt if v.Args[0].Op != OpAMD64MOVBconst { - goto end6d8d1b612af9d253605c8bc69b822903 + break } d := v.Args[0].AuxInt v.reset(OpAMD64MOVBconst) v.AuxInt = c ^ d return true } - goto end6d8d1b612af9d253605c8bc69b822903 -end6d8d1b612af9d253605c8bc69b822903: - ; return false } func rewriteValueAMD64_OpAMD64XORL(v *Value, config *Config) bool { @@ -14636,10 +12641,10 @@ func rewriteValueAMD64_OpAMD64XORL(v *Value, config *Config) bool { // match: (XORL x (MOVLconst [c])) // cond: // result: (XORLconst [c] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVLconst { - goto enda9459d509d3416da67d13a22dd074a9c + break } c := v.Args[1].AuxInt v.reset(OpAMD64XORLconst) @@ -14647,15 +12652,12 @@ func rewriteValueAMD64_OpAMD64XORL(v *Value, config *Config) bool { v.AddArg(x) return true } - goto enda9459d509d3416da67d13a22dd074a9c -enda9459d509d3416da67d13a22dd074a9c: - ; // match: (XORL (MOVLconst [c]) x) // cond: // result: (XORLconst [c] x) - { + for { if v.Args[0].Op != OpAMD64MOVLconst { - goto end9c1a0af00eeadd8aa325e55f1f3fb89c + break } c := v.Args[0].AuxInt x := v.Args[1] @@ -14664,24 +12666,18 @@ enda9459d509d3416da67d13a22dd074a9c: v.AddArg(x) return true } - goto end9c1a0af00eeadd8aa325e55f1f3fb89c -end9c1a0af00eeadd8aa325e55f1f3fb89c: - ; // match: (XORL x x) // cond: // result: (MOVLconst [0]) - { + for { x := v.Args[0] if v.Args[1] != x { - goto end7bcf9cfeb69a0d7647389124eb53ce2a + break } v.reset(OpAMD64MOVLconst) v.AuxInt = 0 return true } - goto end7bcf9cfeb69a0d7647389124eb53ce2a -end7bcf9cfeb69a0d7647389124eb53ce2a: - ; return false } func rewriteValueAMD64_OpAMD64XORLconst(v *Value, config *Config) bool { @@ -14690,36 +12686,30 @@ func rewriteValueAMD64_OpAMD64XORLconst(v *Value, config *Config) bool { // match: (XORLconst [c] x) // cond: int32(c)==0 // result: x - { + for { c := v.AuxInt x := v.Args[0] if !(int32(c) == 0) { - goto end99808ca9fb8e3220e42f5678e1042a08 + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto end99808ca9fb8e3220e42f5678e1042a08 -end99808ca9fb8e3220e42f5678e1042a08: - ; // match: (XORLconst [c] (MOVLconst [d])) // cond: // result: (MOVLconst [c^d]) - { + for { c := v.AuxInt if v.Args[0].Op != OpAMD64MOVLconst { - goto end71238075b10b68a226903cc453c4715c + break } d := v.Args[0].AuxInt v.reset(OpAMD64MOVLconst) v.AuxInt = c ^ d return true } - goto end71238075b10b68a226903cc453c4715c -end71238075b10b68a226903cc453c4715c: - ; return false } func rewriteValueAMD64_OpAMD64XORQ(v *Value, config *Config) bool { @@ -14728,58 +12718,49 @@ func rewriteValueAMD64_OpAMD64XORQ(v *Value, config *Config) bool { // match: (XORQ x (MOVQconst [c])) // cond: is32Bit(c) // result: (XORQconst [c] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVQconst { - goto end452341f950062e0483f16438fb9ec500 + break } c := v.Args[1].AuxInt if !(is32Bit(c)) { - goto end452341f950062e0483f16438fb9ec500 + break } v.reset(OpAMD64XORQconst) v.AuxInt = c v.AddArg(x) return true } - goto end452341f950062e0483f16438fb9ec500 -end452341f950062e0483f16438fb9ec500: - ; // match: (XORQ (MOVQconst [c]) x) // cond: is32Bit(c) // result: (XORQconst [c] x) - { + for { if v.Args[0].Op != OpAMD64MOVQconst { - goto endd221a7e3daaaaa29ee385ad36e061b57 + break } c := v.Args[0].AuxInt x := v.Args[1] if !(is32Bit(c)) { - goto endd221a7e3daaaaa29ee385ad36e061b57 + break } v.reset(OpAMD64XORQconst) v.AuxInt = c v.AddArg(x) return true } - goto endd221a7e3daaaaa29ee385ad36e061b57 -endd221a7e3daaaaa29ee385ad36e061b57: - ; // match: (XORQ x x) // cond: // result: (MOVQconst [0]) - { + for { x := v.Args[0] if v.Args[1] != x { - goto end10575a5d711cf14e6d4dffbb0e8dfaeb + break } v.reset(OpAMD64MOVQconst) v.AuxInt = 0 return true } - goto end10575a5d711cf14e6d4dffbb0e8dfaeb -end10575a5d711cf14e6d4dffbb0e8dfaeb: - ; return false } func rewriteValueAMD64_OpAMD64XORQconst(v *Value, config *Config) bool { @@ -14788,9 +12769,9 @@ func rewriteValueAMD64_OpAMD64XORQconst(v *Value, config *Config) bool { // match: (XORQconst [0] x) // cond: // result: x - { + for { if v.AuxInt != 0 { - goto end0ee8d195a97eff476cf1f69a4dc0ec75 + break } x := v.Args[0] v.reset(OpCopy) @@ -14798,25 +12779,19 @@ func rewriteValueAMD64_OpAMD64XORQconst(v *Value, config *Config) bool { v.AddArg(x) return true } - goto end0ee8d195a97eff476cf1f69a4dc0ec75 -end0ee8d195a97eff476cf1f69a4dc0ec75: - ; // match: (XORQconst [c] (MOVQconst [d])) // cond: // result: (MOVQconst [c^d]) - { + for { c := v.AuxInt if v.Args[0].Op != OpAMD64MOVQconst { - goto end3f404d4f07362319fbad2e1ba0827a9f + break } d := v.Args[0].AuxInt v.reset(OpAMD64MOVQconst) v.AuxInt = c ^ d return true } - goto end3f404d4f07362319fbad2e1ba0827a9f -end3f404d4f07362319fbad2e1ba0827a9f: - ; return false } func rewriteValueAMD64_OpAMD64XORW(v *Value, config *Config) bool { @@ -14825,10 +12800,10 @@ func rewriteValueAMD64_OpAMD64XORW(v *Value, config *Config) bool { // match: (XORW x (MOVWconst [c])) // cond: // result: (XORWconst [c] x) - { + for { x := v.Args[0] if v.Args[1].Op != OpAMD64MOVWconst { - goto end2ca109efd66c221a5691a4da95ec6c67 + break } c := v.Args[1].AuxInt v.reset(OpAMD64XORWconst) @@ -14836,15 +12811,12 @@ func rewriteValueAMD64_OpAMD64XORW(v *Value, config *Config) bool { v.AddArg(x) return true } - goto end2ca109efd66c221a5691a4da95ec6c67 -end2ca109efd66c221a5691a4da95ec6c67: - ; // match: (XORW (MOVWconst [c]) x) // cond: // result: (XORWconst [c] x) - { + for { if v.Args[0].Op != OpAMD64MOVWconst { - goto end51ee62a06d4301e5a4aed7a6639b1d53 + break } c := v.Args[0].AuxInt x := v.Args[1] @@ -14853,24 +12825,18 @@ end2ca109efd66c221a5691a4da95ec6c67: v.AddArg(x) return true } - goto end51ee62a06d4301e5a4aed7a6639b1d53 -end51ee62a06d4301e5a4aed7a6639b1d53: - ; // match: (XORW x x) // cond: // result: (MOVWconst [0]) - { + for { x := v.Args[0] if v.Args[1] != x { - goto end07f332e857be0c2707797ed480a2faf4 + break } v.reset(OpAMD64MOVWconst) v.AuxInt = 0 return true } - goto end07f332e857be0c2707797ed480a2faf4 -end07f332e857be0c2707797ed480a2faf4: - ; return false } func rewriteValueAMD64_OpAMD64XORWconst(v *Value, config *Config) bool { @@ -14879,36 +12845,30 @@ func rewriteValueAMD64_OpAMD64XORWconst(v *Value, config *Config) bool { // match: (XORWconst [c] x) // cond: int16(c)==0 // result: x - { + for { c := v.AuxInt x := v.Args[0] if !(int16(c) == 0) { - goto enda371132353dee83828836da851240f0a + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto enda371132353dee83828836da851240f0a -enda371132353dee83828836da851240f0a: - ; // match: (XORWconst [c] (MOVWconst [d])) // cond: // result: (MOVWconst [c^d]) - { + for { c := v.AuxInt if v.Args[0].Op != OpAMD64MOVWconst { - goto ende24881ccdfa8486c4593fd9aa5df1ed6 + break } d := v.Args[0].AuxInt v.reset(OpAMD64MOVWconst) v.AuxInt = c ^ d return true } - goto ende24881ccdfa8486c4593fd9aa5df1ed6 -ende24881ccdfa8486c4593fd9aa5df1ed6: - ; return false } func rewriteValueAMD64_OpXor16(v *Value, config *Config) bool { @@ -14917,7 +12877,7 @@ func rewriteValueAMD64_OpXor16(v *Value, config *Config) bool { // match: (Xor16 x y) // cond: // result: (XORW x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64XORW) @@ -14925,9 +12885,6 @@ func rewriteValueAMD64_OpXor16(v *Value, config *Config) bool { v.AddArg(y) return true } - goto end20efdd5dfd5130abf818de5546a991a0 -end20efdd5dfd5130abf818de5546a991a0: - ; return false } func rewriteValueAMD64_OpXor32(v *Value, config *Config) bool { @@ -14936,7 +12893,7 @@ func rewriteValueAMD64_OpXor32(v *Value, config *Config) bool { // match: (Xor32 x y) // cond: // result: (XORL x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64XORL) @@ -14944,9 +12901,6 @@ func rewriteValueAMD64_OpXor32(v *Value, config *Config) bool { v.AddArg(y) return true } - goto end9da6bce98b437e2609488346116a75d8 -end9da6bce98b437e2609488346116a75d8: - ; return false } func rewriteValueAMD64_OpXor64(v *Value, config *Config) bool { @@ -14955,7 +12909,7 @@ func rewriteValueAMD64_OpXor64(v *Value, config *Config) bool { // match: (Xor64 x y) // cond: // result: (XORQ x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64XORQ) @@ -14963,9 +12917,6 @@ func rewriteValueAMD64_OpXor64(v *Value, config *Config) bool { v.AddArg(y) return true } - goto endc88cd189c2a6f07ecff324ed94809f8f -endc88cd189c2a6f07ecff324ed94809f8f: - ; return false } func rewriteValueAMD64_OpXor8(v *Value, config *Config) bool { @@ -14974,7 +12925,7 @@ func rewriteValueAMD64_OpXor8(v *Value, config *Config) bool { // match: (Xor8 x y) // cond: // result: (XORB x y) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpAMD64XORB) @@ -14982,9 +12933,6 @@ func rewriteValueAMD64_OpXor8(v *Value, config *Config) bool { v.AddArg(y) return true } - goto end50f4434ef96916d3e65ad3cc236d1723 -end50f4434ef96916d3e65ad3cc236d1723: - ; return false } func rewriteValueAMD64_OpZero(v *Value, config *Config) bool { @@ -14993,9 +12941,9 @@ func rewriteValueAMD64_OpZero(v *Value, config *Config) bool { // match: (Zero [0] _ mem) // cond: // result: mem - { + for { if v.AuxInt != 0 { - goto endc9a38a60f0322f93682daa824611272c + break } mem := v.Args[1] v.reset(OpCopy) @@ -15003,15 +12951,12 @@ func rewriteValueAMD64_OpZero(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto endc9a38a60f0322f93682daa824611272c -endc9a38a60f0322f93682daa824611272c: - ; // match: (Zero [1] destptr mem) // cond: // result: (MOVBstoreconst [0] destptr mem) - { + for { if v.AuxInt != 1 { - goto ende0161981658beee468c9e2368fe31eb8 + break } destptr := v.Args[0] mem := v.Args[1] @@ -15021,15 +12966,12 @@ endc9a38a60f0322f93682daa824611272c: v.AddArg(mem) return true } - goto ende0161981658beee468c9e2368fe31eb8 -ende0161981658beee468c9e2368fe31eb8: - ; // match: (Zero [2] destptr mem) // cond: // result: (MOVWstoreconst [0] destptr mem) - { + for { if v.AuxInt != 2 { - goto end4e4aaf641bf2818bb71f1397e4685bdd + break } destptr := v.Args[0] mem := v.Args[1] @@ -15039,15 +12981,12 @@ ende0161981658beee468c9e2368fe31eb8: v.AddArg(mem) return true } - goto end4e4aaf641bf2818bb71f1397e4685bdd -end4e4aaf641bf2818bb71f1397e4685bdd: - ; // match: (Zero [4] destptr mem) // cond: // result: (MOVLstoreconst [0] destptr mem) - { + for { if v.AuxInt != 4 { - goto end7612f59dd66ebfc632ea5bc85f5437b5 + break } destptr := v.Args[0] mem := v.Args[1] @@ -15057,15 +12996,12 @@ end4e4aaf641bf2818bb71f1397e4685bdd: v.AddArg(mem) return true } - goto end7612f59dd66ebfc632ea5bc85f5437b5 -end7612f59dd66ebfc632ea5bc85f5437b5: - ; // match: (Zero [8] destptr mem) // cond: // result: (MOVQstoreconst [0] destptr mem) - { + for { if v.AuxInt != 8 { - goto end07aaaebfa15a48c52cd79b68e28d266f + break } destptr := v.Args[0] mem := v.Args[1] @@ -15075,15 +13011,12 @@ end7612f59dd66ebfc632ea5bc85f5437b5: v.AddArg(mem) return true } - goto end07aaaebfa15a48c52cd79b68e28d266f -end07aaaebfa15a48c52cd79b68e28d266f: - ; // match: (Zero [3] destptr mem) // cond: // result: (MOVBstoreconst [makeValAndOff(0,2)] destptr (MOVWstoreconst [0] destptr mem)) - { + for { if v.AuxInt != 3 { - goto end3bf4a24a87e0727b9bcfbb5fcd24aabe + break } destptr := v.Args[0] mem := v.Args[1] @@ -15097,15 +13030,12 @@ end07aaaebfa15a48c52cd79b68e28d266f: v.AddArg(v0) return true } - goto end3bf4a24a87e0727b9bcfbb5fcd24aabe -end3bf4a24a87e0727b9bcfbb5fcd24aabe: - ; // match: (Zero [5] destptr mem) // cond: // result: (MOVBstoreconst [makeValAndOff(0,4)] destptr (MOVLstoreconst [0] destptr mem)) - { + for { if v.AuxInt != 5 { - goto end567e4a90c6867faf1dfc2cd57daf2ce4 + break } destptr := v.Args[0] mem := v.Args[1] @@ -15119,15 +13049,12 @@ end3bf4a24a87e0727b9bcfbb5fcd24aabe: v.AddArg(v0) return true } - goto end567e4a90c6867faf1dfc2cd57daf2ce4 -end567e4a90c6867faf1dfc2cd57daf2ce4: - ; // match: (Zero [6] destptr mem) // cond: // result: (MOVWstoreconst [makeValAndOff(0,4)] destptr (MOVLstoreconst [0] destptr mem)) - { + for { if v.AuxInt != 6 { - goto end7cddcaf215fcc2cbca9aa958147b2380 + break } destptr := v.Args[0] mem := v.Args[1] @@ -15141,15 +13068,12 @@ end567e4a90c6867faf1dfc2cd57daf2ce4: v.AddArg(v0) return true } - goto end7cddcaf215fcc2cbca9aa958147b2380 -end7cddcaf215fcc2cbca9aa958147b2380: - ; // match: (Zero [7] destptr mem) // cond: // result: (MOVLstoreconst [makeValAndOff(0,3)] destptr (MOVLstoreconst [0] destptr mem)) - { + for { if v.AuxInt != 7 { - goto end1b58cabccbc912ea4e1cf99be8a9fbf7 + break } destptr := v.Args[0] mem := v.Args[1] @@ -15163,18 +13087,15 @@ end7cddcaf215fcc2cbca9aa958147b2380: v.AddArg(v0) return true } - goto end1b58cabccbc912ea4e1cf99be8a9fbf7 -end1b58cabccbc912ea4e1cf99be8a9fbf7: - ; // 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) { - goto endc8760f86b83b1372fce0042ab5200fc1 + break } v.reset(OpZero) v.AuxInt = size - size%8 @@ -15189,15 +13110,12 @@ end1b58cabccbc912ea4e1cf99be8a9fbf7: v.AddArg(v1) return true } - goto endc8760f86b83b1372fce0042ab5200fc1 -endc8760f86b83b1372fce0042ab5200fc1: - ; // match: (Zero [16] destptr mem) // cond: // result: (MOVQstoreconst [makeValAndOff(0,8)] destptr (MOVQstoreconst [0] destptr mem)) - { + for { if v.AuxInt != 16 { - goto endf1447d60cbf8025adaf1a02a2cd219c4 + break } destptr := v.Args[0] mem := v.Args[1] @@ -15211,15 +13129,12 @@ endc8760f86b83b1372fce0042ab5200fc1: v.AddArg(v0) return true } - goto endf1447d60cbf8025adaf1a02a2cd219c4 -endf1447d60cbf8025adaf1a02a2cd219c4: - ; // 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 { - goto end57f2984a61c64f71a528e7fa75576095 + break } destptr := v.Args[0] mem := v.Args[1] @@ -15237,15 +13152,12 @@ endf1447d60cbf8025adaf1a02a2cd219c4: v.AddArg(v0) return true } - goto end57f2984a61c64f71a528e7fa75576095 -end57f2984a61c64f71a528e7fa75576095: - ; // 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 { - goto end418a59f9f84dd389d37ae5c24aba2760 + break } destptr := v.Args[0] mem := v.Args[1] @@ -15267,18 +13179,15 @@ end57f2984a61c64f71a528e7fa75576095: v.AddArg(v0) return true } - goto end418a59f9f84dd389d37ae5c24aba2760 -end418a59f9f84dd389d37ae5c24aba2760: - ; // 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) { - goto end240266449c3e493db1c3b38a78682ff0 + break } v.reset(OpZero) v.AuxInt = size - 8 @@ -15295,18 +13204,15 @@ end418a59f9f84dd389d37ae5c24aba2760: v.AddArg(v1) return true } - goto end240266449c3e493db1c3b38a78682ff0 -end240266449c3e493db1c3b38a78682ff0: - ; // 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) { - goto endf508bb887eee9119069b22c23dbca138 + break } v.reset(OpAMD64DUFFZERO) v.AuxInt = duffStart(size) @@ -15320,18 +13226,15 @@ end240266449c3e493db1c3b38a78682ff0: v.AddArg(mem) return true } - goto endf508bb887eee9119069b22c23dbca138 -endf508bb887eee9119069b22c23dbca138: - ; // 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) { - goto endb9d55d4ba0e70ed918e3ac757727441b + break } v.reset(OpAMD64REPSTOSQ) v.AddArg(destptr) @@ -15344,9 +13247,6 @@ endf508bb887eee9119069b22c23dbca138: v.AddArg(mem) return true } - goto endb9d55d4ba0e70ed918e3ac757727441b -endb9d55d4ba0e70ed918e3ac757727441b: - ; return false } func rewriteValueAMD64_OpZeroExt16to32(v *Value, config *Config) bool { @@ -15355,15 +13255,12 @@ func rewriteValueAMD64_OpZeroExt16to32(v *Value, config *Config) bool { // match: (ZeroExt16to32 x) // cond: // result: (MOVWQZX x) - { + for { x := v.Args[0] v.reset(OpAMD64MOVWQZX) v.AddArg(x) return true } - goto endbfff79412a2cc96095069c66812844b4 -endbfff79412a2cc96095069c66812844b4: - ; return false } func rewriteValueAMD64_OpZeroExt16to64(v *Value, config *Config) bool { @@ -15372,15 +13269,12 @@ func rewriteValueAMD64_OpZeroExt16to64(v *Value, config *Config) bool { // match: (ZeroExt16to64 x) // cond: // result: (MOVWQZX x) - { + for { x := v.Args[0] v.reset(OpAMD64MOVWQZX) v.AddArg(x) return true } - goto end7a40262c5c856101058d2bd518ed0910 -end7a40262c5c856101058d2bd518ed0910: - ; return false } func rewriteValueAMD64_OpZeroExt32to64(v *Value, config *Config) bool { @@ -15389,15 +13283,12 @@ func rewriteValueAMD64_OpZeroExt32to64(v *Value, config *Config) bool { // match: (ZeroExt32to64 x) // cond: // result: (MOVLQZX x) - { + for { x := v.Args[0] v.reset(OpAMD64MOVLQZX) v.AddArg(x) return true } - goto enddf83bdc8cc6c5673a9ef7aca7affe45a -enddf83bdc8cc6c5673a9ef7aca7affe45a: - ; return false } func rewriteValueAMD64_OpZeroExt8to16(v *Value, config *Config) bool { @@ -15406,15 +13297,12 @@ func rewriteValueAMD64_OpZeroExt8to16(v *Value, config *Config) bool { // match: (ZeroExt8to16 x) // cond: // result: (MOVBQZX x) - { + for { x := v.Args[0] v.reset(OpAMD64MOVBQZX) v.AddArg(x) return true } - goto endd03d53d2a585727e4107ae1a3cc55479 -endd03d53d2a585727e4107ae1a3cc55479: - ; return false } func rewriteValueAMD64_OpZeroExt8to32(v *Value, config *Config) bool { @@ -15423,15 +13311,12 @@ func rewriteValueAMD64_OpZeroExt8to32(v *Value, config *Config) bool { // match: (ZeroExt8to32 x) // cond: // result: (MOVBQZX x) - { + for { x := v.Args[0] v.reset(OpAMD64MOVBQZX) v.AddArg(x) return true } - goto endcbd33e965b3dab14fced5ae93d8949de -endcbd33e965b3dab14fced5ae93d8949de: - ; return false } func rewriteValueAMD64_OpZeroExt8to64(v *Value, config *Config) bool { @@ -15440,15 +13325,12 @@ func rewriteValueAMD64_OpZeroExt8to64(v *Value, config *Config) bool { // match: (ZeroExt8to64 x) // cond: // result: (MOVBQZX x) - { + for { x := v.Args[0] v.reset(OpAMD64MOVBQZX) v.AddArg(x) return true } - goto end63ae7cc15db9d15189b2f1342604b2cb -end63ae7cc15db9d15189b2f1342604b2cb: - ; return false } func rewriteBlockAMD64(b *Block) bool { @@ -15457,10 +13339,10 @@ func rewriteBlockAMD64(b *Block) bool { // match: (EQ (InvertFlags cmp) yes no) // cond: // result: (EQ cmp yes no) - { + for { v := b.Control if v.Op != OpAMD64InvertFlags { - goto end6b8e9afc73b1c4d528f31a60d2575fae + break } cmp := v.Args[0] yes := b.Succs[0] @@ -15471,16 +13353,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end6b8e9afc73b1c4d528f31a60d2575fae - end6b8e9afc73b1c4d528f31a60d2575fae: - ; // match: (EQ (FlagEQ) yes no) // cond: // result: (First nil yes no) - { + for { v := b.Control if v.Op != OpAMD64FlagEQ { - goto end9ff0ac95bed10cc8e2b88351720bf254 + break } yes := b.Succs[0] no := b.Succs[1] @@ -15490,16 +13369,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end9ff0ac95bed10cc8e2b88351720bf254 - end9ff0ac95bed10cc8e2b88351720bf254: - ; // match: (EQ (FlagLT_ULT) yes no) // cond: // result: (First nil no yes) - { + for { v := b.Control if v.Op != OpAMD64FlagLT_ULT { - goto endb087fca771315fb0f3e36b4f3daa1b4f + break } yes := b.Succs[0] no := b.Succs[1] @@ -15510,16 +13386,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Likely *= -1 return true } - goto endb087fca771315fb0f3e36b4f3daa1b4f - endb087fca771315fb0f3e36b4f3daa1b4f: - ; // match: (EQ (FlagLT_UGT) yes no) // cond: // result: (First nil no yes) - { + for { v := b.Control if v.Op != OpAMD64FlagLT_UGT { - goto endd1884731c9bd3c1cc1b27617e4573add + break } yes := b.Succs[0] no := b.Succs[1] @@ -15530,16 +13403,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Likely *= -1 return true } - goto endd1884731c9bd3c1cc1b27617e4573add - endd1884731c9bd3c1cc1b27617e4573add: - ; // match: (EQ (FlagGT_ULT) yes no) // cond: // result: (First nil no yes) - { + for { v := b.Control if v.Op != OpAMD64FlagGT_ULT { - goto end13acc127fef124a130ad1e79fd6a58c9 + break } yes := b.Succs[0] no := b.Succs[1] @@ -15550,16 +13420,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Likely *= -1 return true } - goto end13acc127fef124a130ad1e79fd6a58c9 - end13acc127fef124a130ad1e79fd6a58c9: - ; // match: (EQ (FlagGT_UGT) yes no) // cond: // result: (First nil no yes) - { + for { v := b.Control if v.Op != OpAMD64FlagGT_UGT { - goto end4bdb3694a7ed9860cc65f54840b11e84 + break } yes := b.Succs[0] no := b.Succs[1] @@ -15570,17 +13437,14 @@ func rewriteBlockAMD64(b *Block) bool { b.Likely *= -1 return true } - goto end4bdb3694a7ed9860cc65f54840b11e84 - end4bdb3694a7ed9860cc65f54840b11e84: - ; case BlockAMD64GE: // match: (GE (InvertFlags cmp) yes no) // cond: // result: (LE cmp yes no) - { + for { v := b.Control if v.Op != OpAMD64InvertFlags { - goto end0610f000a6988ee8310307ec2ea138f8 + break } cmp := v.Args[0] yes := b.Succs[0] @@ -15591,16 +13455,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end0610f000a6988ee8310307ec2ea138f8 - end0610f000a6988ee8310307ec2ea138f8: - ; // match: (GE (FlagEQ) yes no) // cond: // result: (First nil yes no) - { + for { v := b.Control if v.Op != OpAMD64FlagEQ { - goto end24ae40580bbb8675d15f6d1451beeb56 + break } yes := b.Succs[0] no := b.Succs[1] @@ -15610,16 +13471,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end24ae40580bbb8675d15f6d1451beeb56 - end24ae40580bbb8675d15f6d1451beeb56: - ; // match: (GE (FlagLT_ULT) yes no) // cond: // result: (First nil no yes) - { + for { v := b.Control if v.Op != OpAMD64FlagLT_ULT { - goto end40cf2bb5d1a99146cc6ce5e9a9dc7eee + break } yes := b.Succs[0] no := b.Succs[1] @@ -15630,16 +13488,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Likely *= -1 return true } - goto end40cf2bb5d1a99146cc6ce5e9a9dc7eee - end40cf2bb5d1a99146cc6ce5e9a9dc7eee: - ; // match: (GE (FlagLT_UGT) yes no) // cond: // result: (First nil no yes) - { + for { v := b.Control if v.Op != OpAMD64FlagLT_UGT { - goto end2d4809306e6243116f4c1b27c7c9e503 + break } yes := b.Succs[0] no := b.Succs[1] @@ -15650,16 +13505,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Likely *= -1 return true } - goto end2d4809306e6243116f4c1b27c7c9e503 - end2d4809306e6243116f4c1b27c7c9e503: - ; // match: (GE (FlagGT_ULT) yes no) // cond: // result: (First nil yes no) - { + for { v := b.Control if v.Op != OpAMD64FlagGT_ULT { - goto end842c411ddb1c5583e1e986f2826bb3cf + break } yes := b.Succs[0] no := b.Succs[1] @@ -15669,16 +13521,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end842c411ddb1c5583e1e986f2826bb3cf - end842c411ddb1c5583e1e986f2826bb3cf: - ; // match: (GE (FlagGT_UGT) yes no) // cond: // result: (First nil yes no) - { + for { v := b.Control if v.Op != OpAMD64FlagGT_UGT { - goto end7402ddc29ccc96070353e9a04e126444 + break } yes := b.Succs[0] no := b.Succs[1] @@ -15688,17 +13537,14 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end7402ddc29ccc96070353e9a04e126444 - end7402ddc29ccc96070353e9a04e126444: - ; case BlockAMD64GT: // match: (GT (InvertFlags cmp) yes no) // cond: // result: (LT cmp yes no) - { + for { v := b.Control if v.Op != OpAMD64InvertFlags { - goto endf60c0660b6a8aa9565c97fc87f04eb34 + break } cmp := v.Args[0] yes := b.Succs[0] @@ -15709,16 +13555,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto endf60c0660b6a8aa9565c97fc87f04eb34 - endf60c0660b6a8aa9565c97fc87f04eb34: - ; // match: (GT (FlagEQ) yes no) // cond: // result: (First nil no yes) - { + for { v := b.Control if v.Op != OpAMD64FlagEQ { - goto end2ba8650a12af813cee310b2a81b9ba1b + break } yes := b.Succs[0] no := b.Succs[1] @@ -15729,16 +13572,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Likely *= -1 return true } - goto end2ba8650a12af813cee310b2a81b9ba1b - end2ba8650a12af813cee310b2a81b9ba1b: - ; // match: (GT (FlagLT_ULT) yes no) // cond: // result: (First nil no yes) - { + for { v := b.Control if v.Op != OpAMD64FlagLT_ULT { - goto endbe873b5adbcdd272c99e04e063f9b7ce + break } yes := b.Succs[0] no := b.Succs[1] @@ -15749,16 +13589,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Likely *= -1 return true } - goto endbe873b5adbcdd272c99e04e063f9b7ce - endbe873b5adbcdd272c99e04e063f9b7ce: - ; // match: (GT (FlagLT_UGT) yes no) // cond: // result: (First nil no yes) - { + for { v := b.Control if v.Op != OpAMD64FlagLT_UGT { - goto ende5dd5906f7fdb5c0e59eeed92a3684d3 + break } yes := b.Succs[0] no := b.Succs[1] @@ -15769,16 +13606,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Likely *= -1 return true } - goto ende5dd5906f7fdb5c0e59eeed92a3684d3 - ende5dd5906f7fdb5c0e59eeed92a3684d3: - ; // match: (GT (FlagGT_ULT) yes no) // cond: // result: (First nil yes no) - { + for { v := b.Control if v.Op != OpAMD64FlagGT_ULT { - goto end7d92e57429ee02c3707f39d861c94f4c + break } yes := b.Succs[0] no := b.Succs[1] @@ -15788,16 +13622,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end7d92e57429ee02c3707f39d861c94f4c - end7d92e57429ee02c3707f39d861c94f4c: - ; // match: (GT (FlagGT_UGT) yes no) // cond: // result: (First nil yes no) - { + for { v := b.Control if v.Op != OpAMD64FlagGT_UGT { - goto end9d77d9a15c1b0938558a4ce821d50aa1 + break } yes := b.Succs[0] no := b.Succs[1] @@ -15807,17 +13638,14 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end9d77d9a15c1b0938558a4ce821d50aa1 - end9d77d9a15c1b0938558a4ce821d50aa1: - ; case BlockIf: // match: (If (SETL cmp) yes no) // cond: // result: (LT cmp yes no) - { + for { v := b.Control if v.Op != OpAMD64SETL { - goto end94277282f4b83f0c035b23711a075801 + break } cmp := v.Args[0] yes := b.Succs[0] @@ -15828,16 +13656,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end94277282f4b83f0c035b23711a075801 - end94277282f4b83f0c035b23711a075801: - ; // match: (If (SETLE cmp) yes no) // cond: // result: (LE cmp yes no) - { + for { v := b.Control if v.Op != OpAMD64SETLE { - goto enda84798dd797927b54a9a2987421b2ba2 + break } cmp := v.Args[0] yes := b.Succs[0] @@ -15848,16 +13673,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto enda84798dd797927b54a9a2987421b2ba2 - enda84798dd797927b54a9a2987421b2ba2: - ; // match: (If (SETG cmp) yes no) // cond: // result: (GT cmp yes no) - { + for { v := b.Control if v.Op != OpAMD64SETG { - goto end3434ef985979cbf394455ab5b559567c + break } cmp := v.Args[0] yes := b.Succs[0] @@ -15868,16 +13690,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end3434ef985979cbf394455ab5b559567c - end3434ef985979cbf394455ab5b559567c: - ; // match: (If (SETGE cmp) yes no) // cond: // result: (GE cmp yes no) - { + for { v := b.Control if v.Op != OpAMD64SETGE { - goto endee147d81d8620a5e23cb92bd9f13cf8d + break } cmp := v.Args[0] yes := b.Succs[0] @@ -15888,16 +13707,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto endee147d81d8620a5e23cb92bd9f13cf8d - endee147d81d8620a5e23cb92bd9f13cf8d: - ; // match: (If (SETEQ cmp) yes no) // cond: // result: (EQ cmp yes no) - { + for { v := b.Control if v.Op != OpAMD64SETEQ { - goto ende7d85ccc850fc3963c50a91df096de17 + break } cmp := v.Args[0] yes := b.Succs[0] @@ -15908,16 +13724,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto ende7d85ccc850fc3963c50a91df096de17 - ende7d85ccc850fc3963c50a91df096de17: - ; // match: (If (SETNE cmp) yes no) // cond: // result: (NE cmp yes no) - { + for { v := b.Control if v.Op != OpAMD64SETNE { - goto endba4b54260ecda1b5731b129c0eb493d0 + break } cmp := v.Args[0] yes := b.Succs[0] @@ -15928,16 +13741,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto endba4b54260ecda1b5731b129c0eb493d0 - endba4b54260ecda1b5731b129c0eb493d0: - ; // match: (If (SETB cmp) yes no) // cond: // result: (ULT cmp yes no) - { + for { v := b.Control if v.Op != OpAMD64SETB { - goto endf84eedfcd3f18f5c9c3f3d1045a24330 + break } cmp := v.Args[0] yes := b.Succs[0] @@ -15948,16 +13758,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto endf84eedfcd3f18f5c9c3f3d1045a24330 - endf84eedfcd3f18f5c9c3f3d1045a24330: - ; // match: (If (SETBE cmp) yes no) // cond: // result: (ULE cmp yes no) - { + for { v := b.Control if v.Op != OpAMD64SETBE { - goto endfe0178f6f4406945ca8966817d04be60 + break } cmp := v.Args[0] yes := b.Succs[0] @@ -15968,16 +13775,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto endfe0178f6f4406945ca8966817d04be60 - endfe0178f6f4406945ca8966817d04be60: - ; // match: (If (SETA cmp) yes no) // cond: // result: (UGT cmp yes no) - { + for { v := b.Control if v.Op != OpAMD64SETA { - goto end2b5a2d7756bdba01a732bf54d9acdb73 + break } cmp := v.Args[0] yes := b.Succs[0] @@ -15988,16 +13792,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end2b5a2d7756bdba01a732bf54d9acdb73 - end2b5a2d7756bdba01a732bf54d9acdb73: - ; // match: (If (SETAE cmp) yes no) // cond: // result: (UGE cmp yes no) - { + for { v := b.Control if v.Op != OpAMD64SETAE { - goto end9bea9963c3c5dfb97249a5feb8287f94 + break } cmp := v.Args[0] yes := b.Succs[0] @@ -16008,16 +13809,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end9bea9963c3c5dfb97249a5feb8287f94 - end9bea9963c3c5dfb97249a5feb8287f94: - ; // match: (If (SETGF cmp) yes no) // cond: // result: (UGT cmp yes no) - { + for { v := b.Control if v.Op != OpAMD64SETGF { - goto enda72d68674cfa26b5982a43756bca6767 + break } cmp := v.Args[0] yes := b.Succs[0] @@ -16028,16 +13826,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto enda72d68674cfa26b5982a43756bca6767 - enda72d68674cfa26b5982a43756bca6767: - ; // match: (If (SETGEF cmp) yes no) // cond: // result: (UGE cmp yes no) - { + for { v := b.Control if v.Op != OpAMD64SETGEF { - goto endccc171c1d66dd60ac0275d1f78259315 + break } cmp := v.Args[0] yes := b.Succs[0] @@ -16048,16 +13843,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto endccc171c1d66dd60ac0275d1f78259315 - endccc171c1d66dd60ac0275d1f78259315: - ; // match: (If (SETEQF cmp) yes no) // cond: // result: (EQF cmp yes no) - { + for { v := b.Control if v.Op != OpAMD64SETEQF { - goto end58cb74d05266a79003ebdd733afb66fa + break } cmp := v.Args[0] yes := b.Succs[0] @@ -16068,16 +13860,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end58cb74d05266a79003ebdd733afb66fa - end58cb74d05266a79003ebdd733afb66fa: - ; // match: (If (SETNEF cmp) yes no) // cond: // result: (NEF cmp yes no) - { + for { v := b.Control if v.Op != OpAMD64SETNEF { - goto endaa989df10b5bbc5fdf8f7f0b81767e86 + break } cmp := v.Args[0] yes := b.Succs[0] @@ -16088,13 +13877,10 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto endaa989df10b5bbc5fdf8f7f0b81767e86 - endaa989df10b5bbc5fdf8f7f0b81767e86: - ; // match: (If cond yes no) // cond: // result: (NE (TESTB cond cond) yes no) - { + for { v := b.Control cond := v yes := b.Succs[0] @@ -16108,17 +13894,14 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end5bdbb8d5ea62ff2a76dccf3f9e89d94d - end5bdbb8d5ea62ff2a76dccf3f9e89d94d: - ; case BlockAMD64LE: // match: (LE (InvertFlags cmp) yes no) // cond: // result: (GE cmp yes no) - { + for { v := b.Control if v.Op != OpAMD64InvertFlags { - goto end0d49d7d087fe7578e8015cf13dae37e3 + break } cmp := v.Args[0] yes := b.Succs[0] @@ -16129,16 +13912,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end0d49d7d087fe7578e8015cf13dae37e3 - end0d49d7d087fe7578e8015cf13dae37e3: - ; // match: (LE (FlagEQ) yes no) // cond: // result: (First nil yes no) - { + for { v := b.Control if v.Op != OpAMD64FlagEQ { - goto end794469f5273ff9b2867ec900775c72d2 + break } yes := b.Succs[0] no := b.Succs[1] @@ -16148,16 +13928,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end794469f5273ff9b2867ec900775c72d2 - end794469f5273ff9b2867ec900775c72d2: - ; // match: (LE (FlagLT_ULT) yes no) // cond: // result: (First nil yes no) - { + for { v := b.Control if v.Op != OpAMD64FlagLT_ULT { - goto end0b9fee7a7eb47fe268039bc0e529d6ac + break } yes := b.Succs[0] no := b.Succs[1] @@ -16167,16 +13944,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end0b9fee7a7eb47fe268039bc0e529d6ac - end0b9fee7a7eb47fe268039bc0e529d6ac: - ; // match: (LE (FlagLT_UGT) yes no) // cond: // result: (First nil yes no) - { + for { v := b.Control if v.Op != OpAMD64FlagLT_UGT { - goto end519d8c93a652b9062fba49942dc7d28d + break } yes := b.Succs[0] no := b.Succs[1] @@ -16186,16 +13960,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end519d8c93a652b9062fba49942dc7d28d - end519d8c93a652b9062fba49942dc7d28d: - ; // match: (LE (FlagGT_ULT) yes no) // cond: // result: (First nil no yes) - { + for { v := b.Control if v.Op != OpAMD64FlagGT_ULT { - goto endbd11ec75f000579a43fd6507282b307d + break } yes := b.Succs[0] no := b.Succs[1] @@ -16206,16 +13977,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Likely *= -1 return true } - goto endbd11ec75f000579a43fd6507282b307d - endbd11ec75f000579a43fd6507282b307d: - ; // match: (LE (FlagGT_UGT) yes no) // cond: // result: (First nil no yes) - { + for { v := b.Control if v.Op != OpAMD64FlagGT_UGT { - goto end3828ab56cc3c548c96ac30592e5f865a + break } yes := b.Succs[0] no := b.Succs[1] @@ -16226,17 +13994,14 @@ func rewriteBlockAMD64(b *Block) bool { b.Likely *= -1 return true } - goto end3828ab56cc3c548c96ac30592e5f865a - end3828ab56cc3c548c96ac30592e5f865a: - ; case BlockAMD64LT: // match: (LT (InvertFlags cmp) yes no) // cond: // result: (GT cmp yes no) - { + for { v := b.Control if v.Op != OpAMD64InvertFlags { - goto end6a408cde0fee0ae7b7da0443c8d902bf + break } cmp := v.Args[0] yes := b.Succs[0] @@ -16247,16 +14012,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end6a408cde0fee0ae7b7da0443c8d902bf - end6a408cde0fee0ae7b7da0443c8d902bf: - ; // match: (LT (FlagEQ) yes no) // cond: // result: (First nil no yes) - { + for { v := b.Control if v.Op != OpAMD64FlagEQ { - goto enda9dfcd37198ce9684d4bb3a2e54feea9 + break } yes := b.Succs[0] no := b.Succs[1] @@ -16267,16 +14029,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Likely *= -1 return true } - goto enda9dfcd37198ce9684d4bb3a2e54feea9 - enda9dfcd37198ce9684d4bb3a2e54feea9: - ; // match: (LT (FlagLT_ULT) yes no) // cond: // result: (First nil yes no) - { + for { v := b.Control if v.Op != OpAMD64FlagLT_ULT { - goto ende2b678683d46e68bb0b1503f351917dc + break } yes := b.Succs[0] no := b.Succs[1] @@ -16286,16 +14045,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto ende2b678683d46e68bb0b1503f351917dc - ende2b678683d46e68bb0b1503f351917dc: - ; // match: (LT (FlagLT_UGT) yes no) // cond: // result: (First nil yes no) - { + for { v := b.Control if v.Op != OpAMD64FlagLT_UGT { - goto end24e744700aa56591fbd23e1335d6e293 + break } yes := b.Succs[0] no := b.Succs[1] @@ -16305,16 +14061,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end24e744700aa56591fbd23e1335d6e293 - end24e744700aa56591fbd23e1335d6e293: - ; // match: (LT (FlagGT_ULT) yes no) // cond: // result: (First nil no yes) - { + for { v := b.Control if v.Op != OpAMD64FlagGT_ULT { - goto enda178f2150e3da5c17e768a4f81af5f9a + break } yes := b.Succs[0] no := b.Succs[1] @@ -16325,16 +14078,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Likely *= -1 return true } - goto enda178f2150e3da5c17e768a4f81af5f9a - enda178f2150e3da5c17e768a4f81af5f9a: - ; // match: (LT (FlagGT_UGT) yes no) // cond: // result: (First nil no yes) - { + for { v := b.Control if v.Op != OpAMD64FlagGT_UGT { - goto end361a42127127ede8ea30e991bb099ebb + break } yes := b.Succs[0] no := b.Succs[1] @@ -16345,20 +14095,17 @@ func rewriteBlockAMD64(b *Block) bool { b.Likely *= -1 return true } - goto end361a42127127ede8ea30e991bb099ebb - end361a42127127ede8ea30e991bb099ebb: - ; case BlockAMD64NE: // match: (NE (TESTB (SETL cmp)) yes no) // cond: // result: (LT cmp yes no) - { + for { v := b.Control if v.Op != OpAMD64TESTB { - goto end0b9ca165d6b395de676eebef94bc62f7 + break } if v.Args[0].Op != OpAMD64SETL { - goto end0b9ca165d6b395de676eebef94bc62f7 + break } cmp := v.Args[0].Args[0] yes := b.Succs[0] @@ -16369,19 +14116,16 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end0b9ca165d6b395de676eebef94bc62f7 - end0b9ca165d6b395de676eebef94bc62f7: - ; // match: (NE (TESTB (SETLE cmp)) yes no) // cond: // result: (LE cmp yes no) - { + for { v := b.Control if v.Op != OpAMD64TESTB { - goto endaaba0ee4d0ff8c66a1c3107d2a14c4bc + break } if v.Args[0].Op != OpAMD64SETLE { - goto endaaba0ee4d0ff8c66a1c3107d2a14c4bc + break } cmp := v.Args[0].Args[0] yes := b.Succs[0] @@ -16392,19 +14136,16 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto endaaba0ee4d0ff8c66a1c3107d2a14c4bc - endaaba0ee4d0ff8c66a1c3107d2a14c4bc: - ; // match: (NE (TESTB (SETG cmp)) yes no) // cond: // result: (GT cmp yes no) - { + for { v := b.Control if v.Op != OpAMD64TESTB { - goto end1b689463137526b36ba9ceed1e76e512 + break } if v.Args[0].Op != OpAMD64SETG { - goto end1b689463137526b36ba9ceed1e76e512 + break } cmp := v.Args[0].Args[0] yes := b.Succs[0] @@ -16415,19 +14156,16 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end1b689463137526b36ba9ceed1e76e512 - end1b689463137526b36ba9ceed1e76e512: - ; // match: (NE (TESTB (SETGE cmp)) yes no) // cond: // result: (GE cmp yes no) - { + for { v := b.Control if v.Op != OpAMD64TESTB { - goto end99eefee595c658b997f41577ed853c2e + break } if v.Args[0].Op != OpAMD64SETGE { - goto end99eefee595c658b997f41577ed853c2e + break } cmp := v.Args[0].Args[0] yes := b.Succs[0] @@ -16438,19 +14176,16 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end99eefee595c658b997f41577ed853c2e - end99eefee595c658b997f41577ed853c2e: - ; // match: (NE (TESTB (SETEQ cmp)) yes no) // cond: // result: (EQ cmp yes no) - { + for { v := b.Control if v.Op != OpAMD64TESTB { - goto end371b67d3d63e9b92d848b09c3324e8b9 + break } if v.Args[0].Op != OpAMD64SETEQ { - goto end371b67d3d63e9b92d848b09c3324e8b9 + break } cmp := v.Args[0].Args[0] yes := b.Succs[0] @@ -16461,19 +14196,16 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end371b67d3d63e9b92d848b09c3324e8b9 - end371b67d3d63e9b92d848b09c3324e8b9: - ; // match: (NE (TESTB (SETNE cmp)) yes no) // cond: // result: (NE cmp yes no) - { + for { v := b.Control if v.Op != OpAMD64TESTB { - goto endd245f2aac2191d32e57cd2e321daa453 + break } if v.Args[0].Op != OpAMD64SETNE { - goto endd245f2aac2191d32e57cd2e321daa453 + break } cmp := v.Args[0].Args[0] yes := b.Succs[0] @@ -16484,19 +14216,16 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto endd245f2aac2191d32e57cd2e321daa453 - endd245f2aac2191d32e57cd2e321daa453: - ; // match: (NE (TESTB (SETB cmp)) yes no) // cond: // result: (ULT cmp yes no) - { + for { v := b.Control if v.Op != OpAMD64TESTB { - goto end90c4bec851e734d37457d611b1a5ff28 + break } if v.Args[0].Op != OpAMD64SETB { - goto end90c4bec851e734d37457d611b1a5ff28 + break } cmp := v.Args[0].Args[0] yes := b.Succs[0] @@ -16507,19 +14236,16 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end90c4bec851e734d37457d611b1a5ff28 - end90c4bec851e734d37457d611b1a5ff28: - ; // match: (NE (TESTB (SETBE cmp)) yes no) // cond: // result: (ULE cmp yes no) - { + for { v := b.Control if v.Op != OpAMD64TESTB { - goto end3a68a28114e9b89ee0708823386bc1ee + break } if v.Args[0].Op != OpAMD64SETBE { - goto end3a68a28114e9b89ee0708823386bc1ee + break } cmp := v.Args[0].Args[0] yes := b.Succs[0] @@ -16530,19 +14256,16 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end3a68a28114e9b89ee0708823386bc1ee - end3a68a28114e9b89ee0708823386bc1ee: - ; // match: (NE (TESTB (SETA cmp)) yes no) // cond: // result: (UGT cmp yes no) - { + for { v := b.Control if v.Op != OpAMD64TESTB { - goto end16496f57185756e960d536b057c776c0 + break } if v.Args[0].Op != OpAMD64SETA { - goto end16496f57185756e960d536b057c776c0 + break } cmp := v.Args[0].Args[0] yes := b.Succs[0] @@ -16553,19 +14276,16 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end16496f57185756e960d536b057c776c0 - end16496f57185756e960d536b057c776c0: - ; // match: (NE (TESTB (SETAE cmp)) yes no) // cond: // result: (UGE cmp yes no) - { + for { v := b.Control if v.Op != OpAMD64TESTB { - goto endbd122fd599aeb9e60881a0fa735e2fde + break } if v.Args[0].Op != OpAMD64SETAE { - goto endbd122fd599aeb9e60881a0fa735e2fde + break } cmp := v.Args[0].Args[0] yes := b.Succs[0] @@ -16576,19 +14296,16 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto endbd122fd599aeb9e60881a0fa735e2fde - endbd122fd599aeb9e60881a0fa735e2fde: - ; // match: (NE (TESTB (SETGF cmp)) yes no) // cond: // result: (UGT cmp yes no) - { + for { v := b.Control if v.Op != OpAMD64TESTB { - goto endb2499521f7f351e24757f8c918c3598e + break } if v.Args[0].Op != OpAMD64SETGF { - goto endb2499521f7f351e24757f8c918c3598e + break } cmp := v.Args[0].Args[0] yes := b.Succs[0] @@ -16599,19 +14316,16 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto endb2499521f7f351e24757f8c918c3598e - endb2499521f7f351e24757f8c918c3598e: - ; // match: (NE (TESTB (SETGEF cmp)) yes no) // cond: // result: (UGE cmp yes no) - { + for { v := b.Control if v.Op != OpAMD64TESTB { - goto end20461774babea665c4ca7c4f790a7209 + break } if v.Args[0].Op != OpAMD64SETGEF { - goto end20461774babea665c4ca7c4f790a7209 + break } cmp := v.Args[0].Args[0] yes := b.Succs[0] @@ -16622,19 +14336,16 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end20461774babea665c4ca7c4f790a7209 - end20461774babea665c4ca7c4f790a7209: - ; // match: (NE (TESTB (SETEQF cmp)) yes no) // cond: // result: (EQF cmp yes no) - { + for { v := b.Control if v.Op != OpAMD64TESTB { - goto end236616ef13d489b78736cda7bcc1d168 + break } if v.Args[0].Op != OpAMD64SETEQF { - goto end236616ef13d489b78736cda7bcc1d168 + break } cmp := v.Args[0].Args[0] yes := b.Succs[0] @@ -16645,19 +14356,16 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end236616ef13d489b78736cda7bcc1d168 - end236616ef13d489b78736cda7bcc1d168: - ; // match: (NE (TESTB (SETNEF cmp)) yes no) // cond: // result: (NEF cmp yes no) - { + for { v := b.Control if v.Op != OpAMD64TESTB { - goto endc992f3c266b16cb5f6aa98faa8f55600 + break } if v.Args[0].Op != OpAMD64SETNEF { - goto endc992f3c266b16cb5f6aa98faa8f55600 + break } cmp := v.Args[0].Args[0] yes := b.Succs[0] @@ -16668,16 +14376,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto endc992f3c266b16cb5f6aa98faa8f55600 - endc992f3c266b16cb5f6aa98faa8f55600: - ; // match: (NE (InvertFlags cmp) yes no) // cond: // result: (NE cmp yes no) - { + for { v := b.Control if v.Op != OpAMD64InvertFlags { - goto end713001aba794e50b582fbff930e110af + break } cmp := v.Args[0] yes := b.Succs[0] @@ -16688,16 +14393,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end713001aba794e50b582fbff930e110af - end713001aba794e50b582fbff930e110af: - ; // match: (NE (FlagEQ) yes no) // cond: // result: (First nil no yes) - { + for { v := b.Control if v.Op != OpAMD64FlagEQ { - goto end55cc491bc7fc08ef27cadaa80d197545 + break } yes := b.Succs[0] no := b.Succs[1] @@ -16708,16 +14410,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Likely *= -1 return true } - goto end55cc491bc7fc08ef27cadaa80d197545 - end55cc491bc7fc08ef27cadaa80d197545: - ; // match: (NE (FlagLT_ULT) yes no) // cond: // result: (First nil yes no) - { + for { v := b.Control if v.Op != OpAMD64FlagLT_ULT { - goto end3293c7b37d9fcc6bd5add16c94108a4b + break } yes := b.Succs[0] no := b.Succs[1] @@ -16727,16 +14426,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end3293c7b37d9fcc6bd5add16c94108a4b - end3293c7b37d9fcc6bd5add16c94108a4b: - ; // match: (NE (FlagLT_UGT) yes no) // cond: // result: (First nil yes no) - { + for { v := b.Control if v.Op != OpAMD64FlagLT_UGT { - goto end1a49ef88420e9d7fd745f9675ca01d6e + break } yes := b.Succs[0] no := b.Succs[1] @@ -16746,16 +14442,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end1a49ef88420e9d7fd745f9675ca01d6e - end1a49ef88420e9d7fd745f9675ca01d6e: - ; // match: (NE (FlagGT_ULT) yes no) // cond: // result: (First nil yes no) - { + for { v := b.Control if v.Op != OpAMD64FlagGT_ULT { - goto endbd468825bdf21bca47f8d83d580794ec + break } yes := b.Succs[0] no := b.Succs[1] @@ -16765,16 +14458,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto endbd468825bdf21bca47f8d83d580794ec - endbd468825bdf21bca47f8d83d580794ec: - ; // match: (NE (FlagGT_UGT) yes no) // cond: // result: (First nil yes no) - { + for { v := b.Control if v.Op != OpAMD64FlagGT_UGT { - goto end43cf7171afb4610818c4b63cc14c1f30 + break } yes := b.Succs[0] no := b.Succs[1] @@ -16784,17 +14474,14 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end43cf7171afb4610818c4b63cc14c1f30 - end43cf7171afb4610818c4b63cc14c1f30: - ; case BlockAMD64UGE: // match: (UGE (InvertFlags cmp) yes no) // cond: // result: (ULE cmp yes no) - { + for { v := b.Control if v.Op != OpAMD64InvertFlags { - goto ende3e4ddc183ca1a46598b11c2d0d13966 + break } cmp := v.Args[0] yes := b.Succs[0] @@ -16805,16 +14492,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto ende3e4ddc183ca1a46598b11c2d0d13966 - ende3e4ddc183ca1a46598b11c2d0d13966: - ; // match: (UGE (FlagEQ) yes no) // cond: // result: (First nil yes no) - { + for { v := b.Control if v.Op != OpAMD64FlagEQ { - goto end13b873811b0cfc7b08501fa2b96cbaa5 + break } yes := b.Succs[0] no := b.Succs[1] @@ -16824,16 +14508,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end13b873811b0cfc7b08501fa2b96cbaa5 - end13b873811b0cfc7b08501fa2b96cbaa5: - ; // match: (UGE (FlagLT_ULT) yes no) // cond: // result: (First nil no yes) - { + for { v := b.Control if v.Op != OpAMD64FlagLT_ULT { - goto end399c10dc3dcdb5864558ecbac4566b7d + break } yes := b.Succs[0] no := b.Succs[1] @@ -16844,16 +14525,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Likely *= -1 return true } - goto end399c10dc3dcdb5864558ecbac4566b7d - end399c10dc3dcdb5864558ecbac4566b7d: - ; // match: (UGE (FlagLT_UGT) yes no) // cond: // result: (First nil yes no) - { + for { v := b.Control if v.Op != OpAMD64FlagLT_UGT { - goto end3013dbd3841b20b5030bafb98ee5e38f + break } yes := b.Succs[0] no := b.Succs[1] @@ -16863,16 +14541,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end3013dbd3841b20b5030bafb98ee5e38f - end3013dbd3841b20b5030bafb98ee5e38f: - ; // match: (UGE (FlagGT_ULT) yes no) // cond: // result: (First nil no yes) - { + for { v := b.Control if v.Op != OpAMD64FlagGT_ULT { - goto end9727eb4bb399457be62dc382bb9a0913 + break } yes := b.Succs[0] no := b.Succs[1] @@ -16883,16 +14558,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Likely *= -1 return true } - goto end9727eb4bb399457be62dc382bb9a0913 - end9727eb4bb399457be62dc382bb9a0913: - ; // match: (UGE (FlagGT_UGT) yes no) // cond: // result: (First nil yes no) - { + for { v := b.Control if v.Op != OpAMD64FlagGT_UGT { - goto ende4099f954bd6511668fda560c56e89b1 + break } yes := b.Succs[0] no := b.Succs[1] @@ -16902,17 +14574,14 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto ende4099f954bd6511668fda560c56e89b1 - ende4099f954bd6511668fda560c56e89b1: - ; case BlockAMD64UGT: // match: (UGT (InvertFlags cmp) yes no) // cond: // result: (ULT cmp yes no) - { + for { v := b.Control if v.Op != OpAMD64InvertFlags { - goto end49818853af2e5251175d06c62768cae7 + break } cmp := v.Args[0] yes := b.Succs[0] @@ -16923,16 +14592,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end49818853af2e5251175d06c62768cae7 - end49818853af2e5251175d06c62768cae7: - ; // match: (UGT (FlagEQ) yes no) // cond: // result: (First nil no yes) - { + for { v := b.Control if v.Op != OpAMD64FlagEQ { - goto end97e91c3348cb91e9278902aaa7fb050a + break } yes := b.Succs[0] no := b.Succs[1] @@ -16943,16 +14609,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Likely *= -1 return true } - goto end97e91c3348cb91e9278902aaa7fb050a - end97e91c3348cb91e9278902aaa7fb050a: - ; // match: (UGT (FlagLT_ULT) yes no) // cond: // result: (First nil no yes) - { + for { v := b.Control if v.Op != OpAMD64FlagLT_ULT { - goto ende2c57da783c6ad18203c9c418ab0de6a + break } yes := b.Succs[0] no := b.Succs[1] @@ -16963,16 +14626,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Likely *= -1 return true } - goto ende2c57da783c6ad18203c9c418ab0de6a - ende2c57da783c6ad18203c9c418ab0de6a: - ; // match: (UGT (FlagLT_UGT) yes no) // cond: // result: (First nil yes no) - { + for { v := b.Control if v.Op != OpAMD64FlagLT_UGT { - goto end65100b76cf3975a42b235b0e10fea2b1 + break } yes := b.Succs[0] no := b.Succs[1] @@ -16982,16 +14642,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end65100b76cf3975a42b235b0e10fea2b1 - end65100b76cf3975a42b235b0e10fea2b1: - ; // match: (UGT (FlagGT_ULT) yes no) // cond: // result: (First nil no yes) - { + for { v := b.Control if v.Op != OpAMD64FlagGT_ULT { - goto end5db8fa9a32980847176e980aa1899bb3 + break } yes := b.Succs[0] no := b.Succs[1] @@ -17002,16 +14659,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Likely *= -1 return true } - goto end5db8fa9a32980847176e980aa1899bb3 - end5db8fa9a32980847176e980aa1899bb3: - ; // match: (UGT (FlagGT_UGT) yes no) // cond: // result: (First nil yes no) - { + for { v := b.Control if v.Op != OpAMD64FlagGT_UGT { - goto end1095a388cf1534294952f4ef4ce3e940 + break } yes := b.Succs[0] no := b.Succs[1] @@ -17021,17 +14675,14 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end1095a388cf1534294952f4ef4ce3e940 - end1095a388cf1534294952f4ef4ce3e940: - ; case BlockAMD64ULE: // match: (ULE (InvertFlags cmp) yes no) // cond: // result: (UGE cmp yes no) - { + for { v := b.Control if v.Op != OpAMD64InvertFlags { - goto endd6698aac0d67261293b558c95ea17b4f + break } cmp := v.Args[0] yes := b.Succs[0] @@ -17042,16 +14693,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto endd6698aac0d67261293b558c95ea17b4f - endd6698aac0d67261293b558c95ea17b4f: - ; // match: (ULE (FlagEQ) yes no) // cond: // result: (First nil yes no) - { + for { v := b.Control if v.Op != OpAMD64FlagEQ { - goto end2d801e9ad76753e9ff3e19ee7c9f8a86 + break } yes := b.Succs[0] no := b.Succs[1] @@ -17061,16 +14709,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end2d801e9ad76753e9ff3e19ee7c9f8a86 - end2d801e9ad76753e9ff3e19ee7c9f8a86: - ; // match: (ULE (FlagLT_ULT) yes no) // cond: // result: (First nil yes no) - { + for { v := b.Control if v.Op != OpAMD64FlagLT_ULT { - goto end93b751a70b8587ce2c2dc0545a77246c + break } yes := b.Succs[0] no := b.Succs[1] @@ -17080,16 +14725,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end93b751a70b8587ce2c2dc0545a77246c - end93b751a70b8587ce2c2dc0545a77246c: - ; // match: (ULE (FlagLT_UGT) yes no) // cond: // result: (First nil no yes) - { + for { v := b.Control if v.Op != OpAMD64FlagLT_UGT { - goto enda318623645491582b19f9de9b3da20e9 + break } yes := b.Succs[0] no := b.Succs[1] @@ -17100,16 +14742,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Likely *= -1 return true } - goto enda318623645491582b19f9de9b3da20e9 - enda318623645491582b19f9de9b3da20e9: - ; // match: (ULE (FlagGT_ULT) yes no) // cond: // result: (First nil yes no) - { + for { v := b.Control if v.Op != OpAMD64FlagGT_ULT { - goto end1dfb9e417c0a518e1fa9c92edd57723e + break } yes := b.Succs[0] no := b.Succs[1] @@ -17119,16 +14758,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end1dfb9e417c0a518e1fa9c92edd57723e - end1dfb9e417c0a518e1fa9c92edd57723e: - ; // match: (ULE (FlagGT_UGT) yes no) // cond: // result: (First nil no yes) - { + for { v := b.Control if v.Op != OpAMD64FlagGT_UGT { - goto end7c9881aac5c0b34d8df3572c8f7b50f3 + break } yes := b.Succs[0] no := b.Succs[1] @@ -17139,17 +14775,14 @@ func rewriteBlockAMD64(b *Block) bool { b.Likely *= -1 return true } - goto end7c9881aac5c0b34d8df3572c8f7b50f3 - end7c9881aac5c0b34d8df3572c8f7b50f3: - ; case BlockAMD64ULT: // match: (ULT (InvertFlags cmp) yes no) // cond: // result: (UGT cmp yes no) - { + for { v := b.Control if v.Op != OpAMD64InvertFlags { - goto end35105dbc9646f02577167e45ae2f2fd2 + break } cmp := v.Args[0] yes := b.Succs[0] @@ -17160,16 +14793,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end35105dbc9646f02577167e45ae2f2fd2 - end35105dbc9646f02577167e45ae2f2fd2: - ; // match: (ULT (FlagEQ) yes no) // cond: // result: (First nil no yes) - { + for { v := b.Control if v.Op != OpAMD64FlagEQ { - goto end4f7ea32f328981623154b68f21c9585f + break } yes := b.Succs[0] no := b.Succs[1] @@ -17180,16 +14810,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Likely *= -1 return true } - goto end4f7ea32f328981623154b68f21c9585f - end4f7ea32f328981623154b68f21c9585f: - ; // match: (ULT (FlagLT_ULT) yes no) // cond: // result: (First nil yes no) - { + for { v := b.Control if v.Op != OpAMD64FlagLT_ULT { - goto endf8739cbf4e7cdcb02b891bbfc103654a + break } yes := b.Succs[0] no := b.Succs[1] @@ -17199,16 +14826,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto endf8739cbf4e7cdcb02b891bbfc103654a - endf8739cbf4e7cdcb02b891bbfc103654a: - ; // match: (ULT (FlagLT_UGT) yes no) // cond: // result: (First nil no yes) - { + for { v := b.Control if v.Op != OpAMD64FlagLT_UGT { - goto enddb12a8de4bdb237aa8a1b6186a0f5f01 + break } yes := b.Succs[0] no := b.Succs[1] @@ -17219,16 +14843,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Likely *= -1 return true } - goto enddb12a8de4bdb237aa8a1b6186a0f5f01 - enddb12a8de4bdb237aa8a1b6186a0f5f01: - ; // match: (ULT (FlagGT_ULT) yes no) // cond: // result: (First nil yes no) - { + for { v := b.Control if v.Op != OpAMD64FlagGT_ULT { - goto end5ceb130f54533e645b6be48ac28dd7a1 + break } yes := b.Succs[0] no := b.Succs[1] @@ -17238,16 +14859,13 @@ func rewriteBlockAMD64(b *Block) bool { b.Succs[1] = no return true } - goto end5ceb130f54533e645b6be48ac28dd7a1 - end5ceb130f54533e645b6be48ac28dd7a1: - ; // match: (ULT (FlagGT_UGT) yes no) // cond: // result: (First nil no yes) - { + for { v := b.Control if v.Op != OpAMD64FlagGT_UGT { - goto end17191a994592b633cbf6f935efbeaf72 + break } yes := b.Succs[0] no := b.Succs[1] @@ -17258,8 +14876,6 @@ func rewriteBlockAMD64(b *Block) bool { b.Likely *= -1 return true } - goto end17191a994592b633cbf6f935efbeaf72 - end17191a994592b633cbf6f935efbeaf72: } return false } diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index 505ea77457..0c091c7a32 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -302,34 +302,31 @@ func rewriteValuegeneric_OpAdd16(v *Value, config *Config) bool { // match: (Add16 (Const16 [c]) (Const16 [d])) // cond: // result: (Const16 [c+d]) - { + for { if v.Args[0].Op != OpConst16 { - goto end359c546ef662b7990116329cb30d6892 + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst16 { - goto end359c546ef662b7990116329cb30d6892 + break } d := v.Args[1].AuxInt v.reset(OpConst16) v.AuxInt = c + d return true } - goto end359c546ef662b7990116329cb30d6892 -end359c546ef662b7990116329cb30d6892: - ; // match: (Add16 x (Const16 [c])) // cond: x.Op != OpConst16 // result: (Add16 (Const16 [c]) x) - { + for { x := v.Args[0] if v.Args[1].Op != OpConst16 { - goto end89b69a89778f375b0ebbc683b0c63176 + break } t := v.Args[1].Type c := v.Args[1].AuxInt if !(x.Op != OpConst16) { - goto end89b69a89778f375b0ebbc683b0c63176 + break } v.reset(OpAdd16) v0 := b.NewValue0(v.Line, OpConst16, t) @@ -338,9 +335,6 @@ end359c546ef662b7990116329cb30d6892: v.AddArg(x) return true } - goto end89b69a89778f375b0ebbc683b0c63176 -end89b69a89778f375b0ebbc683b0c63176: - ; return false } func rewriteValuegeneric_OpAdd32(v *Value, config *Config) bool { @@ -349,34 +343,31 @@ func rewriteValuegeneric_OpAdd32(v *Value, config *Config) bool { // match: (Add32 (Const32 [c]) (Const32 [d])) // cond: // result: (Const32 [c+d]) - { + for { if v.Args[0].Op != OpConst32 { - goto enda3edaa9a512bd1d7a95f002c890bfb88 + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst32 { - goto enda3edaa9a512bd1d7a95f002c890bfb88 + break } d := v.Args[1].AuxInt v.reset(OpConst32) v.AuxInt = c + d return true } - goto enda3edaa9a512bd1d7a95f002c890bfb88 -enda3edaa9a512bd1d7a95f002c890bfb88: - ; // match: (Add32 x (Const32 [c])) // cond: x.Op != OpConst32 // result: (Add32 (Const32 [c]) x) - { + for { x := v.Args[0] if v.Args[1].Op != OpConst32 { - goto end28a8c474bfa6968950dce0ed73b14a0b + break } t := v.Args[1].Type c := v.Args[1].AuxInt if !(x.Op != OpConst32) { - goto end28a8c474bfa6968950dce0ed73b14a0b + break } v.reset(OpAdd32) v0 := b.NewValue0(v.Line, OpConst32, t) @@ -385,9 +376,6 @@ enda3edaa9a512bd1d7a95f002c890bfb88: v.AddArg(x) return true } - goto end28a8c474bfa6968950dce0ed73b14a0b -end28a8c474bfa6968950dce0ed73b14a0b: - ; return false } func rewriteValuegeneric_OpAdd64(v *Value, config *Config) bool { @@ -396,34 +384,31 @@ func rewriteValuegeneric_OpAdd64(v *Value, config *Config) bool { // match: (Add64 (Const64 [c]) (Const64 [d])) // cond: // result: (Const64 [c+d]) - { + for { if v.Args[0].Op != OpConst64 { - goto end8c46df6f85a11cb1d594076b0e467908 + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst64 { - goto end8c46df6f85a11cb1d594076b0e467908 + break } d := v.Args[1].AuxInt v.reset(OpConst64) v.AuxInt = c + d return true } - goto end8c46df6f85a11cb1d594076b0e467908 -end8c46df6f85a11cb1d594076b0e467908: - ; // match: (Add64 x (Const64 [c])) // cond: x.Op != OpConst64 // result: (Add64 (Const64 [c]) x) - { + for { x := v.Args[0] if v.Args[1].Op != OpConst64 { - goto end39caa6cf1044f5c47ddbeb062d1a13bd + break } t := v.Args[1].Type c := v.Args[1].AuxInt if !(x.Op != OpConst64) { - goto end39caa6cf1044f5c47ddbeb062d1a13bd + break } v.reset(OpAdd64) v0 := b.NewValue0(v.Line, OpConst64, t) @@ -432,9 +417,6 @@ end8c46df6f85a11cb1d594076b0e467908: v.AddArg(x) return true } - goto end39caa6cf1044f5c47ddbeb062d1a13bd -end39caa6cf1044f5c47ddbeb062d1a13bd: - ; return false } func rewriteValuegeneric_OpAdd8(v *Value, config *Config) bool { @@ -443,34 +425,31 @@ func rewriteValuegeneric_OpAdd8(v *Value, config *Config) bool { // match: (Add8 (Const8 [c]) (Const8 [d])) // cond: // result: (Const8 [c+d]) - { + for { if v.Args[0].Op != OpConst8 { - goto end60c66721511a442aade8e4da2fb326bd + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst8 { - goto end60c66721511a442aade8e4da2fb326bd + break } d := v.Args[1].AuxInt v.reset(OpConst8) v.AuxInt = c + d return true } - goto end60c66721511a442aade8e4da2fb326bd -end60c66721511a442aade8e4da2fb326bd: - ; // match: (Add8 x (Const8 [c])) // cond: x.Op != OpConst8 // result: (Add8 (Const8 [c]) x) - { + for { x := v.Args[0] if v.Args[1].Op != OpConst8 { - goto end8c2901b8d12fa5c37f190783b4db8df5 + break } t := v.Args[1].Type c := v.Args[1].AuxInt if !(x.Op != OpConst8) { - goto end8c2901b8d12fa5c37f190783b4db8df5 + break } v.reset(OpAdd8) v0 := b.NewValue0(v.Line, OpConst8, t) @@ -479,9 +458,6 @@ end60c66721511a442aade8e4da2fb326bd: v.AddArg(x) return true } - goto end8c2901b8d12fa5c37f190783b4db8df5 -end8c2901b8d12fa5c37f190783b4db8df5: - ; return false } func rewriteValuegeneric_OpAnd16(v *Value, config *Config) bool { @@ -490,19 +466,16 @@ func rewriteValuegeneric_OpAnd16(v *Value, config *Config) bool { // match: (And16 x x) // cond: // result: x - { + for { x := v.Args[0] if v.Args[1] != x { - goto end69ed6ee2a4fb0491b56c17f3c1926b10 + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto end69ed6ee2a4fb0491b56c17f3c1926b10 -end69ed6ee2a4fb0491b56c17f3c1926b10: - ; return false } func rewriteValuegeneric_OpAnd32(v *Value, config *Config) bool { @@ -511,19 +484,16 @@ func rewriteValuegeneric_OpAnd32(v *Value, config *Config) bool { // match: (And32 x x) // cond: // result: x - { + for { x := v.Args[0] if v.Args[1] != x { - goto endbbe8c3c5b2ca8f013aa178d856f3a99c + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto endbbe8c3c5b2ca8f013aa178d856f3a99c -endbbe8c3c5b2ca8f013aa178d856f3a99c: - ; return false } func rewriteValuegeneric_OpAnd64(v *Value, config *Config) bool { @@ -532,19 +502,16 @@ func rewriteValuegeneric_OpAnd64(v *Value, config *Config) bool { // match: (And64 x x) // cond: // result: x - { + for { x := v.Args[0] if v.Args[1] != x { - goto endc9736bf24d2e5cd8d662e1bcf3164640 + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto endc9736bf24d2e5cd8d662e1bcf3164640 -endc9736bf24d2e5cd8d662e1bcf3164640: - ; return false } func rewriteValuegeneric_OpAnd8(v *Value, config *Config) bool { @@ -553,19 +520,16 @@ func rewriteValuegeneric_OpAnd8(v *Value, config *Config) bool { // match: (And8 x x) // cond: // result: x - { + for { x := v.Args[0] if v.Args[1] != x { - goto endeaf127389bd0d4b0e0e297830f8f463b + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto endeaf127389bd0d4b0e0e297830f8f463b -endeaf127389bd0d4b0e0e297830f8f463b: - ; return false } func rewriteValuegeneric_OpArg(v *Value, config *Config) bool { @@ -574,11 +538,11 @@ func rewriteValuegeneric_OpArg(v *Value, config *Config) bool { // match: (Arg {n} [off]) // cond: v.Type.IsString() // result: (StringMake (Arg {n} [off]) (Arg {n} [off+config.PtrSize])) - { + for { n := v.Aux off := v.AuxInt if !(v.Type.IsString()) { - goto end939d3f946bf61eb85b46b374e7afa9e9 + break } v.reset(OpStringMake) v0 := b.NewValue0(v.Line, OpArg, config.fe.TypeBytePtr()) @@ -591,17 +555,14 @@ func rewriteValuegeneric_OpArg(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto end939d3f946bf61eb85b46b374e7afa9e9 -end939d3f946bf61eb85b46b374e7afa9e9: - ; // match: (Arg {n} [off]) // cond: v.Type.IsSlice() // result: (SliceMake (Arg {n} [off]) (Arg {n} [off+config.PtrSize]) (Arg {n} [off+2*config.PtrSize])) - { + for { n := v.Aux off := v.AuxInt if !(v.Type.IsSlice()) { - goto endab4b93ad3b1cf55e5bf25d1fd9cd498e + break } v.reset(OpSliceMake) v0 := b.NewValue0(v.Line, OpArg, config.fe.TypeBytePtr()) @@ -618,17 +579,14 @@ end939d3f946bf61eb85b46b374e7afa9e9: v.AddArg(v2) return true } - goto endab4b93ad3b1cf55e5bf25d1fd9cd498e -endab4b93ad3b1cf55e5bf25d1fd9cd498e: - ; // match: (Arg {n} [off]) // cond: v.Type.IsInterface() // result: (IMake (Arg {n} [off]) (Arg {n} [off+config.PtrSize])) - { + for { n := v.Aux off := v.AuxInt if !(v.Type.IsInterface()) { - goto end851de8e588a39e81b4e2aef06566bf3e + break } v.reset(OpIMake) v0 := b.NewValue0(v.Line, OpArg, config.fe.TypeBytePtr()) @@ -641,17 +599,14 @@ endab4b93ad3b1cf55e5bf25d1fd9cd498e: v.AddArg(v1) return true } - goto end851de8e588a39e81b4e2aef06566bf3e -end851de8e588a39e81b4e2aef06566bf3e: - ; // match: (Arg {n} [off]) // cond: v.Type.IsComplex() && v.Type.Size() == 16 // result: (ComplexMake (Arg {n} [off]) (Arg {n} [off+8])) - { + for { n := v.Aux off := v.AuxInt if !(v.Type.IsComplex() && v.Type.Size() == 16) { - goto end0988fc6a62c810b2f4976cb6cf44387f + break } v.reset(OpComplexMake) v0 := b.NewValue0(v.Line, OpArg, config.fe.TypeFloat64()) @@ -664,17 +619,14 @@ end851de8e588a39e81b4e2aef06566bf3e: v.AddArg(v1) return true } - goto end0988fc6a62c810b2f4976cb6cf44387f -end0988fc6a62c810b2f4976cb6cf44387f: - ; // match: (Arg {n} [off]) // cond: v.Type.IsComplex() && v.Type.Size() == 8 // result: (ComplexMake (Arg {n} [off]) (Arg {n} [off+4])) - { + for { n := v.Aux off := v.AuxInt if !(v.Type.IsComplex() && v.Type.Size() == 8) { - goto enda348e93e0036873dd7089a2939c22e3e + break } v.reset(OpComplexMake) v0 := b.NewValue0(v.Line, OpArg, config.fe.TypeFloat32()) @@ -687,32 +639,26 @@ end0988fc6a62c810b2f4976cb6cf44387f: v.AddArg(v1) return true } - goto enda348e93e0036873dd7089a2939c22e3e -enda348e93e0036873dd7089a2939c22e3e: - ; // match: (Arg ) // 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)) { - goto ende233eeefa826638b0e541bcca531d701 + break } v.reset(OpStructMake0) return true } - goto ende233eeefa826638b0e541bcca531d701 -ende233eeefa826638b0e541bcca531d701: - ; // match: (Arg {n} [off]) // cond: t.IsStruct() && t.NumFields() == 1 && config.fe.CanSSA(t) // result: (StructMake1 (Arg {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)) { - goto ende953e77a0617051dd3f7ad4d58c9ab37 + break } v.reset(OpStructMake1) v0 := b.NewValue0(v.Line, OpArg, t.FieldType(0)) @@ -721,18 +667,15 @@ ende233eeefa826638b0e541bcca531d701: v.AddArg(v0) return true } - goto ende953e77a0617051dd3f7ad4d58c9ab37 -ende953e77a0617051dd3f7ad4d58c9ab37: - ; // match: (Arg {n} [off]) // cond: t.IsStruct() && t.NumFields() == 2 && config.fe.CanSSA(t) // result: (StructMake2 (Arg {n} [off+t.FieldOff(0)]) (Arg {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)) { - goto end9a008048978aabad9de0723212e60631 + break } v.reset(OpStructMake2) v0 := b.NewValue0(v.Line, OpArg, t.FieldType(0)) @@ -745,18 +688,15 @@ ende953e77a0617051dd3f7ad4d58c9ab37: v.AddArg(v1) return true } - goto end9a008048978aabad9de0723212e60631 -end9a008048978aabad9de0723212e60631: - ; // match: (Arg {n} [off]) // cond: t.IsStruct() && t.NumFields() == 3 && config.fe.CanSSA(t) // result: (StructMake3 (Arg {n} [off+t.FieldOff(0)]) (Arg {n} [off+t.FieldOff(1)]) (Arg {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)) { - goto end0196e61dbeebc6402f3aa1e9a182210b + break } v.reset(OpStructMake3) v0 := b.NewValue0(v.Line, OpArg, t.FieldType(0)) @@ -773,18 +713,15 @@ end9a008048978aabad9de0723212e60631: v.AddArg(v2) return true } - goto end0196e61dbeebc6402f3aa1e9a182210b -end0196e61dbeebc6402f3aa1e9a182210b: - ; // match: (Arg {n} [off]) // cond: t.IsStruct() && t.NumFields() == 4 && config.fe.CanSSA(t) // result: (StructMake4 (Arg {n} [off+t.FieldOff(0)]) (Arg {n} [off+t.FieldOff(1)]) (Arg {n} [off+t.FieldOff(2)]) (Arg {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)) { - goto end6bc133c93e50cb14c2e6cc9401850738 + break } v.reset(OpStructMake4) v0 := b.NewValue0(v.Line, OpArg, t.FieldType(0)) @@ -805,9 +742,6 @@ end0196e61dbeebc6402f3aa1e9a182210b: v.AddArg(v3) return true } - goto end6bc133c93e50cb14c2e6cc9401850738 -end6bc133c93e50cb14c2e6cc9401850738: - ; return false } func rewriteValuegeneric_OpArrayIndex(v *Value, config *Config) bool { @@ -816,15 +750,15 @@ func rewriteValuegeneric_OpArrayIndex(v *Value, config *Config) bool { // match: (ArrayIndex (Load ptr mem) idx) // cond: b == v.Args[0].Block // result: (Load (PtrIndex ptr idx) mem) - { + for { if v.Args[0].Op != OpLoad { - goto end68b373270d9d605c420497edefaa71df + break } ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] idx := v.Args[1] if !(b == v.Args[0].Block) { - goto end68b373270d9d605c420497edefaa71df + break } v.reset(OpLoad) v0 := b.NewValue0(v.Line, OpPtrIndex, v.Type.PtrTo()) @@ -834,9 +768,6 @@ func rewriteValuegeneric_OpArrayIndex(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto end68b373270d9d605c420497edefaa71df -end68b373270d9d605c420497edefaa71df: - ; return false } func rewriteValuegeneric_OpCom16(v *Value, config *Config) bool { @@ -845,9 +776,9 @@ func rewriteValuegeneric_OpCom16(v *Value, config *Config) bool { // match: (Com16 (Com16 x)) // cond: // result: x - { + for { if v.Args[0].Op != OpCom16 { - goto end1ea17710dd4dd7ba4e710e0e4c7b5a56 + break } x := v.Args[0].Args[0] v.reset(OpCopy) @@ -855,9 +786,6 @@ func rewriteValuegeneric_OpCom16(v *Value, config *Config) bool { v.AddArg(x) return true } - goto end1ea17710dd4dd7ba4e710e0e4c7b5a56 -end1ea17710dd4dd7ba4e710e0e4c7b5a56: - ; return false } func rewriteValuegeneric_OpCom32(v *Value, config *Config) bool { @@ -866,9 +794,9 @@ func rewriteValuegeneric_OpCom32(v *Value, config *Config) bool { // match: (Com32 (Com32 x)) // cond: // result: x - { + for { if v.Args[0].Op != OpCom32 { - goto end9a04ed536496e292c27bef4414128cbf + break } x := v.Args[0].Args[0] v.reset(OpCopy) @@ -876,9 +804,6 @@ func rewriteValuegeneric_OpCom32(v *Value, config *Config) bool { v.AddArg(x) return true } - goto end9a04ed536496e292c27bef4414128cbf -end9a04ed536496e292c27bef4414128cbf: - ; return false } func rewriteValuegeneric_OpCom64(v *Value, config *Config) bool { @@ -887,9 +812,9 @@ func rewriteValuegeneric_OpCom64(v *Value, config *Config) bool { // match: (Com64 (Com64 x)) // cond: // result: x - { + for { if v.Args[0].Op != OpCom64 { - goto ended44e29d5968f0f7b86972b7bf417ab3 + break } x := v.Args[0].Args[0] v.reset(OpCopy) @@ -897,9 +822,6 @@ func rewriteValuegeneric_OpCom64(v *Value, config *Config) bool { v.AddArg(x) return true } - goto ended44e29d5968f0f7b86972b7bf417ab3 -ended44e29d5968f0f7b86972b7bf417ab3: - ; return false } func rewriteValuegeneric_OpCom8(v *Value, config *Config) bool { @@ -908,9 +830,9 @@ func rewriteValuegeneric_OpCom8(v *Value, config *Config) bool { // match: (Com8 (Com8 x)) // cond: // result: x - { + for { if v.Args[0].Op != OpCom8 { - goto end4d92ff3ba567d9afd38fc9ca113602ad + break } x := v.Args[0].Args[0] v.reset(OpCopy) @@ -918,9 +840,6 @@ func rewriteValuegeneric_OpCom8(v *Value, config *Config) bool { v.AddArg(x) return true } - goto end4d92ff3ba567d9afd38fc9ca113602ad -end4d92ff3ba567d9afd38fc9ca113602ad: - ; return false } func rewriteValuegeneric_OpComplexImag(v *Value, config *Config) bool { @@ -929,9 +848,9 @@ func rewriteValuegeneric_OpComplexImag(v *Value, config *Config) bool { // match: (ComplexImag (ComplexMake _ imag )) // cond: // result: imag - { + for { if v.Args[0].Op != OpComplexMake { - goto endec3009fd8727d03002021997936e091f + break } imag := v.Args[0].Args[1] v.reset(OpCopy) @@ -939,9 +858,6 @@ func rewriteValuegeneric_OpComplexImag(v *Value, config *Config) bool { v.AddArg(imag) return true } - goto endec3009fd8727d03002021997936e091f -endec3009fd8727d03002021997936e091f: - ; return false } func rewriteValuegeneric_OpComplexReal(v *Value, config *Config) bool { @@ -950,9 +866,9 @@ func rewriteValuegeneric_OpComplexReal(v *Value, config *Config) bool { // match: (ComplexReal (ComplexMake real _ )) // cond: // result: real - { + for { if v.Args[0].Op != OpComplexMake { - goto end8db3e16bd59af1adaa4b734c8adcc71d + break } real := v.Args[0].Args[0] v.reset(OpCopy) @@ -960,9 +876,6 @@ func rewriteValuegeneric_OpComplexReal(v *Value, config *Config) bool { v.AddArg(real) return true } - goto end8db3e16bd59af1adaa4b734c8adcc71d -end8db3e16bd59af1adaa4b734c8adcc71d: - ; return false } func rewriteValuegeneric_OpConstInterface(v *Value, config *Config) bool { @@ -971,7 +884,7 @@ func rewriteValuegeneric_OpConstInterface(v *Value, config *Config) bool { // match: (ConstInterface) // cond: // result: (IMake (ConstNil ) (ConstNil )) - { + for { v.reset(OpIMake) v0 := b.NewValue0(v.Line, OpConstNil, config.fe.TypeBytePtr()) v.AddArg(v0) @@ -979,9 +892,6 @@ func rewriteValuegeneric_OpConstInterface(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto end0367bd8f20a320cc41568f2b28657f6b -end0367bd8f20a320cc41568f2b28657f6b: - ; return false } func rewriteValuegeneric_OpConstSlice(v *Value, config *Config) bool { @@ -990,9 +900,9 @@ func rewriteValuegeneric_OpConstSlice(v *Value, config *Config) bool { // match: (ConstSlice) // cond: config.PtrSize == 4 // result: (SliceMake (ConstNil ) (Const32 [0]) (Const32 [0])) - { + for { if !(config.PtrSize == 4) { - goto end9ba6baf9c7247b1f5ba4099c0c3910ce + break } v.reset(OpSliceMake) v0 := b.NewValue0(v.Line, OpConstNil, config.fe.TypeBytePtr()) @@ -1005,15 +915,12 @@ func rewriteValuegeneric_OpConstSlice(v *Value, config *Config) bool { v.AddArg(v2) return true } - goto end9ba6baf9c7247b1f5ba4099c0c3910ce -end9ba6baf9c7247b1f5ba4099c0c3910ce: - ; // match: (ConstSlice) // cond: config.PtrSize == 8 // result: (SliceMake (ConstNil ) (Const64 [0]) (Const64 [0])) - { + for { if !(config.PtrSize == 8) { - goto endabee2aa6bd3e3261628f677221ad2640 + break } v.reset(OpSliceMake) v0 := b.NewValue0(v.Line, OpConstNil, config.fe.TypeBytePtr()) @@ -1026,9 +933,6 @@ end9ba6baf9c7247b1f5ba4099c0c3910ce: v.AddArg(v2) return true } - goto endabee2aa6bd3e3261628f677221ad2640 -endabee2aa6bd3e3261628f677221ad2640: - ; return false } func rewriteValuegeneric_OpConstString(v *Value, config *Config) bool { @@ -1037,10 +941,10 @@ func rewriteValuegeneric_OpConstString(v *Value, config *Config) bool { // match: (ConstString {s}) // cond: config.PtrSize == 4 && s.(string) == "" // result: (StringMake (ConstNil) (Const32 [0])) - { + for { s := v.Aux if !(config.PtrSize == 4 && s.(string) == "") { - goto end85d5f388ba947643af63cdc68c1155a5 + break } v.reset(OpStringMake) v0 := b.NewValue0(v.Line, OpConstNil, config.fe.TypeBytePtr()) @@ -1050,16 +954,13 @@ func rewriteValuegeneric_OpConstString(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto end85d5f388ba947643af63cdc68c1155a5 -end85d5f388ba947643af63cdc68c1155a5: - ; // match: (ConstString {s}) // cond: config.PtrSize == 8 && s.(string) == "" // result: (StringMake (ConstNil) (Const64 [0])) - { + for { s := v.Aux if !(config.PtrSize == 8 && s.(string) == "") { - goto endc807259a5ed2760fbbd3dc7386641343 + break } v.reset(OpStringMake) v0 := b.NewValue0(v.Line, OpConstNil, config.fe.TypeBytePtr()) @@ -1069,16 +970,13 @@ end85d5f388ba947643af63cdc68c1155a5: v.AddArg(v1) return true } - goto endc807259a5ed2760fbbd3dc7386641343 -endc807259a5ed2760fbbd3dc7386641343: - ; // match: (ConstString {s}) // cond: config.PtrSize == 4 && s.(string) != "" // result: (StringMake (Addr {config.fe.StringData(s.(string))} (SB)) (Const32 [int64(len(s.(string)))])) - { + for { s := v.Aux if !(config.PtrSize == 4 && s.(string) != "") { - goto end107a700a4519d18f418602421444ddb6 + break } v.reset(OpStringMake) v0 := b.NewValue0(v.Line, OpAddr, config.fe.TypeBytePtr()) @@ -1091,16 +989,13 @@ endc807259a5ed2760fbbd3dc7386641343: v.AddArg(v2) return true } - goto end107a700a4519d18f418602421444ddb6 -end107a700a4519d18f418602421444ddb6: - ; // match: (ConstString {s}) // cond: config.PtrSize == 8 && s.(string) != "" // result: (StringMake (Addr {config.fe.StringData(s.(string))} (SB)) (Const64 [int64(len(s.(string)))])) - { + for { s := v.Aux if !(config.PtrSize == 8 && s.(string) != "") { - goto end7ce9db29d17866f26d21e6e12f442e54 + break } v.reset(OpStringMake) v0 := b.NewValue0(v.Line, OpAddr, config.fe.TypeBytePtr()) @@ -1113,9 +1008,6 @@ end107a700a4519d18f418602421444ddb6: v.AddArg(v2) return true } - goto end7ce9db29d17866f26d21e6e12f442e54 -end7ce9db29d17866f26d21e6e12f442e54: - ; return false } func rewriteValuegeneric_OpConvert(v *Value, config *Config) bool { @@ -1124,47 +1016,41 @@ func rewriteValuegeneric_OpConvert(v *Value, config *Config) bool { // match: (Convert (Add64 (Convert ptr mem) off) mem) // cond: // result: (Add64 ptr off) - { + for { if v.Args[0].Op != OpAdd64 { - goto endbbc9f1666b4d39a130e1b86f109e7c1b + break } if v.Args[0].Args[0].Op != OpConvert { - goto endbbc9f1666b4d39a130e1b86f109e7c1b + 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 { - goto endbbc9f1666b4d39a130e1b86f109e7c1b + break } v.reset(OpAdd64) v.AddArg(ptr) v.AddArg(off) return true } - goto endbbc9f1666b4d39a130e1b86f109e7c1b -endbbc9f1666b4d39a130e1b86f109e7c1b: - ; // match: (Convert (Convert ptr mem) mem) // cond: // result: ptr - { + for { if v.Args[0].Op != OpConvert { - goto end98c5e0ca257eb216989171786f91b42d + break } ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] if v.Args[1] != mem { - goto end98c5e0ca257eb216989171786f91b42d + break } v.reset(OpCopy) v.Type = ptr.Type v.AddArg(ptr) return true } - goto end98c5e0ca257eb216989171786f91b42d -end98c5e0ca257eb216989171786f91b42d: - ; return false } func rewriteValuegeneric_OpEq16(v *Value, config *Config) bool { @@ -1173,35 +1059,32 @@ func rewriteValuegeneric_OpEq16(v *Value, config *Config) bool { // match: (Eq16 x x) // cond: // result: (ConstBool [1]) - { + for { x := v.Args[0] if v.Args[1] != x { - goto end0c0fe5fdfba3821add3448fd3f1fc6b7 + break } v.reset(OpConstBool) v.AuxInt = 1 return true } - goto end0c0fe5fdfba3821add3448fd3f1fc6b7 -end0c0fe5fdfba3821add3448fd3f1fc6b7: - ; // match: (Eq16 (Const16 [c]) (Add16 (Const16 [d]) x)) // cond: // result: (Eq16 (Const16 [c-d]) x) - { + for { if v.Args[0].Op != OpConst16 { - goto end79c830afa265161fc0f0532c4c4e7f50 + break } t := v.Args[0].Type c := v.Args[0].AuxInt if v.Args[1].Op != OpAdd16 { - goto end79c830afa265161fc0f0532c4c4e7f50 + break } if v.Args[1].Args[0].Op != OpConst16 { - goto end79c830afa265161fc0f0532c4c4e7f50 + break } if v.Args[1].Args[0].Type != v.Args[0].Type { - goto end79c830afa265161fc0f0532c4c4e7f50 + break } d := v.Args[1].Args[0].AuxInt x := v.Args[1].Args[1] @@ -1212,21 +1095,18 @@ end0c0fe5fdfba3821add3448fd3f1fc6b7: v.AddArg(x) return true } - goto end79c830afa265161fc0f0532c4c4e7f50 -end79c830afa265161fc0f0532c4c4e7f50: - ; // match: (Eq16 x (Const16 [c])) // cond: x.Op != OpConst16 // result: (Eq16 (Const16 [c]) x) - { + for { x := v.Args[0] if v.Args[1].Op != OpConst16 { - goto end5d89fe1eeb145f14e11578f41282c904 + break } t := v.Args[1].Type c := v.Args[1].AuxInt if !(x.Op != OpConst16) { - goto end5d89fe1eeb145f14e11578f41282c904 + break } v.reset(OpEq16) v0 := b.NewValue0(v.Line, OpConst16, t) @@ -1235,28 +1115,22 @@ end79c830afa265161fc0f0532c4c4e7f50: v.AddArg(x) return true } - goto end5d89fe1eeb145f14e11578f41282c904 -end5d89fe1eeb145f14e11578f41282c904: - ; // match: (Eq16 (Const16 [c]) (Const16 [d])) // cond: // result: (ConstBool [b2i(int16(c) == int16(d))]) - { + for { if v.Args[0].Op != OpConst16 { - goto end4532e1d01c10d8906fe1da14f9dfaa88 + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst16 { - goto end4532e1d01c10d8906fe1da14f9dfaa88 + break } d := v.Args[1].AuxInt v.reset(OpConstBool) v.AuxInt = b2i(int16(c) == int16(d)) return true } - goto end4532e1d01c10d8906fe1da14f9dfaa88 -end4532e1d01c10d8906fe1da14f9dfaa88: - ; return false } func rewriteValuegeneric_OpEq32(v *Value, config *Config) bool { @@ -1265,35 +1139,32 @@ func rewriteValuegeneric_OpEq32(v *Value, config *Config) bool { // match: (Eq32 x x) // cond: // result: (ConstBool [1]) - { + for { x := v.Args[0] if v.Args[1] != x { - goto end6da547ec4ee93d787434f3bda873e4a0 + break } v.reset(OpConstBool) v.AuxInt = 1 return true } - goto end6da547ec4ee93d787434f3bda873e4a0 -end6da547ec4ee93d787434f3bda873e4a0: - ; // match: (Eq32 (Const32 [c]) (Add32 (Const32 [d]) x)) // cond: // result: (Eq32 (Const32 [c-d]) x) - { + for { if v.Args[0].Op != OpConst32 { - goto end1a69730a32c6e432784dcdf643320ecd + break } t := v.Args[0].Type c := v.Args[0].AuxInt if v.Args[1].Op != OpAdd32 { - goto end1a69730a32c6e432784dcdf643320ecd + break } if v.Args[1].Args[0].Op != OpConst32 { - goto end1a69730a32c6e432784dcdf643320ecd + break } if v.Args[1].Args[0].Type != v.Args[0].Type { - goto end1a69730a32c6e432784dcdf643320ecd + break } d := v.Args[1].Args[0].AuxInt x := v.Args[1].Args[1] @@ -1304,21 +1175,18 @@ end6da547ec4ee93d787434f3bda873e4a0: v.AddArg(x) return true } - goto end1a69730a32c6e432784dcdf643320ecd -end1a69730a32c6e432784dcdf643320ecd: - ; // match: (Eq32 x (Const32 [c])) // cond: x.Op != OpConst32 // result: (Eq32 (Const32 [c]) x) - { + for { x := v.Args[0] if v.Args[1].Op != OpConst32 { - goto end0ca4ef4cf416ec3083d38667e263cf45 + break } t := v.Args[1].Type c := v.Args[1].AuxInt if !(x.Op != OpConst32) { - goto end0ca4ef4cf416ec3083d38667e263cf45 + break } v.reset(OpEq32) v0 := b.NewValue0(v.Line, OpConst32, t) @@ -1327,28 +1195,22 @@ end1a69730a32c6e432784dcdf643320ecd: v.AddArg(x) return true } - goto end0ca4ef4cf416ec3083d38667e263cf45 -end0ca4ef4cf416ec3083d38667e263cf45: - ; // match: (Eq32 (Const32 [c]) (Const32 [d])) // cond: // result: (ConstBool [b2i(int32(c) == int32(d))]) - { + for { if v.Args[0].Op != OpConst32 { - goto end00a2464e02c9ca00e8d0077acacbb5ad + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst32 { - goto end00a2464e02c9ca00e8d0077acacbb5ad + break } d := v.Args[1].AuxInt v.reset(OpConstBool) v.AuxInt = b2i(int32(c) == int32(d)) return true } - goto end00a2464e02c9ca00e8d0077acacbb5ad -end00a2464e02c9ca00e8d0077acacbb5ad: - ; return false } func rewriteValuegeneric_OpEq64(v *Value, config *Config) bool { @@ -1357,35 +1219,32 @@ func rewriteValuegeneric_OpEq64(v *Value, config *Config) bool { // match: (Eq64 x x) // cond: // result: (ConstBool [1]) - { + for { x := v.Args[0] if v.Args[1] != x { - goto endb1d471cc503ba8bb05440f01dbf33d81 + break } v.reset(OpConstBool) v.AuxInt = 1 return true } - goto endb1d471cc503ba8bb05440f01dbf33d81 -endb1d471cc503ba8bb05440f01dbf33d81: - ; // match: (Eq64 (Const64 [c]) (Add64 (Const64 [d]) x)) // cond: // result: (Eq64 (Const64 [c-d]) x) - { + for { if v.Args[0].Op != OpConst64 { - goto endffd67f3b83f6972cd459153d318f714d + break } t := v.Args[0].Type c := v.Args[0].AuxInt if v.Args[1].Op != OpAdd64 { - goto endffd67f3b83f6972cd459153d318f714d + break } if v.Args[1].Args[0].Op != OpConst64 { - goto endffd67f3b83f6972cd459153d318f714d + break } if v.Args[1].Args[0].Type != v.Args[0].Type { - goto endffd67f3b83f6972cd459153d318f714d + break } d := v.Args[1].Args[0].AuxInt x := v.Args[1].Args[1] @@ -1396,21 +1255,18 @@ endb1d471cc503ba8bb05440f01dbf33d81: v.AddArg(x) return true } - goto endffd67f3b83f6972cd459153d318f714d -endffd67f3b83f6972cd459153d318f714d: - ; // match: (Eq64 x (Const64 [c])) // cond: x.Op != OpConst64 // result: (Eq64 (Const64 [c]) x) - { + for { x := v.Args[0] if v.Args[1].Op != OpConst64 { - goto endc2ecf8254dc736e97c5815362d0b477d + break } t := v.Args[1].Type c := v.Args[1].AuxInt if !(x.Op != OpConst64) { - goto endc2ecf8254dc736e97c5815362d0b477d + break } v.reset(OpEq64) v0 := b.NewValue0(v.Line, OpConst64, t) @@ -1419,28 +1275,22 @@ endffd67f3b83f6972cd459153d318f714d: v.AddArg(x) return true } - goto endc2ecf8254dc736e97c5815362d0b477d -endc2ecf8254dc736e97c5815362d0b477d: - ; // match: (Eq64 (Const64 [c]) (Const64 [d])) // cond: // result: (ConstBool [b2i(int64(c) == int64(d))]) - { + for { if v.Args[0].Op != OpConst64 { - goto end405568a707dbbc86432e91f4ce7d97d7 + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst64 { - goto end405568a707dbbc86432e91f4ce7d97d7 + break } d := v.Args[1].AuxInt v.reset(OpConstBool) v.AuxInt = b2i(int64(c) == int64(d)) return true } - goto end405568a707dbbc86432e91f4ce7d97d7 -end405568a707dbbc86432e91f4ce7d97d7: - ; return false } func rewriteValuegeneric_OpEq8(v *Value, config *Config) bool { @@ -1449,35 +1299,32 @@ func rewriteValuegeneric_OpEq8(v *Value, config *Config) bool { // match: (Eq8 x x) // cond: // result: (ConstBool [1]) - { + for { x := v.Args[0] if v.Args[1] != x { - goto enda66da0d3e7e51624ee46527727c48a9a + break } v.reset(OpConstBool) v.AuxInt = 1 return true } - goto enda66da0d3e7e51624ee46527727c48a9a -enda66da0d3e7e51624ee46527727c48a9a: - ; // match: (Eq8 (Const8 [c]) (Add8 (Const8 [d]) x)) // cond: // result: (Eq8 (Const8 [c-d]) x) - { + for { if v.Args[0].Op != OpConst8 { - goto end6912961350bb485f56ef176522aa683b + break } t := v.Args[0].Type c := v.Args[0].AuxInt if v.Args[1].Op != OpAdd8 { - goto end6912961350bb485f56ef176522aa683b + break } if v.Args[1].Args[0].Op != OpConst8 { - goto end6912961350bb485f56ef176522aa683b + break } if v.Args[1].Args[0].Type != v.Args[0].Type { - goto end6912961350bb485f56ef176522aa683b + break } d := v.Args[1].Args[0].AuxInt x := v.Args[1].Args[1] @@ -1488,21 +1335,18 @@ enda66da0d3e7e51624ee46527727c48a9a: v.AddArg(x) return true } - goto end6912961350bb485f56ef176522aa683b -end6912961350bb485f56ef176522aa683b: - ; // match: (Eq8 x (Const8 [c])) // cond: x.Op != OpConst8 // result: (Eq8 (Const8 [c]) x) - { + for { x := v.Args[0] if v.Args[1].Op != OpConst8 { - goto end70d0b569427b24e7a912a1aa8fab3b20 + break } t := v.Args[1].Type c := v.Args[1].AuxInt if !(x.Op != OpConst8) { - goto end70d0b569427b24e7a912a1aa8fab3b20 + break } v.reset(OpEq8) v0 := b.NewValue0(v.Line, OpConst8, t) @@ -1511,28 +1355,22 @@ end6912961350bb485f56ef176522aa683b: v.AddArg(x) return true } - goto end70d0b569427b24e7a912a1aa8fab3b20 -end70d0b569427b24e7a912a1aa8fab3b20: - ; // match: (Eq8 (Const8 [c]) (Const8 [d])) // cond: // result: (ConstBool [b2i(int8(c) == int8(d))]) - { + for { if v.Args[0].Op != OpConst8 { - goto endd49f3700ba2d1e500d3ab4fa34fd090d + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst8 { - goto endd49f3700ba2d1e500d3ab4fa34fd090d + break } d := v.Args[1].AuxInt v.reset(OpConstBool) v.AuxInt = b2i(int8(c) == int8(d)) return true } - goto endd49f3700ba2d1e500d3ab4fa34fd090d -endd49f3700ba2d1e500d3ab4fa34fd090d: - ; return false } func rewriteValuegeneric_OpEqInter(v *Value, config *Config) bool { @@ -1541,7 +1379,7 @@ func rewriteValuegeneric_OpEqInter(v *Value, config *Config) bool { // match: (EqInter x y) // cond: // result: (EqPtr (ITab x) (ITab y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpEqPtr) @@ -1553,9 +1391,6 @@ func rewriteValuegeneric_OpEqInter(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto end1cc40483caab33ece971ab7e6c8fdfca -end1cc40483caab33ece971ab7e6c8fdfca: - ; return false } func rewriteValuegeneric_OpEqPtr(v *Value, config *Config) bool { @@ -1564,10 +1399,10 @@ func rewriteValuegeneric_OpEqPtr(v *Value, config *Config) bool { // match: (EqPtr p (ConstNil)) // cond: // result: (Not (IsNonNil p)) - { + for { p := v.Args[0] if v.Args[1].Op != OpConstNil { - goto ende701cdb6a2c1fff4d4b283b7f8f6178b + break } v.reset(OpNot) v0 := b.NewValue0(v.Line, OpIsNonNil, config.fe.TypeBool()) @@ -1575,15 +1410,12 @@ func rewriteValuegeneric_OpEqPtr(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto ende701cdb6a2c1fff4d4b283b7f8f6178b -ende701cdb6a2c1fff4d4b283b7f8f6178b: - ; // match: (EqPtr (ConstNil) p) // cond: // result: (Not (IsNonNil p)) - { + for { if v.Args[0].Op != OpConstNil { - goto end7cdc0d5c38fbffe6287c8928803b038e + break } p := v.Args[1] v.reset(OpNot) @@ -1592,9 +1424,6 @@ ende701cdb6a2c1fff4d4b283b7f8f6178b: v.AddArg(v0) return true } - goto end7cdc0d5c38fbffe6287c8928803b038e -end7cdc0d5c38fbffe6287c8928803b038e: - ; return false } func rewriteValuegeneric_OpEqSlice(v *Value, config *Config) bool { @@ -1603,7 +1432,7 @@ func rewriteValuegeneric_OpEqSlice(v *Value, config *Config) bool { // match: (EqSlice x y) // cond: // result: (EqPtr (SlicePtr x) (SlicePtr y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpEqPtr) @@ -1615,9 +1444,6 @@ func rewriteValuegeneric_OpEqSlice(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto end9cd53ca57ee90aa09c54f8071c8e8769 -end9cd53ca57ee90aa09c54f8071c8e8769: - ; return false } func rewriteValuegeneric_OpGeq16(v *Value, config *Config) bool { @@ -1626,22 +1452,19 @@ func rewriteValuegeneric_OpGeq16(v *Value, config *Config) bool { // match: (Geq16 (Const16 [c]) (Const16 [d])) // cond: // result: (ConstBool [b2i(int16(c) >= int16(d))]) - { + for { if v.Args[0].Op != OpConst16 { - goto endbac100e9f1065e7d2ff863951f686f4b + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst16 { - goto endbac100e9f1065e7d2ff863951f686f4b + break } d := v.Args[1].AuxInt v.reset(OpConstBool) v.AuxInt = b2i(int16(c) >= int16(d)) return true } - goto endbac100e9f1065e7d2ff863951f686f4b -endbac100e9f1065e7d2ff863951f686f4b: - ; return false } func rewriteValuegeneric_OpGeq16U(v *Value, config *Config) bool { @@ -1650,22 +1473,19 @@ func rewriteValuegeneric_OpGeq16U(v *Value, config *Config) bool { // match: (Geq16U (Const16 [c]) (Const16 [d])) // cond: // result: (ConstBool [b2i(uint16(c) >= uint16(d))]) - { + for { if v.Args[0].Op != OpConst16 { - goto end11c6acbc5827fc9508424b0ffcf98b34 + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst16 { - goto end11c6acbc5827fc9508424b0ffcf98b34 + break } d := v.Args[1].AuxInt v.reset(OpConstBool) v.AuxInt = b2i(uint16(c) >= uint16(d)) return true } - goto end11c6acbc5827fc9508424b0ffcf98b34 -end11c6acbc5827fc9508424b0ffcf98b34: - ; return false } func rewriteValuegeneric_OpGeq32(v *Value, config *Config) bool { @@ -1674,22 +1494,19 @@ func rewriteValuegeneric_OpGeq32(v *Value, config *Config) bool { // match: (Geq32 (Const32 [c]) (Const32 [d])) // cond: // result: (ConstBool [b2i(int32(c) >= int32(d))]) - { + for { if v.Args[0].Op != OpConst32 { - goto end89ced97524ac75045911ca7cf6d44b28 + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst32 { - goto end89ced97524ac75045911ca7cf6d44b28 + break } d := v.Args[1].AuxInt v.reset(OpConstBool) v.AuxInt = b2i(int32(c) >= int32(d)) return true } - goto end89ced97524ac75045911ca7cf6d44b28 -end89ced97524ac75045911ca7cf6d44b28: - ; return false } func rewriteValuegeneric_OpGeq32U(v *Value, config *Config) bool { @@ -1698,22 +1515,19 @@ func rewriteValuegeneric_OpGeq32U(v *Value, config *Config) bool { // match: (Geq32U (Const32 [c]) (Const32 [d])) // cond: // result: (ConstBool [b2i(uint32(c) >= uint32(d))]) - { + for { if v.Args[0].Op != OpConst32 { - goto end92fbe85c7bbbf0db287932822bdde991 + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst32 { - goto end92fbe85c7bbbf0db287932822bdde991 + break } d := v.Args[1].AuxInt v.reset(OpConstBool) v.AuxInt = b2i(uint32(c) >= uint32(d)) return true } - goto end92fbe85c7bbbf0db287932822bdde991 -end92fbe85c7bbbf0db287932822bdde991: - ; return false } func rewriteValuegeneric_OpGeq64(v *Value, config *Config) bool { @@ -1722,22 +1536,19 @@ func rewriteValuegeneric_OpGeq64(v *Value, config *Config) bool { // match: (Geq64 (Const64 [c]) (Const64 [d])) // cond: // result: (ConstBool [b2i(int64(c) >= int64(d))]) - { + for { if v.Args[0].Op != OpConst64 { - goto end08a5a4bff12a346befe05ad561b080ac + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst64 { - goto end08a5a4bff12a346befe05ad561b080ac + break } d := v.Args[1].AuxInt v.reset(OpConstBool) v.AuxInt = b2i(int64(c) >= int64(d)) return true } - goto end08a5a4bff12a346befe05ad561b080ac -end08a5a4bff12a346befe05ad561b080ac: - ; return false } func rewriteValuegeneric_OpGeq64U(v *Value, config *Config) bool { @@ -1746,22 +1557,19 @@ func rewriteValuegeneric_OpGeq64U(v *Value, config *Config) bool { // match: (Geq64U (Const64 [c]) (Const64 [d])) // cond: // result: (ConstBool [b2i(uint64(c) >= uint64(d))]) - { + for { if v.Args[0].Op != OpConst64 { - goto endd72c497b6cc2b01d43a39ec12d5010b3 + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst64 { - goto endd72c497b6cc2b01d43a39ec12d5010b3 + break } d := v.Args[1].AuxInt v.reset(OpConstBool) v.AuxInt = b2i(uint64(c) >= uint64(d)) return true } - goto endd72c497b6cc2b01d43a39ec12d5010b3 -endd72c497b6cc2b01d43a39ec12d5010b3: - ; return false } func rewriteValuegeneric_OpGeq8(v *Value, config *Config) bool { @@ -1770,22 +1578,19 @@ func rewriteValuegeneric_OpGeq8(v *Value, config *Config) bool { // match: (Geq8 (Const8 [c]) (Const8 [d])) // cond: // result: (ConstBool [b2i(int8(c) >= int8(d))]) - { + for { if v.Args[0].Op != OpConst8 { - goto endea141068e84038c63cbdd87a8cb227d7 + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst8 { - goto endea141068e84038c63cbdd87a8cb227d7 + break } d := v.Args[1].AuxInt v.reset(OpConstBool) v.AuxInt = b2i(int8(c) >= int8(d)) return true } - goto endea141068e84038c63cbdd87a8cb227d7 -endea141068e84038c63cbdd87a8cb227d7: - ; return false } func rewriteValuegeneric_OpGeq8U(v *Value, config *Config) bool { @@ -1794,22 +1599,19 @@ func rewriteValuegeneric_OpGeq8U(v *Value, config *Config) bool { // match: (Geq8U (Const8 [c]) (Const8 [d])) // cond: // result: (ConstBool [b2i(uint8(c) >= uint8(d))]) - { + for { if v.Args[0].Op != OpConst8 { - goto end47c128ccdc54151a243c5856b0c52ef1 + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst8 { - goto end47c128ccdc54151a243c5856b0c52ef1 + break } d := v.Args[1].AuxInt v.reset(OpConstBool) v.AuxInt = b2i(uint8(c) >= uint8(d)) return true } - goto end47c128ccdc54151a243c5856b0c52ef1 -end47c128ccdc54151a243c5856b0c52ef1: - ; return false } func rewriteValuegeneric_OpGreater16(v *Value, config *Config) bool { @@ -1818,22 +1620,19 @@ func rewriteValuegeneric_OpGreater16(v *Value, config *Config) bool { // match: (Greater16 (Const16 [c]) (Const16 [d])) // cond: // result: (ConstBool [b2i(int16(c) > int16(d))]) - { + for { if v.Args[0].Op != OpConst16 { - goto end390bae49463ace4d703dd24e18920f66 + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst16 { - goto end390bae49463ace4d703dd24e18920f66 + break } d := v.Args[1].AuxInt v.reset(OpConstBool) v.AuxInt = b2i(int16(c) > int16(d)) return true } - goto end390bae49463ace4d703dd24e18920f66 -end390bae49463ace4d703dd24e18920f66: - ; return false } func rewriteValuegeneric_OpGreater16U(v *Value, config *Config) bool { @@ -1842,22 +1641,19 @@ func rewriteValuegeneric_OpGreater16U(v *Value, config *Config) bool { // match: (Greater16U (Const16 [c]) (Const16 [d])) // cond: // result: (ConstBool [b2i(uint16(c) > uint16(d))]) - { + for { if v.Args[0].Op != OpConst16 { - goto end89ba3caf5c156fa6d908ac04c058187b + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst16 { - goto end89ba3caf5c156fa6d908ac04c058187b + break } d := v.Args[1].AuxInt v.reset(OpConstBool) v.AuxInt = b2i(uint16(c) > uint16(d)) return true } - goto end89ba3caf5c156fa6d908ac04c058187b -end89ba3caf5c156fa6d908ac04c058187b: - ; return false } func rewriteValuegeneric_OpGreater32(v *Value, config *Config) bool { @@ -1866,22 +1662,19 @@ func rewriteValuegeneric_OpGreater32(v *Value, config *Config) bool { // match: (Greater32 (Const32 [c]) (Const32 [d])) // cond: // result: (ConstBool [b2i(int32(c) > int32(d))]) - { + for { if v.Args[0].Op != OpConst32 { - goto end86482a9dc6439e8470da5352dd74d68d + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst32 { - goto end86482a9dc6439e8470da5352dd74d68d + break } d := v.Args[1].AuxInt v.reset(OpConstBool) v.AuxInt = b2i(int32(c) > int32(d)) return true } - goto end86482a9dc6439e8470da5352dd74d68d -end86482a9dc6439e8470da5352dd74d68d: - ; return false } func rewriteValuegeneric_OpGreater32U(v *Value, config *Config) bool { @@ -1890,22 +1683,19 @@ func rewriteValuegeneric_OpGreater32U(v *Value, config *Config) bool { // match: (Greater32U (Const32 [c]) (Const32 [d])) // cond: // result: (ConstBool [b2i(uint32(c) > uint32(d))]) - { + for { if v.Args[0].Op != OpConst32 { - goto end1bf3f05c1e3599a969b8be1f5f6949e4 + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst32 { - goto end1bf3f05c1e3599a969b8be1f5f6949e4 + break } d := v.Args[1].AuxInt v.reset(OpConstBool) v.AuxInt = b2i(uint32(c) > uint32(d)) return true } - goto end1bf3f05c1e3599a969b8be1f5f6949e4 -end1bf3f05c1e3599a969b8be1f5f6949e4: - ; return false } func rewriteValuegeneric_OpGreater64(v *Value, config *Config) bool { @@ -1914,22 +1704,19 @@ func rewriteValuegeneric_OpGreater64(v *Value, config *Config) bool { // match: (Greater64 (Const64 [c]) (Const64 [d])) // cond: // result: (ConstBool [b2i(int64(c) > int64(d))]) - { + for { if v.Args[0].Op != OpConst64 { - goto end96a82e893fda4882f23b6bab5f7fbff7 + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst64 { - goto end96a82e893fda4882f23b6bab5f7fbff7 + break } d := v.Args[1].AuxInt v.reset(OpConstBool) v.AuxInt = b2i(int64(c) > int64(d)) return true } - goto end96a82e893fda4882f23b6bab5f7fbff7 -end96a82e893fda4882f23b6bab5f7fbff7: - ; return false } func rewriteValuegeneric_OpGreater64U(v *Value, config *Config) bool { @@ -1938,22 +1725,19 @@ func rewriteValuegeneric_OpGreater64U(v *Value, config *Config) bool { // match: (Greater64U (Const64 [c]) (Const64 [d])) // cond: // result: (ConstBool [b2i(uint64(c) > uint64(d))]) - { + for { if v.Args[0].Op != OpConst64 { - goto end2d8f5ad85fbffeb92af985a888f6fa69 + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst64 { - goto end2d8f5ad85fbffeb92af985a888f6fa69 + break } d := v.Args[1].AuxInt v.reset(OpConstBool) v.AuxInt = b2i(uint64(c) > uint64(d)) return true } - goto end2d8f5ad85fbffeb92af985a888f6fa69 -end2d8f5ad85fbffeb92af985a888f6fa69: - ; return false } func rewriteValuegeneric_OpGreater8(v *Value, config *Config) bool { @@ -1962,22 +1746,19 @@ func rewriteValuegeneric_OpGreater8(v *Value, config *Config) bool { // match: (Greater8 (Const8 [c]) (Const8 [d])) // cond: // result: (ConstBool [b2i(int8(c) > int8(d))]) - { + for { if v.Args[0].Op != OpConst8 { - goto ende221967c7516b7749109cf8343fe9c83 + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst8 { - goto ende221967c7516b7749109cf8343fe9c83 + break } d := v.Args[1].AuxInt v.reset(OpConstBool) v.AuxInt = b2i(int8(c) > int8(d)) return true } - goto ende221967c7516b7749109cf8343fe9c83 -ende221967c7516b7749109cf8343fe9c83: - ; return false } func rewriteValuegeneric_OpGreater8U(v *Value, config *Config) bool { @@ -1986,22 +1767,19 @@ func rewriteValuegeneric_OpGreater8U(v *Value, config *Config) bool { // match: (Greater8U (Const8 [c]) (Const8 [d])) // cond: // result: (ConstBool [b2i(uint8(c) > uint8(d))]) - { + for { if v.Args[0].Op != OpConst8 { - goto enda9398c8188156dd46689fa2939147525 + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst8 { - goto enda9398c8188156dd46689fa2939147525 + break } d := v.Args[1].AuxInt v.reset(OpConstBool) v.AuxInt = b2i(uint8(c) > uint8(d)) return true } - goto enda9398c8188156dd46689fa2939147525 -enda9398c8188156dd46689fa2939147525: - ; return false } func rewriteValuegeneric_OpIData(v *Value, config *Config) bool { @@ -2010,9 +1788,9 @@ func rewriteValuegeneric_OpIData(v *Value, config *Config) bool { // match: (IData (IMake _ data)) // cond: // result: data - { + for { if v.Args[0].Op != OpIMake { - goto endbfa1bb944cdc07933effb16a35152e12 + break } data := v.Args[0].Args[1] v.reset(OpCopy) @@ -2020,9 +1798,6 @@ func rewriteValuegeneric_OpIData(v *Value, config *Config) bool { v.AddArg(data) return true } - goto endbfa1bb944cdc07933effb16a35152e12 -endbfa1bb944cdc07933effb16a35152e12: - ; return false } func rewriteValuegeneric_OpITab(v *Value, config *Config) bool { @@ -2031,9 +1806,9 @@ func rewriteValuegeneric_OpITab(v *Value, config *Config) bool { // match: (ITab (IMake itab _)) // cond: // result: itab - { + for { if v.Args[0].Op != OpIMake { - goto endfcbb9414a776ff9c8512da3e0f4d8fbd + break } itab := v.Args[0].Args[0] v.reset(OpCopy) @@ -2041,9 +1816,6 @@ func rewriteValuegeneric_OpITab(v *Value, config *Config) bool { v.AddArg(itab) return true } - goto endfcbb9414a776ff9c8512da3e0f4d8fbd -endfcbb9414a776ff9c8512da3e0f4d8fbd: - ; return false } func rewriteValuegeneric_OpIsInBounds(v *Value, config *Config) bool { @@ -2052,41 +1824,35 @@ func rewriteValuegeneric_OpIsInBounds(v *Value, config *Config) bool { // match: (IsInBounds (Const32 [c]) (Const32 [d])) // cond: // result: (ConstBool [b2i(inBounds32(c,d))]) - { + for { if v.Args[0].Op != OpConst32 { - goto endf0a2ecfe84b293de6ff0919e45d19d9d + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst32 { - goto endf0a2ecfe84b293de6ff0919e45d19d9d + break } d := v.Args[1].AuxInt v.reset(OpConstBool) v.AuxInt = b2i(inBounds32(c, d)) return true } - goto endf0a2ecfe84b293de6ff0919e45d19d9d -endf0a2ecfe84b293de6ff0919e45d19d9d: - ; // match: (IsInBounds (Const64 [c]) (Const64 [d])) // cond: // result: (ConstBool [b2i(inBounds64(c,d))]) - { + for { if v.Args[0].Op != OpConst64 { - goto end4b406f402c135f50f71effcc904ecb2b + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst64 { - goto end4b406f402c135f50f71effcc904ecb2b + break } d := v.Args[1].AuxInt v.reset(OpConstBool) v.AuxInt = b2i(inBounds64(c, d)) return true } - goto end4b406f402c135f50f71effcc904ecb2b -end4b406f402c135f50f71effcc904ecb2b: - ; return false } func rewriteValuegeneric_OpIsSliceInBounds(v *Value, config *Config) bool { @@ -2095,41 +1861,35 @@ func rewriteValuegeneric_OpIsSliceInBounds(v *Value, config *Config) bool { // match: (IsSliceInBounds (Const32 [c]) (Const32 [d])) // cond: // result: (ConstBool [b2i(sliceInBounds32(c,d))]) - { + for { if v.Args[0].Op != OpConst32 { - goto end5e84a230c28cac987437cfed8f432cc3 + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst32 { - goto end5e84a230c28cac987437cfed8f432cc3 + break } d := v.Args[1].AuxInt v.reset(OpConstBool) v.AuxInt = b2i(sliceInBounds32(c, d)) return true } - goto end5e84a230c28cac987437cfed8f432cc3 -end5e84a230c28cac987437cfed8f432cc3: - ; // match: (IsSliceInBounds (Const64 [c]) (Const64 [d])) // cond: // result: (ConstBool [b2i(sliceInBounds64(c,d))]) - { + for { if v.Args[0].Op != OpConst64 { - goto end3880a6fe20ad4152e98f76d84da233a7 + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst64 { - goto end3880a6fe20ad4152e98f76d84da233a7 + break } d := v.Args[1].AuxInt v.reset(OpConstBool) v.AuxInt = b2i(sliceInBounds64(c, d)) return true } - goto end3880a6fe20ad4152e98f76d84da233a7 -end3880a6fe20ad4152e98f76d84da233a7: - ; return false } func rewriteValuegeneric_OpLeq16(v *Value, config *Config) bool { @@ -2138,22 +1898,19 @@ func rewriteValuegeneric_OpLeq16(v *Value, config *Config) bool { // match: (Leq16 (Const16 [c]) (Const16 [d])) // cond: // result: (ConstBool [b2i(int16(c) <= int16(d))]) - { + for { if v.Args[0].Op != OpConst16 { - goto end76b1c51f9b7cd7ee2f75b9f7057569de + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst16 { - goto end76b1c51f9b7cd7ee2f75b9f7057569de + break } d := v.Args[1].AuxInt v.reset(OpConstBool) v.AuxInt = b2i(int16(c) <= int16(d)) return true } - goto end76b1c51f9b7cd7ee2f75b9f7057569de -end76b1c51f9b7cd7ee2f75b9f7057569de: - ; return false } func rewriteValuegeneric_OpLeq16U(v *Value, config *Config) bool { @@ -2162,22 +1919,19 @@ func rewriteValuegeneric_OpLeq16U(v *Value, config *Config) bool { // match: (Leq16U (Const16 [c]) (Const16 [d])) // cond: // result: (ConstBool [b2i(uint16(c) <= uint16(d))]) - { + for { if v.Args[0].Op != OpConst16 { - goto endf010fdf7f2c438ec18c33f493dd062aa + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst16 { - goto endf010fdf7f2c438ec18c33f493dd062aa + break } d := v.Args[1].AuxInt v.reset(OpConstBool) v.AuxInt = b2i(uint16(c) <= uint16(d)) return true } - goto endf010fdf7f2c438ec18c33f493dd062aa -endf010fdf7f2c438ec18c33f493dd062aa: - ; return false } func rewriteValuegeneric_OpLeq32(v *Value, config *Config) bool { @@ -2186,22 +1940,19 @@ func rewriteValuegeneric_OpLeq32(v *Value, config *Config) bool { // match: (Leq32 (Const32 [c]) (Const32 [d])) // cond: // result: (ConstBool [b2i(int32(c) <= int32(d))]) - { + for { if v.Args[0].Op != OpConst32 { - goto end6c7d61cfd188680bea8a5e23f08ca1de + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst32 { - goto end6c7d61cfd188680bea8a5e23f08ca1de + break } d := v.Args[1].AuxInt v.reset(OpConstBool) v.AuxInt = b2i(int32(c) <= int32(d)) return true } - goto end6c7d61cfd188680bea8a5e23f08ca1de -end6c7d61cfd188680bea8a5e23f08ca1de: - ; return false } func rewriteValuegeneric_OpLeq32U(v *Value, config *Config) bool { @@ -2210,22 +1961,19 @@ func rewriteValuegeneric_OpLeq32U(v *Value, config *Config) bool { // match: (Leq32U (Const32 [c]) (Const32 [d])) // cond: // result: (ConstBool [b2i(uint32(c) <= uint32(d))]) - { + for { if v.Args[0].Op != OpConst32 { - goto end4363555333511ee9b649b36f1a0ba34e + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst32 { - goto end4363555333511ee9b649b36f1a0ba34e + break } d := v.Args[1].AuxInt v.reset(OpConstBool) v.AuxInt = b2i(uint32(c) <= uint32(d)) return true } - goto end4363555333511ee9b649b36f1a0ba34e -end4363555333511ee9b649b36f1a0ba34e: - ; return false } func rewriteValuegeneric_OpLeq64(v *Value, config *Config) bool { @@ -2234,22 +1982,19 @@ func rewriteValuegeneric_OpLeq64(v *Value, config *Config) bool { // match: (Leq64 (Const64 [c]) (Const64 [d])) // cond: // result: (ConstBool [b2i(int64(c) <= int64(d))]) - { + for { if v.Args[0].Op != OpConst64 { - goto enddc865cd7ac2093abc7617bedbf371c22 + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst64 { - goto enddc865cd7ac2093abc7617bedbf371c22 + break } d := v.Args[1].AuxInt v.reset(OpConstBool) v.AuxInt = b2i(int64(c) <= int64(d)) return true } - goto enddc865cd7ac2093abc7617bedbf371c22 -enddc865cd7ac2093abc7617bedbf371c22: - ; return false } func rewriteValuegeneric_OpLeq64U(v *Value, config *Config) bool { @@ -2258,22 +2003,19 @@ func rewriteValuegeneric_OpLeq64U(v *Value, config *Config) bool { // match: (Leq64U (Const64 [c]) (Const64 [d])) // cond: // result: (ConstBool [b2i(uint64(c) <= uint64(d))]) - { + for { if v.Args[0].Op != OpConst64 { - goto end412eadb168738ba92f3f0705d4495305 + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst64 { - goto end412eadb168738ba92f3f0705d4495305 + break } d := v.Args[1].AuxInt v.reset(OpConstBool) v.AuxInt = b2i(uint64(c) <= uint64(d)) return true } - goto end412eadb168738ba92f3f0705d4495305 -end412eadb168738ba92f3f0705d4495305: - ; return false } func rewriteValuegeneric_OpLeq8(v *Value, config *Config) bool { @@ -2282,22 +2024,19 @@ func rewriteValuegeneric_OpLeq8(v *Value, config *Config) bool { // match: (Leq8 (Const8 [c]) (Const8 [d])) // cond: // result: (ConstBool [b2i(int8(c) <= int8(d))]) - { + for { if v.Args[0].Op != OpConst8 { - goto endb5a459da8e18c40abc0c7a20e71d0187 + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst8 { - goto endb5a459da8e18c40abc0c7a20e71d0187 + break } d := v.Args[1].AuxInt v.reset(OpConstBool) v.AuxInt = b2i(int8(c) <= int8(d)) return true } - goto endb5a459da8e18c40abc0c7a20e71d0187 -endb5a459da8e18c40abc0c7a20e71d0187: - ; return false } func rewriteValuegeneric_OpLeq8U(v *Value, config *Config) bool { @@ -2306,22 +2045,19 @@ func rewriteValuegeneric_OpLeq8U(v *Value, config *Config) bool { // match: (Leq8U (Const8 [c]) (Const8 [d])) // cond: // result: (ConstBool [b2i(uint8(c) <= uint8(d))]) - { + for { if v.Args[0].Op != OpConst8 { - goto endd6622d55fcdf3fa7b08e7511cd3b7d85 + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst8 { - goto endd6622d55fcdf3fa7b08e7511cd3b7d85 + break } d := v.Args[1].AuxInt v.reset(OpConstBool) v.AuxInt = b2i(uint8(c) <= uint8(d)) return true } - goto endd6622d55fcdf3fa7b08e7511cd3b7d85 -endd6622d55fcdf3fa7b08e7511cd3b7d85: - ; return false } func rewriteValuegeneric_OpLess16(v *Value, config *Config) bool { @@ -2330,22 +2066,19 @@ func rewriteValuegeneric_OpLess16(v *Value, config *Config) bool { // match: (Less16 (Const16 [c]) (Const16 [d])) // cond: // result: (ConstBool [b2i(int16(c) < int16(d))]) - { + for { if v.Args[0].Op != OpConst16 { - goto end0dc915d089f05e79589ebb5c498cc360 + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst16 { - goto end0dc915d089f05e79589ebb5c498cc360 + break } d := v.Args[1].AuxInt v.reset(OpConstBool) v.AuxInt = b2i(int16(c) < int16(d)) return true } - goto end0dc915d089f05e79589ebb5c498cc360 -end0dc915d089f05e79589ebb5c498cc360: - ; return false } func rewriteValuegeneric_OpLess16U(v *Value, config *Config) bool { @@ -2354,22 +2087,19 @@ func rewriteValuegeneric_OpLess16U(v *Value, config *Config) bool { // match: (Less16U (Const16 [c]) (Const16 [d])) // cond: // result: (ConstBool [b2i(uint16(c) < uint16(d))]) - { + for { if v.Args[0].Op != OpConst16 { - goto endd2bb8249443788690946fc184631a00a + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst16 { - goto endd2bb8249443788690946fc184631a00a + break } d := v.Args[1].AuxInt v.reset(OpConstBool) v.AuxInt = b2i(uint16(c) < uint16(d)) return true } - goto endd2bb8249443788690946fc184631a00a -endd2bb8249443788690946fc184631a00a: - ; return false } func rewriteValuegeneric_OpLess32(v *Value, config *Config) bool { @@ -2378,22 +2108,19 @@ func rewriteValuegeneric_OpLess32(v *Value, config *Config) bool { // match: (Less32 (Const32 [c]) (Const32 [d])) // cond: // result: (ConstBool [b2i(int32(c) < int32(d))]) - { + for { if v.Args[0].Op != OpConst32 { - goto endc86f65e499688809d414f03539bec5bf + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst32 { - goto endc86f65e499688809d414f03539bec5bf + break } d := v.Args[1].AuxInt v.reset(OpConstBool) v.AuxInt = b2i(int32(c) < int32(d)) return true } - goto endc86f65e499688809d414f03539bec5bf -endc86f65e499688809d414f03539bec5bf: - ; return false } func rewriteValuegeneric_OpLess32U(v *Value, config *Config) bool { @@ -2402,22 +2129,19 @@ func rewriteValuegeneric_OpLess32U(v *Value, config *Config) bool { // match: (Less32U (Const32 [c]) (Const32 [d])) // cond: // result: (ConstBool [b2i(uint32(c) < uint32(d))]) - { + for { if v.Args[0].Op != OpConst32 { - goto end2cc68b5247b1afb90a9d3923b28ff247 + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst32 { - goto end2cc68b5247b1afb90a9d3923b28ff247 + break } d := v.Args[1].AuxInt v.reset(OpConstBool) v.AuxInt = b2i(uint32(c) < uint32(d)) return true } - goto end2cc68b5247b1afb90a9d3923b28ff247 -end2cc68b5247b1afb90a9d3923b28ff247: - ; return false } func rewriteValuegeneric_OpLess64(v *Value, config *Config) bool { @@ -2426,22 +2150,19 @@ func rewriteValuegeneric_OpLess64(v *Value, config *Config) bool { // match: (Less64 (Const64 [c]) (Const64 [d])) // cond: // result: (ConstBool [b2i(int64(c) < int64(d))]) - { + for { if v.Args[0].Op != OpConst64 { - goto end505de73cd15125dbb59b05d8975d3128 + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst64 { - goto end505de73cd15125dbb59b05d8975d3128 + break } d := v.Args[1].AuxInt v.reset(OpConstBool) v.AuxInt = b2i(int64(c) < int64(d)) return true } - goto end505de73cd15125dbb59b05d8975d3128 -end505de73cd15125dbb59b05d8975d3128: - ; return false } func rewriteValuegeneric_OpLess64U(v *Value, config *Config) bool { @@ -2450,22 +2171,19 @@ func rewriteValuegeneric_OpLess64U(v *Value, config *Config) bool { // match: (Less64U (Const64 [c]) (Const64 [d])) // cond: // result: (ConstBool [b2i(uint64(c) < uint64(d))]) - { + for { if v.Args[0].Op != OpConst64 { - goto endeb249ef36416cd1abf4f807026c059cd + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst64 { - goto endeb249ef36416cd1abf4f807026c059cd + break } d := v.Args[1].AuxInt v.reset(OpConstBool) v.AuxInt = b2i(uint64(c) < uint64(d)) return true } - goto endeb249ef36416cd1abf4f807026c059cd -endeb249ef36416cd1abf4f807026c059cd: - ; return false } func rewriteValuegeneric_OpLess8(v *Value, config *Config) bool { @@ -2474,22 +2192,19 @@ func rewriteValuegeneric_OpLess8(v *Value, config *Config) bool { // match: (Less8 (Const8 [c]) (Const8 [d])) // cond: // result: (ConstBool [b2i(int8(c) < int8(d))]) - { + for { if v.Args[0].Op != OpConst8 { - goto endef134de03bc8537ac1f38d5eccff7673 + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst8 { - goto endef134de03bc8537ac1f38d5eccff7673 + break } d := v.Args[1].AuxInt v.reset(OpConstBool) v.AuxInt = b2i(int8(c) < int8(d)) return true } - goto endef134de03bc8537ac1f38d5eccff7673 -endef134de03bc8537ac1f38d5eccff7673: - ; return false } func rewriteValuegeneric_OpLess8U(v *Value, config *Config) bool { @@ -2498,22 +2213,19 @@ func rewriteValuegeneric_OpLess8U(v *Value, config *Config) bool { // match: (Less8U (Const8 [c]) (Const8 [d])) // cond: // result: (ConstBool [b2i(uint8(c) < uint8(d))]) - { + for { if v.Args[0].Op != OpConst8 { - goto end263ecdc279924bff8771dd1ac3f42222 + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst8 { - goto end263ecdc279924bff8771dd1ac3f42222 + break } d := v.Args[1].AuxInt v.reset(OpConstBool) v.AuxInt = b2i(uint8(c) < uint8(d)) return true } - goto end263ecdc279924bff8771dd1ac3f42222 -end263ecdc279924bff8771dd1ac3f42222: - ; return false } func rewriteValuegeneric_OpLoad(v *Value, config *Config) bool { @@ -2522,26 +2234,23 @@ func rewriteValuegeneric_OpLoad(v *Value, config *Config) bool { // match: (Load _ _) // 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)) { - goto end8d25f5c949948132921b6be29ede6bde + break } v.reset(OpStructMake0) return true } - goto end8d25f5c949948132921b6be29ede6bde -end8d25f5c949948132921b6be29ede6bde: - ; // match: (Load ptr mem) // cond: t.IsStruct() && t.NumFields() == 1 && config.fe.CanSSA(t) // result: (StructMake1 (Load ptr mem)) - { + for { t := v.Type ptr := v.Args[0] mem := v.Args[1] if !(t.IsStruct() && t.NumFields() == 1 && config.fe.CanSSA(t)) { - goto endfe908e5a8617dd39df2f9b2b92e93ae5 + break } v.reset(OpStructMake1) v0 := b.NewValue0(v.Line, OpLoad, t.FieldType(0)) @@ -2550,18 +2259,15 @@ end8d25f5c949948132921b6be29ede6bde: v.AddArg(v0) return true } - goto endfe908e5a8617dd39df2f9b2b92e93ae5 -endfe908e5a8617dd39df2f9b2b92e93ae5: - ; // match: (Load ptr mem) // cond: t.IsStruct() && t.NumFields() == 2 && config.fe.CanSSA(t) // result: (StructMake2 (Load ptr mem) (Load (OffPtr [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)) { - goto end20e20e64004b765012cfb80c575ef27b + break } v.reset(OpStructMake2) v0 := b.NewValue0(v.Line, OpLoad, t.FieldType(0)) @@ -2577,18 +2283,15 @@ endfe908e5a8617dd39df2f9b2b92e93ae5: v.AddArg(v1) return true } - goto end20e20e64004b765012cfb80c575ef27b -end20e20e64004b765012cfb80c575ef27b: - ; // match: (Load ptr mem) // cond: t.IsStruct() && t.NumFields() == 3 && config.fe.CanSSA(t) // result: (StructMake3 (Load ptr mem) (Load (OffPtr [t.FieldOff(1)] ptr) mem) (Load (OffPtr [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)) { - goto ende612bf71067ed67541735cdc8b5a3288 + break } v.reset(OpStructMake3) v0 := b.NewValue0(v.Line, OpLoad, t.FieldType(0)) @@ -2611,18 +2314,15 @@ end20e20e64004b765012cfb80c575ef27b: v.AddArg(v3) return true } - goto ende612bf71067ed67541735cdc8b5a3288 -ende612bf71067ed67541735cdc8b5a3288: - ; // match: (Load ptr mem) // cond: t.IsStruct() && t.NumFields() == 4 && config.fe.CanSSA(t) // result: (StructMake4 (Load ptr mem) (Load (OffPtr [t.FieldOff(1)] ptr) mem) (Load (OffPtr [t.FieldOff(2)] ptr) mem) (Load (OffPtr [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)) { - goto end46c66c64d9030f2cc9a7a767f67953d1 + break } v.reset(OpStructMake4) v0 := b.NewValue0(v.Line, OpLoad, t.FieldType(0)) @@ -2652,18 +2352,15 @@ ende612bf71067ed67541735cdc8b5a3288: v.AddArg(v5) return true } - goto end46c66c64d9030f2cc9a7a767f67953d1 -end46c66c64d9030f2cc9a7a767f67953d1: - ; // match: (Load ptr mem) // cond: t.IsComplex() && t.Size() == 8 // result: (ComplexMake (Load ptr mem) (Load (OffPtr [4] ptr) mem) ) - { + for { t := v.Type ptr := v.Args[0] mem := v.Args[1] if !(t.IsComplex() && t.Size() == 8) { - goto end665854b31b828893d90b36bb462ff381 + break } v.reset(OpComplexMake) v0 := b.NewValue0(v.Line, OpLoad, config.fe.TypeFloat32()) @@ -2679,18 +2376,15 @@ end46c66c64d9030f2cc9a7a767f67953d1: v.AddArg(v1) return true } - goto end665854b31b828893d90b36bb462ff381 -end665854b31b828893d90b36bb462ff381: - ; // match: (Load ptr mem) // cond: t.IsComplex() && t.Size() == 16 // result: (ComplexMake (Load ptr mem) (Load (OffPtr [8] ptr) mem) ) - { + for { t := v.Type ptr := v.Args[0] mem := v.Args[1] if !(t.IsComplex() && t.Size() == 16) { - goto end1b106f89e0e3e26c613b957a7c98d8ad + break } v.reset(OpComplexMake) v0 := b.NewValue0(v.Line, OpLoad, config.fe.TypeFloat64()) @@ -2706,18 +2400,15 @@ end665854b31b828893d90b36bb462ff381: v.AddArg(v1) return true } - goto end1b106f89e0e3e26c613b957a7c98d8ad -end1b106f89e0e3e26c613b957a7c98d8ad: - ; // match: (Load ptr mem) // cond: t.IsString() // result: (StringMake (Load ptr mem) (Load (OffPtr [config.PtrSize] ptr) mem)) - { + for { t := v.Type ptr := v.Args[0] mem := v.Args[1] if !(t.IsString()) { - goto enddd15a6f3d53a6ce7a19d4e181dd1c13a + break } v.reset(OpStringMake) v0 := b.NewValue0(v.Line, OpLoad, config.fe.TypeBytePtr()) @@ -2733,18 +2424,15 @@ end1b106f89e0e3e26c613b957a7c98d8ad: v.AddArg(v1) return true } - goto enddd15a6f3d53a6ce7a19d4e181dd1c13a -enddd15a6f3d53a6ce7a19d4e181dd1c13a: - ; // match: (Load ptr mem) // cond: t.IsSlice() // result: (SliceMake (Load ptr mem) (Load (OffPtr [config.PtrSize] ptr) mem) (Load (OffPtr [2*config.PtrSize] ptr) mem)) - { + for { t := v.Type ptr := v.Args[0] mem := v.Args[1] if !(t.IsSlice()) { - goto end65e8b0055aa7491b9b6066d9fe1b2c13 + break } v.reset(OpSliceMake) v0 := b.NewValue0(v.Line, OpLoad, config.fe.TypeBytePtr()) @@ -2767,18 +2455,15 @@ enddd15a6f3d53a6ce7a19d4e181dd1c13a: v.AddArg(v3) return true } - goto end65e8b0055aa7491b9b6066d9fe1b2c13 -end65e8b0055aa7491b9b6066d9fe1b2c13: - ; // match: (Load ptr mem) // cond: t.IsInterface() // result: (IMake (Load ptr mem) (Load (OffPtr [config.PtrSize] ptr) mem)) - { + for { t := v.Type ptr := v.Args[0] mem := v.Args[1] if !(t.IsInterface()) { - goto end12671c83ebe3ccbc8e53383765ee7675 + break } v.reset(OpIMake) v0 := b.NewValue0(v.Line, OpLoad, config.fe.TypeBytePtr()) @@ -2794,9 +2479,6 @@ end65e8b0055aa7491b9b6066d9fe1b2c13: v.AddArg(v1) return true } - goto end12671c83ebe3ccbc8e53383765ee7675 -end12671c83ebe3ccbc8e53383765ee7675: - ; return false } func rewriteValuegeneric_OpLsh16x16(v *Value, config *Config) bool { @@ -2805,11 +2487,11 @@ func rewriteValuegeneric_OpLsh16x16(v *Value, config *Config) bool { // match: (Lsh16x16 x (Const16 [c])) // cond: // result: (Lsh16x64 x (Const64 [int64(uint16(c))])) - { + for { t := v.Type x := v.Args[0] if v.Args[1].Op != OpConst16 { - goto end2f5aa78b30ebd2471e8d03a307923b06 + break } c := v.Args[1].AuxInt v.reset(OpLsh16x64) @@ -2819,9 +2501,6 @@ func rewriteValuegeneric_OpLsh16x16(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end2f5aa78b30ebd2471e8d03a307923b06 -end2f5aa78b30ebd2471e8d03a307923b06: - ; return false } func rewriteValuegeneric_OpLsh16x32(v *Value, config *Config) bool { @@ -2830,11 +2509,11 @@ func rewriteValuegeneric_OpLsh16x32(v *Value, config *Config) bool { // match: (Lsh16x32 x (Const32 [c])) // cond: // result: (Lsh16x64 x (Const64 [int64(uint32(c))])) - { + for { t := v.Type x := v.Args[0] if v.Args[1].Op != OpConst32 { - goto endedeb000c8c97090261a47f08a2ff17e4 + break } c := v.Args[1].AuxInt v.reset(OpLsh16x64) @@ -2844,9 +2523,6 @@ func rewriteValuegeneric_OpLsh16x32(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto endedeb000c8c97090261a47f08a2ff17e4 -endedeb000c8c97090261a47f08a2ff17e4: - ; return false } func rewriteValuegeneric_OpLsh16x64(v *Value, config *Config) bool { @@ -2855,78 +2531,69 @@ func rewriteValuegeneric_OpLsh16x64(v *Value, config *Config) bool { // match: (Lsh16x64 (Const16 [c]) (Const64 [d])) // cond: // result: (Const16 [int64(int16(c) << uint64(d))]) - { + for { if v.Args[0].Op != OpConst16 { - goto endc9f0d91f3da4bdd46a634a62549810e0 + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst64 { - goto endc9f0d91f3da4bdd46a634a62549810e0 + break } d := v.Args[1].AuxInt v.reset(OpConst16) v.AuxInt = int64(int16(c) << uint64(d)) return true } - goto endc9f0d91f3da4bdd46a634a62549810e0 -endc9f0d91f3da4bdd46a634a62549810e0: - ; // match: (Lsh16x64 x (Const64 [0])) // cond: // result: x - { + for { x := v.Args[0] if v.Args[1].Op != OpConst64 { - goto end7ecc343739fab9b50a0bdff6e9d121e6 + break } if v.Args[1].AuxInt != 0 { - goto end7ecc343739fab9b50a0bdff6e9d121e6 + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto end7ecc343739fab9b50a0bdff6e9d121e6 -end7ecc343739fab9b50a0bdff6e9d121e6: - ; // match: (Lsh16x64 _ (Const64 [c])) // cond: uint64(c) >= 16 // result: (Const64 [0]) - { + for { if v.Args[1].Op != OpConst64 { - goto end1d2c74d359df9d89b16c4f658a231dfe + break } c := v.Args[1].AuxInt if !(uint64(c) >= 16) { - goto end1d2c74d359df9d89b16c4f658a231dfe + break } v.reset(OpConst64) v.AuxInt = 0 return true } - goto end1d2c74d359df9d89b16c4f658a231dfe -end1d2c74d359df9d89b16c4f658a231dfe: - ; // match: (Lsh16x64 (Lsh16x64 x (Const64 [c])) (Const64 [d])) // cond: !uaddOvf(c,d) // result: (Lsh16x64 x (Const64 [c+d])) - { + for { t := v.Type if v.Args[0].Op != OpLsh16x64 { - goto end26a91e42735a02a30e94a998f54372dd + break } x := v.Args[0].Args[0] if v.Args[0].Args[1].Op != OpConst64 { - goto end26a91e42735a02a30e94a998f54372dd + break } c := v.Args[0].Args[1].AuxInt if v.Args[1].Op != OpConst64 { - goto end26a91e42735a02a30e94a998f54372dd + break } d := v.Args[1].AuxInt if !(!uaddOvf(c, d)) { - goto end26a91e42735a02a30e94a998f54372dd + break } v.reset(OpLsh16x64) v.AddArg(x) @@ -2935,9 +2602,6 @@ end1d2c74d359df9d89b16c4f658a231dfe: v.AddArg(v0) return true } - goto end26a91e42735a02a30e94a998f54372dd -end26a91e42735a02a30e94a998f54372dd: - ; return false } func rewriteValuegeneric_OpLsh16x8(v *Value, config *Config) bool { @@ -2946,11 +2610,11 @@ func rewriteValuegeneric_OpLsh16x8(v *Value, config *Config) bool { // match: (Lsh16x8 x (Const8 [c])) // cond: // result: (Lsh16x64 x (Const64 [int64(uint8(c))])) - { + for { t := v.Type x := v.Args[0] if v.Args[1].Op != OpConst8 { - goto endce2401b8a6c6190fe81d77e2d562a10c + break } c := v.Args[1].AuxInt v.reset(OpLsh16x64) @@ -2960,9 +2624,6 @@ func rewriteValuegeneric_OpLsh16x8(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto endce2401b8a6c6190fe81d77e2d562a10c -endce2401b8a6c6190fe81d77e2d562a10c: - ; return false } func rewriteValuegeneric_OpLsh32x16(v *Value, config *Config) bool { @@ -2971,11 +2632,11 @@ func rewriteValuegeneric_OpLsh32x16(v *Value, config *Config) bool { // match: (Lsh32x16 x (Const16 [c])) // cond: // result: (Lsh32x64 x (Const64 [int64(uint16(c))])) - { + for { t := v.Type x := v.Args[0] if v.Args[1].Op != OpConst16 { - goto end7205eb3e315971143ac5584d07045570 + break } c := v.Args[1].AuxInt v.reset(OpLsh32x64) @@ -2985,9 +2646,6 @@ func rewriteValuegeneric_OpLsh32x16(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end7205eb3e315971143ac5584d07045570 -end7205eb3e315971143ac5584d07045570: - ; return false } func rewriteValuegeneric_OpLsh32x32(v *Value, config *Config) bool { @@ -2996,11 +2654,11 @@ func rewriteValuegeneric_OpLsh32x32(v *Value, config *Config) bool { // match: (Lsh32x32 x (Const32 [c])) // cond: // result: (Lsh32x64 x (Const64 [int64(uint32(c))])) - { + for { t := v.Type x := v.Args[0] if v.Args[1].Op != OpConst32 { - goto endc1a330b287199c80228e665a53881298 + break } c := v.Args[1].AuxInt v.reset(OpLsh32x64) @@ -3010,9 +2668,6 @@ func rewriteValuegeneric_OpLsh32x32(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto endc1a330b287199c80228e665a53881298 -endc1a330b287199c80228e665a53881298: - ; return false } func rewriteValuegeneric_OpLsh32x64(v *Value, config *Config) bool { @@ -3021,78 +2676,69 @@ func rewriteValuegeneric_OpLsh32x64(v *Value, config *Config) bool { // match: (Lsh32x64 (Const32 [c]) (Const64 [d])) // cond: // result: (Const32 [int64(int32(c) << uint64(d))]) - { + for { if v.Args[0].Op != OpConst32 { - goto end5896bd9a3fe78f1e1712563642d33254 + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst64 { - goto end5896bd9a3fe78f1e1712563642d33254 + break } d := v.Args[1].AuxInt v.reset(OpConst32) v.AuxInt = int64(int32(c) << uint64(d)) return true } - goto end5896bd9a3fe78f1e1712563642d33254 -end5896bd9a3fe78f1e1712563642d33254: - ; // match: (Lsh32x64 x (Const64 [0])) // cond: // result: x - { + for { x := v.Args[0] if v.Args[1].Op != OpConst64 { - goto endd9ce9639a91b11e601823be3d4d6c209 + break } if v.Args[1].AuxInt != 0 { - goto endd9ce9639a91b11e601823be3d4d6c209 + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto endd9ce9639a91b11e601823be3d4d6c209 -endd9ce9639a91b11e601823be3d4d6c209: - ; // match: (Lsh32x64 _ (Const64 [c])) // cond: uint64(c) >= 32 // result: (Const64 [0]) - { + for { if v.Args[1].Op != OpConst64 { - goto end81247a2423f489be15859d3930738fdf + break } c := v.Args[1].AuxInt if !(uint64(c) >= 32) { - goto end81247a2423f489be15859d3930738fdf + break } v.reset(OpConst64) v.AuxInt = 0 return true } - goto end81247a2423f489be15859d3930738fdf -end81247a2423f489be15859d3930738fdf: - ; // match: (Lsh32x64 (Lsh32x64 x (Const64 [c])) (Const64 [d])) // cond: !uaddOvf(c,d) // result: (Lsh32x64 x (Const64 [c+d])) - { + for { t := v.Type if v.Args[0].Op != OpLsh32x64 { - goto endf96a7c9571797fe61a5b63a4923d7e6e + break } x := v.Args[0].Args[0] if v.Args[0].Args[1].Op != OpConst64 { - goto endf96a7c9571797fe61a5b63a4923d7e6e + break } c := v.Args[0].Args[1].AuxInt if v.Args[1].Op != OpConst64 { - goto endf96a7c9571797fe61a5b63a4923d7e6e + break } d := v.Args[1].AuxInt if !(!uaddOvf(c, d)) { - goto endf96a7c9571797fe61a5b63a4923d7e6e + break } v.reset(OpLsh32x64) v.AddArg(x) @@ -3101,9 +2747,6 @@ end81247a2423f489be15859d3930738fdf: v.AddArg(v0) return true } - goto endf96a7c9571797fe61a5b63a4923d7e6e -endf96a7c9571797fe61a5b63a4923d7e6e: - ; return false } func rewriteValuegeneric_OpLsh32x8(v *Value, config *Config) bool { @@ -3112,11 +2755,11 @@ func rewriteValuegeneric_OpLsh32x8(v *Value, config *Config) bool { // match: (Lsh32x8 x (Const8 [c])) // cond: // result: (Lsh32x64 x (Const64 [int64(uint8(c))])) - { + for { t := v.Type x := v.Args[0] if v.Args[1].Op != OpConst8 { - goto end1759d7c25a5bcda288e34d1d197c0b8f + break } c := v.Args[1].AuxInt v.reset(OpLsh32x64) @@ -3126,9 +2769,6 @@ func rewriteValuegeneric_OpLsh32x8(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end1759d7c25a5bcda288e34d1d197c0b8f -end1759d7c25a5bcda288e34d1d197c0b8f: - ; return false } func rewriteValuegeneric_OpLsh64x16(v *Value, config *Config) bool { @@ -3137,11 +2777,11 @@ func rewriteValuegeneric_OpLsh64x16(v *Value, config *Config) bool { // match: (Lsh64x16 x (Const16 [c])) // cond: // result: (Lsh64x64 x (Const64 [int64(uint16(c))])) - { + for { t := v.Type x := v.Args[0] if v.Args[1].Op != OpConst16 { - goto enda649fbb5e14490c9eea9616550a76b5c + break } c := v.Args[1].AuxInt v.reset(OpLsh64x64) @@ -3151,9 +2791,6 @@ func rewriteValuegeneric_OpLsh64x16(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto enda649fbb5e14490c9eea9616550a76b5c -enda649fbb5e14490c9eea9616550a76b5c: - ; return false } func rewriteValuegeneric_OpLsh64x32(v *Value, config *Config) bool { @@ -3162,11 +2799,11 @@ func rewriteValuegeneric_OpLsh64x32(v *Value, config *Config) bool { // match: (Lsh64x32 x (Const32 [c])) // cond: // result: (Lsh64x64 x (Const64 [int64(uint32(c))])) - { + for { t := v.Type x := v.Args[0] if v.Args[1].Op != OpConst32 { - goto end40069675cde851a63cce81b1b02751f9 + break } c := v.Args[1].AuxInt v.reset(OpLsh64x64) @@ -3176,9 +2813,6 @@ func rewriteValuegeneric_OpLsh64x32(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end40069675cde851a63cce81b1b02751f9 -end40069675cde851a63cce81b1b02751f9: - ; return false } func rewriteValuegeneric_OpLsh64x64(v *Value, config *Config) bool { @@ -3187,78 +2821,69 @@ func rewriteValuegeneric_OpLsh64x64(v *Value, config *Config) bool { // match: (Lsh64x64 (Const64 [c]) (Const64 [d])) // cond: // result: (Const64 [c << uint64(d)]) - { + for { if v.Args[0].Op != OpConst64 { - goto end9c157a23e021f659f1568566435ed57b + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst64 { - goto end9c157a23e021f659f1568566435ed57b + break } d := v.Args[1].AuxInt v.reset(OpConst64) v.AuxInt = c << uint64(d) return true } - goto end9c157a23e021f659f1568566435ed57b -end9c157a23e021f659f1568566435ed57b: - ; // match: (Lsh64x64 x (Const64 [0])) // cond: // result: x - { + for { x := v.Args[0] if v.Args[1].Op != OpConst64 { - goto end9f18ca0556dbb4b50fe888273fab20ca + break } if v.Args[1].AuxInt != 0 { - goto end9f18ca0556dbb4b50fe888273fab20ca + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto end9f18ca0556dbb4b50fe888273fab20ca -end9f18ca0556dbb4b50fe888273fab20ca: - ; // match: (Lsh64x64 _ (Const64 [c])) // cond: uint64(c) >= 64 // result: (Const64 [0]) - { + for { if v.Args[1].Op != OpConst64 { - goto end33da2e0ce5ca3e0554564477ef422402 + break } c := v.Args[1].AuxInt if !(uint64(c) >= 64) { - goto end33da2e0ce5ca3e0554564477ef422402 + break } v.reset(OpConst64) v.AuxInt = 0 return true } - goto end33da2e0ce5ca3e0554564477ef422402 -end33da2e0ce5ca3e0554564477ef422402: - ; // match: (Lsh64x64 (Lsh64x64 x (Const64 [c])) (Const64 [d])) // cond: !uaddOvf(c,d) // result: (Lsh64x64 x (Const64 [c+d])) - { + for { t := v.Type if v.Args[0].Op != OpLsh64x64 { - goto end001c62ee580a700ec7b07ccaa3740ac2 + break } x := v.Args[0].Args[0] if v.Args[0].Args[1].Op != OpConst64 { - goto end001c62ee580a700ec7b07ccaa3740ac2 + break } c := v.Args[0].Args[1].AuxInt if v.Args[1].Op != OpConst64 { - goto end001c62ee580a700ec7b07ccaa3740ac2 + break } d := v.Args[1].AuxInt if !(!uaddOvf(c, d)) { - goto end001c62ee580a700ec7b07ccaa3740ac2 + break } v.reset(OpLsh64x64) v.AddArg(x) @@ -3267,9 +2892,6 @@ end33da2e0ce5ca3e0554564477ef422402: v.AddArg(v0) return true } - goto end001c62ee580a700ec7b07ccaa3740ac2 -end001c62ee580a700ec7b07ccaa3740ac2: - ; return false } func rewriteValuegeneric_OpLsh64x8(v *Value, config *Config) bool { @@ -3278,11 +2900,11 @@ func rewriteValuegeneric_OpLsh64x8(v *Value, config *Config) bool { // match: (Lsh64x8 x (Const8 [c])) // cond: // result: (Lsh64x64 x (Const64 [int64(uint8(c))])) - { + for { t := v.Type x := v.Args[0] if v.Args[1].Op != OpConst8 { - goto end4d9224069abdade8e405df343938d932 + break } c := v.Args[1].AuxInt v.reset(OpLsh64x64) @@ -3292,9 +2914,6 @@ func rewriteValuegeneric_OpLsh64x8(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end4d9224069abdade8e405df343938d932 -end4d9224069abdade8e405df343938d932: - ; return false } func rewriteValuegeneric_OpLsh8x16(v *Value, config *Config) bool { @@ -3303,11 +2922,11 @@ func rewriteValuegeneric_OpLsh8x16(v *Value, config *Config) bool { // match: (Lsh8x16 x (Const16 [c])) // cond: // result: (Lsh8x64 x (Const64 [int64(uint16(c))])) - { + for { t := v.Type x := v.Args[0] if v.Args[1].Op != OpConst16 { - goto end0ad4a82e2eb4c7ca7407d79ec3aa5142 + break } c := v.Args[1].AuxInt v.reset(OpLsh8x64) @@ -3317,9 +2936,6 @@ func rewriteValuegeneric_OpLsh8x16(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end0ad4a82e2eb4c7ca7407d79ec3aa5142 -end0ad4a82e2eb4c7ca7407d79ec3aa5142: - ; return false } func rewriteValuegeneric_OpLsh8x32(v *Value, config *Config) bool { @@ -3328,11 +2944,11 @@ func rewriteValuegeneric_OpLsh8x32(v *Value, config *Config) bool { // match: (Lsh8x32 x (Const32 [c])) // cond: // result: (Lsh8x64 x (Const64 [int64(uint32(c))])) - { + for { t := v.Type x := v.Args[0] if v.Args[1].Op != OpConst32 { - goto enddaacda113ecc79fe0621fd22ebc548dd + break } c := v.Args[1].AuxInt v.reset(OpLsh8x64) @@ -3342,9 +2958,6 @@ func rewriteValuegeneric_OpLsh8x32(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto enddaacda113ecc79fe0621fd22ebc548dd -enddaacda113ecc79fe0621fd22ebc548dd: - ; return false } func rewriteValuegeneric_OpLsh8x64(v *Value, config *Config) bool { @@ -3353,78 +2966,69 @@ func rewriteValuegeneric_OpLsh8x64(v *Value, config *Config) bool { // match: (Lsh8x64 (Const8 [c]) (Const64 [d])) // cond: // result: (Const8 [int64(int8(c) << uint64(d))]) - { + for { if v.Args[0].Op != OpConst8 { - goto endbc3297ea9642b97eb71f0a9735048d7b + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst64 { - goto endbc3297ea9642b97eb71f0a9735048d7b + break } d := v.Args[1].AuxInt v.reset(OpConst8) v.AuxInt = int64(int8(c) << uint64(d)) return true } - goto endbc3297ea9642b97eb71f0a9735048d7b -endbc3297ea9642b97eb71f0a9735048d7b: - ; // match: (Lsh8x64 x (Const64 [0])) // cond: // result: x - { + for { x := v.Args[0] if v.Args[1].Op != OpConst64 { - goto end715f3db41cccf963e25a20c33f618a04 + break } if v.Args[1].AuxInt != 0 { - goto end715f3db41cccf963e25a20c33f618a04 + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto end715f3db41cccf963e25a20c33f618a04 -end715f3db41cccf963e25a20c33f618a04: - ; // match: (Lsh8x64 _ (Const64 [c])) // cond: uint64(c) >= 8 // result: (Const64 [0]) - { + for { if v.Args[1].Op != OpConst64 { - goto endb6749df4d0cdc0cd9acc627187d73488 + break } c := v.Args[1].AuxInt if !(uint64(c) >= 8) { - goto endb6749df4d0cdc0cd9acc627187d73488 + break } v.reset(OpConst64) v.AuxInt = 0 return true } - goto endb6749df4d0cdc0cd9acc627187d73488 -endb6749df4d0cdc0cd9acc627187d73488: - ; // match: (Lsh8x64 (Lsh8x64 x (Const64 [c])) (Const64 [d])) // cond: !uaddOvf(c,d) // result: (Lsh8x64 x (Const64 [c+d])) - { + for { t := v.Type if v.Args[0].Op != OpLsh8x64 { - goto end73a4878b6bbd21c9e22fb99226ef947e + break } x := v.Args[0].Args[0] if v.Args[0].Args[1].Op != OpConst64 { - goto end73a4878b6bbd21c9e22fb99226ef947e + break } c := v.Args[0].Args[1].AuxInt if v.Args[1].Op != OpConst64 { - goto end73a4878b6bbd21c9e22fb99226ef947e + break } d := v.Args[1].AuxInt if !(!uaddOvf(c, d)) { - goto end73a4878b6bbd21c9e22fb99226ef947e + break } v.reset(OpLsh8x64) v.AddArg(x) @@ -3433,9 +3037,6 @@ endb6749df4d0cdc0cd9acc627187d73488: v.AddArg(v0) return true } - goto end73a4878b6bbd21c9e22fb99226ef947e -end73a4878b6bbd21c9e22fb99226ef947e: - ; return false } func rewriteValuegeneric_OpLsh8x8(v *Value, config *Config) bool { @@ -3444,11 +3045,11 @@ func rewriteValuegeneric_OpLsh8x8(v *Value, config *Config) bool { // match: (Lsh8x8 x (Const8 [c])) // cond: // result: (Lsh8x64 x (Const64 [int64(uint8(c))])) - { + for { t := v.Type x := v.Args[0] if v.Args[1].Op != OpConst8 { - goto end8b770597435467b0c96014624d522b33 + break } c := v.Args[1].AuxInt v.reset(OpLsh8x64) @@ -3458,9 +3059,6 @@ func rewriteValuegeneric_OpLsh8x8(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end8b770597435467b0c96014624d522b33 -end8b770597435467b0c96014624d522b33: - ; return false } func rewriteValuegeneric_OpMul16(v *Value, config *Config) bool { @@ -3469,22 +3067,19 @@ func rewriteValuegeneric_OpMul16(v *Value, config *Config) bool { // match: (Mul16 (Const16 [c]) (Const16 [d])) // cond: // result: (Const16 [c*d]) - { + for { if v.Args[0].Op != OpConst16 { - goto ende8dd468add3015aea24531cf3c89ccb7 + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst16 { - goto ende8dd468add3015aea24531cf3c89ccb7 + break } d := v.Args[1].AuxInt v.reset(OpConst16) v.AuxInt = c * d return true } - goto ende8dd468add3015aea24531cf3c89ccb7 -ende8dd468add3015aea24531cf3c89ccb7: - ; return false } func rewriteValuegeneric_OpMul32(v *Value, config *Config) bool { @@ -3493,22 +3088,19 @@ func rewriteValuegeneric_OpMul32(v *Value, config *Config) bool { // match: (Mul32 (Const32 [c]) (Const32 [d])) // cond: // result: (Const32 [c*d]) - { + for { if v.Args[0].Op != OpConst32 { - goto end60b4523099fa7b55e2e872e05bd497a7 + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst32 { - goto end60b4523099fa7b55e2e872e05bd497a7 + break } d := v.Args[1].AuxInt v.reset(OpConst32) v.AuxInt = c * d return true } - goto end60b4523099fa7b55e2e872e05bd497a7 -end60b4523099fa7b55e2e872e05bd497a7: - ; return false } func rewriteValuegeneric_OpMul64(v *Value, config *Config) bool { @@ -3517,22 +3109,19 @@ func rewriteValuegeneric_OpMul64(v *Value, config *Config) bool { // match: (Mul64 (Const64 [c]) (Const64 [d])) // cond: // result: (Const64 [c*d]) - { + for { if v.Args[0].Op != OpConst64 { - goto end7aea1048b5d1230974b97f17238380ae + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst64 { - goto end7aea1048b5d1230974b97f17238380ae + break } d := v.Args[1].AuxInt v.reset(OpConst64) v.AuxInt = c * d return true } - goto end7aea1048b5d1230974b97f17238380ae -end7aea1048b5d1230974b97f17238380ae: - ; return false } func rewriteValuegeneric_OpMul8(v *Value, config *Config) bool { @@ -3541,22 +3130,19 @@ func rewriteValuegeneric_OpMul8(v *Value, config *Config) bool { // match: (Mul8 (Const8 [c]) (Const8 [d])) // cond: // result: (Const8 [c*d]) - { + for { if v.Args[0].Op != OpConst8 { - goto end2f1952fd654c4a62ff00511041728809 + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst8 { - goto end2f1952fd654c4a62ff00511041728809 + break } d := v.Args[1].AuxInt v.reset(OpConst8) v.AuxInt = c * d return true } - goto end2f1952fd654c4a62ff00511041728809 -end2f1952fd654c4a62ff00511041728809: - ; return false } func rewriteValuegeneric_OpNeq16(v *Value, config *Config) bool { @@ -3565,35 +3151,32 @@ func rewriteValuegeneric_OpNeq16(v *Value, config *Config) bool { // match: (Neq16 x x) // cond: // result: (ConstBool [0]) - { + for { x := v.Args[0] if v.Args[1] != x { - goto ende76a50b524aeb16c7aeccf5f5cc60c06 + break } v.reset(OpConstBool) v.AuxInt = 0 return true } - goto ende76a50b524aeb16c7aeccf5f5cc60c06 -ende76a50b524aeb16c7aeccf5f5cc60c06: - ; // match: (Neq16 (Const16 [c]) (Add16 (Const16 [d]) x)) // cond: // result: (Neq16 (Const16 [c-d]) x) - { + for { if v.Args[0].Op != OpConst16 { - goto end552011bd97e6f92ebc2672aa1843eadd + break } t := v.Args[0].Type c := v.Args[0].AuxInt if v.Args[1].Op != OpAdd16 { - goto end552011bd97e6f92ebc2672aa1843eadd + break } if v.Args[1].Args[0].Op != OpConst16 { - goto end552011bd97e6f92ebc2672aa1843eadd + break } if v.Args[1].Args[0].Type != v.Args[0].Type { - goto end552011bd97e6f92ebc2672aa1843eadd + break } d := v.Args[1].Args[0].AuxInt x := v.Args[1].Args[1] @@ -3604,21 +3187,18 @@ ende76a50b524aeb16c7aeccf5f5cc60c06: v.AddArg(x) return true } - goto end552011bd97e6f92ebc2672aa1843eadd -end552011bd97e6f92ebc2672aa1843eadd: - ; // match: (Neq16 x (Const16 [c])) // cond: x.Op != OpConst16 // result: (Neq16 (Const16 [c]) x) - { + for { x := v.Args[0] if v.Args[1].Op != OpConst16 { - goto end0e45958f29e87997f632248aa9ee97e0 + break } t := v.Args[1].Type c := v.Args[1].AuxInt if !(x.Op != OpConst16) { - goto end0e45958f29e87997f632248aa9ee97e0 + break } v.reset(OpNeq16) v0 := b.NewValue0(v.Line, OpConst16, t) @@ -3627,28 +3207,22 @@ end552011bd97e6f92ebc2672aa1843eadd: v.AddArg(x) return true } - goto end0e45958f29e87997f632248aa9ee97e0 -end0e45958f29e87997f632248aa9ee97e0: - ; // match: (Neq16 (Const16 [c]) (Const16 [d])) // cond: // result: (ConstBool [b2i(int16(c) != int16(d))]) - { + for { if v.Args[0].Op != OpConst16 { - goto end6302c9b645bb191982d28c2f846904d6 + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst16 { - goto end6302c9b645bb191982d28c2f846904d6 + break } d := v.Args[1].AuxInt v.reset(OpConstBool) v.AuxInt = b2i(int16(c) != int16(d)) return true } - goto end6302c9b645bb191982d28c2f846904d6 -end6302c9b645bb191982d28c2f846904d6: - ; return false } func rewriteValuegeneric_OpNeq32(v *Value, config *Config) bool { @@ -3657,35 +3231,32 @@ func rewriteValuegeneric_OpNeq32(v *Value, config *Config) bool { // match: (Neq32 x x) // cond: // result: (ConstBool [0]) - { + for { x := v.Args[0] if v.Args[1] != x { - goto end3713a608cffd29b40ff7c3b3f2585cbb + break } v.reset(OpConstBool) v.AuxInt = 0 return true } - goto end3713a608cffd29b40ff7c3b3f2585cbb -end3713a608cffd29b40ff7c3b3f2585cbb: - ; // match: (Neq32 (Const32 [c]) (Add32 (Const32 [d]) x)) // cond: // result: (Neq32 (Const32 [c-d]) x) - { + for { if v.Args[0].Op != OpConst32 { - goto end93fc3b4a3639b965b414891111b16245 + break } t := v.Args[0].Type c := v.Args[0].AuxInt if v.Args[1].Op != OpAdd32 { - goto end93fc3b4a3639b965b414891111b16245 + break } if v.Args[1].Args[0].Op != OpConst32 { - goto end93fc3b4a3639b965b414891111b16245 + break } if v.Args[1].Args[0].Type != v.Args[0].Type { - goto end93fc3b4a3639b965b414891111b16245 + break } d := v.Args[1].Args[0].AuxInt x := v.Args[1].Args[1] @@ -3696,21 +3267,18 @@ end3713a608cffd29b40ff7c3b3f2585cbb: v.AddArg(x) return true } - goto end93fc3b4a3639b965b414891111b16245 -end93fc3b4a3639b965b414891111b16245: - ; // match: (Neq32 x (Const32 [c])) // cond: x.Op != OpConst32 // result: (Neq32 (Const32 [c]) x) - { + for { x := v.Args[0] if v.Args[1].Op != OpConst32 { - goto end5376f9ab90e282450f49011d0e0ce236 + break } t := v.Args[1].Type c := v.Args[1].AuxInt if !(x.Op != OpConst32) { - goto end5376f9ab90e282450f49011d0e0ce236 + break } v.reset(OpNeq32) v0 := b.NewValue0(v.Line, OpConst32, t) @@ -3719,28 +3287,22 @@ end93fc3b4a3639b965b414891111b16245: v.AddArg(x) return true } - goto end5376f9ab90e282450f49011d0e0ce236 -end5376f9ab90e282450f49011d0e0ce236: - ; // match: (Neq32 (Const32 [c]) (Const32 [d])) // cond: // result: (ConstBool [b2i(int32(c) != int32(d))]) - { + for { if v.Args[0].Op != OpConst32 { - goto endf9f3d0814854d2d0879d331e9bdfcae2 + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst32 { - goto endf9f3d0814854d2d0879d331e9bdfcae2 + break } d := v.Args[1].AuxInt v.reset(OpConstBool) v.AuxInt = b2i(int32(c) != int32(d)) return true } - goto endf9f3d0814854d2d0879d331e9bdfcae2 -endf9f3d0814854d2d0879d331e9bdfcae2: - ; return false } func rewriteValuegeneric_OpNeq64(v *Value, config *Config) bool { @@ -3749,35 +3311,32 @@ func rewriteValuegeneric_OpNeq64(v *Value, config *Config) bool { // match: (Neq64 x x) // cond: // result: (ConstBool [0]) - { + for { x := v.Args[0] if v.Args[1] != x { - goto end3601ad382705ea12b79d2008c1e5725c + break } v.reset(OpConstBool) v.AuxInt = 0 return true } - goto end3601ad382705ea12b79d2008c1e5725c -end3601ad382705ea12b79d2008c1e5725c: - ; // match: (Neq64 (Const64 [c]) (Add64 (Const64 [d]) x)) // cond: // result: (Neq64 (Const64 [c-d]) x) - { + for { if v.Args[0].Op != OpConst64 { - goto enda3d39cad13a557a2aa6d086f43596c1b + break } t := v.Args[0].Type c := v.Args[0].AuxInt if v.Args[1].Op != OpAdd64 { - goto enda3d39cad13a557a2aa6d086f43596c1b + break } if v.Args[1].Args[0].Op != OpConst64 { - goto enda3d39cad13a557a2aa6d086f43596c1b + break } if v.Args[1].Args[0].Type != v.Args[0].Type { - goto enda3d39cad13a557a2aa6d086f43596c1b + break } d := v.Args[1].Args[0].AuxInt x := v.Args[1].Args[1] @@ -3788,21 +3347,18 @@ end3601ad382705ea12b79d2008c1e5725c: v.AddArg(x) return true } - goto enda3d39cad13a557a2aa6d086f43596c1b -enda3d39cad13a557a2aa6d086f43596c1b: - ; // match: (Neq64 x (Const64 [c])) // cond: x.Op != OpConst64 // result: (Neq64 (Const64 [c]) x) - { + for { x := v.Args[0] if v.Args[1].Op != OpConst64 { - goto end0936a57de20373ca6cacb9506ddde708 + break } t := v.Args[1].Type c := v.Args[1].AuxInt if !(x.Op != OpConst64) { - goto end0936a57de20373ca6cacb9506ddde708 + break } v.reset(OpNeq64) v0 := b.NewValue0(v.Line, OpConst64, t) @@ -3811,28 +3367,22 @@ enda3d39cad13a557a2aa6d086f43596c1b: v.AddArg(x) return true } - goto end0936a57de20373ca6cacb9506ddde708 -end0936a57de20373ca6cacb9506ddde708: - ; // match: (Neq64 (Const64 [c]) (Const64 [d])) // cond: // result: (ConstBool [b2i(int64(c) != int64(d))]) - { + for { if v.Args[0].Op != OpConst64 { - goto endf07433ecd3c150b1b75e943aa44a7203 + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst64 { - goto endf07433ecd3c150b1b75e943aa44a7203 + break } d := v.Args[1].AuxInt v.reset(OpConstBool) v.AuxInt = b2i(int64(c) != int64(d)) return true } - goto endf07433ecd3c150b1b75e943aa44a7203 -endf07433ecd3c150b1b75e943aa44a7203: - ; return false } func rewriteValuegeneric_OpNeq8(v *Value, config *Config) bool { @@ -3841,35 +3391,32 @@ func rewriteValuegeneric_OpNeq8(v *Value, config *Config) bool { // match: (Neq8 x x) // cond: // result: (ConstBool [0]) - { + for { x := v.Args[0] if v.Args[1] != x { - goto end09a0deaf3c42627d0d2d3efa96e30745 + break } v.reset(OpConstBool) v.AuxInt = 0 return true } - goto end09a0deaf3c42627d0d2d3efa96e30745 -end09a0deaf3c42627d0d2d3efa96e30745: - ; // match: (Neq8 (Const8 [c]) (Add8 (Const8 [d]) x)) // cond: // result: (Neq8 (Const8 [c-d]) x) - { + for { if v.Args[0].Op != OpConst8 { - goto endc8f853c610c460c887cbfdca958e3691 + break } t := v.Args[0].Type c := v.Args[0].AuxInt if v.Args[1].Op != OpAdd8 { - goto endc8f853c610c460c887cbfdca958e3691 + break } if v.Args[1].Args[0].Op != OpConst8 { - goto endc8f853c610c460c887cbfdca958e3691 + break } if v.Args[1].Args[0].Type != v.Args[0].Type { - goto endc8f853c610c460c887cbfdca958e3691 + break } d := v.Args[1].Args[0].AuxInt x := v.Args[1].Args[1] @@ -3880,21 +3427,18 @@ end09a0deaf3c42627d0d2d3efa96e30745: v.AddArg(x) return true } - goto endc8f853c610c460c887cbfdca958e3691 -endc8f853c610c460c887cbfdca958e3691: - ; // match: (Neq8 x (Const8 [c])) // cond: x.Op != OpConst8 // result: (Neq8 (Const8 [c]) x) - { + for { x := v.Args[0] if v.Args[1].Op != OpConst8 { - goto end04dc0ae2b08cf0447b50e5b8ef469252 + break } t := v.Args[1].Type c := v.Args[1].AuxInt if !(x.Op != OpConst8) { - goto end04dc0ae2b08cf0447b50e5b8ef469252 + break } v.reset(OpNeq8) v0 := b.NewValue0(v.Line, OpConst8, t) @@ -3903,28 +3447,22 @@ endc8f853c610c460c887cbfdca958e3691: v.AddArg(x) return true } - goto end04dc0ae2b08cf0447b50e5b8ef469252 -end04dc0ae2b08cf0447b50e5b8ef469252: - ; // match: (Neq8 (Const8 [c]) (Const8 [d])) // cond: // result: (ConstBool [b2i(int8(c) != int8(d))]) - { + for { if v.Args[0].Op != OpConst8 { - goto end72ebdaf2de9b3aa57cf0cb8e068b5f9c + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst8 { - goto end72ebdaf2de9b3aa57cf0cb8e068b5f9c + break } d := v.Args[1].AuxInt v.reset(OpConstBool) v.AuxInt = b2i(int8(c) != int8(d)) return true } - goto end72ebdaf2de9b3aa57cf0cb8e068b5f9c -end72ebdaf2de9b3aa57cf0cb8e068b5f9c: - ; return false } func rewriteValuegeneric_OpNeqInter(v *Value, config *Config) bool { @@ -3933,7 +3471,7 @@ func rewriteValuegeneric_OpNeqInter(v *Value, config *Config) bool { // match: (NeqInter x y) // cond: // result: (NeqPtr (ITab x) (ITab y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpNeqPtr) @@ -3945,9 +3483,6 @@ func rewriteValuegeneric_OpNeqInter(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto end17b2333bf57e9fe81a671be02f9c4c14 -end17b2333bf57e9fe81a671be02f9c4c14: - ; return false } func rewriteValuegeneric_OpNeqPtr(v *Value, config *Config) bool { @@ -3956,33 +3491,27 @@ func rewriteValuegeneric_OpNeqPtr(v *Value, config *Config) bool { // match: (NeqPtr p (ConstNil)) // cond: // result: (IsNonNil p) - { + for { p := v.Args[0] if v.Args[1].Op != OpConstNil { - goto endba798520b4d41172b110347158c44791 + break } v.reset(OpIsNonNil) v.AddArg(p) return true } - goto endba798520b4d41172b110347158c44791 -endba798520b4d41172b110347158c44791: - ; // match: (NeqPtr (ConstNil) p) // cond: // result: (IsNonNil p) - { + for { if v.Args[0].Op != OpConstNil { - goto enddd95e9c3606d9fd48034f1a703561e45 + break } p := v.Args[1] v.reset(OpIsNonNil) v.AddArg(p) return true } - goto enddd95e9c3606d9fd48034f1a703561e45 -enddd95e9c3606d9fd48034f1a703561e45: - ; return false } func rewriteValuegeneric_OpNeqSlice(v *Value, config *Config) bool { @@ -3991,7 +3520,7 @@ func rewriteValuegeneric_OpNeqSlice(v *Value, config *Config) bool { // match: (NeqSlice x y) // cond: // result: (NeqPtr (SlicePtr x) (SlicePtr y)) - { + for { x := v.Args[0] y := v.Args[1] v.reset(OpNeqPtr) @@ -4003,9 +3532,6 @@ func rewriteValuegeneric_OpNeqSlice(v *Value, config *Config) bool { v.AddArg(v1) return true } - goto endc6bc83c506e491236ca66ea1081231a2 -endc6bc83c506e491236ca66ea1081231a2: - ; return false } func rewriteValuegeneric_OpOr16(v *Value, config *Config) bool { @@ -4014,19 +3540,16 @@ func rewriteValuegeneric_OpOr16(v *Value, config *Config) bool { // match: (Or16 x x) // cond: // result: x - { + for { x := v.Args[0] if v.Args[1] != x { - goto end47a2f25fd31a76807aced3e2b126acdc + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto end47a2f25fd31a76807aced3e2b126acdc -end47a2f25fd31a76807aced3e2b126acdc: - ; return false } func rewriteValuegeneric_OpOr32(v *Value, config *Config) bool { @@ -4035,19 +3558,16 @@ func rewriteValuegeneric_OpOr32(v *Value, config *Config) bool { // match: (Or32 x x) // cond: // result: x - { + for { x := v.Args[0] if v.Args[1] != x { - goto end231e283e568e90bd9a3e6a4fa328c8a4 + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto end231e283e568e90bd9a3e6a4fa328c8a4 -end231e283e568e90bd9a3e6a4fa328c8a4: - ; return false } func rewriteValuegeneric_OpOr64(v *Value, config *Config) bool { @@ -4056,19 +3576,16 @@ func rewriteValuegeneric_OpOr64(v *Value, config *Config) bool { // match: (Or64 x x) // cond: // result: x - { + for { x := v.Args[0] if v.Args[1] != x { - goto end6b0efc212016dc97d0e3939db04c81d9 + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto end6b0efc212016dc97d0e3939db04c81d9 -end6b0efc212016dc97d0e3939db04c81d9: - ; return false } func rewriteValuegeneric_OpOr8(v *Value, config *Config) bool { @@ -4077,19 +3594,16 @@ func rewriteValuegeneric_OpOr8(v *Value, config *Config) bool { // match: (Or8 x x) // cond: // result: x - { + for { x := v.Args[0] if v.Args[1] != x { - goto end05295dbfafd6869af79b4daee9fda000 + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto end05295dbfafd6869af79b4daee9fda000 -end05295dbfafd6869af79b4daee9fda000: - ; return false } func rewriteValuegeneric_OpPtrIndex(v *Value, config *Config) bool { @@ -4098,12 +3612,12 @@ func rewriteValuegeneric_OpPtrIndex(v *Value, config *Config) bool { // match: (PtrIndex ptr idx) // cond: config.PtrSize == 4 // result: (AddPtr ptr (Mul32 idx (Const32 [t.Elem().Size()]))) - { + for { t := v.Type ptr := v.Args[0] idx := v.Args[1] if !(config.PtrSize == 4) { - goto endd902622aaa1e7545b5a2a0c08b47d287 + break } v.reset(OpAddPtr) v.AddArg(ptr) @@ -4115,18 +3629,15 @@ func rewriteValuegeneric_OpPtrIndex(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto endd902622aaa1e7545b5a2a0c08b47d287 -endd902622aaa1e7545b5a2a0c08b47d287: - ; // match: (PtrIndex ptr idx) // cond: config.PtrSize == 8 // result: (AddPtr ptr (Mul64 idx (Const64 [t.Elem().Size()]))) - { + for { t := v.Type ptr := v.Args[0] idx := v.Args[1] if !(config.PtrSize == 8) { - goto end47a5f1d1b158914fa383de024bbe3b08 + break } v.reset(OpAddPtr) v.AddArg(ptr) @@ -4138,9 +3649,6 @@ endd902622aaa1e7545b5a2a0c08b47d287: v.AddArg(v0) return true } - goto end47a5f1d1b158914fa383de024bbe3b08 -end47a5f1d1b158914fa383de024bbe3b08: - ; return false } func rewriteValuegeneric_OpRsh16Ux16(v *Value, config *Config) bool { @@ -4149,11 +3657,11 @@ func rewriteValuegeneric_OpRsh16Ux16(v *Value, config *Config) bool { // match: (Rsh16Ux16 x (Const16 [c])) // cond: // result: (Rsh16Ux64 x (Const64 [int64(uint16(c))])) - { + for { t := v.Type x := v.Args[0] if v.Args[1].Op != OpConst16 { - goto endd981df40f353104ef828d13ad4ccdf02 + break } c := v.Args[1].AuxInt v.reset(OpRsh16Ux64) @@ -4163,9 +3671,6 @@ func rewriteValuegeneric_OpRsh16Ux16(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto endd981df40f353104ef828d13ad4ccdf02 -endd981df40f353104ef828d13ad4ccdf02: - ; return false } func rewriteValuegeneric_OpRsh16Ux32(v *Value, config *Config) bool { @@ -4174,11 +3679,11 @@ func rewriteValuegeneric_OpRsh16Ux32(v *Value, config *Config) bool { // match: (Rsh16Ux32 x (Const32 [c])) // cond: // result: (Rsh16Ux64 x (Const64 [int64(uint32(c))])) - { + for { t := v.Type x := v.Args[0] if v.Args[1].Op != OpConst32 { - goto ende0be9ee562725206dcf96d3e5750b5ea + break } c := v.Args[1].AuxInt v.reset(OpRsh16Ux64) @@ -4188,9 +3693,6 @@ func rewriteValuegeneric_OpRsh16Ux32(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto ende0be9ee562725206dcf96d3e5750b5ea -ende0be9ee562725206dcf96d3e5750b5ea: - ; return false } func rewriteValuegeneric_OpRsh16Ux64(v *Value, config *Config) bool { @@ -4199,78 +3701,69 @@ func rewriteValuegeneric_OpRsh16Ux64(v *Value, config *Config) bool { // match: (Rsh16Ux64 (Const16 [c]) (Const64 [d])) // cond: // result: (Const16 [int64(uint16(c) >> uint64(d))]) - { + for { if v.Args[0].Op != OpConst16 { - goto ended17f40375fb44bcbaf2d87161c5ed3c + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst64 { - goto ended17f40375fb44bcbaf2d87161c5ed3c + break } d := v.Args[1].AuxInt v.reset(OpConst16) v.AuxInt = int64(uint16(c) >> uint64(d)) return true } - goto ended17f40375fb44bcbaf2d87161c5ed3c -ended17f40375fb44bcbaf2d87161c5ed3c: - ; // match: (Rsh16Ux64 x (Const64 [0])) // cond: // result: x - { + for { x := v.Args[0] if v.Args[1].Op != OpConst64 { - goto end752d1b5a60f87afa7e40febbf1bce309 + break } if v.Args[1].AuxInt != 0 { - goto end752d1b5a60f87afa7e40febbf1bce309 + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto end752d1b5a60f87afa7e40febbf1bce309 -end752d1b5a60f87afa7e40febbf1bce309: - ; // match: (Rsh16Ux64 _ (Const64 [c])) // cond: uint64(c) >= 16 // result: (Const64 [0]) - { + for { if v.Args[1].Op != OpConst64 { - goto endca5c7ae2e51f2ae32486c2b1a3033b77 + break } c := v.Args[1].AuxInt if !(uint64(c) >= 16) { - goto endca5c7ae2e51f2ae32486c2b1a3033b77 + break } v.reset(OpConst64) v.AuxInt = 0 return true } - goto endca5c7ae2e51f2ae32486c2b1a3033b77 -endca5c7ae2e51f2ae32486c2b1a3033b77: - ; // match: (Rsh16Ux64 (Rsh16Ux64 x (Const64 [c])) (Const64 [d])) // cond: !uaddOvf(c,d) // result: (Rsh16Ux64 x (Const64 [c+d])) - { + for { t := v.Type if v.Args[0].Op != OpRsh16Ux64 { - goto end56f2c0034c9fbe651abb36fb640af465 + break } x := v.Args[0].Args[0] if v.Args[0].Args[1].Op != OpConst64 { - goto end56f2c0034c9fbe651abb36fb640af465 + break } c := v.Args[0].Args[1].AuxInt if v.Args[1].Op != OpConst64 { - goto end56f2c0034c9fbe651abb36fb640af465 + break } d := v.Args[1].AuxInt if !(!uaddOvf(c, d)) { - goto end56f2c0034c9fbe651abb36fb640af465 + break } v.reset(OpRsh16Ux64) v.AddArg(x) @@ -4279,9 +3772,6 @@ endca5c7ae2e51f2ae32486c2b1a3033b77: v.AddArg(v0) return true } - goto end56f2c0034c9fbe651abb36fb640af465 -end56f2c0034c9fbe651abb36fb640af465: - ; return false } func rewriteValuegeneric_OpRsh16Ux8(v *Value, config *Config) bool { @@ -4290,11 +3780,11 @@ func rewriteValuegeneric_OpRsh16Ux8(v *Value, config *Config) bool { // match: (Rsh16Ux8 x (Const8 [c])) // cond: // result: (Rsh16Ux64 x (Const64 [int64(uint8(c))])) - { + for { t := v.Type x := v.Args[0] if v.Args[1].Op != OpConst8 { - goto end20d4667094c32c71bac4e0805dab85c9 + break } c := v.Args[1].AuxInt v.reset(OpRsh16Ux64) @@ -4304,9 +3794,6 @@ func rewriteValuegeneric_OpRsh16Ux8(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end20d4667094c32c71bac4e0805dab85c9 -end20d4667094c32c71bac4e0805dab85c9: - ; return false } func rewriteValuegeneric_OpRsh16x16(v *Value, config *Config) bool { @@ -4315,11 +3802,11 @@ func rewriteValuegeneric_OpRsh16x16(v *Value, config *Config) bool { // match: (Rsh16x16 x (Const16 [c])) // cond: // result: (Rsh16x64 x (Const64 [int64(uint16(c))])) - { + for { t := v.Type x := v.Args[0] if v.Args[1].Op != OpConst16 { - goto end1b501c7ae2fe58ad3a88b467f2d95389 + break } c := v.Args[1].AuxInt v.reset(OpRsh16x64) @@ -4329,9 +3816,6 @@ func rewriteValuegeneric_OpRsh16x16(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end1b501c7ae2fe58ad3a88b467f2d95389 -end1b501c7ae2fe58ad3a88b467f2d95389: - ; return false } func rewriteValuegeneric_OpRsh16x32(v *Value, config *Config) bool { @@ -4340,11 +3824,11 @@ func rewriteValuegeneric_OpRsh16x32(v *Value, config *Config) bool { // match: (Rsh16x32 x (Const32 [c])) // cond: // result: (Rsh16x64 x (Const64 [int64(uint32(c))])) - { + for { t := v.Type x := v.Args[0] if v.Args[1].Op != OpConst32 { - goto end4d3a41113d2d0b09924bf5759ca49cab + break } c := v.Args[1].AuxInt v.reset(OpRsh16x64) @@ -4354,9 +3838,6 @@ func rewriteValuegeneric_OpRsh16x32(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end4d3a41113d2d0b09924bf5759ca49cab -end4d3a41113d2d0b09924bf5759ca49cab: - ; return false } func rewriteValuegeneric_OpRsh16x64(v *Value, config *Config) bool { @@ -4365,60 +3846,54 @@ func rewriteValuegeneric_OpRsh16x64(v *Value, config *Config) bool { // match: (Rsh16x64 (Const16 [c]) (Const64 [d])) // cond: // result: (Const16 [int64(int16(c) >> uint64(d))]) - { + for { if v.Args[0].Op != OpConst16 { - goto end8f05fede35a3d2f687fcd4a5829a25ad + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst64 { - goto end8f05fede35a3d2f687fcd4a5829a25ad + break } d := v.Args[1].AuxInt v.reset(OpConst16) v.AuxInt = int64(int16(c) >> uint64(d)) return true } - goto end8f05fede35a3d2f687fcd4a5829a25ad -end8f05fede35a3d2f687fcd4a5829a25ad: - ; // match: (Rsh16x64 x (Const64 [0])) // cond: // result: x - { + for { x := v.Args[0] if v.Args[1].Op != OpConst64 { - goto end750fafe01fcc689d953101d53efc19ab + break } if v.Args[1].AuxInt != 0 { - goto end750fafe01fcc689d953101d53efc19ab + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto end750fafe01fcc689d953101d53efc19ab -end750fafe01fcc689d953101d53efc19ab: - ; // match: (Rsh16x64 (Rsh16x64 x (Const64 [c])) (Const64 [d])) // cond: !uaddOvf(c,d) // result: (Rsh16x64 x (Const64 [c+d])) - { + for { t := v.Type if v.Args[0].Op != OpRsh16x64 { - goto endf425eff9e05aad27194af957e3383c76 + break } x := v.Args[0].Args[0] if v.Args[0].Args[1].Op != OpConst64 { - goto endf425eff9e05aad27194af957e3383c76 + break } c := v.Args[0].Args[1].AuxInt if v.Args[1].Op != OpConst64 { - goto endf425eff9e05aad27194af957e3383c76 + break } d := v.Args[1].AuxInt if !(!uaddOvf(c, d)) { - goto endf425eff9e05aad27194af957e3383c76 + break } v.reset(OpRsh16x64) v.AddArg(x) @@ -4427,9 +3902,6 @@ end750fafe01fcc689d953101d53efc19ab: v.AddArg(v0) return true } - goto endf425eff9e05aad27194af957e3383c76 -endf425eff9e05aad27194af957e3383c76: - ; return false } func rewriteValuegeneric_OpRsh16x8(v *Value, config *Config) bool { @@ -4438,11 +3910,11 @@ func rewriteValuegeneric_OpRsh16x8(v *Value, config *Config) bool { // match: (Rsh16x8 x (Const8 [c])) // cond: // result: (Rsh16x64 x (Const64 [int64(uint8(c))])) - { + for { t := v.Type x := v.Args[0] if v.Args[1].Op != OpConst8 { - goto end0b5e274d62a3ae8df9f4089756c6a9d4 + break } c := v.Args[1].AuxInt v.reset(OpRsh16x64) @@ -4452,9 +3924,6 @@ func rewriteValuegeneric_OpRsh16x8(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end0b5e274d62a3ae8df9f4089756c6a9d4 -end0b5e274d62a3ae8df9f4089756c6a9d4: - ; return false } func rewriteValuegeneric_OpRsh32Ux16(v *Value, config *Config) bool { @@ -4463,11 +3932,11 @@ func rewriteValuegeneric_OpRsh32Ux16(v *Value, config *Config) bool { // match: (Rsh32Ux16 x (Const16 [c])) // cond: // result: (Rsh32Ux64 x (Const64 [int64(uint16(c))])) - { + for { t := v.Type x := v.Args[0] if v.Args[1].Op != OpConst16 { - goto end8d8f9f3e2e1f7a5e9a186fb792fc40a8 + break } c := v.Args[1].AuxInt v.reset(OpRsh32Ux64) @@ -4477,9 +3946,6 @@ func rewriteValuegeneric_OpRsh32Ux16(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end8d8f9f3e2e1f7a5e9a186fb792fc40a8 -end8d8f9f3e2e1f7a5e9a186fb792fc40a8: - ; return false } func rewriteValuegeneric_OpRsh32Ux32(v *Value, config *Config) bool { @@ -4488,11 +3954,11 @@ func rewriteValuegeneric_OpRsh32Ux32(v *Value, config *Config) bool { // match: (Rsh32Ux32 x (Const32 [c])) // cond: // result: (Rsh32Ux64 x (Const64 [int64(uint32(c))])) - { + for { t := v.Type x := v.Args[0] if v.Args[1].Op != OpConst32 { - goto endd23d060f74e00f34cc967b6fb9a4d320 + break } c := v.Args[1].AuxInt v.reset(OpRsh32Ux64) @@ -4502,9 +3968,6 @@ func rewriteValuegeneric_OpRsh32Ux32(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto endd23d060f74e00f34cc967b6fb9a4d320 -endd23d060f74e00f34cc967b6fb9a4d320: - ; return false } func rewriteValuegeneric_OpRsh32Ux64(v *Value, config *Config) bool { @@ -4513,78 +3976,69 @@ func rewriteValuegeneric_OpRsh32Ux64(v *Value, config *Config) bool { // match: (Rsh32Ux64 (Const32 [c]) (Const64 [d])) // cond: // result: (Const32 [int64(uint32(c) >> uint64(d))]) - { + for { if v.Args[0].Op != OpConst32 { - goto enda101e6b765d7ecffd9b7410c9dc3be82 + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst64 { - goto enda101e6b765d7ecffd9b7410c9dc3be82 + break } d := v.Args[1].AuxInt v.reset(OpConst32) v.AuxInt = int64(uint32(c) >> uint64(d)) return true } - goto enda101e6b765d7ecffd9b7410c9dc3be82 -enda101e6b765d7ecffd9b7410c9dc3be82: - ; // match: (Rsh32Ux64 x (Const64 [0])) // cond: // result: x - { + for { x := v.Args[0] if v.Args[1].Op != OpConst64 { - goto end162e4e182a665d4e6f0d85fe131e7288 + break } if v.Args[1].AuxInt != 0 { - goto end162e4e182a665d4e6f0d85fe131e7288 + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto end162e4e182a665d4e6f0d85fe131e7288 -end162e4e182a665d4e6f0d85fe131e7288: - ; // match: (Rsh32Ux64 _ (Const64 [c])) // cond: uint64(c) >= 32 // result: (Const64 [0]) - { + for { if v.Args[1].Op != OpConst64 { - goto endca322c370839b4264b219ee042a6ab33 + break } c := v.Args[1].AuxInt if !(uint64(c) >= 32) { - goto endca322c370839b4264b219ee042a6ab33 + break } v.reset(OpConst64) v.AuxInt = 0 return true } - goto endca322c370839b4264b219ee042a6ab33 -endca322c370839b4264b219ee042a6ab33: - ; // match: (Rsh32Ux64 (Rsh32Ux64 x (Const64 [c])) (Const64 [d])) // cond: !uaddOvf(c,d) // result: (Rsh32Ux64 x (Const64 [c+d])) - { + for { t := v.Type if v.Args[0].Op != OpRsh32Ux64 { - goto end2e502d68a32663142684194adbe6c297 + break } x := v.Args[0].Args[0] if v.Args[0].Args[1].Op != OpConst64 { - goto end2e502d68a32663142684194adbe6c297 + break } c := v.Args[0].Args[1].AuxInt if v.Args[1].Op != OpConst64 { - goto end2e502d68a32663142684194adbe6c297 + break } d := v.Args[1].AuxInt if !(!uaddOvf(c, d)) { - goto end2e502d68a32663142684194adbe6c297 + break } v.reset(OpRsh32Ux64) v.AddArg(x) @@ -4593,9 +4047,6 @@ endca322c370839b4264b219ee042a6ab33: v.AddArg(v0) return true } - goto end2e502d68a32663142684194adbe6c297 -end2e502d68a32663142684194adbe6c297: - ; return false } func rewriteValuegeneric_OpRsh32Ux8(v *Value, config *Config) bool { @@ -4604,11 +4055,11 @@ func rewriteValuegeneric_OpRsh32Ux8(v *Value, config *Config) bool { // match: (Rsh32Ux8 x (Const8 [c])) // cond: // result: (Rsh32Ux64 x (Const64 [int64(uint8(c))])) - { + for { t := v.Type x := v.Args[0] if v.Args[1].Op != OpConst8 { - goto end967cea80158afaffb783f6da7aa898ca + break } c := v.Args[1].AuxInt v.reset(OpRsh32Ux64) @@ -4618,9 +4069,6 @@ func rewriteValuegeneric_OpRsh32Ux8(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end967cea80158afaffb783f6da7aa898ca -end967cea80158afaffb783f6da7aa898ca: - ; return false } func rewriteValuegeneric_OpRsh32x16(v *Value, config *Config) bool { @@ -4629,11 +4077,11 @@ func rewriteValuegeneric_OpRsh32x16(v *Value, config *Config) bool { // match: (Rsh32x16 x (Const16 [c])) // cond: // result: (Rsh32x64 x (Const64 [int64(uint16(c))])) - { + for { t := v.Type x := v.Args[0] if v.Args[1].Op != OpConst16 { - goto end6a62ebdcc98ea2e3214559214708d26a + break } c := v.Args[1].AuxInt v.reset(OpRsh32x64) @@ -4643,9 +4091,6 @@ func rewriteValuegeneric_OpRsh32x16(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end6a62ebdcc98ea2e3214559214708d26a -end6a62ebdcc98ea2e3214559214708d26a: - ; return false } func rewriteValuegeneric_OpRsh32x32(v *Value, config *Config) bool { @@ -4654,11 +4099,11 @@ func rewriteValuegeneric_OpRsh32x32(v *Value, config *Config) bool { // match: (Rsh32x32 x (Const32 [c])) // cond: // result: (Rsh32x64 x (Const64 [int64(uint32(c))])) - { + for { t := v.Type x := v.Args[0] if v.Args[1].Op != OpConst32 { - goto end6e3b467acdca74f58e9177fb42a1968b + break } c := v.Args[1].AuxInt v.reset(OpRsh32x64) @@ -4668,9 +4113,6 @@ func rewriteValuegeneric_OpRsh32x32(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end6e3b467acdca74f58e9177fb42a1968b -end6e3b467acdca74f58e9177fb42a1968b: - ; return false } func rewriteValuegeneric_OpRsh32x64(v *Value, config *Config) bool { @@ -4679,60 +4121,54 @@ func rewriteValuegeneric_OpRsh32x64(v *Value, config *Config) bool { // match: (Rsh32x64 (Const32 [c]) (Const64 [d])) // cond: // result: (Const32 [int64(int32(c) >> uint64(d))]) - { + for { if v.Args[0].Op != OpConst32 { - goto end7e4b8c499cffe1fef73a16e6be54d4d2 + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst64 { - goto end7e4b8c499cffe1fef73a16e6be54d4d2 + break } d := v.Args[1].AuxInt v.reset(OpConst32) v.AuxInt = int64(int32(c) >> uint64(d)) return true } - goto end7e4b8c499cffe1fef73a16e6be54d4d2 -end7e4b8c499cffe1fef73a16e6be54d4d2: - ; // match: (Rsh32x64 x (Const64 [0])) // cond: // result: x - { + for { x := v.Args[0] if v.Args[1].Op != OpConst64 { - goto end72da2611eaaffe407efa1cc45c23ade3 + break } if v.Args[1].AuxInt != 0 { - goto end72da2611eaaffe407efa1cc45c23ade3 + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto end72da2611eaaffe407efa1cc45c23ade3 -end72da2611eaaffe407efa1cc45c23ade3: - ; // match: (Rsh32x64 (Rsh32x64 x (Const64 [c])) (Const64 [d])) // cond: !uaddOvf(c,d) // result: (Rsh32x64 x (Const64 [c+d])) - { + for { t := v.Type if v.Args[0].Op != OpRsh32x64 { - goto endadb415be78ee46a8a4135ec50df772b0 + break } x := v.Args[0].Args[0] if v.Args[0].Args[1].Op != OpConst64 { - goto endadb415be78ee46a8a4135ec50df772b0 + break } c := v.Args[0].Args[1].AuxInt if v.Args[1].Op != OpConst64 { - goto endadb415be78ee46a8a4135ec50df772b0 + break } d := v.Args[1].AuxInt if !(!uaddOvf(c, d)) { - goto endadb415be78ee46a8a4135ec50df772b0 + break } v.reset(OpRsh32x64) v.AddArg(x) @@ -4741,9 +4177,6 @@ end72da2611eaaffe407efa1cc45c23ade3: v.AddArg(v0) return true } - goto endadb415be78ee46a8a4135ec50df772b0 -endadb415be78ee46a8a4135ec50df772b0: - ; return false } func rewriteValuegeneric_OpRsh32x8(v *Value, config *Config) bool { @@ -4752,11 +4185,11 @@ func rewriteValuegeneric_OpRsh32x8(v *Value, config *Config) bool { // match: (Rsh32x8 x (Const8 [c])) // cond: // result: (Rsh32x64 x (Const64 [int64(uint8(c))])) - { + for { t := v.Type x := v.Args[0] if v.Args[1].Op != OpConst8 { - goto end7b59b42c5c68a2d55be469a0c086dd8b + break } c := v.Args[1].AuxInt v.reset(OpRsh32x64) @@ -4766,9 +4199,6 @@ func rewriteValuegeneric_OpRsh32x8(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end7b59b42c5c68a2d55be469a0c086dd8b -end7b59b42c5c68a2d55be469a0c086dd8b: - ; return false } func rewriteValuegeneric_OpRsh64Ux16(v *Value, config *Config) bool { @@ -4777,11 +4207,11 @@ func rewriteValuegeneric_OpRsh64Ux16(v *Value, config *Config) bool { // match: (Rsh64Ux16 x (Const16 [c])) // cond: // result: (Rsh64Ux64 x (Const64 [int64(uint16(c))])) - { + for { t := v.Type x := v.Args[0] if v.Args[1].Op != OpConst16 { - goto end733d85a7b599bcba969ca1cb4bdb9e48 + break } c := v.Args[1].AuxInt v.reset(OpRsh64Ux64) @@ -4791,9 +4221,6 @@ func rewriteValuegeneric_OpRsh64Ux16(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end733d85a7b599bcba969ca1cb4bdb9e48 -end733d85a7b599bcba969ca1cb4bdb9e48: - ; return false } func rewriteValuegeneric_OpRsh64Ux32(v *Value, config *Config) bool { @@ -4802,11 +4229,11 @@ func rewriteValuegeneric_OpRsh64Ux32(v *Value, config *Config) bool { // match: (Rsh64Ux32 x (Const32 [c])) // cond: // result: (Rsh64Ux64 x (Const64 [int64(uint32(c))])) - { + for { t := v.Type x := v.Args[0] if v.Args[1].Op != OpConst32 { - goto endeac7b34169de1fb0393b833e65b9bb19 + break } c := v.Args[1].AuxInt v.reset(OpRsh64Ux64) @@ -4816,9 +4243,6 @@ func rewriteValuegeneric_OpRsh64Ux32(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto endeac7b34169de1fb0393b833e65b9bb19 -endeac7b34169de1fb0393b833e65b9bb19: - ; return false } func rewriteValuegeneric_OpRsh64Ux64(v *Value, config *Config) bool { @@ -4827,78 +4251,69 @@ func rewriteValuegeneric_OpRsh64Ux64(v *Value, config *Config) bool { // match: (Rsh64Ux64 (Const64 [c]) (Const64 [d])) // cond: // result: (Const64 [int64(uint64(c) >> uint64(d))]) - { + for { if v.Args[0].Op != OpConst64 { - goto end102f4cfd7979a2aa222d52c34ac6802d + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst64 { - goto end102f4cfd7979a2aa222d52c34ac6802d + break } d := v.Args[1].AuxInt v.reset(OpConst64) v.AuxInt = int64(uint64(c) >> uint64(d)) return true } - goto end102f4cfd7979a2aa222d52c34ac6802d -end102f4cfd7979a2aa222d52c34ac6802d: - ; // match: (Rsh64Ux64 x (Const64 [0])) // cond: // result: x - { + for { x := v.Args[0] if v.Args[1].Op != OpConst64 { - goto end5ad037b910698f2847df90177c23a6ac + break } if v.Args[1].AuxInt != 0 { - goto end5ad037b910698f2847df90177c23a6ac + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto end5ad037b910698f2847df90177c23a6ac -end5ad037b910698f2847df90177c23a6ac: - ; // match: (Rsh64Ux64 _ (Const64 [c])) // cond: uint64(c) >= 64 // result: (Const64 [0]) - { + for { if v.Args[1].Op != OpConst64 { - goto end16ea16aa61862207ea64e514369d608b + break } c := v.Args[1].AuxInt if !(uint64(c) >= 64) { - goto end16ea16aa61862207ea64e514369d608b + break } v.reset(OpConst64) v.AuxInt = 0 return true } - goto end16ea16aa61862207ea64e514369d608b -end16ea16aa61862207ea64e514369d608b: - ; // match: (Rsh64Ux64 (Rsh64Ux64 x (Const64 [c])) (Const64 [d])) // cond: !uaddOvf(c,d) // result: (Rsh64Ux64 x (Const64 [c+d])) - { + for { t := v.Type if v.Args[0].Op != OpRsh64Ux64 { - goto end32bfdb1b4ccc23a5cd62fc0348ebd877 + break } x := v.Args[0].Args[0] if v.Args[0].Args[1].Op != OpConst64 { - goto end32bfdb1b4ccc23a5cd62fc0348ebd877 + break } c := v.Args[0].Args[1].AuxInt if v.Args[1].Op != OpConst64 { - goto end32bfdb1b4ccc23a5cd62fc0348ebd877 + break } d := v.Args[1].AuxInt if !(!uaddOvf(c, d)) { - goto end32bfdb1b4ccc23a5cd62fc0348ebd877 + break } v.reset(OpRsh64Ux64) v.AddArg(x) @@ -4907,9 +4322,6 @@ end16ea16aa61862207ea64e514369d608b: v.AddArg(v0) return true } - goto end32bfdb1b4ccc23a5cd62fc0348ebd877 -end32bfdb1b4ccc23a5cd62fc0348ebd877: - ; return false } func rewriteValuegeneric_OpRsh64Ux8(v *Value, config *Config) bool { @@ -4918,11 +4330,11 @@ func rewriteValuegeneric_OpRsh64Ux8(v *Value, config *Config) bool { // match: (Rsh64Ux8 x (Const8 [c])) // cond: // result: (Rsh64Ux64 x (Const64 [int64(uint8(c))])) - { + for { t := v.Type x := v.Args[0] if v.Args[1].Op != OpConst8 { - goto ende3d8090a67a52dbcd24b52ee32c9d7f0 + break } c := v.Args[1].AuxInt v.reset(OpRsh64Ux64) @@ -4932,9 +4344,6 @@ func rewriteValuegeneric_OpRsh64Ux8(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto ende3d8090a67a52dbcd24b52ee32c9d7f0 -ende3d8090a67a52dbcd24b52ee32c9d7f0: - ; return false } func rewriteValuegeneric_OpRsh64x16(v *Value, config *Config) bool { @@ -4943,11 +4352,11 @@ func rewriteValuegeneric_OpRsh64x16(v *Value, config *Config) bool { // match: (Rsh64x16 x (Const16 [c])) // cond: // result: (Rsh64x64 x (Const64 [int64(uint16(c))])) - { + for { t := v.Type x := v.Args[0] if v.Args[1].Op != OpConst16 { - goto endd5151d0bfc38c55ae6ae6836014df3bc + break } c := v.Args[1].AuxInt v.reset(OpRsh64x64) @@ -4957,9 +4366,6 @@ func rewriteValuegeneric_OpRsh64x16(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto endd5151d0bfc38c55ae6ae6836014df3bc -endd5151d0bfc38c55ae6ae6836014df3bc: - ; return false } func rewriteValuegeneric_OpRsh64x32(v *Value, config *Config) bool { @@ -4968,11 +4374,11 @@ func rewriteValuegeneric_OpRsh64x32(v *Value, config *Config) bool { // match: (Rsh64x32 x (Const32 [c])) // cond: // result: (Rsh64x64 x (Const64 [int64(uint32(c))])) - { + for { t := v.Type x := v.Args[0] if v.Args[1].Op != OpConst32 { - goto end0f2dbca5c7d6b100890c94a97bf0de7c + break } c := v.Args[1].AuxInt v.reset(OpRsh64x64) @@ -4982,9 +4388,6 @@ func rewriteValuegeneric_OpRsh64x32(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end0f2dbca5c7d6b100890c94a97bf0de7c -end0f2dbca5c7d6b100890c94a97bf0de7c: - ; return false } func rewriteValuegeneric_OpRsh64x64(v *Value, config *Config) bool { @@ -4993,60 +4396,54 @@ func rewriteValuegeneric_OpRsh64x64(v *Value, config *Config) bool { // match: (Rsh64x64 (Const64 [c]) (Const64 [d])) // cond: // result: (Const64 [c >> uint64(d)]) - { + for { if v.Args[0].Op != OpConst64 { - goto endfa4609d6bea8a3e3d3a777b1968c97d9 + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst64 { - goto endfa4609d6bea8a3e3d3a777b1968c97d9 + break } d := v.Args[1].AuxInt v.reset(OpConst64) v.AuxInt = c >> uint64(d) return true } - goto endfa4609d6bea8a3e3d3a777b1968c97d9 -endfa4609d6bea8a3e3d3a777b1968c97d9: - ; // match: (Rsh64x64 x (Const64 [0])) // cond: // result: x - { + for { x := v.Args[0] if v.Args[1].Op != OpConst64 { - goto ende62e0c67d3f04eb221646371a2a91d05 + break } if v.Args[1].AuxInt != 0 { - goto ende62e0c67d3f04eb221646371a2a91d05 + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto ende62e0c67d3f04eb221646371a2a91d05 -ende62e0c67d3f04eb221646371a2a91d05: - ; // match: (Rsh64x64 (Rsh64x64 x (Const64 [c])) (Const64 [d])) // cond: !uaddOvf(c,d) // result: (Rsh64x64 x (Const64 [c+d])) - { + for { t := v.Type if v.Args[0].Op != OpRsh64x64 { - goto endd3e8ea66dc3ad0bc393001d6babb7160 + break } x := v.Args[0].Args[0] if v.Args[0].Args[1].Op != OpConst64 { - goto endd3e8ea66dc3ad0bc393001d6babb7160 + break } c := v.Args[0].Args[1].AuxInt if v.Args[1].Op != OpConst64 { - goto endd3e8ea66dc3ad0bc393001d6babb7160 + break } d := v.Args[1].AuxInt if !(!uaddOvf(c, d)) { - goto endd3e8ea66dc3ad0bc393001d6babb7160 + break } v.reset(OpRsh64x64) v.AddArg(x) @@ -5055,9 +4452,6 @@ ende62e0c67d3f04eb221646371a2a91d05: v.AddArg(v0) return true } - goto endd3e8ea66dc3ad0bc393001d6babb7160 -endd3e8ea66dc3ad0bc393001d6babb7160: - ; return false } func rewriteValuegeneric_OpRsh64x8(v *Value, config *Config) bool { @@ -5066,11 +4460,11 @@ func rewriteValuegeneric_OpRsh64x8(v *Value, config *Config) bool { // match: (Rsh64x8 x (Const8 [c])) // cond: // result: (Rsh64x64 x (Const64 [int64(uint8(c))])) - { + for { t := v.Type x := v.Args[0] if v.Args[1].Op != OpConst8 { - goto end1a9e5a89849344396210da7c7ec810be + break } c := v.Args[1].AuxInt v.reset(OpRsh64x64) @@ -5080,9 +4474,6 @@ func rewriteValuegeneric_OpRsh64x8(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end1a9e5a89849344396210da7c7ec810be -end1a9e5a89849344396210da7c7ec810be: - ; return false } func rewriteValuegeneric_OpRsh8Ux16(v *Value, config *Config) bool { @@ -5091,11 +4482,11 @@ func rewriteValuegeneric_OpRsh8Ux16(v *Value, config *Config) bool { // match: (Rsh8Ux16 x (Const16 [c])) // cond: // result: (Rsh8Ux64 x (Const64 [int64(uint16(c))])) - { + for { t := v.Type x := v.Args[0] if v.Args[1].Op != OpConst16 { - goto end7acc015610273092e9efcce2949ee0f9 + break } c := v.Args[1].AuxInt v.reset(OpRsh8Ux64) @@ -5105,9 +4496,6 @@ func rewriteValuegeneric_OpRsh8Ux16(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end7acc015610273092e9efcce2949ee0f9 -end7acc015610273092e9efcce2949ee0f9: - ; return false } func rewriteValuegeneric_OpRsh8Ux32(v *Value, config *Config) bool { @@ -5116,11 +4504,11 @@ func rewriteValuegeneric_OpRsh8Ux32(v *Value, config *Config) bool { // match: (Rsh8Ux32 x (Const32 [c])) // cond: // result: (Rsh8Ux64 x (Const64 [int64(uint32(c))])) - { + for { t := v.Type x := v.Args[0] if v.Args[1].Op != OpConst32 { - goto end27e9b4472e085b653a105b1d67554ce8 + break } c := v.Args[1].AuxInt v.reset(OpRsh8Ux64) @@ -5130,9 +4518,6 @@ func rewriteValuegeneric_OpRsh8Ux32(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end27e9b4472e085b653a105b1d67554ce8 -end27e9b4472e085b653a105b1d67554ce8: - ; return false } func rewriteValuegeneric_OpRsh8Ux64(v *Value, config *Config) bool { @@ -5141,78 +4526,69 @@ func rewriteValuegeneric_OpRsh8Ux64(v *Value, config *Config) bool { // match: (Rsh8Ux64 (Const8 [c]) (Const64 [d])) // cond: // result: (Const8 [int64(uint8(c) >> uint64(d))]) - { + for { if v.Args[0].Op != OpConst8 { - goto enddd166e450d81ba7b466d61d2fbec178c + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst64 { - goto enddd166e450d81ba7b466d61d2fbec178c + break } d := v.Args[1].AuxInt v.reset(OpConst8) v.AuxInt = int64(uint8(c) >> uint64(d)) return true } - goto enddd166e450d81ba7b466d61d2fbec178c -enddd166e450d81ba7b466d61d2fbec178c: - ; // match: (Rsh8Ux64 x (Const64 [0])) // cond: // result: x - { + for { x := v.Args[0] if v.Args[1].Op != OpConst64 { - goto end570cb1d9db3c7bebd85e485eeb2c0969 + break } if v.Args[1].AuxInt != 0 { - goto end570cb1d9db3c7bebd85e485eeb2c0969 + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto end570cb1d9db3c7bebd85e485eeb2c0969 -end570cb1d9db3c7bebd85e485eeb2c0969: - ; // match: (Rsh8Ux64 _ (Const64 [c])) // cond: uint64(c) >= 8 // result: (Const64 [0]) - { + for { if v.Args[1].Op != OpConst64 { - goto endb63e1a7d1d91716ca0d9d74215361323 + break } c := v.Args[1].AuxInt if !(uint64(c) >= 8) { - goto endb63e1a7d1d91716ca0d9d74215361323 + break } v.reset(OpConst64) v.AuxInt = 0 return true } - goto endb63e1a7d1d91716ca0d9d74215361323 -endb63e1a7d1d91716ca0d9d74215361323: - ; // match: (Rsh8Ux64 (Rsh8Ux64 x (Const64 [c])) (Const64 [d])) // cond: !uaddOvf(c,d) // result: (Rsh8Ux64 x (Const64 [c+d])) - { + for { t := v.Type if v.Args[0].Op != OpRsh8Ux64 { - goto endee8824b7071ed1a6dba4fcbaab98229e + break } x := v.Args[0].Args[0] if v.Args[0].Args[1].Op != OpConst64 { - goto endee8824b7071ed1a6dba4fcbaab98229e + break } c := v.Args[0].Args[1].AuxInt if v.Args[1].Op != OpConst64 { - goto endee8824b7071ed1a6dba4fcbaab98229e + break } d := v.Args[1].AuxInt if !(!uaddOvf(c, d)) { - goto endee8824b7071ed1a6dba4fcbaab98229e + break } v.reset(OpRsh8Ux64) v.AddArg(x) @@ -5221,9 +4597,6 @@ endb63e1a7d1d91716ca0d9d74215361323: v.AddArg(v0) return true } - goto endee8824b7071ed1a6dba4fcbaab98229e -endee8824b7071ed1a6dba4fcbaab98229e: - ; return false } func rewriteValuegeneric_OpRsh8Ux8(v *Value, config *Config) bool { @@ -5232,11 +4605,11 @@ func rewriteValuegeneric_OpRsh8Ux8(v *Value, config *Config) bool { // match: (Rsh8Ux8 x (Const8 [c])) // cond: // result: (Rsh8Ux64 x (Const64 [int64(uint8(c))])) - { + for { t := v.Type x := v.Args[0] if v.Args[1].Op != OpConst8 { - goto ended7e4f4d9ab89dc26e6649d466577930 + break } c := v.Args[1].AuxInt v.reset(OpRsh8Ux64) @@ -5246,9 +4619,6 @@ func rewriteValuegeneric_OpRsh8Ux8(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto ended7e4f4d9ab89dc26e6649d466577930 -ended7e4f4d9ab89dc26e6649d466577930: - ; return false } func rewriteValuegeneric_OpRsh8x16(v *Value, config *Config) bool { @@ -5257,11 +4627,11 @@ func rewriteValuegeneric_OpRsh8x16(v *Value, config *Config) bool { // match: (Rsh8x16 x (Const16 [c])) // cond: // result: (Rsh8x64 x (Const64 [int64(uint16(c))])) - { + for { t := v.Type x := v.Args[0] if v.Args[1].Op != OpConst16 { - goto end136bef6f60180bc8b4befbfc370af7ef + break } c := v.Args[1].AuxInt v.reset(OpRsh8x64) @@ -5271,9 +4641,6 @@ func rewriteValuegeneric_OpRsh8x16(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end136bef6f60180bc8b4befbfc370af7ef -end136bef6f60180bc8b4befbfc370af7ef: - ; return false } func rewriteValuegeneric_OpRsh8x32(v *Value, config *Config) bool { @@ -5282,11 +4649,11 @@ func rewriteValuegeneric_OpRsh8x32(v *Value, config *Config) bool { // match: (Rsh8x32 x (Const32 [c])) // cond: // result: (Rsh8x64 x (Const64 [int64(uint32(c))])) - { + for { t := v.Type x := v.Args[0] if v.Args[1].Op != OpConst32 { - goto end2ef95c222a7c552fa9cc86e36196644e + break } c := v.Args[1].AuxInt v.reset(OpRsh8x64) @@ -5296,9 +4663,6 @@ func rewriteValuegeneric_OpRsh8x32(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto end2ef95c222a7c552fa9cc86e36196644e -end2ef95c222a7c552fa9cc86e36196644e: - ; return false } func rewriteValuegeneric_OpRsh8x64(v *Value, config *Config) bool { @@ -5307,60 +4671,54 @@ func rewriteValuegeneric_OpRsh8x64(v *Value, config *Config) bool { // match: (Rsh8x64 (Const8 [c]) (Const64 [d])) // cond: // result: (Const8 [int64(int8(c) >> uint64(d))]) - { + for { if v.Args[0].Op != OpConst8 { - goto end3b90206d75365466dfd1368e5b69db35 + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst64 { - goto end3b90206d75365466dfd1368e5b69db35 + break } d := v.Args[1].AuxInt v.reset(OpConst8) v.AuxInt = int64(int8(c) >> uint64(d)) return true } - goto end3b90206d75365466dfd1368e5b69db35 -end3b90206d75365466dfd1368e5b69db35: - ; // match: (Rsh8x64 x (Const64 [0])) // cond: // result: x - { + for { x := v.Args[0] if v.Args[1].Op != OpConst64 { - goto end1e664cc720a11d1c769de8081cfa1de4 + break } if v.Args[1].AuxInt != 0 { - goto end1e664cc720a11d1c769de8081cfa1de4 + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto end1e664cc720a11d1c769de8081cfa1de4 -end1e664cc720a11d1c769de8081cfa1de4: - ; // match: (Rsh8x64 (Rsh8x64 x (Const64 [c])) (Const64 [d])) // cond: !uaddOvf(c,d) // result: (Rsh8x64 x (Const64 [c+d])) - { + for { t := v.Type if v.Args[0].Op != OpRsh8x64 { - goto end6408685a7276af7e76ec086f359c942c + break } x := v.Args[0].Args[0] if v.Args[0].Args[1].Op != OpConst64 { - goto end6408685a7276af7e76ec086f359c942c + break } c := v.Args[0].Args[1].AuxInt if v.Args[1].Op != OpConst64 { - goto end6408685a7276af7e76ec086f359c942c + break } d := v.Args[1].AuxInt if !(!uaddOvf(c, d)) { - goto end6408685a7276af7e76ec086f359c942c + break } v.reset(OpRsh8x64) v.AddArg(x) @@ -5369,9 +4727,6 @@ end1e664cc720a11d1c769de8081cfa1de4: v.AddArg(v0) return true } - goto end6408685a7276af7e76ec086f359c942c -end6408685a7276af7e76ec086f359c942c: - ; return false } func rewriteValuegeneric_OpRsh8x8(v *Value, config *Config) bool { @@ -5380,11 +4735,11 @@ func rewriteValuegeneric_OpRsh8x8(v *Value, config *Config) bool { // match: (Rsh8x8 x (Const8 [c])) // cond: // result: (Rsh8x64 x (Const64 [int64(uint8(c))])) - { + for { t := v.Type x := v.Args[0] if v.Args[1].Op != OpConst8 { - goto endae44f60f364cddd8903763dd921a007e + break } c := v.Args[1].AuxInt v.reset(OpRsh8x64) @@ -5394,9 +4749,6 @@ func rewriteValuegeneric_OpRsh8x8(v *Value, config *Config) bool { v.AddArg(v0) return true } - goto endae44f60f364cddd8903763dd921a007e -endae44f60f364cddd8903763dd921a007e: - ; return false } func rewriteValuegeneric_OpSliceCap(v *Value, config *Config) bool { @@ -5405,9 +4757,9 @@ func rewriteValuegeneric_OpSliceCap(v *Value, config *Config) bool { // match: (SliceCap (SliceMake _ _ cap)) // cond: // result: cap - { + for { if v.Args[0].Op != OpSliceMake { - goto end1bd11616743632b33b410964667fb3c6 + break } cap := v.Args[0].Args[2] v.reset(OpCopy) @@ -5415,9 +4767,6 @@ func rewriteValuegeneric_OpSliceCap(v *Value, config *Config) bool { v.AddArg(cap) return true } - goto end1bd11616743632b33b410964667fb3c6 -end1bd11616743632b33b410964667fb3c6: - ; return false } func rewriteValuegeneric_OpSliceLen(v *Value, config *Config) bool { @@ -5426,9 +4775,9 @@ func rewriteValuegeneric_OpSliceLen(v *Value, config *Config) bool { // match: (SliceLen (SliceMake _ len _)) // cond: // result: len - { + for { if v.Args[0].Op != OpSliceMake { - goto endebb2090199d13e4c2ae52fb3e778f7fd + break } len := v.Args[0].Args[1] v.reset(OpCopy) @@ -5436,9 +4785,6 @@ func rewriteValuegeneric_OpSliceLen(v *Value, config *Config) bool { v.AddArg(len) return true } - goto endebb2090199d13e4c2ae52fb3e778f7fd -endebb2090199d13e4c2ae52fb3e778f7fd: - ; return false } func rewriteValuegeneric_OpSlicePtr(v *Value, config *Config) bool { @@ -5447,9 +4793,9 @@ func rewriteValuegeneric_OpSlicePtr(v *Value, config *Config) bool { // match: (SlicePtr (SliceMake ptr _ _ )) // cond: // result: ptr - { + for { if v.Args[0].Op != OpSliceMake { - goto end526acc0a705137a5d25577499206720b + break } ptr := v.Args[0].Args[0] v.reset(OpCopy) @@ -5457,9 +4803,6 @@ func rewriteValuegeneric_OpSlicePtr(v *Value, config *Config) bool { v.AddArg(ptr) return true } - goto end526acc0a705137a5d25577499206720b -end526acc0a705137a5d25577499206720b: - ; return false } func rewriteValuegeneric_OpStore(v *Value, config *Config) bool { @@ -5468,9 +4811,9 @@ func rewriteValuegeneric_OpStore(v *Value, config *Config) bool { // match: (Store _ (StructMake0) mem) // cond: // result: mem - { + for { if v.Args[1].Op != OpStructMake0 { - goto endd4f364b0adfc229d8c200af183d4c808 + break } mem := v.Args[2] v.reset(OpCopy) @@ -5478,16 +4821,13 @@ func rewriteValuegeneric_OpStore(v *Value, config *Config) bool { v.AddArg(mem) return true } - goto endd4f364b0adfc229d8c200af183d4c808 -endd4f364b0adfc229d8c200af183d4c808: - ; // match: (Store dst (StructMake1 f0) mem) // cond: // result: (Store [t.FieldType(0).Size()] dst f0 mem) - { + for { dst := v.Args[0] if v.Args[1].Op != OpStructMake1 { - goto end2cff6d06f4440132f48ca374b6b1e9d8 + break } t := v.Args[1].Type f0 := v.Args[1].Args[0] @@ -5499,16 +4839,13 @@ endd4f364b0adfc229d8c200af183d4c808: v.AddArg(mem) return true } - goto end2cff6d06f4440132f48ca374b6b1e9d8 -end2cff6d06f4440132f48ca374b6b1e9d8: - ; // match: (Store dst (StructMake2 f0 f1) mem) // cond: // result: (Store [t.FieldType(1).Size()] (OffPtr [t.FieldOff(1)] dst) f1 (Store [t.FieldType(0).Size()] dst f0 mem)) - { + for { dst := v.Args[0] if v.Args[1].Op != OpStructMake2 { - goto end4e8ede6cc575a287795971da6b637973 + break } t := v.Args[1].Type f0 := v.Args[1].Args[0] @@ -5529,16 +4866,13 @@ end2cff6d06f4440132f48ca374b6b1e9d8: v.AddArg(v1) return true } - goto end4e8ede6cc575a287795971da6b637973 -end4e8ede6cc575a287795971da6b637973: - ; // match: (Store dst (StructMake3 f0 f1 f2) mem) // cond: // result: (Store [t.FieldType(2).Size()] (OffPtr [t.FieldOff(2)] dst) f2 (Store [t.FieldType(1).Size()] (OffPtr [t.FieldOff(1)] dst) f1 (Store [t.FieldType(0).Size()] dst f0 mem))) - { + for { dst := v.Args[0] if v.Args[1].Op != OpStructMake3 { - goto end6ad675267724a87c8f852dd1e185e911 + break } t := v.Args[1].Type f0 := v.Args[1].Args[0] @@ -5568,16 +4902,13 @@ end4e8ede6cc575a287795971da6b637973: v.AddArg(v1) return true } - goto end6ad675267724a87c8f852dd1e185e911 -end6ad675267724a87c8f852dd1e185e911: - ; // match: (Store dst (StructMake4 f0 f1 f2 f3) mem) // cond: // result: (Store [t.FieldType(3).Size()] (OffPtr [t.FieldOff(3)] dst) f3 (Store [t.FieldType(2).Size()] (OffPtr [t.FieldOff(2)] dst) f2 (Store [t.FieldType(1).Size()] (OffPtr [t.FieldOff(1)] dst) f1 (Store [t.FieldType(0).Size()] dst f0 mem)))) - { + for { dst := v.Args[0] if v.Args[1].Op != OpStructMake4 { - goto end7ea91abd44794f7653374502a5a405ea + break } t := v.Args[1].Type f0 := v.Args[1].Args[0] @@ -5616,19 +4947,16 @@ end6ad675267724a87c8f852dd1e185e911: v.AddArg(v1) return true } - goto end7ea91abd44794f7653374502a5a405ea -end7ea91abd44794f7653374502a5a405ea: - ; // match: (Store [8] dst (ComplexMake real imag) mem) // cond: // result: (Store [4] (OffPtr [4] dst) imag (Store [4] dst real mem)) - { + for { if v.AuxInt != 8 { - goto endced898cb0a165662afe48ea44ad3318a + break } dst := v.Args[0] if v.Args[1].Op != OpComplexMake { - goto endced898cb0a165662afe48ea44ad3318a + break } real := v.Args[1].Args[0] imag := v.Args[1].Args[1] @@ -5648,19 +4976,16 @@ end7ea91abd44794f7653374502a5a405ea: v.AddArg(v1) return true } - goto endced898cb0a165662afe48ea44ad3318a -endced898cb0a165662afe48ea44ad3318a: - ; // match: (Store [16] dst (ComplexMake real imag) mem) // cond: // result: (Store [8] (OffPtr [8] dst) imag (Store [8] dst real mem)) - { + for { if v.AuxInt != 16 { - goto end3851a482d7bd37a93c4d81581e85b3ab + break } dst := v.Args[0] if v.Args[1].Op != OpComplexMake { - goto end3851a482d7bd37a93c4d81581e85b3ab + break } real := v.Args[1].Args[0] imag := v.Args[1].Args[1] @@ -5680,19 +5005,16 @@ endced898cb0a165662afe48ea44ad3318a: v.AddArg(v1) return true } - goto end3851a482d7bd37a93c4d81581e85b3ab -end3851a482d7bd37a93c4d81581e85b3ab: - ; // match: (Store [2*config.PtrSize] dst (StringMake ptr len) mem) // cond: // result: (Store [config.PtrSize] (OffPtr [config.PtrSize] dst) len (Store [config.PtrSize] dst ptr mem)) - { + for { if v.AuxInt != 2*config.PtrSize { - goto endd3a6ecebdad5899570a79fe5c62f34f1 + break } dst := v.Args[0] if v.Args[1].Op != OpStringMake { - goto endd3a6ecebdad5899570a79fe5c62f34f1 + break } ptr := v.Args[1].Args[0] len := v.Args[1].Args[1] @@ -5712,19 +5034,16 @@ end3851a482d7bd37a93c4d81581e85b3ab: v.AddArg(v1) return true } - goto endd3a6ecebdad5899570a79fe5c62f34f1 -endd3a6ecebdad5899570a79fe5c62f34f1: - ; // match: (Store [3*config.PtrSize] dst (SliceMake ptr len cap) mem) // cond: // result: (Store [config.PtrSize] (OffPtr [2*config.PtrSize] dst) cap (Store [config.PtrSize] (OffPtr [config.PtrSize] dst) len (Store [config.PtrSize] dst ptr mem))) - { + for { if v.AuxInt != 3*config.PtrSize { - goto endd5cc8c3dad7d24c845b0b88fc51487ae + break } dst := v.Args[0] if v.Args[1].Op != OpSliceMake { - goto endd5cc8c3dad7d24c845b0b88fc51487ae + break } ptr := v.Args[1].Args[0] len := v.Args[1].Args[1] @@ -5753,19 +5072,16 @@ endd3a6ecebdad5899570a79fe5c62f34f1: v.AddArg(v1) return true } - goto endd5cc8c3dad7d24c845b0b88fc51487ae -endd5cc8c3dad7d24c845b0b88fc51487ae: - ; // match: (Store [2*config.PtrSize] dst (IMake itab data) mem) // cond: // result: (Store [config.PtrSize] (OffPtr [config.PtrSize] dst) data (Store [config.PtrSize] dst itab mem)) - { + for { if v.AuxInt != 2*config.PtrSize { - goto endaa801a871178ae3256b3f6f5d9f13514 + break } dst := v.Args[0] if v.Args[1].Op != OpIMake { - goto endaa801a871178ae3256b3f6f5d9f13514 + break } itab := v.Args[1].Args[0] data := v.Args[1].Args[1] @@ -5785,26 +5101,23 @@ endd5cc8c3dad7d24c845b0b88fc51487ae: v.AddArg(v1) return true } - goto endaa801a871178ae3256b3f6f5d9f13514 -endaa801a871178ae3256b3f6f5d9f13514: - ; // match: (Store [size] dst (Load 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 { - goto end45295326269ba18413dceb7b608a0b9d + break } t := v.Args[1].Type src := v.Args[1].Args[0] mem := v.Args[1].Args[1] if v.Args[2] != mem { - goto end45295326269ba18413dceb7b608a0b9d + break } if !(!config.fe.CanSSA(t)) { - goto end45295326269ba18413dceb7b608a0b9d + break } v.reset(OpMove) v.AuxInt = size @@ -5813,30 +5126,27 @@ endaa801a871178ae3256b3f6f5d9f13514: v.AddArg(mem) return true } - goto end45295326269ba18413dceb7b608a0b9d -end45295326269ba18413dceb7b608a0b9d: - ; // match: (Store [size] dst (Load 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 { - goto end7f3cc0baffb82ba3ee879599b189a512 + break } t := v.Args[1].Type src := v.Args[1].Args[0] mem := v.Args[1].Args[1] if v.Args[2].Op != OpVarDef { - goto end7f3cc0baffb82ba3ee879599b189a512 + break } x := v.Args[2].Aux if v.Args[2].Args[0] != mem { - goto end7f3cc0baffb82ba3ee879599b189a512 + break } if !(!config.fe.CanSSA(t)) { - goto end7f3cc0baffb82ba3ee879599b189a512 + break } v.reset(OpMove) v.AuxInt = size @@ -5848,9 +5158,6 @@ end45295326269ba18413dceb7b608a0b9d: v.AddArg(v0) return true } - goto end7f3cc0baffb82ba3ee879599b189a512 -end7f3cc0baffb82ba3ee879599b189a512: - ; return false } func rewriteValuegeneric_OpStringLen(v *Value, config *Config) bool { @@ -5859,9 +5166,9 @@ func rewriteValuegeneric_OpStringLen(v *Value, config *Config) bool { // match: (StringLen (StringMake _ len)) // cond: // result: len - { + for { if v.Args[0].Op != OpStringMake { - goto end0d922460b7e5ca88324034f4bd6c027c + break } len := v.Args[0].Args[1] v.reset(OpCopy) @@ -5869,9 +5176,6 @@ func rewriteValuegeneric_OpStringLen(v *Value, config *Config) bool { v.AddArg(len) return true } - goto end0d922460b7e5ca88324034f4bd6c027c -end0d922460b7e5ca88324034f4bd6c027c: - ; return false } func rewriteValuegeneric_OpStringPtr(v *Value, config *Config) bool { @@ -5880,9 +5184,9 @@ func rewriteValuegeneric_OpStringPtr(v *Value, config *Config) bool { // match: (StringPtr (StringMake ptr _)) // cond: // result: ptr - { + for { if v.Args[0].Op != OpStringMake { - goto end061edc5d85c73ad909089af2556d9380 + break } ptr := v.Args[0].Args[0] v.reset(OpCopy) @@ -5890,9 +5194,6 @@ func rewriteValuegeneric_OpStringPtr(v *Value, config *Config) bool { v.AddArg(ptr) return true } - goto end061edc5d85c73ad909089af2556d9380 -end061edc5d85c73ad909089af2556d9380: - ; return false } func rewriteValuegeneric_OpStructSelect(v *Value, config *Config) bool { @@ -5901,9 +5202,9 @@ func rewriteValuegeneric_OpStructSelect(v *Value, config *Config) bool { // match: (StructSelect (StructMake1 x)) // cond: // result: x - { + for { if v.Args[0].Op != OpStructMake1 { - goto end17af582e7eba5216b4a51fe6c9206d3c + break } x := v.Args[0].Args[0] v.reset(OpCopy) @@ -5911,18 +5212,15 @@ func rewriteValuegeneric_OpStructSelect(v *Value, config *Config) bool { v.AddArg(x) return true } - goto end17af582e7eba5216b4a51fe6c9206d3c -end17af582e7eba5216b4a51fe6c9206d3c: - ; // match: (StructSelect [0] (StructMake2 x _)) // cond: // result: x - { + for { if v.AuxInt != 0 { - goto end355cfff99c8e9af975c3ae450d49b7f9 + break } if v.Args[0].Op != OpStructMake2 { - goto end355cfff99c8e9af975c3ae450d49b7f9 + break } x := v.Args[0].Args[0] v.reset(OpCopy) @@ -5930,18 +5228,15 @@ end17af582e7eba5216b4a51fe6c9206d3c: v.AddArg(x) return true } - goto end355cfff99c8e9af975c3ae450d49b7f9 -end355cfff99c8e9af975c3ae450d49b7f9: - ; // match: (StructSelect [1] (StructMake2 _ x)) // cond: // result: x - { + for { if v.AuxInt != 1 { - goto end69baa65e494ef9ae154e0943b53734f9 + break } if v.Args[0].Op != OpStructMake2 { - goto end69baa65e494ef9ae154e0943b53734f9 + break } x := v.Args[0].Args[1] v.reset(OpCopy) @@ -5949,18 +5244,15 @@ end355cfff99c8e9af975c3ae450d49b7f9: v.AddArg(x) return true } - goto end69baa65e494ef9ae154e0943b53734f9 -end69baa65e494ef9ae154e0943b53734f9: - ; // match: (StructSelect [0] (StructMake3 x _ _)) // cond: // result: x - { + for { if v.AuxInt != 0 { - goto endb0d98e2c46bb51c9abd4c3543392e0ec + break } if v.Args[0].Op != OpStructMake3 { - goto endb0d98e2c46bb51c9abd4c3543392e0ec + break } x := v.Args[0].Args[0] v.reset(OpCopy) @@ -5968,18 +5260,15 @@ end69baa65e494ef9ae154e0943b53734f9: v.AddArg(x) return true } - goto endb0d98e2c46bb51c9abd4c3543392e0ec -endb0d98e2c46bb51c9abd4c3543392e0ec: - ; // match: (StructSelect [1] (StructMake3 _ x _)) // cond: // result: x - { + for { if v.AuxInt != 1 { - goto end2e40457286d26c2f14ad4fd127946773 + break } if v.Args[0].Op != OpStructMake3 { - goto end2e40457286d26c2f14ad4fd127946773 + break } x := v.Args[0].Args[1] v.reset(OpCopy) @@ -5987,18 +5276,15 @@ endb0d98e2c46bb51c9abd4c3543392e0ec: v.AddArg(x) return true } - goto end2e40457286d26c2f14ad4fd127946773 -end2e40457286d26c2f14ad4fd127946773: - ; // match: (StructSelect [2] (StructMake3 _ _ x)) // cond: // result: x - { + for { if v.AuxInt != 2 { - goto end3e3b96ad431206175d002ece87aa1409 + break } if v.Args[0].Op != OpStructMake3 { - goto end3e3b96ad431206175d002ece87aa1409 + break } x := v.Args[0].Args[2] v.reset(OpCopy) @@ -6006,18 +5292,15 @@ end2e40457286d26c2f14ad4fd127946773: v.AddArg(x) return true } - goto end3e3b96ad431206175d002ece87aa1409 -end3e3b96ad431206175d002ece87aa1409: - ; // match: (StructSelect [0] (StructMake4 x _ _ _)) // cond: // result: x - { + for { if v.AuxInt != 0 { - goto end09f8a1ffa3d8c3124bc6d4083b941108 + break } if v.Args[0].Op != OpStructMake4 { - goto end09f8a1ffa3d8c3124bc6d4083b941108 + break } x := v.Args[0].Args[0] v.reset(OpCopy) @@ -6025,18 +5308,15 @@ end3e3b96ad431206175d002ece87aa1409: v.AddArg(x) return true } - goto end09f8a1ffa3d8c3124bc6d4083b941108 -end09f8a1ffa3d8c3124bc6d4083b941108: - ; // match: (StructSelect [1] (StructMake4 _ x _ _)) // cond: // result: x - { + for { if v.AuxInt != 1 { - goto endd3ef25e605a927e9251be6d9221f4acf + break } if v.Args[0].Op != OpStructMake4 { - goto endd3ef25e605a927e9251be6d9221f4acf + break } x := v.Args[0].Args[1] v.reset(OpCopy) @@ -6044,18 +5324,15 @@ end09f8a1ffa3d8c3124bc6d4083b941108: v.AddArg(x) return true } - goto endd3ef25e605a927e9251be6d9221f4acf -endd3ef25e605a927e9251be6d9221f4acf: - ; // match: (StructSelect [2] (StructMake4 _ _ x _)) // cond: // result: x - { + for { if v.AuxInt != 2 { - goto end0438e22cc8f41123fa42009a81ee723a + break } if v.Args[0].Op != OpStructMake4 { - goto end0438e22cc8f41123fa42009a81ee723a + break } x := v.Args[0].Args[2] v.reset(OpCopy) @@ -6063,18 +5340,15 @@ endd3ef25e605a927e9251be6d9221f4acf: v.AddArg(x) return true } - goto end0438e22cc8f41123fa42009a81ee723a -end0438e22cc8f41123fa42009a81ee723a: - ; // match: (StructSelect [3] (StructMake4 _ _ _ x)) // cond: // result: x - { + for { if v.AuxInt != 3 { - goto end56a7c7781fee35eeff0a3652dc206012 + break } if v.Args[0].Op != OpStructMake4 { - goto end56a7c7781fee35eeff0a3652dc206012 + break } x := v.Args[0].Args[3] v.reset(OpCopy) @@ -6082,22 +5356,19 @@ end0438e22cc8f41123fa42009a81ee723a: v.AddArg(x) return true } - goto end56a7c7781fee35eeff0a3652dc206012 -end56a7c7781fee35eeff0a3652dc206012: - ; // match: (StructSelect [i] (Load ptr mem)) // cond: !config.fe.CanSSA(t) // result: @v.Args[0].Block (Load (OffPtr [t.FieldOff(i)] ptr) mem) - { + for { i := v.AuxInt if v.Args[0].Op != OpLoad { - goto end2afd47b4fcaaab7a73325bd8a75e3e8e + break } t := v.Args[0].Type ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] if !(!config.fe.CanSSA(t)) { - goto end2afd47b4fcaaab7a73325bd8a75e3e8e + break } v0 := v.Args[0].Block.NewValue0(v.Line, OpLoad, v.Type) v.reset(OpCopy) @@ -6109,9 +5380,6 @@ end56a7c7781fee35eeff0a3652dc206012: v0.AddArg(mem) return true } - goto end2afd47b4fcaaab7a73325bd8a75e3e8e -end2afd47b4fcaaab7a73325bd8a75e3e8e: - ; return false } func rewriteValuegeneric_OpSub16(v *Value, config *Config) bool { @@ -6120,34 +5388,31 @@ func rewriteValuegeneric_OpSub16(v *Value, config *Config) bool { // match: (Sub16 (Const16 [c]) (Const16 [d])) // cond: // result: (Const16 [c-d]) - { + for { if v.Args[0].Op != OpConst16 { - goto end5c6fab95c9dbeff5973119096bfd4e78 + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst16 { - goto end5c6fab95c9dbeff5973119096bfd4e78 + break } d := v.Args[1].AuxInt v.reset(OpConst16) v.AuxInt = c - d return true } - goto end5c6fab95c9dbeff5973119096bfd4e78 -end5c6fab95c9dbeff5973119096bfd4e78: - ; // match: (Sub16 x (Const16 [c])) // cond: x.Op != OpConst16 // result: (Add16 (Const16 [-c]) x) - { + for { x := v.Args[0] if v.Args[1].Op != OpConst16 { - goto end493545258a8e7e79d005b34c712ddd0c + break } t := v.Args[1].Type c := v.Args[1].AuxInt if !(x.Op != OpConst16) { - goto end493545258a8e7e79d005b34c712ddd0c + break } v.reset(OpAdd16) v0 := b.NewValue0(v.Line, OpConst16, t) @@ -6156,64 +5421,52 @@ end5c6fab95c9dbeff5973119096bfd4e78: v.AddArg(x) return true } - goto end493545258a8e7e79d005b34c712ddd0c -end493545258a8e7e79d005b34c712ddd0c: - ; // match: (Sub16 x x) // cond: // result: (Const16 [0]) - { + for { x := v.Args[0] if v.Args[1] != x { - goto end83da541391be564f2a08464e674a49e7 + break } v.reset(OpConst16) v.AuxInt = 0 return true } - goto end83da541391be564f2a08464e674a49e7 -end83da541391be564f2a08464e674a49e7: - ; // match: (Sub16 (Add16 x y) x) // cond: // result: y - { + for { if v.Args[0].Op != OpAdd16 { - goto end0dd8f250c457b9c005ecbed59fc2e758 + break } x := v.Args[0].Args[0] y := v.Args[0].Args[1] if v.Args[1] != x { - goto end0dd8f250c457b9c005ecbed59fc2e758 + break } v.reset(OpCopy) v.Type = y.Type v.AddArg(y) return true } - goto end0dd8f250c457b9c005ecbed59fc2e758 -end0dd8f250c457b9c005ecbed59fc2e758: - ; // match: (Sub16 (Add16 x y) y) // cond: // result: x - { + for { if v.Args[0].Op != OpAdd16 { - goto end01c8db2e0bce69e048cf79f3bdc82b9b + break } x := v.Args[0].Args[0] y := v.Args[0].Args[1] if v.Args[1] != y { - goto end01c8db2e0bce69e048cf79f3bdc82b9b + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto end01c8db2e0bce69e048cf79f3bdc82b9b -end01c8db2e0bce69e048cf79f3bdc82b9b: - ; return false } func rewriteValuegeneric_OpSub32(v *Value, config *Config) bool { @@ -6222,34 +5475,31 @@ func rewriteValuegeneric_OpSub32(v *Value, config *Config) bool { // match: (Sub32 (Const32 [c]) (Const32 [d])) // cond: // result: (Const32 [c-d]) - { + for { if v.Args[0].Op != OpConst32 { - goto end7623799db780e1bcc42c6ea0df9c49d3 + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst32 { - goto end7623799db780e1bcc42c6ea0df9c49d3 + break } d := v.Args[1].AuxInt v.reset(OpConst32) v.AuxInt = c - d return true } - goto end7623799db780e1bcc42c6ea0df9c49d3 -end7623799db780e1bcc42c6ea0df9c49d3: - ; // match: (Sub32 x (Const32 [c])) // cond: x.Op != OpConst32 // result: (Add32 (Const32 [-c]) x) - { + for { x := v.Args[0] if v.Args[1].Op != OpConst32 { - goto end391e2f2ba8c7502b62c0153ec69c4fbd + break } t := v.Args[1].Type c := v.Args[1].AuxInt if !(x.Op != OpConst32) { - goto end391e2f2ba8c7502b62c0153ec69c4fbd + break } v.reset(OpAdd32) v0 := b.NewValue0(v.Line, OpConst32, t) @@ -6258,64 +5508,52 @@ end7623799db780e1bcc42c6ea0df9c49d3: v.AddArg(x) return true } - goto end391e2f2ba8c7502b62c0153ec69c4fbd -end391e2f2ba8c7502b62c0153ec69c4fbd: - ; // match: (Sub32 x x) // cond: // result: (Const32 [0]) - { + for { x := v.Args[0] if v.Args[1] != x { - goto enda747581e798f199e07f4ad69747cd069 + break } v.reset(OpConst32) v.AuxInt = 0 return true } - goto enda747581e798f199e07f4ad69747cd069 -enda747581e798f199e07f4ad69747cd069: - ; // match: (Sub32 (Add32 x y) x) // cond: // result: y - { + for { if v.Args[0].Op != OpAdd32 { - goto end70c1e60e58a6c106d060f10cd3f179ea + break } x := v.Args[0].Args[0] y := v.Args[0].Args[1] if v.Args[1] != x { - goto end70c1e60e58a6c106d060f10cd3f179ea + break } v.reset(OpCopy) v.Type = y.Type v.AddArg(y) return true } - goto end70c1e60e58a6c106d060f10cd3f179ea -end70c1e60e58a6c106d060f10cd3f179ea: - ; // match: (Sub32 (Add32 x y) y) // cond: // result: x - { + for { if v.Args[0].Op != OpAdd32 { - goto end20e42db178ec4f423cc56a991863a4a2 + break } x := v.Args[0].Args[0] y := v.Args[0].Args[1] if v.Args[1] != y { - goto end20e42db178ec4f423cc56a991863a4a2 + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto end20e42db178ec4f423cc56a991863a4a2 -end20e42db178ec4f423cc56a991863a4a2: - ; return false } func rewriteValuegeneric_OpSub64(v *Value, config *Config) bool { @@ -6324,34 +5562,31 @@ func rewriteValuegeneric_OpSub64(v *Value, config *Config) bool { // match: (Sub64 (Const64 [c]) (Const64 [d])) // cond: // result: (Const64 [c-d]) - { + for { if v.Args[0].Op != OpConst64 { - goto end5a84a285ff0ff48b8ad3c64b15e3459f + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst64 { - goto end5a84a285ff0ff48b8ad3c64b15e3459f + break } d := v.Args[1].AuxInt v.reset(OpConst64) v.AuxInt = c - d return true } - goto end5a84a285ff0ff48b8ad3c64b15e3459f -end5a84a285ff0ff48b8ad3c64b15e3459f: - ; // match: (Sub64 x (Const64 [c])) // cond: x.Op != OpConst64 // result: (Add64 (Const64 [-c]) x) - { + for { x := v.Args[0] if v.Args[1].Op != OpConst64 { - goto enda80d30f6794bcf02cd4442b238f68333 + break } t := v.Args[1].Type c := v.Args[1].AuxInt if !(x.Op != OpConst64) { - goto enda80d30f6794bcf02cd4442b238f68333 + break } v.reset(OpAdd64) v0 := b.NewValue0(v.Line, OpConst64, t) @@ -6360,64 +5595,52 @@ end5a84a285ff0ff48b8ad3c64b15e3459f: v.AddArg(x) return true } - goto enda80d30f6794bcf02cd4442b238f68333 -enda80d30f6794bcf02cd4442b238f68333: - ; // match: (Sub64 x x) // cond: // result: (Const64 [0]) - { + for { x := v.Args[0] if v.Args[1] != x { - goto end0387dc2b7bbe57d4aa54eab5d959da4b + break } v.reset(OpConst64) v.AuxInt = 0 return true } - goto end0387dc2b7bbe57d4aa54eab5d959da4b -end0387dc2b7bbe57d4aa54eab5d959da4b: - ; // match: (Sub64 (Add64 x y) x) // cond: // result: y - { + for { if v.Args[0].Op != OpAdd64 { - goto end7d177451cf8959cb781f52d5ded46fff + break } x := v.Args[0].Args[0] y := v.Args[0].Args[1] if v.Args[1] != x { - goto end7d177451cf8959cb781f52d5ded46fff + break } v.reset(OpCopy) v.Type = y.Type v.AddArg(y) return true } - goto end7d177451cf8959cb781f52d5ded46fff -end7d177451cf8959cb781f52d5ded46fff: - ; // match: (Sub64 (Add64 x y) y) // cond: // result: x - { + for { if v.Args[0].Op != OpAdd64 { - goto end6ea8172b21100cfe3dc86b7a850fbe97 + break } x := v.Args[0].Args[0] y := v.Args[0].Args[1] if v.Args[1] != y { - goto end6ea8172b21100cfe3dc86b7a850fbe97 + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto end6ea8172b21100cfe3dc86b7a850fbe97 -end6ea8172b21100cfe3dc86b7a850fbe97: - ; return false } func rewriteValuegeneric_OpSub8(v *Value, config *Config) bool { @@ -6426,34 +5649,31 @@ func rewriteValuegeneric_OpSub8(v *Value, config *Config) bool { // match: (Sub8 (Const8 [c]) (Const8 [d])) // cond: // result: (Const8 [c-d]) - { + for { if v.Args[0].Op != OpConst8 { - goto endc00ea11c7535529e211710574f5cff24 + break } c := v.Args[0].AuxInt if v.Args[1].Op != OpConst8 { - goto endc00ea11c7535529e211710574f5cff24 + break } d := v.Args[1].AuxInt v.reset(OpConst8) v.AuxInt = c - d return true } - goto endc00ea11c7535529e211710574f5cff24 -endc00ea11c7535529e211710574f5cff24: - ; // match: (Sub8 x (Const8 [c])) // cond: x.Op != OpConst8 // result: (Add8 (Const8 [-c]) x) - { + for { x := v.Args[0] if v.Args[1].Op != OpConst8 { - goto end0bfab5b6f1037e55dc049b79e2636678 + break } t := v.Args[1].Type c := v.Args[1].AuxInt if !(x.Op != OpConst8) { - goto end0bfab5b6f1037e55dc049b79e2636678 + break } v.reset(OpAdd8) v0 := b.NewValue0(v.Line, OpConst8, t) @@ -6462,64 +5682,52 @@ endc00ea11c7535529e211710574f5cff24: v.AddArg(x) return true } - goto end0bfab5b6f1037e55dc049b79e2636678 -end0bfab5b6f1037e55dc049b79e2636678: - ; // match: (Sub8 x x) // cond: // result: (Const8 [0]) - { + for { x := v.Args[0] if v.Args[1] != x { - goto end4e2ee15ef17611919a1a6b5f80bbfe18 + break } v.reset(OpConst8) v.AuxInt = 0 return true } - goto end4e2ee15ef17611919a1a6b5f80bbfe18 -end4e2ee15ef17611919a1a6b5f80bbfe18: - ; // match: (Sub8 (Add8 x y) x) // cond: // result: y - { + for { if v.Args[0].Op != OpAdd8 { - goto endd79d561e14dc3d11da4c3bb20270b541 + break } x := v.Args[0].Args[0] y := v.Args[0].Args[1] if v.Args[1] != x { - goto endd79d561e14dc3d11da4c3bb20270b541 + break } v.reset(OpCopy) v.Type = y.Type v.AddArg(y) return true } - goto endd79d561e14dc3d11da4c3bb20270b541 -endd79d561e14dc3d11da4c3bb20270b541: - ; // match: (Sub8 (Add8 x y) y) // cond: // result: x - { + for { if v.Args[0].Op != OpAdd8 { - goto endcb7111b11d6d068c97026a97ecff8248 + break } x := v.Args[0].Args[0] y := v.Args[0].Args[1] if v.Args[1] != y { - goto endcb7111b11d6d068c97026a97ecff8248 + break } v.reset(OpCopy) v.Type = x.Type v.AddArg(x) return true } - goto endcb7111b11d6d068c97026a97ecff8248 -endcb7111b11d6d068c97026a97ecff8248: - ; return false } func rewriteValuegeneric_OpXor16(v *Value, config *Config) bool { @@ -6528,18 +5736,15 @@ func rewriteValuegeneric_OpXor16(v *Value, config *Config) bool { // match: (Xor16 x x) // cond: // result: (Const16 [0]) - { + for { x := v.Args[0] if v.Args[1] != x { - goto end5733ceb1903b8140248d8e2cac02fefe + break } v.reset(OpConst16) v.AuxInt = 0 return true } - goto end5733ceb1903b8140248d8e2cac02fefe -end5733ceb1903b8140248d8e2cac02fefe: - ; return false } func rewriteValuegeneric_OpXor32(v *Value, config *Config) bool { @@ -6548,18 +5753,15 @@ func rewriteValuegeneric_OpXor32(v *Value, config *Config) bool { // match: (Xor32 x x) // cond: // result: (Const32 [0]) - { + for { x := v.Args[0] if v.Args[1] != x { - goto end268ca02df6515d648e0bfb4e90981d25 + break } v.reset(OpConst32) v.AuxInt = 0 return true } - goto end268ca02df6515d648e0bfb4e90981d25 -end268ca02df6515d648e0bfb4e90981d25: - ; return false } func rewriteValuegeneric_OpXor64(v *Value, config *Config) bool { @@ -6568,18 +5770,15 @@ func rewriteValuegeneric_OpXor64(v *Value, config *Config) bool { // match: (Xor64 x x) // cond: // result: (Const64 [0]) - { + for { x := v.Args[0] if v.Args[1] != x { - goto endaf44e7f9fc58af30df69070953fb45ce + break } v.reset(OpConst64) v.AuxInt = 0 return true } - goto endaf44e7f9fc58af30df69070953fb45ce -endaf44e7f9fc58af30df69070953fb45ce: - ; return false } func rewriteValuegeneric_OpXor8(v *Value, config *Config) bool { @@ -6588,18 +5787,15 @@ func rewriteValuegeneric_OpXor8(v *Value, config *Config) bool { // match: (Xor8 x x) // cond: // result: (Const8 [0]) - { + for { x := v.Args[0] if v.Args[1] != x { - goto end949b3a60b7d181688e6f79f93c782fc8 + break } v.reset(OpConst8) v.AuxInt = 0 return true } - goto end949b3a60b7d181688e6f79f93c782fc8 -end949b3a60b7d181688e6f79f93c782fc8: - ; return false } func rewriteBlockgeneric(b *Block) bool { @@ -6608,13 +5804,13 @@ func rewriteBlockgeneric(b *Block) bool { // match: (Check (NilCheck (GetG _) _) next) // cond: // result: (Plain nil next) - { + for { v := b.Control if v.Op != OpNilCheck { - goto end6e20d932d6961903b0dcf16eac513826 + break } if v.Args[0].Op != OpGetG { - goto end6e20d932d6961903b0dcf16eac513826 + break } next := b.Succs[0] b.Kind = BlockPlain @@ -6623,17 +5819,14 @@ func rewriteBlockgeneric(b *Block) bool { b.Likely = BranchUnknown return true } - goto end6e20d932d6961903b0dcf16eac513826 - end6e20d932d6961903b0dcf16eac513826: - ; case BlockIf: // match: (If (Not cond) yes no) // cond: // result: (If cond no yes) - { + for { v := b.Control if v.Op != OpNot { - goto endebe19c1c3c3bec068cdb2dd29ef57f96 + break } cond := v.Args[0] yes := b.Succs[0] @@ -6645,22 +5838,19 @@ func rewriteBlockgeneric(b *Block) bool { b.Likely *= -1 return true } - goto endebe19c1c3c3bec068cdb2dd29ef57f96 - endebe19c1c3c3bec068cdb2dd29ef57f96: - ; // match: (If (ConstBool [c]) yes no) // cond: c == 1 // result: (First nil yes no) - { + for { v := b.Control if v.Op != OpConstBool { - goto endc58ecbb85af78c0d58bb232ca86b67a4 + break } c := v.AuxInt yes := b.Succs[0] no := b.Succs[1] if !(c == 1) { - goto endc58ecbb85af78c0d58bb232ca86b67a4 + break } b.Kind = BlockFirst b.Control = nil @@ -6668,22 +5858,19 @@ func rewriteBlockgeneric(b *Block) bool { b.Succs[1] = no return true } - goto endc58ecbb85af78c0d58bb232ca86b67a4 - endc58ecbb85af78c0d58bb232ca86b67a4: - ; // match: (If (ConstBool [c]) yes no) // cond: c == 0 // result: (First nil no yes) - { + for { v := b.Control if v.Op != OpConstBool { - goto end4c3e297e275dd7e2e67f8ccd348c4bb5 + break } c := v.AuxInt yes := b.Succs[0] no := b.Succs[1] if !(c == 0) { - goto end4c3e297e275dd7e2e67f8ccd348c4bb5 + break } b.Kind = BlockFirst b.Control = nil @@ -6692,8 +5879,6 @@ func rewriteBlockgeneric(b *Block) bool { b.Likely *= -1 return true } - goto end4c3e297e275dd7e2e67f8ccd348c4bb5 - end4c3e297e275dd7e2e67f8ccd348c4bb5: } return false } -- cgit v1.3 From a0da2d242c0830daf9de469f2db7f1b85523bf05 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Thu, 4 Feb 2016 15:08:47 -0800 Subject: [dev.ssa] cmd/compile: Use ADD instead of LEA when we can MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit If the output register is one of the input registers, we can use a real add instead of LEA. Change-Id: Ide58f1536afb077c0b939d3a8c7555807fd1c5e3 Reviewed-on: https://go-review.googlesource.com/19234 Reviewed-by: Alexandru Moșoi --- src/cmd/compile/internal/gc/ssa.go | 75 ++++++++++++++++++++++++-------------- src/cmd/compile/internal/ssa/TODO | 2 - 2 files changed, 47 insertions(+), 30 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 8ae02bd4ca..7b85b2fc8a 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -3689,31 +3689,41 @@ func opregreg(op int, dest, src int16) *obj.Prog { func (s *genState) genValue(v *ssa.Value) { lineno = v.Line switch v.Op { - case ssa.OpAMD64ADDQ: - // TODO: use addq instead of leaq if target is in the right register. - p := Prog(x86.ALEAQ) - p.From.Type = obj.TYPE_MEM - p.From.Reg = regnum(v.Args[0]) - p.From.Scale = 1 - p.From.Index = regnum(v.Args[1]) - p.To.Type = obj.TYPE_REG - p.To.Reg = regnum(v) - case ssa.OpAMD64ADDL: - p := Prog(x86.ALEAL) - p.From.Type = obj.TYPE_MEM - p.From.Reg = regnum(v.Args[0]) - p.From.Scale = 1 - p.From.Index = regnum(v.Args[1]) - p.To.Type = obj.TYPE_REG - p.To.Reg = regnum(v) - case ssa.OpAMD64ADDW: - p := Prog(x86.ALEAW) - p.From.Type = obj.TYPE_MEM - p.From.Reg = regnum(v.Args[0]) - p.From.Scale = 1 - p.From.Index = regnum(v.Args[1]) - p.To.Type = obj.TYPE_REG - p.To.Reg = regnum(v) + 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.ALEAW + } + 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, @@ -3903,7 +3913,16 @@ func (s *genState) genValue(v *ssa.Value) { p.To.Type = obj.TYPE_REG p.To.Reg = r case ssa.OpAMD64ADDQconst, ssa.OpAMD64ADDLconst, ssa.OpAMD64ADDWconst: - // TODO: use addq instead of leaq if target is in the right register. + r := regnum(v) + a := regnum(v.Args[0]) + if r == a { + p := Prog(v.Op.Asm()) + p.From.Type = obj.TYPE_CONST + p.From.Offset = v.AuxInt + p.To.Type = obj.TYPE_REG + p.To.Reg = r + return + } var asm int switch v.Op { case ssa.OpAMD64ADDQconst: @@ -3915,10 +3934,10 @@ func (s *genState) genValue(v *ssa.Value) { } p := Prog(asm) p.From.Type = obj.TYPE_MEM - p.From.Reg = regnum(v.Args[0]) + p.From.Reg = a p.From.Offset = v.AuxInt p.To.Type = obj.TYPE_REG - p.To.Reg = regnum(v) + p.To.Reg = r case ssa.OpAMD64MULQconst, ssa.OpAMD64MULLconst, ssa.OpAMD64MULWconst, ssa.OpAMD64MULBconst: r := regnum(v) x := regnum(v.Args[0]) diff --git a/src/cmd/compile/internal/ssa/TODO b/src/cmd/compile/internal/ssa/TODO index 3191670a0e..73396c7637 100644 --- a/src/cmd/compile/internal/ssa/TODO +++ b/src/cmd/compile/internal/ssa/TODO @@ -21,7 +21,6 @@ Optimizations (better compiled code) - Add a value range propagation pass (for bounds elim & bitwidth reduction) - Make dead store pass inter-block - (x86) More combining address arithmetic into loads/stores -- (x86) use ADDQ instead of LEAQ when we can - redundant CMP in sequences like this: SUBQ $8, AX CMP AX, $0 @@ -37,7 +36,6 @@ Optimizations (better compiled code) Same for interfaces? - boolean logic: movb/xorb$1/testb/jeq -> movb/testb/jne - (ADDQconst (SUBQconst x)) and vice-versa -- combine LEAQs - store followed by load to same address - (CMPconst [0] (AND x y)) -> (TEST x y) - more (LOAD (ADDQ )) -> LOADIDX -- cgit v1.3 From a6fb514bf8dd43cff37185eb02b448d8244af9da Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Thu, 4 Feb 2016 15:53:33 -0800 Subject: [dev.ssa] cmd/compile: add store constant indexed operations Change-Id: Ifb8eba1929c79ee7a8cae2191613c55a3b8f74e5 Reviewed-on: https://go-review.googlesource.com/19236 Reviewed-by: Todd Neal --- src/cmd/compile/internal/gc/ssa.go | 22 ++ src/cmd/compile/internal/ssa/gen/AMD64.rules | 28 +++ src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 12 +- src/cmd/compile/internal/ssa/opGen.go | 48 ++++ src/cmd/compile/internal/ssa/rewriteAMD64.go | 316 +++++++++++++++++++++++++++ 5 files changed, 423 insertions(+), 3 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 7b85b2fc8a..d56ff495ab 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -4168,6 +4168,28 @@ func (s *genState) genValue(v *ssa.Value) { 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, diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 692ea467e4..465d7030f3 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -727,6 +727,16 @@ (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) @@ -756,6 +766,24 @@ (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) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index bb7a42ea07..7fcf24782c 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -115,9 +115,10 @@ func init() { 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}} + 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} @@ -402,6 +403,11 @@ func init() { {name: "MOVLstoreconst", reg: gpstoreconst, asm: "MOVL", aux: "SymValAndOff", typ: "Mem"}, // store low 4 bytes of ... {name: "MOVQstoreconst", reg: gpstoreconst, asm: "MOVQ", aux: "SymValAndOff", typ: "Mem"}, // store 8 bytes of ... + {name: "MOVBstoreconstidx1", 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", reg: gpstoreconstidx, asm: "MOVW", aux: "SymValAndOff", typ: "Mem"}, // store low 2 bytes of ... 2*arg1 ... + {name: "MOVLstoreconstidx4", reg: gpstoreconstidx, asm: "MOVL", aux: "SymValAndOff", typ: "Mem"}, // store low 4 bytes of ... 4*arg1 ... + {name: "MOVQstoreconstidx8", 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 diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 219d526cad..8ce9c82f67 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -278,6 +278,10 @@ const ( OpAMD64MOVWstoreconst OpAMD64MOVLstoreconst OpAMD64MOVQstoreconst + OpAMD64MOVBstoreconstidx1 + OpAMD64MOVWstoreconstidx2 + OpAMD64MOVLstoreconstidx4 + OpAMD64MOVQstoreconstidx8 OpAMD64DUFFZERO OpAMD64MOVOconst OpAMD64REPSTOSQ @@ -3344,6 +3348,50 @@ var opcodeTable = [...]opInfo{ }, }, }, + { + name: "MOVBstoreconstidx1", + auxType: auxSymValAndOff, + 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, + 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, + 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, + 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, diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 25bbbcdeb1..a5593444e9 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -335,6 +335,8 @@ func rewriteValueAMD64(v *Value, config *Config) bool { 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: @@ -349,6 +351,8 @@ func rewriteValueAMD64(v *Value, config *Config) bool { 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: @@ -363,6 +367,8 @@ func rewriteValueAMD64(v *Value, config *Config) bool { 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: @@ -393,6 +399,8 @@ func rewriteValueAMD64(v *Value, config *Config) bool { 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: @@ -5699,6 +5707,98 @@ func rewriteValueAMD64_OpAMD64MOVBstoreconst(v *Value, config *Config) bool { 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 { @@ -6140,6 +6240,78 @@ func rewriteValueAMD64_OpAMD64MOVLstoreconst(v *Value, config *Config) bool { 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 { @@ -6558,6 +6730,78 @@ func rewriteValueAMD64_OpAMD64MOVQstoreconst(v *Value, config *Config) bool { 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 { @@ -7495,6 +7739,78 @@ func rewriteValueAMD64_OpAMD64MOVWstoreconst(v *Value, config *Config) bool { 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 { -- cgit v1.3 From aebf6611dfba195d15c5119e14d6f5b708adbdfb Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Fri, 29 Jan 2016 21:57:57 -0800 Subject: [dev.ssa] cmd/compile: reorg write barriers a bit Use just a single write barrier flag test, even if there are multiple pointer fields in a struct. This helps move more of the wb-specific code (like the LEA needed to materialize the write address) into the unlikely path. Change-Id: Ic7a67145904369c4ff031e464d51267d71281c8f Reviewed-on: https://go-review.googlesource.com/19085 Run-TryBot: Keith Randall TryBot-Result: Gobot Gobot Reviewed-by: David Chase --- src/cmd/compile/internal/gc/ssa.go | 129 +++++++++++++++++++++++-------------- src/cmd/compile/internal/ssa/TODO | 2 - 2 files changed, 81 insertions(+), 50 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index d56ff495ab..8109117982 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -2770,22 +2770,45 @@ func (s *state) insertWBstore(t *Type, left, right *ssa.Value, line int32) { // store pointer fields // } - if 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) - if haspointers(ft.(*Type)) { - s.insertWBstore(ft.(*Type), addr, val, line) - } else { - s.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, ft.Size(), addr, val, s.mem()) - } - } - return + 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[TBOOL]), aux, s.sb) + // TODO: select the .enabled field. It is currently first, so not needed for now. + flag := s.newValue2(ssa.OpLoad, Types[TBOOL], flagaddr, s.mem()) + 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(): @@ -2803,70 +2826,80 @@ func (s *state) insertWBstore(t *Type, left, right *ssa.Value, line int32) { // 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) } +} - 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[TBOOL]), aux, s.sb) - // TODO: select the .enabled field. It is currently first, so not needed for now. - flag := s.newValue2(ssa.OpLoad, Types[TBOOL], flagaddr, s.mem()) - 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) +// 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.rtcall(writebarrierptr, true, nil, left, right) + 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.rtcall(writebarrierptr, true, nil, left, ptr) + 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.rtcall(writebarrierptr, true, nil, left, ptr) + 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.rtcall(writebarrierptr, true, nil, idataAddr, idata) + 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) } - s.endBlock().AddEdgeTo(bEnd) +} - // Issue regular stores for pointer writes. - s.startBlock(bElse) +// 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.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, s.config.PtrSize, left, right, s.mem()) + s.rtcall(writebarrierptr, true, nil, left, right) 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()) + s.rtcall(writebarrierptr, true, nil, left, ptr) 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()) + 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.vars[&memVar] = s.newValue3I(ssa.OpStore, ssa.TypeMem, s.config.PtrSize, idataAddr, idata, s.mem()) + 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) } - s.endBlock().AddEdgeTo(bEnd) - - s.startBlock(bEnd) - - if Debug_wb > 0 { - Warnl(int(line), "write barrier") - } } // slice computes the slice v[i:j:k] and returns ptr, len, and cap of result. diff --git a/src/cmd/compile/internal/ssa/TODO b/src/cmd/compile/internal/ssa/TODO index 73396c7637..5fa14ee44b 100644 --- a/src/cmd/compile/internal/ssa/TODO +++ b/src/cmd/compile/internal/ssa/TODO @@ -7,7 +7,6 @@ Coverage Correctness ----------- - Debugging info (check & fix as much as we can) -- Fix write barriers so cgo tests work (misc/cgo/errors/ptr.go) - Re-enable TestStackBarrierProfiling (src/runtime/pprof/pprof_test.go) - @ directive in rewrites might read overwritten data. Save @loc in variable before modifying v. @@ -25,7 +24,6 @@ Optimizations (better compiled code) SUBQ $8, AX CMP AX, $0 JEQ ... -- Use better write barrier calls - 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. -- cgit v1.3 From a3055af45e655cce1070f6f346a3ed76e01039e2 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Fri, 5 Feb 2016 20:26:18 -0800 Subject: [dev.ssa] cmd/compile: strength-reduce 64-bit constant divides The frontend does this for 32 bits and below, but SSA needs to do it for 64 bits. The algorithms are all copied from cgen.go:cgen_div. Speeds up TimeFormat substantially: ~40% slower to ~10% slower. Change-Id: I023ea2eb6040df98ccd9105e15ca6ea695610a7a Reviewed-on: https://go-review.googlesource.com/19302 Run-TryBot: Keith Randall TryBot-Result: Gobot Gobot Reviewed-by: Todd Neal --- src/cmd/compile/internal/gc/ssa.go | 31 ++- src/cmd/compile/internal/ssa/gen/AMD64.rules | 4 + src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 4 + src/cmd/compile/internal/ssa/gen/generic.rules | 97 +++++++++ src/cmd/compile/internal/ssa/gen/genericOps.go | 6 +- src/cmd/compile/internal/ssa/magic.go | 260 +++++++++++++++++++++++ src/cmd/compile/internal/ssa/opGen.go | 59 ++++++ src/cmd/compile/internal/ssa/rewriteAMD64.go | 54 +++++ src/cmd/compile/internal/ssa/rewritegeneric.go | 283 +++++++++++++++++++++++++ 9 files changed, 795 insertions(+), 3 deletions(-) create mode 100644 src/cmd/compile/internal/ssa/magic.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 8109117982..71d5920824 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -3904,10 +3904,11 @@ func (s *genState) genValue(v *ssa.Value) { j2.To.Val = Pc } - case ssa.OpAMD64HMULL, ssa.OpAMD64HMULW, ssa.OpAMD64HMULB, - ssa.OpAMD64HMULLU, ssa.OpAMD64HMULWU, ssa.OpAMD64HMULBU: + 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) @@ -3925,6 +3926,32 @@ func (s *genState) genValue(v *ssa.Value) { 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: diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 465d7030f3..15457b8f6d 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -45,6 +45,8 @@ (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) @@ -52,6 +54,8 @@ (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) diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index 7fcf24782c..d139145e04 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -193,13 +193,17 @@ func init() { {name: "MULWconst", reg: gp11, asm: "IMULW", aux: "Int16"}, // arg0 * auxint {name: "MULBconst", reg: gp11, asm: "IMULW", aux: "Int8"}, // arg0 * auxint + {name: "HMULQ", reg: gp11hmul, asm: "IMULQ"}, // (arg0 * arg1) >> width {name: "HMULL", reg: gp11hmul, asm: "IMULL"}, // (arg0 * arg1) >> width {name: "HMULW", reg: gp11hmul, asm: "IMULW"}, // (arg0 * arg1) >> width {name: "HMULB", reg: gp11hmul, asm: "IMULB"}, // (arg0 * arg1) >> width + {name: "HMULQU", reg: gp11hmul, asm: "MULQ"}, // (arg0 * arg1) >> width {name: "HMULLU", reg: gp11hmul, asm: "MULL"}, // (arg0 * arg1) >> width {name: "HMULWU", reg: gp11hmul, asm: "MULW"}, // (arg0 * arg1) >> width {name: "HMULBU", reg: gp11hmul, asm: "MULB"}, // (arg0 * arg1) >> width + {name: "AVGQU", reg: gp21}, // (arg0 + arg1) / 2 as unsigned, all 64 result bits + {name: "DIVQ", reg: gp11div, asm: "IDIVQ"}, // arg0 / arg1 {name: "DIVL", reg: gp11div, asm: "IDIVL"}, // arg0 / arg1 {name: "DIVW", reg: gp11div, asm: "IDIVW"}, // arg0 / arg1 diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index 28fe9ff878..2b811cc7ab 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -514,3 +514,100 @@ (Arg {n} [off+t.FieldOff(1)]) (Arg {n} [off+t.FieldOff(2)]) (Arg {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 n (Const64 [c])) && isPowerOfTwo(c) -> (Rsh64Ux64 n (Const64 [log2(c)])) +//(Mod64u n (Const64 [c])) && isPowerOfTwo(c) -> (And64 n (Const64 [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 n (Const64 [c])) && isPowerOfTwo(c) -> +// (Rsh64x64 +// (Add64 +// n +// (Rsh64Ux64 +// (Rsh64x64 n (Const64 [63])) +// (Const64 [64-log2(c)]))) +// (Const64 [log2(c)])) + +// Unsigned divide, not a power of 2. Strength reduce to a multiply. +(Div64u x (Const64 [c])) && umagic64ok(c) && !umagic64a(c) -> + (Rsh64Ux64 + (Hmul64u + (Const64 [umagic64m(c)]) + x) + (Const64 [umagic64s(c)])) +(Div64u x (Const64 [c])) && umagic64ok(c) && umagic64a(c) -> + (Rsh64Ux64 + (Avg64u + (Hmul64u + x + (Const64 [umagic64m(c)])) + x) + (Const64 [umagic64s(c)-1])) + +// Signed divide, not a power of 2. Strength reduce to a multiply. +(Div64 x (Const64 [c])) && c > 0 && smagic64ok(c) && smagic64m(c) > 0 -> + (Sub64 + (Rsh64x64 + (Hmul64 + (Const64 [smagic64m(c)]) + x) + (Const64 [smagic64s(c)])) + (Rsh64x64 + x + (Const64 [63]))) +(Div64 x (Const64 [c])) && c > 0 && smagic64ok(c) && smagic64m(c) < 0 -> + (Sub64 + (Rsh64x64 + (Add64 + (Hmul64 + (Const64 [smagic64m(c)]) + x) + x) + (Const64 [smagic64s(c)])) + (Rsh64x64 + x + (Const64 [63]))) +(Div64 x (Const64 [c])) && c < 0 && smagic64ok(c) && smagic64m(c) > 0 -> + (Neg64 + (Sub64 + (Rsh64x64 + (Hmul64 + (Const64 [smagic64m(c)]) + x) + (Const64 [smagic64s(c)])) + (Rsh64x64 + x + (Const64 [63])))) +(Div64 x (Const64 [c])) && c < 0 && smagic64ok(c) && smagic64m(c) < 0 -> + (Neg64 + (Sub64 + (Rsh64x64 + (Add64 + (Hmul64 + (Const64 [smagic64m(c)]) + x) + x) + (Const64 [smagic64s(c)])) + (Rsh64x64 + x + (Const64 [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 x (Const64 [c])) && smagic64ok(c) -> (Sub64 x (Mul64 (Div64 x (Const64 [c])) (Const64 [c]))) +(Mod64u x (Const64 [c])) && umagic64ok(c) -> (Sub64 x (Mul64 (Div64u x (Const64 [c])) (Const64 [c]))) diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 3c7aa84ee3..ec74859cbc 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -41,7 +41,11 @@ var genericOps = []opData{ {name: "Hmul16u"}, {name: "Hmul32"}, {name: "Hmul32u"}, - // frontend currently doesn't generate a 64 bit hmul + {name: "Hmul64"}, + {name: "Hmul64u"}, + + // Weird special instruction for strength reduction of divides. + {name: "Avg64u"}, // (uint64(arg0) + uint64(arg1)) / 2, correct to all 64 bits. {name: "Div8"}, // arg0 / arg1 {name: "Div8u"}, diff --git a/src/cmd/compile/internal/ssa/magic.go b/src/cmd/compile/internal/ssa/magic.go new file mode 100644 index 0000000000..a8e84d5c93 --- /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/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index 8ce9c82f67..dfd9df8ba4 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -109,12 +109,15 @@ const ( OpAMD64MULLconst OpAMD64MULWconst OpAMD64MULBconst + OpAMD64HMULQ OpAMD64HMULL OpAMD64HMULW OpAMD64HMULB + OpAMD64HMULQU OpAMD64HMULLU OpAMD64HMULWU OpAMD64HMULBU + OpAMD64AVGQU OpAMD64DIVQ OpAMD64DIVL OpAMD64DIVW @@ -331,6 +334,9 @@ const ( OpHmul16u OpHmul32 OpHmul32u + OpHmul64 + OpHmul64u + OpAvg64u OpDiv8 OpDiv8u OpDiv16 @@ -1144,6 +1150,20 @@ var opcodeTable = [...]opInfo{ }, }, }, + { + name: "HMULQ", + 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", asm: x86.AIMULL, @@ -1186,6 +1206,20 @@ var opcodeTable = [...]opInfo{ }, }, }, + { + name: "HMULQU", + 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", asm: x86.AMULL, @@ -1228,6 +1262,19 @@ var opcodeTable = [...]opInfo{ }, }, }, + { + name: "AVGQU", + 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", asm: x86.AIDIVQ, @@ -3661,6 +3708,18 @@ var opcodeTable = [...]opInfo{ name: "Hmul32u", generic: true, }, + { + name: "Hmul64", + generic: true, + }, + { + name: "Hmul64u", + generic: true, + }, + { + name: "Avg64u", + generic: true, + }, { name: "Div8", generic: true, diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index a5593444e9..601e9b8ce3 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -63,6 +63,8 @@ func rewriteValueAMD64(v *Value, config *Config) bool { 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: @@ -217,6 +219,10 @@ func rewriteValueAMD64(v *Value, config *Config) bool { 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: @@ -1972,6 +1978,22 @@ func rewriteValueAMD64_OpAnd8(v *Value, config *Config) bool { } 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 @@ -3755,6 +3777,38 @@ func rewriteValueAMD64_OpHmul32u(v *Value, config *Config) bool { } 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 diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index 0c091c7a32..a5d8a4d9eb 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -47,6 +47,10 @@ func rewriteValuegeneric(v *Value, config *Config) bool { 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: @@ -167,6 +171,10 @@ func rewriteValuegeneric(v *Value, config *Config) bool { 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: @@ -1053,6 +1061,215 @@ func rewriteValuegeneric_OpConvert(v *Value, config *Config) bool { } return false } +func rewriteValuegeneric_OpDiv64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Div64 x (Const64 [c])) + // cond: c > 0 && smagic64ok(c) && smagic64m(c) > 0 + // result: (Sub64 (Rsh64x64 (Hmul64 (Const64 [smagic64m(c)]) x) (Const64 [smagic64s(c)])) (Rsh64x64 x (Const64 [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 x (Const64 [c])) + // cond: c > 0 && smagic64ok(c) && smagic64m(c) < 0 + // result: (Sub64 (Rsh64x64 (Add64 (Hmul64 (Const64 [smagic64m(c)]) x) x) (Const64 [smagic64s(c)])) (Rsh64x64 x (Const64 [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 x (Const64 [c])) + // cond: c < 0 && smagic64ok(c) && smagic64m(c) > 0 + // result: (Neg64 (Sub64 (Rsh64x64 (Hmul64 (Const64 [smagic64m(c)]) x) (Const64 [smagic64s(c)])) (Rsh64x64 x (Const64 [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 x (Const64 [c])) + // cond: c < 0 && smagic64ok(c) && smagic64m(c) < 0 + // result: (Neg64 (Sub64 (Rsh64x64 (Add64 (Hmul64 (Const64 [smagic64m(c)]) x) x) (Const64 [smagic64s(c)])) (Rsh64x64 x (Const64 [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 x (Const64 [c])) + // cond: umagic64ok(c) && !umagic64a(c) + // result: (Rsh64Ux64 (Hmul64u (Const64 [umagic64m(c)]) x) (Const64 [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 x (Const64 [c])) + // cond: umagic64ok(c) && umagic64a(c) + // result: (Rsh64Ux64 (Avg64u (Hmul64u x (Const64 [umagic64m(c)])) x) (Const64 [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 @@ -3061,6 +3278,72 @@ func rewriteValuegeneric_OpLsh8x8(v *Value, config *Config) bool { } return false } +func rewriteValuegeneric_OpMod64(v *Value, config *Config) bool { + b := v.Block + _ = b + // match: (Mod64 x (Const64 [c])) + // cond: smagic64ok(c) + // result: (Sub64 x (Mul64 (Div64 x (Const64 [c])) (Const64 [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 x (Const64 [c])) + // cond: umagic64ok(c) + // result: (Sub64 x (Mul64 (Div64u x (Const64 [c])) (Const64 [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 -- cgit v1.3 From faf1bdb42b81f75b49307667e170754621b6653f Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Sat, 6 Feb 2016 22:35:34 -0800 Subject: [dev.ssa] cmd/compile: panic doesn't return Panic doesn't return, so record that we immediately exit after a panic call. This will help code analysis. Change-Id: I4d1f67494f97b6aee130c43ff4e44307b2b0f149 Reviewed-on: https://go-review.googlesource.com/19303 Run-TryBot: Keith Randall Reviewed-by: David Chase --- src/cmd/compile/internal/gc/ssa.go | 9 +++++++++ 1 file changed, 9 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 71d5920824..b7019d68b7 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -544,6 +544,15 @@ func (s *state) stmt(n *Node) { // Expression statements case OCALLFUNC, OCALLMETH, OCALLINTER: s.call(n, callNormal) + if n.Op == OCALLFUNC && n.Left.Op == ONAME && n.Left.Class == PFUNC && n.Left.Sym.Pkg == Runtimepkg && n.Left.Sym.Name == "gopanic" { + 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: -- cgit v1.3 From bc0792284306ade896db24002a52d00901ce5f69 Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Sat, 6 Feb 2016 20:56:50 -0600 Subject: [dev.ssa] cmd/compile: speed up cse Examine both Aux and AuxInt to form more precise initial partitions. Restructure loop to avoid repeated type.Equal() call. Speeds up compilation of testdata/gen/arithConst_ssa by 25%. Change-Id: I3cfb1d254adf0601ee69239e1885b0cf2a23575b Reviewed-on: https://go-review.googlesource.com/19313 Run-TryBot: Todd Neal Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/cse.go | 58 +++++++++++++++++++++++++------------ 1 file changed, 40 insertions(+), 18 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/cse.go b/src/cmd/compile/internal/ssa/cse.go index 1cf0dfd4d9..052d12dd33 100644 --- a/src/cmd/compile/internal/ssa/cse.go +++ b/src/cmd/compile/internal/ssa/cse.go @@ -99,17 +99,22 @@ func cse(f *Func) { 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] || !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 + 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++ } @@ -212,8 +217,12 @@ func partitionValues(a []*Value) []eqclass { len(v.Args) != len(w.Args) || v.Op == OpPhi && v.Block != w.Block || v.Aux != w.Aux || - len(v.Args) >= 1 && v.Args[0].Op != w.Args[0].Op || - len(v.Args) >= 2 && v.Args[1].Op != w.Args[1].Op || + len(v.Args) >= 1 && (v.Args[0].Op != w.Args[0].Op || + v.Args[0].Aux != w.Args[0].Aux || + v.Args[0].AuxInt != w.Args[0].AuxInt) || + len(v.Args) >= 2 && (v.Args[1].Op != w.Args[1].Op || + v.Args[1].Aux != w.Args[1].Aux || + v.Args[1].AuxInt != w.Args[1].AuxInt) || typNames[v.Type] != typNames[w.Type] { break } @@ -258,16 +267,29 @@ func (sv sortvalues) Less(i, j int) bool { return v.Block.ID < w.Block.ID } if len(v.Args) >= 1 { - x := v.Args[0].Op - y := w.Args[0].Op - if x != y { - return x < y + vOp := v.Args[0].Op + wOp := w.Args[0].Op + if vOp != wOp { + return vOp < wOp + } + + vAuxInt := v.Args[0].AuxInt + wAuxInt := w.Args[0].AuxInt + if vAuxInt != wAuxInt { + return vAuxInt < wAuxInt } + if len(v.Args) >= 2 { - x = v.Args[1].Op - y = w.Args[1].Op - if x != y { - return x < y + vOp = v.Args[1].Op + wOp = w.Args[1].Op + if vOp != wOp { + return vOp < wOp + } + + vAuxInt = v.Args[1].AuxInt + wAuxInt = w.Args[1].AuxInt + if vAuxInt != wAuxInt { + return vAuxInt < wAuxInt } } } -- cgit v1.3 From 58cfa40419f2ef1c58f58015eb8421a5a1b94129 Mon Sep 17 00:00:00 2001 From: David Chase Date: Mon, 8 Feb 2016 12:07:39 -0500 Subject: [dev.ssa] cmd/compile: fix for bug in cse speed improvements Problem was caused by use of Args[].Aux differences in early partitioning. This artificially separated two equivalent expressions because sort ignores the Aux field, hence things can end with equal things separated by unequal things and thus the equal things are split into more than one partition. For example: SliceLen(a), SliceLen(b), SliceLen(a). Fix: don't use Args[].Aux in initial partitioning. Left in a debugging flag and some debugging Fprintf's; not sure if that is house style or not. We'll probably want to be more systematic in our naming conventions, e.g. ssa.cse, ssa.scc, etc. Change-Id: Ib1412539cc30d91ea542c0ac7b2f9b504108ca7f Reviewed-on: https://go-review.googlesource.com/19316 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/lex.go | 2 ++ src/cmd/compile/internal/ssa/compile.go | 2 ++ src/cmd/compile/internal/ssa/cse.go | 35 +++++++++++++++++++++++++++------ 3 files changed, 33 insertions(+), 6 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/lex.go b/src/cmd/compile/internal/gc/lex.go index fb30d58527..9a1e70f43d 100644 --- a/src/cmd/compile/internal/gc/lex.go +++ b/src/cmd/compile/internal/gc/lex.go @@ -8,6 +8,7 @@ package gc import ( "bytes" + "cmd/compile/internal/ssa" "cmd/internal/obj" "flag" "fmt" @@ -54,6 +55,7 @@ var debugtab = []struct { {"typeassert", &Debug_typeassert}, // print information about type assertion inlining {"wb", &Debug_wb}, // print information about write barriers {"export", &Debug_export}, // print export data + {"ssa", &ssa.Debug}, // ssa debugging flag } const ( diff --git a/src/cmd/compile/internal/ssa/compile.go b/src/cmd/compile/internal/ssa/compile.go index e602d8f5b3..04fd82bfb5 100644 --- a/src/cmd/compile/internal/ssa/compile.go +++ b/src/cmd/compile/internal/ssa/compile.go @@ -11,6 +11,8 @@ import ( "time" ) +var Debug int + // 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 diff --git a/src/cmd/compile/internal/ssa/cse.go b/src/cmd/compile/internal/ssa/cse.go index 052d12dd33..36ab6a3680 100644 --- a/src/cmd/compile/internal/ssa/cse.go +++ b/src/cmd/compile/internal/ssa/cse.go @@ -4,7 +4,10 @@ package ssa -import "sort" +import ( + "fmt" + "sort" +) // cse does common-subexpression elimination on the Function. // Values are just relinked, nothing is deleted. A subsequent deadcode @@ -77,6 +80,13 @@ func cse(f *Func) { for _, v := range e { valueEqClass[v.ID] = ID(i) } + if 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 @@ -196,7 +206,8 @@ type eqclass []*Value // - aux // - nargs // - block # if a phi op -// - first two arg's opcodes +// - 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. @@ -212,18 +223,30 @@ func partitionValues(a []*Value) []eqclass { j := 1 for ; j < len(a); j++ { w := a[j] - if v.Op != w.Op || + rootsDiffer := v.Op != w.Op || v.AuxInt != w.AuxInt || len(v.Args) != len(w.Args) || v.Op == OpPhi && v.Block != w.Block || - v.Aux != w.Aux || + v.Aux != w.Aux + if rootsDiffer || len(v.Args) >= 1 && (v.Args[0].Op != w.Args[0].Op || - v.Args[0].Aux != w.Args[0].Aux || v.Args[0].AuxInt != w.Args[0].AuxInt) || len(v.Args) >= 2 && (v.Args[1].Op != w.Args[1].Op || - v.Args[1].Aux != w.Args[1].Aux || v.Args[1].AuxInt != w.Args[1].AuxInt) || typNames[v.Type] != typNames[w.Type] { + if Debug > 3 { + fmt.Printf("CSE.partitionValues separates %s from %s, AuxInt=%v, Aux=%v, typNames=%v", + v.LongString(), w.LongString(), v.AuxInt != w.AuxInt, v.Aux != w.Aux, typNames[v.Type] != typNames[w.Type]) + if !rootsDiffer { + if len(v.Args) >= 1 { + fmt.Printf(", a0Op=%v, a0AuxInt=%v", v.Args[0].Op != w.Args[0].Op, v.Args[0].AuxInt != w.Args[0].AuxInt) + if len(v.Args) >= 2 { + fmt.Printf(", a1Op=%v, a1AuxInt=%v", v.Args[1].Op != w.Args[1].Op, v.Args[1].AuxInt != w.Args[1].AuxInt) + } + } + } + fmt.Printf("\n") + } break } } -- cgit v1.3 From 964dda9bf1a5ddff5f258d0a0ad07d3a01d5a952 Mon Sep 17 00:00:00 2001 From: Alexandru Moșoi Date: Mon, 8 Feb 2016 18:55:56 +0100 Subject: [dev.ssa] cmd/compile/internal/ssa/gen: constant fold Neg*. Change-Id: Id51e5c97e9653b764b809bf3424f1a6d31b6ffea Reviewed-on: https://go-review.googlesource.com/19338 Run-TryBot: David Chase Reviewed-by: David Chase --- src/cmd/compile/internal/ssa/gen/generic.rules | 5 ++ src/cmd/compile/internal/ssa/rewritegeneric.go | 76 ++++++++++++++++++++++++++ 2 files changed, 81 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index 2b811cc7ab..a3cc5654ea 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -20,6 +20,11 @@ // For now, the generated successors must be a permutation of the matched successors. // constant folding +(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]) diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index a5d8a4d9eb..a724a2d369 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -183,6 +183,14 @@ func rewriteValuegeneric(v *Value, config *Config) bool { 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: @@ -3428,6 +3436,74 @@ func rewriteValuegeneric_OpMul8(v *Value, config *Config) bool { } 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 + } + 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 + } + 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 + } + 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 + } + return false +} func rewriteValuegeneric_OpNeq16(v *Value, config *Config) bool { b := v.Block _ = b -- cgit v1.3 From e93410d3e51064e3ec119c9ec47766f8467a3a4c Mon Sep 17 00:00:00 2001 From: Ilya Tocar Date: Fri, 5 Feb 2016 19:24:53 +0300 Subject: [dev.ssa] cmd/compile: use INC/DEC instead of add when we can INC/DEC produces slightly faster and smaller code. Change-Id: I329d9bdb01b90041be45e053d9df640818bf0c2d Reviewed-on: https://go-review.googlesource.com/19238 Run-TryBot: Ilya Tocar TryBot-Result: Gobot Gobot Reviewed-by: David Chase --- src/cmd/compile/internal/gc/ssa.go | 125 +++++++++++++++++++++++++++++++++---- 1 file changed, 114 insertions(+), 11 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index b7019d68b7..35a492923f 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -3985,12 +3985,47 @@ func (s *genState) genValue(v *ssa.Value) { r := regnum(v) a := regnum(v.Args[0]) if r == a { - p := Prog(v.Op.Asm()) - p.From.Type = obj.TYPE_CONST - p.From.Offset = v.AuxInt - p.To.Type = obj.TYPE_REG - p.To.Reg = r - return + if v.AuxInt == 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.AINCW + } + p := Prog(asm) + p.To.Type = obj.TYPE_REG + p.To.Reg = r + return + } else if v.AuxInt == -1 { + var asm int + switch v.Op { + case ssa.OpAMD64ADDQconst: + asm = x86.ADECQ + case ssa.OpAMD64ADDLconst: + asm = x86.ADECL + case ssa.OpAMD64ADDWconst: + asm = x86.ADECW + } + 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.AuxInt + p.To.Type = obj.TYPE_REG + p.To.Reg = r + return + } } var asm int switch v.Op { @@ -4027,15 +4062,83 @@ func (s *genState) genValue(v *ssa.Value) { //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.AuxInt == -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.AuxInt + p.To.Type = obj.TYPE_REG + p.To.Reg = r + } else if x == r && v.AuxInt == -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.AINCW + } + p := Prog(asm) + p.To.Type = obj.TYPE_REG + p.To.Reg = r + } else if x == r && v.AuxInt == 1 { + var asm int + switch v.Op { + case ssa.OpAMD64SUBQconst: + asm = x86.ADECQ + case ssa.OpAMD64SUBLconst: + asm = x86.ADECL + case ssa.OpAMD64SUBWconst: + asm = x86.ADECW + } + 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.ALEAW + } + p := Prog(asm) + p.From.Type = obj.TYPE_MEM + p.From.Reg = x + p.From.Offset = -v.AuxInt + 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.OpAMD64SUBQconst, ssa.OpAMD64SUBLconst, ssa.OpAMD64SUBWconst, 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: + 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]) -- cgit v1.3 From 9763f6f8cf6c62d19fd108e023dd759e457d0389 Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Mon, 8 Feb 2016 18:06:12 -0600 Subject: [dev.ssa] cmd/compile: add test to detect cse bug Adds a test to detect the bug that slipped in earlier when partioning by the Aux value, but not sorting by it. Change-Id: I56d0ba76383bbc1514b3dabd295e369771c26645 Reviewed-on: https://go-review.googlesource.com/19382 Run-TryBot: Todd Neal TryBot-Result: Gobot Gobot Reviewed-by: David Chase --- src/cmd/compile/internal/ssa/cse_test.go | 81 +++++++++++++++++++++++++++++++ src/cmd/compile/internal/ssa/type_test.go | 1 + 2 files changed, 82 insertions(+) create mode 100644 src/cmd/compile/internal/ssa/cse_test.go (limited to 'src/cmd') 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 0000000000..fb9fada120 --- /dev/null +++ b/src/cmd/compile/internal/ssa/cse_test.go @@ -0,0 +1,81 @@ +// 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" + +// This tests for a bug found when partitioning, but not sorting by the Aux value. +func TestCSEAuxPartitionBug(t *testing.T) { + c := testConfig(t) + arg1Aux := "arg1-aux" + arg2Aux := "arg2-aux" + arg3Aux := "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) + } + +} diff --git a/src/cmd/compile/internal/ssa/type_test.go b/src/cmd/compile/internal/ssa/type_test.go index af111a59af..f09919a652 100644 --- a/src/cmd/compile/internal/ssa/type_test.go +++ b/src/cmd/compile/internal/ssa/type_test.go @@ -73,4 +73,5 @@ var ( 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"} ) -- cgit v1.3 From 7f7f7cddec65b48b35845c5fb537bb59bb7ecca6 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Mon, 8 Feb 2016 11:00:43 -0800 Subject: [dev.ssa] cmd/compile: split decompose pass in two A first pass to decompose user types (structs, maybe arrays someday), and a second pass to decompose builtin types (strings, interfaces, slices, complex). David wants this for value range analysis so he can have structs decomposed but slices and friends will still be intact and he can deduce things like the length of a slice is >= 0. Change-Id: Ia2300d07663329b51ed6270cfed21d31980daa7c Reviewed-on: https://go-review.googlesource.com/19340 Run-TryBot: David Chase Reviewed-by: David Chase --- src/cmd/compile/internal/ssa/compile.go | 7 ++-- src/cmd/compile/internal/ssa/decompose.go | 67 +++++++++++++++++++++++-------- 2 files changed, 55 insertions(+), 19 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/compile.go b/src/cmd/compile/internal/ssa/compile.go index 04fd82bfb5..69f751187d 100644 --- a/src/cmd/compile/internal/ssa/compile.go +++ b/src/cmd/compile/internal/ssa/compile.go @@ -99,7 +99,8 @@ var passes = [...]pass{ {"early copyelim", copyelim, false}, {"early deadcode", deadcode, false}, // remove generated dead code to avoid doing pointless work during opt {"short circuit", shortcircuit, false}, - {"decompose", decompose, true}, + {"decompose user", decomposeUser, true}, + {"decompose builtin", decomposeBuiltIn, true}, {"opt", opt, true}, // TODO: split required rules and optimizing rules {"opt deadcode", deadcode, false}, // remove any blocks orphaned during opt {"generic cse", cse, true}, @@ -148,8 +149,8 @@ var passOrder = [...]constraint{ // 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 compound objects - {"decompose", "opt"}, + // 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 diff --git a/src/cmd/compile/internal/ssa/decompose.go b/src/cmd/compile/internal/ssa/decompose.go index fd8d6b802c..826eff1ee0 100644 --- a/src/cmd/compile/internal/ssa/decompose.go +++ b/src/cmd/compile/internal/ssa/decompose.go @@ -4,16 +4,16 @@ package ssa -// decompose converts phi ops on compound types into phi +// decompose converts phi ops on compound builtin types into phi // ops on simple types. // (The remaining compound ops are decomposed with rewrite rules.) -func decompose(f *Func) { +func decomposeBuiltIn(f *Func) { for _, b := range f.Blocks { for _, v := range b.Values { if v.Op != OpPhi { continue } - decomposePhi(v) + decomposeBuiltInPhi(v) } } @@ -78,22 +78,13 @@ func decompose(f *Func) { f.NamedValues[typeName] = append(f.NamedValues[typeName], typ) f.NamedValues[dataName] = append(f.NamedValues[dataName], data) } - 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) - } - } case t.Size() > f.Config.IntSize: f.Unimplementedf("undecomposed named type %s", t) } } } -func decomposePhi(v *Value) { +func decomposeBuiltInPhi(v *Value) { // TODO: decompose 64-bit ops on 32-bit archs? switch { case v.Type.IsComplex(): @@ -104,8 +95,6 @@ func decomposePhi(v *Value) { decomposeSlicePhi(v) case v.Type.IsInterface(): decomposeInterfacePhi(v) - case v.Type.IsStruct(): - decomposeStructPhi(v) case v.Type.Size() > v.Block.Func.Config.IntSize: v.Unimplementedf("undecomposed type %s", v.Type) } @@ -182,6 +171,50 @@ func decomposeInterfacePhi(v *Value) { 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() @@ -199,7 +232,9 @@ func decomposeStructPhi(v *Value) { // Recursively decompose phis for each field. for _, f := range fields[:n] { - decomposePhi(f) + if f.Type.IsStruct() { + decomposeStructPhi(f) + } } } -- cgit v1.3 From d0d04d2d6cdd79428f2c3b97d33b65638c1cdd71 Mon Sep 17 00:00:00 2001 From: Alexandru Moșoi Date: Tue, 9 Feb 2016 19:46:26 +0100 Subject: [dev.ssa] cmd/compile/internal/ssa: handle rewrite of Phis. * Phis can have variable number of arguments, but rulegen assumed that each operation has fixed number of arguments. * Rewriting Phis is necessary to handle the following case: func f1_ssa(a bool, x int) int { v := 0 if a { v = -1 } else { v = -1 } return x|v } Change-Id: Iff6bd411b854f3d1d6d3ce21934bf566757094f2 Reviewed-on: https://go-review.googlesource.com/19412 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/testdata/arith_ssa.go | 20 +++++ src/cmd/compile/internal/ssa/gen/generic.rules | 6 ++ src/cmd/compile/internal/ssa/gen/genericOps.go | 4 +- src/cmd/compile/internal/ssa/gen/main.go | 1 + src/cmd/compile/internal/ssa/gen/rulegen.go | 17 ++++ src/cmd/compile/internal/ssa/rewritegeneric.go | 94 +++++++++++++++++++++++ 6 files changed, 140 insertions(+), 2 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/testdata/arith_ssa.go b/src/cmd/compile/internal/gc/testdata/arith_ssa.go index 22a78105e0..821c0dd12d 100644 --- a/src/cmd/compile/internal/gc/testdata/arith_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/arith_ssa.go @@ -358,6 +358,26 @@ func testSubConst() { } } +//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() { diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index a3cc5654ea..29b1d42c9e 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -263,6 +263,12 @@ (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) diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index ec74859cbc..fe5169d233 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -240,8 +240,8 @@ var genericOps = []opData{ {name: "Sqrt"}, // sqrt(arg0), float64 only // Data movement - {name: "Phi"}, // select an argument based on which predecessor block we came from - {name: "Copy"}, // output = arg0 + {name: "Phi", variableLength: true}, // select an argument based on which predecessor block we came from + {name: "Copy"}, // 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 diff --git a/src/cmd/compile/internal/ssa/gen/main.go b/src/cmd/compile/internal/ssa/gen/main.go index f8f6c8b5f6..d739b29079 100644 --- a/src/cmd/compile/internal/ssa/gen/main.go +++ b/src/cmd/compile/internal/ssa/gen/main.go @@ -32,6 +32,7 @@ type opData struct { typ string // default result type aux string rematerializeable bool + variableLength bool // if true the operation has a variable number of arguments } type blockData struct { diff --git a/src/cmd/compile/internal/ssa/gen/rulegen.go b/src/cmd/compile/internal/ssa/gen/rulegen.go index 1a0f5d4b1e..b9aa51d165 100644 --- a/src/cmd/compile/internal/ssa/gen/rulegen.go +++ b/src/cmd/compile/internal/ssa/gen/rulegen.go @@ -395,6 +395,23 @@ func genMatch0(w io.Writer, arch arch, match, v string, m map[string]string, top argnum++ } } + + variableLength := false + for _, op := range genericOps { + if op.name == s[0] { + variableLength = op.variableLength + break + } + } + for _, op := range arch.ops { + if op.name == s[0] { + variableLength = op.variableLength + 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) { diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index a724a2d369..e0f03d2e45 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -213,6 +213,8 @@ func rewriteValuegeneric(v *Value, config *Config) bool { 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: @@ -3965,6 +3967,98 @@ func rewriteValuegeneric_OpOr8(v *Value, config *Config) bool { } 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 -- cgit v1.3 From fd458ba49991fbdd65acaa83c970b9d6c63ec87e Mon Sep 17 00:00:00 2001 From: Alexandru Moșoi Date: Tue, 9 Feb 2016 19:13:43 +0100 Subject: [dev.ssa] cmd/compile/internal/ssa: more simplifications and normalization Found by inspecting random generated code. Change-Id: I57d0fed7c3a8dc91fd13cdccb4819101f9976ec9 Reviewed-on: https://go-review.googlesource.com/19413 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/gen/generic.rules | 69 +- src/cmd/compile/internal/ssa/rewritegeneric.go | 1024 +++++++++++++++++++++++- 2 files changed, 1064 insertions(+), 29 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index 29b1d42c9e..cf1bb76735 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -76,7 +76,7 @@ (Neq16 (Const16 [c]) (Add16 (Const16 [d]) x)) -> (Neq16 (Const16 [c-d]) x) (Neq8 (Const8 [c]) (Add8 (Const8 [d]) x)) -> (Neq8 (Const8 [c-d]) x) -// canonicalize: swap arguments for commutative opertions when one argument is a constant. +// canonicalize: swap arguments for commutative operations when one argument is a constant. (Eq64 x (Const64 [c])) && x.Op != OpConst64 -> (Eq64 (Const64 [c]) x) (Eq32 x (Const32 [c])) && x.Op != OpConst32 -> (Eq32 (Const32 [c]) x) (Eq16 x (Const16 [c])) && x.Op != OpConst16 -> (Eq16 (Const16 [c]) x) @@ -92,11 +92,31 @@ (Add16 x (Const16 [c])) && x.Op != OpConst16 -> (Add16 (Const16 [c]) x) (Add8 x (Const8 [c])) && x.Op != OpConst8 -> (Add8 (Const8 [c]) x) +(Mul64 x (Const64 [c])) && x.Op != OpConst64 -> (Mul64 (Const64 [c]) x) +(Mul32 x (Const32 [c])) && x.Op != OpConst32 -> (Mul32 (Const32 [c]) x) +(Mul16 x (Const16 [c])) && x.Op != OpConst16 -> (Mul16 (Const16 [c]) x) +(Mul8 x (Const8 [c])) && x.Op != OpConst8 -> (Mul8 (Const8 [c]) x) + (Sub64 x (Const64 [c])) && x.Op != OpConst64 -> (Add64 (Const64 [-c]) x) (Sub32 x (Const32 [c])) && x.Op != OpConst32 -> (Add32 (Const32 [-c]) x) (Sub16 x (Const16 [c])) && x.Op != OpConst16 -> (Add16 (Const16 [-c]) x) (Sub8 x (Const8 [c])) && x.Op != OpConst8 -> (Add8 (Const8 [-c]) x) +(And64 x (Const64 [c])) && x.Op != OpConst64 -> (And64 (Const64 [c]) x) +(And32 x (Const32 [c])) && x.Op != OpConst32 -> (And32 (Const32 [c]) x) +(And16 x (Const16 [c])) && x.Op != OpConst16 -> (And16 (Const16 [c]) x) +(And8 x (Const8 [c])) && x.Op != OpConst8 -> (And8 (Const8 [c]) x) + +(Or64 x (Const64 [c])) && x.Op != OpConst64 -> (Or64 (Const64 [c]) x) +(Or32 x (Const32 [c])) && x.Op != OpConst32 -> (Or32 (Const32 [c]) x) +(Or16 x (Const16 [c])) && x.Op != OpConst16 -> (Or16 (Const16 [c]) x) +(Or8 x (Const8 [c])) && x.Op != OpConst8 -> (Or8 (Const8 [c]) x) + +(Xor64 x (Const64 [c])) && x.Op != OpConst64 -> (Xor64 (Const64 [c]) x) +(Xor32 x (Const32 [c])) && x.Op != OpConst32 -> (Xor32 (Const32 [c]) x) +(Xor16 x (Const16 [c])) && x.Op != OpConst16 -> (Xor16 (Const16 [c]) x) +(Xor8 x (Const8 [c])) && x.Op != OpConst8 -> (Xor8 (Const8 [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 x (Const32 [c])) -> (Lsh64x64 x (Const64 [int64(uint32(c))])) @@ -153,6 +173,21 @@ (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]) @@ -236,22 +271,54 @@ (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) // simplifications often used for lengths. e.g. len(s[i:i+5])==5 (Sub64 (Add64 x y) x) -> y diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index e0f03d2e45..0d905235e9 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -353,6 +353,22 @@ func rewriteValuegeneric_OpAdd16(v *Value, config *Config) bool { 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 { @@ -394,6 +410,22 @@ func rewriteValuegeneric_OpAdd32(v *Value, config *Config) bool { 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 { @@ -435,6 +467,22 @@ func rewriteValuegeneric_OpAdd64(v *Value, config *Config) bool { 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 { @@ -476,11 +524,47 @@ func rewriteValuegeneric_OpAdd8(v *Value, config *Config) bool { 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 [c])) + // cond: x.Op != OpConst16 + // result: (And16 (Const16 [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 @@ -494,11 +578,61 @@ func rewriteValuegeneric_OpAnd16(v *Value, config *Config) bool { 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 [c])) + // cond: x.Op != OpConst32 + // result: (And32 (Const32 [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 @@ -512,11 +646,61 @@ func rewriteValuegeneric_OpAnd32(v *Value, config *Config) bool { 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 + } return false } func rewriteValuegeneric_OpAnd64(v *Value, config *Config) bool { b := v.Block _ = b + // match: (And64 x (Const64 [c])) + // cond: x.Op != OpConst64 + // result: (And64 (Const64 [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 @@ -530,11 +714,61 @@ func rewriteValuegeneric_OpAnd64(v *Value, config *Config) bool { 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 + } return false } func rewriteValuegeneric_OpAnd8(v *Value, config *Config) bool { b := v.Block _ = b + // match: (And8 x (Const8 [c])) + // cond: x.Op != OpConst8 + // result: (And8 (Const8 [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 @@ -548,6 +782,36 @@ func rewriteValuegeneric_OpAnd8(v *Value, config *Config) bool { 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 { @@ -3018,6 +3282,20 @@ func rewriteValuegeneric_OpLsh64x16(v *Value, config *Config) bool { 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 { @@ -3040,6 +3318,20 @@ func rewriteValuegeneric_OpLsh64x32(v *Value, config *Config) bool { 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 { @@ -3077,6 +3369,20 @@ func rewriteValuegeneric_OpLsh64x64(v *Value, config *Config) bool { 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]) @@ -3141,6 +3447,20 @@ func rewriteValuegeneric_OpLsh64x8(v *Value, config *Config) bool { 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 { @@ -3373,6 +3693,40 @@ func rewriteValuegeneric_OpMul16(v *Value, config *Config) bool { v.AuxInt = c * d return true } + // match: (Mul16 x (Const16 [c])) + // cond: x.Op != OpConst16 + // result: (Mul16 (Const16 [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 { @@ -3394,6 +3748,40 @@ func rewriteValuegeneric_OpMul32(v *Value, config *Config) bool { v.AuxInt = c * d return true } + // match: (Mul32 x (Const32 [c])) + // cond: x.Op != OpConst32 + // result: (Mul32 (Const32 [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 [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 { @@ -3415,6 +3803,40 @@ func rewriteValuegeneric_OpMul64(v *Value, config *Config) bool { v.AuxInt = c * d return true } + // match: (Mul64 x (Const64 [c])) + // cond: x.Op != OpConst64 + // result: (Mul64 (Const64 [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 [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 { @@ -3436,6 +3858,40 @@ func rewriteValuegeneric_OpMul8(v *Value, config *Config) bool { v.AuxInt = c * d return true } + // match: (Mul8 x (Const8 [c])) + // cond: x.Op != OpConst8 + // result: (Mul8 (Const8 [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 { @@ -3453,6 +3909,20 @@ func rewriteValuegeneric_OpNeg16(v *Value, config *Config) bool { 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 { @@ -3470,6 +3940,20 @@ func rewriteValuegeneric_OpNeg32(v *Value, config *Config) bool { 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 { @@ -3487,6 +3971,20 @@ func rewriteValuegeneric_OpNeg64(v *Value, config *Config) bool { 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 { @@ -3504,6 +4002,20 @@ func rewriteValuegeneric_OpNeg8(v *Value, config *Config) bool { 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 { @@ -3898,6 +4410,26 @@ func rewriteValuegeneric_OpNeqSlice(v *Value, config *Config) bool { func rewriteValuegeneric_OpOr16(v *Value, config *Config) bool { b := v.Block _ = b + // match: (Or16 x (Const16 [c])) + // cond: x.Op != OpConst16 + // result: (Or16 (Const16 [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 @@ -3906,17 +4438,203 @@ func rewriteValuegeneric_OpOr16(v *Value, config *Config) bool { if v.Args[1] != x { break } - v.reset(OpCopy) - v.Type = x.Type + 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 [c])) + // cond: x.Op != OpConst32 + // result: (Or32 (Const32 [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 [c])) + // cond: x.Op != OpConst64 + // result: (Or64 (Const64 [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 [c])) + // cond: x.Op != OpConst8 + // result: (Or8 (Const8 [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 } - return false -} -func rewriteValuegeneric_OpOr32(v *Value, config *Config) bool { - b := v.Block - _ = b - // match: (Or32 x x) + // match: (Or8 x x) // cond: // result: x for { @@ -3929,40 +4647,34 @@ func rewriteValuegeneric_OpOr32(v *Value, config *Config) bool { v.AddArg(x) return true } - return false -} -func rewriteValuegeneric_OpOr64(v *Value, config *Config) bool { - b := v.Block - _ = b - // match: (Or64 x x) + // match: (Or8 (Const8 [0]) x) // cond: // result: x for { - x := v.Args[0] - if v.Args[1] != x { + 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_OpOr8(v *Value, config *Config) bool { - b := v.Block - _ = b - // match: (Or8 x x) + // match: (Or8 (Const8 [-1]) _) // cond: - // result: x + // result: (Const8 [-1]) for { - x := v.Args[0] - if v.Args[1] != x { + if v.Args[0].Op != OpConst8 { break } - v.reset(OpCopy) - v.Type = x.Type - v.AddArg(x) + if v.Args[0].AuxInt != -1 { + break + } + v.reset(OpConst8) + v.AuxInt = -1 return true } return false @@ -4674,6 +5386,20 @@ func rewriteValuegeneric_OpRsh64Ux16(v *Value, config *Config) bool { 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 { @@ -4696,6 +5422,20 @@ func rewriteValuegeneric_OpRsh64Ux32(v *Value, config *Config) bool { 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 { @@ -4733,6 +5473,20 @@ func rewriteValuegeneric_OpRsh64Ux64(v *Value, config *Config) bool { 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]) @@ -4797,6 +5551,20 @@ func rewriteValuegeneric_OpRsh64Ux8(v *Value, config *Config) bool { 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 { @@ -4819,6 +5587,20 @@ func rewriteValuegeneric_OpRsh64x16(v *Value, config *Config) bool { 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 { @@ -4841,6 +5623,20 @@ func rewriteValuegeneric_OpRsh64x32(v *Value, config *Config) bool { 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 { @@ -4878,6 +5674,20 @@ func rewriteValuegeneric_OpRsh64x64(v *Value, config *Config) bool { 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 (Rsh64x64 x (Const64 [c])) (Const64 [d])) // cond: !uaddOvf(c,d) // result: (Rsh64x64 x (Const64 [c+d])) @@ -4927,6 +5737,20 @@ func rewriteValuegeneric_OpRsh64x8(v *Value, config *Config) bool { 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 { @@ -6186,6 +7010,26 @@ func rewriteValuegeneric_OpSub8(v *Value, config *Config) bool { func rewriteValuegeneric_OpXor16(v *Value, config *Config) bool { b := v.Block _ = b + // match: (Xor16 x (Const16 [c])) + // cond: x.Op != OpConst16 + // result: (Xor16 (Const16 [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]) @@ -6198,11 +7042,47 @@ func rewriteValuegeneric_OpXor16(v *Value, config *Config) bool { 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 [c])) + // cond: x.Op != OpConst32 + // result: (Xor32 (Const32 [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]) @@ -6215,11 +7095,47 @@ func rewriteValuegeneric_OpXor32(v *Value, config *Config) bool { 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 [c])) + // cond: x.Op != OpConst64 + // result: (Xor64 (Const64 [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]) @@ -6232,11 +7148,47 @@ func rewriteValuegeneric_OpXor64(v *Value, config *Config) bool { 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 [c])) + // cond: x.Op != OpConst8 + // result: (Xor8 (Const8 [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]) @@ -6249,6 +7201,22 @@ func rewriteValuegeneric_OpXor8(v *Value, config *Config) bool { 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 { -- cgit v1.3 From 6d40c62732ac76333426bdd6a67f8c1457ac8334 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Thu, 4 Feb 2016 18:02:03 -0800 Subject: [dev.ssa] cmd/compile: remove redundant compare ops Flagalloc was recalculating flags is some situations when it didn't need to. Fixed by using the same name for the original flag calculation instruction throughout. Change-Id: Ic0bf58f728a8d87748434dd25a67b0708755e1f8 Reviewed-on: https://go-review.googlesource.com/19237 Run-TryBot: Keith Randall Reviewed-by: David Chase --- src/cmd/compile/internal/ssa/flagalloc.go | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/flagalloc.go b/src/cmd/compile/internal/ssa/flagalloc.go index 85e9c4fbee..7ed1fe5908 100644 --- a/src/cmd/compile/internal/ssa/flagalloc.go +++ b/src/cmd/compile/internal/ssa/flagalloc.go @@ -66,7 +66,7 @@ func flagalloc(f *Func) { for _, b := range f.Blocks { oldSched = append(oldSched[:0], b.Values...) b.Values = b.Values[:0] - // The current live flag value. + // The current live flag value the pre-flagalloc copy). var flag *Value if len(b.Preds) > 0 { flag = end[b.Preds[0].ID] @@ -95,7 +95,7 @@ func flagalloc(f *Func) { // Update v. v.SetArg(i, c) // Remember the most-recently computed flag value. - flag = c + flag = a } // Issue v. b.Values = append(b.Values, v) @@ -110,7 +110,7 @@ func flagalloc(f *Func) { // Recalculate control value. c := v.copyInto(b) b.Control = c - flag = c + flag = v } if v := end[b.ID]; v != nil && v != flag { // Need to reissue flag generator for use by -- cgit v1.3 From e49c91090000f22969e819326ed7e1c74f13bde3 Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Thu, 11 Feb 2016 18:13:17 -0600 Subject: [dev.ssa] cmd/compile: print aux value also When printing a value with just an aux, print the aux as well. Debugging cse is easier when the aux values are visible. Change-Id: Ifaf96bdb25462c9df7ba01fdfdbf0d379631f555 Reviewed-on: https://go-review.googlesource.com/19476 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/value.go | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/value.go b/src/cmd/compile/internal/ssa/value.go index 0d6c19b80a..c2ea6ee202 100644 --- a/src/cmd/compile/internal/ssa/value.go +++ b/src/cmd/compile/internal/ssa/value.go @@ -113,6 +113,10 @@ func (v *Value) LongString() string { 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) -- cgit v1.3 From adc8d491c2318b4b9e3b60ea868bd65c82ca13df Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Thu, 11 Feb 2016 20:43:15 -0600 Subject: [dev.ssa] cmd/compiler: rewrite AND x const as a shift if possible ANDs of constants whose only set bits are leading or trailing can be rewritten as two shifts instead. This is slightly faster for 32 or 64 bit operands. Change-Id: Id5c1ff27e5a4df22fac67b03b9bddb944871145d Reviewed-on: https://go-review.googlesource.com/19485 Run-TryBot: Todd Neal TryBot-Result: Gobot Gobot Reviewed-by: David Chase --- src/cmd/compile/internal/ssa/gen/generic.rules | 8 ++ src/cmd/compile/internal/ssa/rewrite.go | 46 +++++++++-- src/cmd/compile/internal/ssa/rewrite_test.go | 102 +++++++++++++++++++++++++ src/cmd/compile/internal/ssa/rewritegeneric.go | 100 ++++++++++++++++++++++++ 4 files changed, 251 insertions(+), 5 deletions(-) create mode 100644 src/cmd/compile/internal/ssa/rewrite_test.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index cf1bb76735..3971794d1a 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -320,6 +320,14 @@ (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 (Const64 [y]) x) && nlz(y) + nto(y) == 64 -> (Rsh64Ux64 (Lsh64x64 x (Const64 [nlz(y)])) (Const64 [nlz(y)])) +(And32 (Const32 [y]) x) && nlz(int64(int32(y))) + nto(int64(int32(y))) == 64 -> (Rsh32Ux32 (Lsh32x32 x (Const32 [nlz(int64(int32(y)))-32])) (Const32 [nlz(int64(int32(y)))-32])) +// trailing zeros can be shifted right, then left +(And64 (Const64 [y]) x) && nlo(y) + ntz(y) == 64 -> (Lsh64x64 (Rsh64Ux64 x (Const64 [ntz(y)])) (Const64 [ntz(y)])) +(And32 (Const32 [y]) x) && nlo(int64(int32(y))) + ntz(int64(int32(y))) == 64 -> (Lsh32x32 (Rsh32Ux32 x (Const32 [ntz(int64(int32(y)))])) (Const32 [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 diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go index 7dd0d2e5d5..69a463d4de 100644 --- a/src/cmd/compile/internal/ssa/rewrite.go +++ b/src/cmd/compile/internal/ssa/rewrite.go @@ -148,14 +148,50 @@ 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 } -// log2 returns logarithm in base of n. -// expects n to be a power of 2. +// 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) { - for n > 1 { + 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++ - n >>= 1 } - return l + return } // isPowerOfTwo reports whether n is a power of 2. 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 0000000000..b786df887b --- /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 index 0d905235e9..72b3553c30 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -676,6 +676,56 @@ func rewriteValuegeneric_OpAnd32(v *Value, config *Config) bool { v.AuxInt = 0 return true } + // match: (And32 (Const32 [y]) x) + // cond: nlz(int64(int32(y))) + nto(int64(int32(y))) == 64 + // result: (Rsh32Ux32 (Lsh32x32 x (Const32 [nlz(int64(int32(y)))-32])) (Const32 [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 (Const32 [y]) x) + // cond: nlo(int64(int32(y))) + ntz(int64(int32(y))) == 64 + // result: (Lsh32x32 (Rsh32Ux32 x (Const32 [ntz(int64(int32(y)))])) (Const32 [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 { @@ -744,6 +794,56 @@ func rewriteValuegeneric_OpAnd64(v *Value, config *Config) bool { v.AuxInt = 0 return true } + // match: (And64 (Const64 [y]) x) + // cond: nlz(y) + nto(y) == 64 + // result: (Rsh64Ux64 (Lsh64x64 x (Const64 [nlz(y)])) (Const64 [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 (Const64 [y]) x) + // cond: nlo(y) + ntz(y) == 64 + // result: (Lsh64x64 (Rsh64Ux64 x (Const64 [ntz(y)])) (Const64 [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 { -- cgit v1.3 From 65855cf64022905c9b66abc26adc175e337193c9 Mon Sep 17 00:00:00 2001 From: Alexandru Moșoi Date: Thu, 11 Feb 2016 20:46:43 +0100 Subject: [dev.ssa] cmd/compile/internal/ssa: factor out copyelimValue and phielimValue * Merge copyelim into phielim. * Add phielimValue to rewrite. cgoIsGoPointer is, for example, 2 instructions smaller now. Change-Id: I8baeb206d1b3ef8aba4a6e3bcdc432959bcae2d5 Reviewed-on: https://go-review.googlesource.com/19462 Reviewed-by: David Chase --- src/cmd/compile/internal/ssa/copyelim.go | 35 +++++++++++----- src/cmd/compile/internal/ssa/phielim.go | 69 +++++++++++++++++--------------- src/cmd/compile/internal/ssa/rewrite.go | 24 +---------- 3 files changed, 64 insertions(+), 64 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/copyelim.go b/src/cmd/compile/internal/ssa/copyelim.go index 067d5e2606..cfeff21e84 100644 --- a/src/cmd/compile/internal/ssa/copyelim.go +++ b/src/cmd/compile/internal/ssa/copyelim.go @@ -8,15 +8,7 @@ package ssa func copyelim(f *Func) { for _, b := range f.Blocks { for _, v := range b.Values { - for i, w := range v.Args { - x := w - for x.Op == OpCopy { - x = x.Args[0] - } - if x != w { - v.Args[i] = x - } - } + copyelimValue(v) } v := b.Control if v != nil { @@ -41,3 +33,28 @@ func copyelim(f *Func) { } } } + +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/phielim.go b/src/cmd/compile/internal/ssa/phielim.go index aaa0a0f238..20ce592030 100644 --- a/src/cmd/compile/internal/ssa/phielim.go +++ b/src/cmd/compile/internal/ssa/phielim.go @@ -18,44 +18,47 @@ package ssa // and would that be useful? func phielim(f *Func) { for { - changed := false + change := false for _, b := range f.Blocks { - nextv: for _, v := range b.Values { - if v.Op != OpPhi { - continue - } - // 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 _, x := range v.Args { - for x.Op == OpCopy { - x = x.Args[0] - } - if x == v { - continue - } - if x == w { - continue - } - if w != nil { - continue nextv - } - w = x - } - if w == nil { - // v references only itself. It must be in - // a dead code loop. Don't bother modifying it. - continue - } - v.Op = OpCopy - v.SetArgs1(w) - changed = true + copyelimValue(v) + change = phielimValue(v) || change } } - if !changed { + 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 _, x := range v.Args { + 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/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go index 69a463d4de..a580945702 100644 --- a/src/cmd/compile/internal/ssa/rewrite.go +++ b/src/cmd/compile/internal/ssa/rewrite.go @@ -40,28 +40,8 @@ func applyRewrite(f *Func, rb func(*Block) bool, rv func(*Value, *Config) bool) } curb = nil for _, v := range b.Values { - // 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 = a - } - advance = !advance - } - v.Args[i] = a - } + copyelimValue(v) + change = phielimValue(v) || change // apply rewrite function curv = v -- cgit v1.3 From c67cac07035c6b4d0f48df4c1f19641589f50e74 Mon Sep 17 00:00:00 2001 From: Alexandru Moșoi Date: Wed, 10 Feb 2016 00:27:33 +0100 Subject: [dev.ssa] cmd/compile/internal/ssa: transform degenerate control blocks MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * In cases where we end up with empty branches like in if a then jmp b else jmp b; the flow can be replaced by a; jmp b. The following functions is optimized as follows: func f(a bool, x int) int { v := 0 if a { v = -1 } else { v = -1 } return x | v } Before this change: 02819 (arith_ssa.go:362) VARDEF "".~r2+16(FP) 02820 (arith_ssa.go:362) MOVQ $0, "".~r2+16(FP) 02821 (arith_ssa.go:362) MOVB "".a(FP), AX 02822 (arith_ssa.go:362) TESTB AX, AX 02823 (arith_ssa.go:364) JEQ 2824 02824 (arith_ssa.go:369) VARDEF "".~r2+16(FP) 02825 (arith_ssa.go:369) MOVQ $-1, "".~r2+16(FP) 02826 (arith_ssa.go:369) RET After this change: 02819 (arith_ssa.go:362) VARDEF "".~r2+16(FP) 02820 (arith_ssa.go:369) VARDEF "".~r2+16(FP) 02821 (arith_ssa.go:369) MOVQ $-1, "".~r2+16(FP) 02822 (arith_ssa.go:369) RET Updates #14277 Change-Id: Ibe7d284f43406c704903632a4fcf2a4a64059686 Reviewed-on: https://go-review.googlesource.com/19464 Reviewed-by: Keith Randall Run-TryBot: Alexandru Moșoi TryBot-Result: Gobot Gobot --- src/cmd/compile/internal/ssa/fuse.go | 152 ++++++++++++++++++++------ src/cmd/compile/internal/ssa/fuse_test.go | 95 ++++++++++++++++ src/cmd/compile/internal/ssa/nilcheck_test.go | 3 + 3 files changed, 218 insertions(+), 32 deletions(-) create mode 100644 src/cmd/compile/internal/ssa/fuse_test.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/fuse.go b/src/cmd/compile/internal/ssa/fuse.go index f191c7f9fd..2647b841d7 100644 --- a/src/cmd/compile/internal/ssa/fuse.go +++ b/src/cmd/compile/internal/ssa/fuse.go @@ -6,43 +6,131 @@ package ssa // fuse simplifies control flow by joining basic blocks. func fuse(f *Func) { - for _, b := range f.Blocks { - if b.Kind != BlockPlain { - continue - } - c := b.Succs[0] - if len(c.Preds) != 1 { - continue + for changed := true; changed; { + changed = false + for _, b := range f.Blocks { + changed = fuseBlockIf(b) || changed + changed = fuseBlockPlain(b) || changed } + } +} - // move all of b's values to c. - for _, v := range b.Values { - v.Block = c - c.Values = append(c.Values, v) - } +// fuseBlockIf handles the following cases where s0 and s1 are empty blocks. +// +// b b b +// / \ | \ / | +// s0 s1 | s1 s0 | +// \ / | / \ | +// ss ss ss +// +// If ss doesn't contain any Phi ops and s0 & s1 are empty then the branch +// can be dropped. +// TODO: If ss doesn't contain any Phi ops, 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 = nil, s0 + } else { + ss0 = s0.Succs[0] + } + s1 := b.Succs[1] + if s1.Kind != BlockPlain || len(s1.Preds) != 1 || len(s1.Values) != 0 { + s1, ss1 = nil, s1 + } else { + ss1 = s1.Succs[0] + } - // 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...) + if ss0 != ss1 { + return false + } + ss := ss0 + + // TODO: Handle OpPhi operations. We can still replace OpPhi if the + // slots corresponding to b, s0 and s1 point to the same variable. + for _, v := range ss.Values { + if v.Op == OpPhi { + return false } - for _, p := range c.Preds { - for i, q := range p.Succs { - if q == b { - p.Succs[i] = c - } + } + + // Now we have two 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 ss has no phis + // which is checked above. + // No critical edge is introduced because b will have one successor. + if s0 != nil { + ss.removePred(s0) + } + if s1 != nil { + ss.removePred(s1) + } + if s0 != nil && s1 != nil { + // Add an edge if both edges are removed, otherwise b is no longer connected to ss. + ss.Preds = append(ss.Preds, b) + } + b.Kind = BlockPlain + b.Control = nil + b.Succs = append(b.Succs[:0], ss) + + // Trash the empty blocks s0 & s1. + if s0 != nil { + s0.Kind = BlockInvalid + s0.Values = nil + s0.Succs = nil + s0.Preds = nil + } + if s1 != nil { + 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.Entry == b { - f.Entry = c - } - - // trash b, just in case - b.Kind = BlockInvalid - b.Values = nil - b.Preds = nil - b.Succs = nil } + 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 0000000000..b6f6b82c35 --- /dev/null +++ b/src/cmd/compile/internal/ssa/fuse_test.go @@ -0,0 +1,95 @@ +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, "sb"), + 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, "sb"), + 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 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/nilcheck_test.go b/src/cmd/compile/internal/ssa/nilcheck_test.go index 14955e77d8..b90d11e540 100644 --- a/src/cmd/compile/internal/ssa/nilcheck_test.go +++ b/src/cmd/compile/internal/ssa/nilcheck_test.go @@ -403,8 +403,11 @@ func TestNilcheckBug(t *testing.T) { 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) -- cgit v1.3 From bc1fb32e9d4e5dd239907839f5ffcbe524ac7e25 Mon Sep 17 00:00:00 2001 From: Alexandru Moșoi Date: Wed, 17 Feb 2016 14:08:36 +0100 Subject: [dev.ssa] cmd/compile/internal/ssa: fix the type of constant shift folding. Also throw in a few more shift constant folding. Change-Id: Iabe00596987f594e0686fbac3d76376d94612340 Reviewed-on: https://go-review.googlesource.com/19543 Run-TryBot: David Chase TryBot-Result: Gobot Gobot Reviewed-by: David Chase --- src/cmd/compile/internal/ssa/gen/generic.rules | 25 +++- src/cmd/compile/internal/ssa/rewritegeneric.go | 192 +++++++++++++++++++++++-- 2 files changed, 199 insertions(+), 18 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index 3971794d1a..09ab918787 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -53,6 +53,19 @@ (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))]) @@ -191,12 +204,12 @@ // 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 -> (Const64 [0]) -(Rsh32Ux64 _ (Const64 [c])) && uint64(c) >= 32 -> (Const64 [0]) -(Lsh16x64 _ (Const64 [c])) && uint64(c) >= 16 -> (Const64 [0]) -(Rsh16Ux64 _ (Const64 [c])) && uint64(c) >= 16 -> (Const64 [0]) -(Lsh8x64 _ (Const64 [c])) && uint64(c) >= 8 -> (Const64 [0]) -(Rsh8Ux64 _ (Const64 [c])) && uint64(c) >= 8 -> (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 diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index 72b3553c30..c6fcb22565 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -3135,6 +3135,20 @@ func rewriteValuegeneric_OpLsh16x64(v *Value, config *Config) bool { 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 @@ -3153,7 +3167,7 @@ func rewriteValuegeneric_OpLsh16x64(v *Value, config *Config) bool { } // match: (Lsh16x64 _ (Const64 [c])) // cond: uint64(c) >= 16 - // result: (Const64 [0]) + // result: (Const16 [0]) for { if v.Args[1].Op != OpConst64 { break @@ -3162,7 +3176,7 @@ func rewriteValuegeneric_OpLsh16x64(v *Value, config *Config) bool { if !(uint64(c) >= 16) { break } - v.reset(OpConst64) + v.reset(OpConst16) v.AuxInt = 0 return true } @@ -3280,6 +3294,20 @@ func rewriteValuegeneric_OpLsh32x64(v *Value, config *Config) bool { 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 @@ -3298,7 +3326,7 @@ func rewriteValuegeneric_OpLsh32x64(v *Value, config *Config) bool { } // match: (Lsh32x64 _ (Const64 [c])) // cond: uint64(c) >= 32 - // result: (Const64 [0]) + // result: (Const32 [0]) for { if v.Args[1].Op != OpConst64 { break @@ -3307,7 +3335,7 @@ func rewriteValuegeneric_OpLsh32x64(v *Value, config *Config) bool { if !(uint64(c) >= 32) { break } - v.reset(OpConst64) + v.reset(OpConst32) v.AuxInt = 0 return true } @@ -3453,6 +3481,20 @@ func rewriteValuegeneric_OpLsh64x64(v *Value, config *Config) bool { 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 @@ -3626,6 +3668,20 @@ func rewriteValuegeneric_OpLsh8x64(v *Value, config *Config) bool { 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 @@ -3644,7 +3700,7 @@ func rewriteValuegeneric_OpLsh8x64(v *Value, config *Config) bool { } // match: (Lsh8x64 _ (Const64 [c])) // cond: uint64(c) >= 8 - // result: (Const64 [0]) + // result: (Const8 [0]) for { if v.Args[1].Op != OpConst64 { break @@ -3653,7 +3709,7 @@ func rewriteValuegeneric_OpLsh8x64(v *Value, config *Config) bool { if !(uint64(c) >= 8) { break } - v.reset(OpConst64) + v.reset(OpConst8) v.AuxInt = 0 return true } @@ -4979,6 +5035,20 @@ func rewriteValuegeneric_OpRsh16Ux64(v *Value, config *Config) bool { 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 @@ -4997,7 +5067,7 @@ func rewriteValuegeneric_OpRsh16Ux64(v *Value, config *Config) bool { } // match: (Rsh16Ux64 _ (Const64 [c])) // cond: uint64(c) >= 16 - // result: (Const64 [0]) + // result: (Const16 [0]) for { if v.Args[1].Op != OpConst64 { break @@ -5006,7 +5076,7 @@ func rewriteValuegeneric_OpRsh16Ux64(v *Value, config *Config) bool { if !(uint64(c) >= 16) { break } - v.reset(OpConst64) + v.reset(OpConst16) v.AuxInt = 0 return true } @@ -5124,6 +5194,20 @@ func rewriteValuegeneric_OpRsh16x64(v *Value, config *Config) bool { 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 @@ -5254,6 +5338,20 @@ func rewriteValuegeneric_OpRsh32Ux64(v *Value, config *Config) bool { 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 @@ -5272,7 +5370,7 @@ func rewriteValuegeneric_OpRsh32Ux64(v *Value, config *Config) bool { } // match: (Rsh32Ux64 _ (Const64 [c])) // cond: uint64(c) >= 32 - // result: (Const64 [0]) + // result: (Const32 [0]) for { if v.Args[1].Op != OpConst64 { break @@ -5281,7 +5379,7 @@ func rewriteValuegeneric_OpRsh32Ux64(v *Value, config *Config) bool { if !(uint64(c) >= 32) { break } - v.reset(OpConst64) + v.reset(OpConst32) v.AuxInt = 0 return true } @@ -5399,6 +5497,20 @@ func rewriteValuegeneric_OpRsh32x64(v *Value, config *Config) bool { 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 @@ -5557,6 +5669,20 @@ func rewriteValuegeneric_OpRsh64Ux64(v *Value, config *Config) bool { 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 @@ -5758,6 +5884,20 @@ func rewriteValuegeneric_OpRsh64x64(v *Value, config *Config) bool { 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 @@ -5916,6 +6056,20 @@ func rewriteValuegeneric_OpRsh8Ux64(v *Value, config *Config) bool { 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 @@ -5934,7 +6088,7 @@ func rewriteValuegeneric_OpRsh8Ux64(v *Value, config *Config) bool { } // match: (Rsh8Ux64 _ (Const64 [c])) // cond: uint64(c) >= 8 - // result: (Const64 [0]) + // result: (Const8 [0]) for { if v.Args[1].Op != OpConst64 { break @@ -5943,7 +6097,7 @@ func rewriteValuegeneric_OpRsh8Ux64(v *Value, config *Config) bool { if !(uint64(c) >= 8) { break } - v.reset(OpConst64) + v.reset(OpConst8) v.AuxInt = 0 return true } @@ -6061,6 +6215,20 @@ func rewriteValuegeneric_OpRsh8x64(v *Value, config *Config) bool { 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 -- cgit v1.3 From ae276d8c2342aff7b9bdf6563ffac5d21da70db6 Mon Sep 17 00:00:00 2001 From: David Chase Date: Thu, 18 Feb 2016 17:49:45 -0500 Subject: [dev.ssa] cmd/compile: reenable TestStackBarrierProfiling Tested it 1000x on OS X and Linux amd64, no failures. Updated TODO. Change-Id: Ia60c8d90962f6e5f7c3ed1ded6ba1b25eee983e1 Reviewed-on: https://go-review.googlesource.com/19662 Reviewed-by: Todd Neal --- src/cmd/compile/internal/ssa/TODO | 1 - src/runtime/pprof/pprof_test.go | 5 ----- 2 files changed, 6 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/TODO b/src/cmd/compile/internal/ssa/TODO index 5fa14ee44b..5e5cb4b865 100644 --- a/src/cmd/compile/internal/ssa/TODO +++ b/src/cmd/compile/internal/ssa/TODO @@ -7,7 +7,6 @@ Coverage Correctness ----------- - Debugging info (check & fix as much as we can) -- Re-enable TestStackBarrierProfiling (src/runtime/pprof/pprof_test.go) - @ directive in rewrites might read overwritten data. Save @loc in variable before modifying v. diff --git a/src/runtime/pprof/pprof_test.go b/src/runtime/pprof/pprof_test.go index f7c1a46805..ab6b1835c5 100644 --- a/src/runtime/pprof/pprof_test.go +++ b/src/runtime/pprof/pprof_test.go @@ -375,11 +375,6 @@ func TestStackBarrierProfiling(t *testing.T) { t.Skipf("low resolution timers inhibit profiling signals (golang.org/issue/13405)") return } - if true { - // TODO(khr): remove - t.Skipf("skipping for SSA branch, flaky") - return - } if !strings.Contains(os.Getenv("GODEBUG"), "gcstackbarrierall=1") { // Re-execute this test with constant GC and stack -- cgit v1.3 From e4bee4be9276dc5a7ba5e06aa9d287cbf39d8758 Mon Sep 17 00:00:00 2001 From: Alexandru Moșoi Date: Wed, 17 Feb 2016 12:17:11 +0100 Subject: [dev.ssa] cmd/compile/internal/ssa: constant fold truncates and bool comparisons Change-Id: I731722eb77f373ff7d6101f93830ab0a50497e2c Reviewed-on: https://go-review.googlesource.com/19542 Run-TryBot: David Chase TryBot-Result: Gobot Gobot Reviewed-by: David Chase --- src/cmd/compile/internal/ssa/gen/generic.rules | 17 ++ src/cmd/compile/internal/ssa/rewritegeneric.go | 248 +++++++++++++++++++++++++ 2 files changed, 265 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index 09ab918787..f83634c394 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -20,6 +20,13 @@ // 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]) @@ -70,14 +77,22 @@ (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 [c]) (Add64 (Const64 [d]) x)) -> (Eq64 (Const64 [c-d]) x) (Eq32 (Const32 [c]) (Add32 (Const32 [d]) x)) -> (Eq32 (Const32 [c-d]) x) @@ -94,11 +109,13 @@ (Eq32 x (Const32 [c])) && x.Op != OpConst32 -> (Eq32 (Const32 [c]) x) (Eq16 x (Const16 [c])) && x.Op != OpConst16 -> (Eq16 (Const16 [c]) x) (Eq8 x (Const8 [c])) && x.Op != OpConst8 -> (Eq8 (Const8 [c]) x) +(Eq8 x (ConstBool [c])) && x.Op != OpConstBool -> (Eq8 (ConstBool [c]) x) (Neq64 x (Const64 [c])) && x.Op != OpConst64 -> (Neq64 (Const64 [c]) x) (Neq32 x (Const32 [c])) && x.Op != OpConst32 -> (Neq32 (Const32 [c]) x) (Neq16 x (Const16 [c])) && x.Op != OpConst16 -> (Neq16 (Const16 [c]) x) (Neq8 x (Const8 [c])) && x.Op != OpConst8 -> (Neq8 (Const8 [c]) x) +(Neq8 x (ConstBool [c])) && x.Op != OpConstBool -> (Neq8 (ConstBool [c]) x) (Add64 x (Const64 [c])) && x.Op != OpConst64 -> (Add64 (Const64 [c]) x) (Add32 x (Const32 [c])) && x.Op != OpConst32 -> (Add32 (Const32 [c]) x) diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index c6fcb22565..ae36112a50 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -303,6 +303,18 @@ func rewriteValuegeneric(v *Value, config *Config) bool { 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: @@ -1899,6 +1911,53 @@ func rewriteValuegeneric_OpEq8(v *Value, config *Config) bool { 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 [c]) (Add8 (Const8 [d]) x)) // cond: // result: (Eq8 (Const8 [c-d]) x) @@ -1946,6 +2005,26 @@ func rewriteValuegeneric_OpEq8(v *Value, config *Config) bool { v.AddArg(x) return true } + // match: (Eq8 x (ConstBool [c])) + // cond: x.Op != OpConstBool + // result: (Eq8 (ConstBool [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))]) @@ -4429,6 +4508,53 @@ func rewriteValuegeneric_OpNeq8(v *Value, config *Config) bool { 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 [c]) (Add8 (Const8 [d]) x)) // cond: // result: (Neq8 (Const8 [c-d]) x) @@ -4476,6 +4602,26 @@ func rewriteValuegeneric_OpNeq8(v *Value, config *Config) bool { v.AddArg(x) return true } + // match: (Neq8 x (ConstBool [c])) + // cond: x.Op != OpConstBool + // result: (Neq8 (ConstBool [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))]) @@ -7275,6 +7421,108 @@ func rewriteValuegeneric_OpSub8(v *Value, config *Config) bool { } 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 -- cgit v1.3 From 5949524fc48aa514154cfb939ae28af58aaf6540 Mon Sep 17 00:00:00 2001 From: Alexandru Moșoi Date: Wed, 17 Feb 2016 17:21:53 +0100 Subject: [dev.ssa] cmd/compile/internal/ssa: handle phis in fuse. Change-Id: Idd880cc6c1e5dc34dddbdea0841a7a718d2fa836 Reviewed-on: https://go-review.googlesource.com/19544 Reviewed-by: David Chase --- src/cmd/compile/internal/ssa/fuse.go | 72 ++++++++++++++++++++----------- src/cmd/compile/internal/ssa/fuse_test.go | 34 +++++++++++++++ 2 files changed, 81 insertions(+), 25 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/fuse.go b/src/cmd/compile/internal/ssa/fuse.go index 2647b841d7..3f81e452b6 100644 --- a/src/cmd/compile/internal/ssa/fuse.go +++ b/src/cmd/compile/internal/ssa/fuse.go @@ -17,15 +17,15 @@ func fuse(f *Func) { // fuseBlockIf handles the following cases where s0 and s1 are empty blocks. // -// b b b -// / \ | \ / | -// s0 s1 | s1 s0 | -// \ / | / \ | -// ss ss ss +// b b b b +// / \ | \ / | | | +// s0 s1 | s1 s0 | | | +// \ / | / \ | | | +// ss ss ss ss // -// If ss doesn't contain any Phi ops and s0 & s1 are empty then the branch -// can be dropped. -// TODO: If ss doesn't contain any Phi ops, are s0 and s1 dead code anyway? +// 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 @@ -34,13 +34,13 @@ func fuseBlockIf(b *Block) bool { var ss0, ss1 *Block s0 := b.Succs[0] if s0.Kind != BlockPlain || len(s0.Preds) != 1 || len(s0.Values) != 0 { - s0, ss0 = nil, s0 + 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 = nil, s1 + s1, ss1 = b, s1 } else { ss1 = s1.Succs[0] } @@ -50,41 +50,63 @@ func fuseBlockIf(b *Block) bool { } ss := ss0 - // TODO: Handle OpPhi operations. We can still replace OpPhi if the - // slots corresponding to b, s0 and s1 point to the same variable. + // 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 { + if v.Op == OpPhi && v.Args[i0] != v.Args[i1] { return false } } - // Now we have two following b->ss, b->s0->ss and b->s1->ss, + // 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 ss has no phis - // which is checked above. + // 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 != nil { + if s0 != b && s1 != b { ss.removePred(s0) - } - if s1 != nil { + + // 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) } - if s0 != nil && s1 != nil { - // Add an edge if both edges are removed, otherwise b is no longer connected to ss. - ss.Preds = append(ss.Preds, b) - } b.Kind = BlockPlain b.Control = nil b.Succs = append(b.Succs[:0], ss) // Trash the empty blocks s0 & s1. - if s0 != nil { + if s0 != b { s0.Kind = BlockInvalid s0.Values = nil s0.Succs = nil s0.Preds = nil } - if s1 != nil { + if s1 != b { s1.Kind = BlockInvalid s1.Values = nil s1.Succs = nil diff --git a/src/cmd/compile/internal/ssa/fuse_test.go b/src/cmd/compile/internal/ssa/fuse_test.go index b6f6b82c35..3ce8ea54b3 100644 --- a/src/cmd/compile/internal/ssa/fuse_test.go +++ b/src/cmd/compile/internal/ssa/fuse_test.go @@ -65,6 +65,40 @@ func TestFuseEliminatesBothBranches(t *testing.T) { } } +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, "sb"), + 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", -- cgit v1.3 From 4827c6d0778d93afeaee658a330d97b8f1b510a6 Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Sun, 21 Feb 2016 20:21:23 -0600 Subject: [dev.ssa] test: add test of pointer aliasing This adds a test case with aliased pointers to ensure modifications to dse don't remove valid stores. Change-Id: I143653250f46a403835218ec685bcd336d5087ef Reviewed-on: https://go-review.googlesource.com/19795 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/testdata/unsafe_ssa.go | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/testdata/unsafe_ssa.go b/src/cmd/compile/internal/gc/testdata/unsafe_ssa.go index bc292828d5..d074eb1d5e 100644 --- a/src/cmd/compile/internal/gc/testdata/unsafe_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/unsafe_ssa.go @@ -123,7 +123,26 @@ func testg() { } } +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() } -- cgit v1.3 From 94f02451148755b31cc4dd455c9e215d5f898898 Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Wed, 10 Feb 2016 19:39:32 -0600 Subject: [dev.ssa] cmd/compile: add a zero arg cse pass Add an initial cse pass that only operates on zero argument values. This removes the need for a special case in cse for removing OpSB and speeds up arithConst_ssa.go compilation by 9% while slowing "test -c net/http" by 1.5%. Change-Id: Id1500482485426f66c6c2eba75eeaf4f19c8a889 Reviewed-on: https://go-review.googlesource.com/19454 Run-TryBot: Todd Neal TryBot-Result: Gobot Gobot Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/compile.go | 3 +- src/cmd/compile/internal/ssa/cse.go | 36 +++--------- src/cmd/compile/internal/ssa/cse_test.go | 48 +++++++++++++++- src/cmd/compile/internal/ssa/zcse.go | 95 ++++++++++++++++++++++++++++++++ 4 files changed, 150 insertions(+), 32 deletions(-) create mode 100644 src/cmd/compile/internal/ssa/zcse.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/compile.go b/src/cmd/compile/internal/ssa/compile.go index 69f751187d..dfead98c65 100644 --- a/src/cmd/compile/internal/ssa/compile.go +++ b/src/cmd/compile/internal/ssa/compile.go @@ -102,8 +102,9 @@ var passes = [...]pass{ {"decompose user", decomposeUser, true}, {"decompose builtin", decomposeBuiltIn, true}, {"opt", opt, true}, // TODO: split required rules and optimizing rules + {"zero arg cse", zcse, true}, // required to merge OpSB values {"opt deadcode", deadcode, false}, // remove any blocks orphaned during opt - {"generic cse", cse, true}, + {"generic cse", cse, false}, {"nilcheckelim", nilcheckelim, false}, {"generic deadcode", deadcode, false}, {"fuse", fuse, false}, diff --git a/src/cmd/compile/internal/ssa/cse.go b/src/cmd/compile/internal/ssa/cse.go index 36ab6a3680..545e173928 100644 --- a/src/cmd/compile/internal/ssa/cse.go +++ b/src/cmd/compile/internal/ssa/cse.go @@ -13,34 +13,6 @@ import ( // Values are just relinked, nothing is deleted. A subsequent deadcode // pass is required to actually remove duplicate expressions. func cse(f *Func) { - if !f.Config.optimize { - // Don't do CSE in this case. But we need to do - // just a little bit, to combine multiple OpSB ops. - // Regalloc gets very confused otherwise. - var sb *Value - outer: - for _, b := range f.Blocks { - for _, v := range b.Values { - if v.Op == OpSB { - sb = v - break outer - } - } - } - if sb == nil { - return - } - for _, b := range f.Blocks { - for _, v := range b.Values { - for i, a := range v.Args { - if a.Op == OpSB { - v.Args[i] = sb - } - } - } - } - return - } // Two values are equivalent if they satisfy the following definition: // equivalent(v, w): // v.op == w.op @@ -77,6 +49,14 @@ func cse(f *Func) { } } for i, e := range partition { + if 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) } diff --git a/src/cmd/compile/internal/ssa/cse_test.go b/src/cmd/compile/internal/ssa/cse_test.go index fb9fada120..905939fc32 100644 --- a/src/cmd/compile/internal/ssa/cse_test.go +++ b/src/cmd/compile/internal/ssa/cse_test.go @@ -6,12 +6,16 @@ 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 := "arg1-aux" - arg2Aux := "arg2-aux" - arg3Aux := "arg3-aux" + 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 @@ -77,5 +81,43 @@ func TestCSEAuxPartitionBug(t *testing.T) { 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/zcse.go b/src/cmd/compile/internal/ssa/zcse.go new file mode 100644 index 0000000000..3206e19974 --- /dev/null +++ b/src/cmd/compile/internal/ssa/zcse.go @@ -0,0 +1,95 @@ +// 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 + switch v.Op { + case OpSB, OpConst64, OpConst32, OpConst16, OpConst8, OpConst64F, + OpConst32F, OpConstBool, OpConstNil, OpConstSlice, OpConstInterface: + key := vkey{v.Op, keyFor(v), 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 { + // TODO: encode arglen in the opcode table, then do this switch with a table lookup? + switch a.Op { + case OpSB, OpConst64, OpConst32, OpConst16, OpConst8, OpConst64F, + OpConst32F, OpConstBool, OpConstNil, OpConstSlice, OpConstInterface: + key := vkey{a.Op, keyFor(a), 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 + a int64 // 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: + // Also matches OpSB, OpConstNil, OpConstSlice, OpConstInterface: + return 0 + } +} -- cgit v1.3 From b86cafc7dced537165a7cda61b90feae44796055 Mon Sep 17 00:00:00 2001 From: David Chase Date: Wed, 10 Feb 2016 17:43:31 -0500 Subject: [dev.ssa] cmd/compile: memory allocation tweaks to regalloc and dom Spotted a minor source of excess allocation in the register allocator. Rearranged the dominator tree code to pull its scratch memory from a reused buffer attached to Config. Change-Id: I6da6e7b112f7d3eb1fd00c58faa8214cdea44e38 Reviewed-on: https://go-review.googlesource.com/19450 Reviewed-by: Keith Randall Run-TryBot: David Chase TryBot-Result: Gobot Gobot --- src/cmd/compile/internal/ssa/config.go | 3 +- src/cmd/compile/internal/ssa/dom.go | 76 +++++++++++++++++++++++++------- src/cmd/compile/internal/ssa/regalloc.go | 15 +++++-- 3 files changed, 74 insertions(+), 20 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/config.go b/src/cmd/compile/internal/ssa/config.go index 530c480004..81061a7219 100644 --- a/src/cmd/compile/internal/ssa/config.go +++ b/src/cmd/compile/internal/ssa/config.go @@ -24,7 +24,8 @@ type Config struct { values [2000]Value blocks [200]Block - scrSparse []*sparseSet // scratch sparse sets to be re-used. + domblockstore []ID // scratch space for computing dominators + scrSparse []*sparseSet // scratch sparse sets to be re-used. } type TypeSource interface { diff --git a/src/cmd/compile/internal/ssa/dom.go b/src/cmd/compile/internal/ssa/dom.go index 50ff472ca3..2d53b5a957 100644 --- a/src/cmd/compile/internal/ssa/dom.go +++ b/src/cmd/compile/internal/ssa/dom.go @@ -54,17 +54,53 @@ func postorder(f *Func) []*Block { 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 dfs(entries []*Block, succFn linkedBlocks) (fromID []*Block, dfnum []int32, order []ID, parent []ID) { +func (f *Func) dfs(entries []*Block, succFn linkedBlocks, dfnum, order, parent []ID) (fromID []*Block) { maxBlockID := entries[0].Func.NumBlocks() - dfnum = make([]int32, maxBlockID) - order = make([]ID, maxBlockID) - parent = make([]ID, maxBlockID) fromID = make([]*Block, maxBlockID) for _, entry := range entries[0].Func.Blocks { @@ -75,7 +111,7 @@ func dfs(entries []*Block, succFn linkedBlocks) (fromID []*Block, dfnum []int32, fromID[eid] = entry } - n := int32(0) + n := ID(0) s := make([]*Block, 0, 256) for _, entry := range entries { if dfnum[entry.ID] != notFound { @@ -113,7 +149,7 @@ func dominators(f *Func) []*Block { //TODO: benchmark and try to find criteria for swapping between // dominatorsSimple and dominatorsLT - return dominatorsLT([]*Block{f.Entry}, preds, succs) + return f.dominatorsLT([]*Block{f.Entry}, preds, succs) } // postDominators computes the post-dominator tree for f. @@ -139,27 +175,35 @@ func postDominators(f *Func) []*Block { if exits == nil { return make([]*Block, f.NumBlocks()) } - return dominatorsLT(exits, succs, preds) + 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 dominatorsLT(entries []*Block, predFn linkedBlocks, succFn linkedBlocks) []*Block { +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, dfnum, vertex, parent := dfs(entries, succFn) + fromID := f.dfs(entries, succFn, dfnum, vertex, parent) - maxBlockID := entries[0].Func.NumBlocks() - semi := make([]ID, maxBlockID) - samedom := make([]ID, maxBlockID) - ancestor := make([]ID, maxBlockID) - best := make([]ID, maxBlockID) - bucket := make([]ID, maxBlockID) idom := make([]*Block, maxBlockID) // Step 2. Compute the semidominators of all vertices by applying @@ -242,7 +286,7 @@ func dominatorsLT(entries []*Block, predFn linkedBlocks, succFn linkedBlocks) [] } // eval function from LT paper with path compression -func eval(v ID, ancestor []ID, semi []ID, dfnum []int32, best []ID) ID { +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) diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index bfb6f7da76..a55f81d4ac 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -964,7 +964,16 @@ func (s *regAllocState) regalloc(f *Func) { } // Save end-of-block register state. - var regList []endReg + // 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 { @@ -1609,8 +1618,8 @@ func (s *regAllocState) computeLive() { } // The live set has changed, update it. l := s.live[p.ID][:0] - if cap(l) == 0 { - l = make([]liveInfo, 0, len(t.contents())) + if cap(l) < t.size() { + l = make([]liveInfo, 0, t.size()) } for _, e := range t.contents() { l = append(l, liveInfo{e.key, e.val}) -- cgit v1.3 From 88c1ef5b450a9cb50ee412b0240e135a74e64517 Mon Sep 17 00:00:00 2001 From: Alexandru Moșoi Date: Mon, 22 Feb 2016 11:19:15 +0100 Subject: [dev.ssa] cmd/compile/internal/ssa: handle commutative operations in cse MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * If a operation is commutative order the parameters in a canonical way. Size of pkg/tool/linux_amd64/* excluding compile: before: 95882288 after: 95868152 change: 14136 ~0.015% I tried something similar with Leq and Geq, but the results were not great because it confuses the 'lowered cse' pass too much which can no longer remove redundant comparisons from IsInBounds. Change-Id: I2f928663a11320bfc51c7fa47e384b7411c420ba Reviewed-on: https://go-review.googlesource.com/19727 Reviewed-by: Keith Randall Run-TryBot: Alexandru Moșoi TryBot-Result: Gobot Gobot --- src/cmd/compile/internal/ssa/cse.go | 4 + src/cmd/compile/internal/ssa/gen/genericOps.go | 60 +++++----- src/cmd/compile/internal/ssa/gen/main.go | 6 +- src/cmd/compile/internal/ssa/op.go | 1 + src/cmd/compile/internal/ssa/opGen.go | 150 +++++++++++++++---------- 5 files changed, 130 insertions(+), 91 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/cse.go b/src/cmd/compile/internal/ssa/cse.go index 545e173928..ea4fe0a97b 100644 --- a/src/cmd/compile/internal/ssa/cse.go +++ b/src/cmd/compile/internal/ssa/cse.go @@ -35,6 +35,10 @@ func cse(f *Func) { 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) } } diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index fe5169d233..9f53024b21 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -8,10 +8,10 @@ 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"}, // arg0 + arg1 - {name: "Add16"}, - {name: "Add32"}, - {name: "Add64"}, + {name: "Add8", commutative: true}, // arg0 + arg1 + {name: "Add16", commutative: true}, + {name: "Add32", commutative: true}, + {name: "Add64", commutative: true}, {name: "AddPtr"}, // For address calculations. arg0 is a pointer and arg1 is an int. {name: "Add32F"}, {name: "Add64F"}, @@ -25,10 +25,10 @@ var genericOps = []opData{ {name: "Sub32F"}, {name: "Sub64F"}, - {name: "Mul8"}, // arg0 * arg1 - {name: "Mul16"}, - {name: "Mul32"}, - {name: "Mul64"}, + {name: "Mul8", commutative: true}, // arg0 * arg1 + {name: "Mul16", commutative: true}, + {name: "Mul32", commutative: true}, + {name: "Mul64", commutative: true}, {name: "Mul32F"}, {name: "Mul64F"}, @@ -65,20 +65,20 @@ var genericOps = []opData{ {name: "Mod64"}, {name: "Mod64u"}, - {name: "And8"}, // arg0 & arg1 - {name: "And16"}, - {name: "And32"}, - {name: "And64"}, + {name: "And8", commutative: true}, // arg0 & arg1 + {name: "And16", commutative: true}, + {name: "And32", commutative: true}, + {name: "And64", commutative: true}, - {name: "Or8"}, // arg0 | arg1 - {name: "Or16"}, - {name: "Or32"}, - {name: "Or64"}, + {name: "Or8", commutative: true}, // arg0 | arg1 + {name: "Or16", commutative: true}, + {name: "Or32", commutative: true}, + {name: "Or64", commutative: true}, - {name: "Xor8"}, // arg0 ^ arg1 - {name: "Xor16"}, - {name: "Xor32"}, - {name: "Xor64"}, + {name: "Xor8", commutative: true}, // arg0 ^ arg1 + {name: "Xor16", commutative: true}, + {name: "Xor32", commutative: true}, + {name: "Xor64", commutative: true}, // For shifts, AxB means the shifted value has A bits and the shift amount has B bits. {name: "Lsh8x8"}, // arg0 << arg1 @@ -158,21 +158,21 @@ var genericOps = []opData{ {name: "Lrot64", aux: "Int64"}, // 2-input comparisons - {name: "Eq8"}, // arg0 == arg1 - {name: "Eq16"}, - {name: "Eq32"}, - {name: "Eq64"}, - {name: "EqPtr"}, + {name: "Eq8", commutative: true}, // arg0 == arg1 + {name: "Eq16", commutative: true}, + {name: "Eq32", commutative: true}, + {name: "Eq64", commutative: true}, + {name: "EqPtr", commutative: true}, {name: "EqInter"}, // arg0 or arg1 is nil; other cases handled by frontend {name: "EqSlice"}, // arg0 or arg1 is nil; other cases handled by frontend {name: "Eq32F"}, {name: "Eq64F"}, - {name: "Neq8"}, // arg0 != arg1 - {name: "Neq16"}, - {name: "Neq32"}, - {name: "Neq64"}, - {name: "NeqPtr"}, + {name: "Neq8", commutative: true}, // arg0 != arg1 + {name: "Neq16", commutative: true}, + {name: "Neq32", commutative: true}, + {name: "Neq64", commutative: true}, + {name: "NeqPtr", commutative: true}, {name: "NeqInter"}, // arg0 or arg1 is nil; other cases handled by frontend {name: "NeqSlice"}, // arg0 or arg1 is nil; other cases handled by frontend {name: "Neq32F"}, diff --git a/src/cmd/compile/internal/ssa/gen/main.go b/src/cmd/compile/internal/ssa/gen/main.go index d739b29079..bb4188c349 100644 --- a/src/cmd/compile/internal/ssa/gen/main.go +++ b/src/cmd/compile/internal/ssa/gen/main.go @@ -32,7 +32,8 @@ type opData struct { typ string // default result type aux string rematerializeable bool - variableLength bool // if true the operation has a variable number of arguments + variableLength bool // this operation has a variable number of arguments + commutative bool // this operation is commutative (e.g. addition) } type blockData struct { @@ -131,6 +132,9 @@ func genOp() { } 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 diff --git a/src/cmd/compile/internal/ssa/op.go b/src/cmd/compile/internal/ssa/op.go index a868fdbb6f..c118a6c609 100644 --- a/src/cmd/compile/internal/ssa/op.go +++ b/src/cmd/compile/internal/ssa/op.go @@ -21,6 +21,7 @@ type opInfo struct { auxType auxType 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 { diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index dfd9df8ba4..ae257c0ba6 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -3597,20 +3597,24 @@ var opcodeTable = [...]opInfo{ }, { - name: "Add8", - generic: true, + name: "Add8", + commutative: true, + generic: true, }, { - name: "Add16", - generic: true, + name: "Add16", + commutative: true, + generic: true, }, { - name: "Add32", - generic: true, + name: "Add32", + commutative: true, + generic: true, }, { - name: "Add64", - generic: true, + name: "Add64", + commutative: true, + generic: true, }, { name: "AddPtr", @@ -3653,20 +3657,24 @@ var opcodeTable = [...]opInfo{ generic: true, }, { - name: "Mul8", - generic: true, + name: "Mul8", + commutative: true, + generic: true, }, { - name: "Mul16", - generic: true, + name: "Mul16", + commutative: true, + generic: true, }, { - name: "Mul32", - generic: true, + name: "Mul32", + commutative: true, + generic: true, }, { - name: "Mul64", - generic: true, + name: "Mul64", + commutative: true, + generic: true, }, { name: "Mul32F", @@ -3785,52 +3793,64 @@ var opcodeTable = [...]opInfo{ generic: true, }, { - name: "And8", - generic: true, + name: "And8", + commutative: true, + generic: true, }, { - name: "And16", - generic: true, + name: "And16", + commutative: true, + generic: true, }, { - name: "And32", - generic: true, + name: "And32", + commutative: true, + generic: true, }, { - name: "And64", - generic: true, + name: "And64", + commutative: true, + generic: true, }, { - name: "Or8", - generic: true, + name: "Or8", + commutative: true, + generic: true, }, { - name: "Or16", - generic: true, + name: "Or16", + commutative: true, + generic: true, }, { - name: "Or32", - generic: true, + name: "Or32", + commutative: true, + generic: true, }, { - name: "Or64", - generic: true, + name: "Or64", + commutative: true, + generic: true, }, { - name: "Xor8", - generic: true, + name: "Xor8", + commutative: true, + generic: true, }, { - name: "Xor16", - generic: true, + name: "Xor16", + commutative: true, + generic: true, }, { - name: "Xor32", - generic: true, + name: "Xor32", + commutative: true, + generic: true, }, { - name: "Xor64", - generic: true, + name: "Xor64", + commutative: true, + generic: true, }, { name: "Lsh8x8", @@ -4045,24 +4065,29 @@ var opcodeTable = [...]opInfo{ generic: true, }, { - name: "Eq8", - generic: true, + name: "Eq8", + commutative: true, + generic: true, }, { - name: "Eq16", - generic: true, + name: "Eq16", + commutative: true, + generic: true, }, { - name: "Eq32", - generic: true, + name: "Eq32", + commutative: true, + generic: true, }, { - name: "Eq64", - generic: true, + name: "Eq64", + commutative: true, + generic: true, }, { - name: "EqPtr", - generic: true, + name: "EqPtr", + commutative: true, + generic: true, }, { name: "EqInter", @@ -4081,24 +4106,29 @@ var opcodeTable = [...]opInfo{ generic: true, }, { - name: "Neq8", - generic: true, + name: "Neq8", + commutative: true, + generic: true, }, { - name: "Neq16", - generic: true, + name: "Neq16", + commutative: true, + generic: true, }, { - name: "Neq32", - generic: true, + name: "Neq32", + commutative: true, + generic: true, }, { - name: "Neq64", - generic: true, + name: "Neq64", + commutative: true, + generic: true, }, { - name: "NeqPtr", - generic: true, + name: "NeqPtr", + commutative: true, + generic: true, }, { name: "NeqInter", -- cgit v1.3 From c3db6c95b6f933e1489565aa65a94edc880a3f3d Mon Sep 17 00:00:00 2001 From: David Chase Date: Thu, 11 Feb 2016 15:09:43 -0500 Subject: [dev.ssa] cmd/compile: double speed of CSE phase Replaced comparison based on (*Type).String() with an allocation-free structural comparison. Roughly doubles speed of CSE, also reduces allocations. Checked that roughly the same number of CSEs were detected during make.bash (about a million) and that "new" CSEs were caused by the effect described above. Change-Id: Id205a9f6986efd518043e12d651f0b01206aeb1b Reviewed-on: https://go-review.googlesource.com/19471 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/reflect.go | 3 +- src/cmd/compile/internal/gc/type.go | 243 ++++++++++++++++++++++++++++++ src/cmd/compile/internal/ssa/cse.go | 43 +++--- src/cmd/compile/internal/ssa/type.go | 35 +++++ src/cmd/compile/internal/ssa/type_test.go | 23 +++ 5 files changed, 321 insertions(+), 26 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/reflect.go b/src/cmd/compile/internal/gc/reflect.go index 264955c702..f6dd75ec4a 100644 --- a/src/cmd/compile/internal/gc/reflect.go +++ b/src/cmd/compile/internal/gc/reflect.go @@ -55,8 +55,7 @@ const ( 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/type.go b/src/cmd/compile/internal/gc/type.go index 3f218ee3da..f09094ce23 100644 --- a/src/cmd/compile/internal/gc/type.go +++ b/src/cmd/compile/internal/gc/type.go @@ -11,6 +11,7 @@ package gc import ( "cmd/compile/internal/ssa" + "fmt" ) func (t *Type) Size() int64 { @@ -35,6 +36,248 @@ func (t *Type) Equal(u ssa.Type) bool { 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 tx, 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 } diff --git a/src/cmd/compile/internal/ssa/cse.go b/src/cmd/compile/internal/ssa/cse.go index ea4fe0a97b..44bd87683d 100644 --- a/src/cmd/compile/internal/ssa/cse.go +++ b/src/cmd/compile/internal/ssa/cse.go @@ -155,12 +155,15 @@ func cse(f *Func) { } } + rewrites := 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++ } } } @@ -175,6 +178,9 @@ func cse(f *Func) { } } } + if Debug > 0 && rewrites > 0 { + fmt.Printf("CSE: %d rewrites\n", rewrites) + } } // An eqclass approximates an equivalence class. During the @@ -197,9 +203,8 @@ type eqclass []*Value // backed by the same storage as the input slice. // Equivalence classes of size 1 are ignored. func partitionValues(a []*Value) []eqclass { - typNames := map[Type]string{} auxIDs := map[interface{}]int32{} - sort.Sort(sortvalues{a, typNames, auxIDs}) + sort.Sort(sortvalues{a, auxIDs}) var partition []eqclass for len(a) > 0 { @@ -217,10 +222,10 @@ func partitionValues(a []*Value) []eqclass { v.Args[0].AuxInt != w.Args[0].AuxInt) || len(v.Args) >= 2 && (v.Args[1].Op != w.Args[1].Op || v.Args[1].AuxInt != w.Args[1].AuxInt) || - typNames[v.Type] != typNames[w.Type] { + v.Type.Compare(w.Type) != CMPeq { if Debug > 3 { - fmt.Printf("CSE.partitionValues separates %s from %s, AuxInt=%v, Aux=%v, typNames=%v", - v.LongString(), w.LongString(), v.AuxInt != w.AuxInt, v.Aux != w.Aux, typNames[v.Type] != typNames[w.Type]) + fmt.Printf("CSE.partitionValues separates %s from %s, AuxInt=%v, Aux=%v, Type.compare=%v", + v.LongString(), w.LongString(), v.AuxInt != w.AuxInt, v.Aux != w.Aux, v.Type.Compare(w.Type)) if !rootsDiffer { if len(v.Args) >= 1 { fmt.Printf(", a0Op=%v, a0AuxInt=%v", v.Args[0].Op != w.Args[0].Op, v.Args[0].AuxInt != w.Args[0].AuxInt) @@ -245,9 +250,8 @@ func partitionValues(a []*Value) []eqclass { // Sort values to make the initial partition. type sortvalues struct { - a []*Value // array of values - typNames map[Type]string // type -> type ID map - auxIDs map[interface{}]int32 // aux -> aux ID map + a []*Value // array of values + auxIDs map[interface{}]int32 // aux -> aux ID map } func (sv sortvalues) Len() int { return len(sv.a) } @@ -301,26 +305,17 @@ func (sv sortvalues) Less(i, j int) bool { } } - // Sort by type. Types are just interfaces, so we can't compare - // them with < directly. Instead, map types to their names and - // sort on that. + // Sort by type, using the ssa.Type Compare method if v.Type != w.Type { - x := sv.typNames[v.Type] - if x == "" { - x = v.Type.String() - sv.typNames[v.Type] = x - } - y := sv.typNames[w.Type] - if y == "" { - y = w.Type.String() - sv.typNames[w.Type] = y - } - if x != y { - return x < y + c := v.Type.Compare(w.Type) + if c != CMPeq { + return c == CMPlt } } - // Same deal for aux fields. + // Aux fields are interfaces with no comparison + // method. Use a map to number distinct ones, + // and use those numbers for comparison. if v.Aux != w.Aux { x := sv.auxIDs[v.Aux] if x == 0 { diff --git a/src/cmd/compile/internal/ssa/type.go b/src/cmd/compile/internal/ssa/type.go index 9a692dcfb0..afe04fa043 100644 --- a/src/cmd/compile/internal/ssa/type.go +++ b/src/cmd/compile/internal/ssa/type.go @@ -40,6 +40,7 @@ type Type interface { 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. @@ -76,6 +77,40 @@ 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 + } + // 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 { diff --git a/src/cmd/compile/internal/ssa/type_test.go b/src/cmd/compile/internal/ssa/type_test.go index f09919a652..26c8223c62 100644 --- a/src/cmd/compile/internal/ssa/type_test.go +++ b/src/cmd/compile/internal/ssa/type_test.go @@ -57,6 +57,29 @@ func (t *TypeImpl) Equal(u Type) bool { 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"} -- cgit v1.3 From 9dc1334cc76eda231bd776e78d678649e630563b Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Sat, 13 Feb 2016 17:37:19 -0600 Subject: [dev.ssa] cmd/compile : replace load of store with a copy Loads of stores from the same pointer with compatible types can be replaced with a copy. Change-Id: I514b3ed8e5b6a9c432946880eac67a51b1607932 Reviewed-on: https://go-review.googlesource.com/19743 Run-TryBot: Todd Neal TryBot-Result: Gobot Gobot Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/gen/generic.rules | 5 +++++ src/cmd/compile/internal/ssa/rewrite.go | 9 +++++++++ src/cmd/compile/internal/ssa/rewritegeneric.go | 20 ++++++++++++++++++++ 3 files changed, 34 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index f83634c394..4d43105557 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -388,6 +388,11 @@ (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 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 ptr idx) mem) diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go index a580945702..4197b0da88 100644 --- a/src/cmd/compile/internal/ssa/rewrite.go +++ b/src/cmd/compile/internal/ssa/rewrite.go @@ -202,6 +202,15 @@ 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 { + // 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 ( diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index ae36112a50..7916c6d8f4 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -2901,6 +2901,26 @@ func rewriteValuegeneric_OpLess8U(v *Value, config *Config) bool { func rewriteValuegeneric_OpLoad(v *Value, config *Config) bool { b := v.Block _ = b + // match: (Load 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 _ _) // cond: t.IsStruct() && t.NumFields() == 0 && config.fe.CanSSA(t) // result: (StructMake0) -- cgit v1.3 From c17b6b488cbf448da374d576be0f921e655b00b1 Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Fri, 19 Feb 2016 16:58:21 -0600 Subject: [dev.ssa] cmd/compile: truncate auxint when constructing Prog The upper bits of 8/16/32 bit constants are undefined. We need to truncate in order to prevent x86.oclass misidentifying the size of the constant. Fixes #14389 Change-Id: I3e5ff79cd904376572a93f489ba7e152a5cb6e60 Reviewed-on: https://go-review.googlesource.com/19740 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 39 ++++++++--------------- src/cmd/compile/internal/gc/testdata/arith_ssa.go | 37 +++++++++++++++++++++ src/cmd/compile/internal/ssa/value.go | 19 +++++++++++ 3 files changed, 70 insertions(+), 25 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 3f8fdce83b..19fda373bf 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -3990,7 +3990,7 @@ func (s *genState) genValue(v *ssa.Value) { r := regnum(v) a := regnum(v.Args[0]) if r == a { - if v.AuxInt == 1 { + if v.AuxInt2Int64() == 1 { var asm int switch v.Op { // Software optimization manual recommends add $1,reg. @@ -4009,7 +4009,7 @@ func (s *genState) genValue(v *ssa.Value) { p.To.Type = obj.TYPE_REG p.To.Reg = r return - } else if v.AuxInt == -1 { + } else if v.AuxInt2Int64() == -1 { var asm int switch v.Op { case ssa.OpAMD64ADDQconst: @@ -4026,7 +4026,7 @@ func (s *genState) genValue(v *ssa.Value) { } else { p := Prog(v.Op.Asm()) p.From.Type = obj.TYPE_CONST - p.From.Offset = v.AuxInt + p.From.Offset = v.AuxInt2Int64() p.To.Type = obj.TYPE_REG p.To.Reg = r return @@ -4044,7 +4044,7 @@ func (s *genState) genValue(v *ssa.Value) { p := Prog(asm) p.From.Type = obj.TYPE_MEM p.From.Reg = a - p.From.Offset = v.AuxInt + p.From.Offset = v.AuxInt2Int64() p.To.Type = obj.TYPE_REG p.To.Reg = r case ssa.OpAMD64MULQconst, ssa.OpAMD64MULLconst, ssa.OpAMD64MULWconst, ssa.OpAMD64MULBconst: @@ -4059,7 +4059,7 @@ func (s *genState) genValue(v *ssa.Value) { } p := Prog(v.Op.Asm()) p.From.Type = obj.TYPE_CONST - p.From.Offset = v.AuxInt + 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 @@ -4074,7 +4074,7 @@ func (s *genState) genValue(v *ssa.Value) { // 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.AuxInt == -1<<31 || x == r { + 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. @@ -4086,10 +4086,10 @@ func (s *genState) genValue(v *ssa.Value) { } p := Prog(v.Op.Asm()) p.From.Type = obj.TYPE_CONST - p.From.Offset = v.AuxInt + p.From.Offset = v.AuxInt2Int64() p.To.Type = obj.TYPE_REG p.To.Reg = r - } else if x == r && v.AuxInt == -1 { + } 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 @@ -4104,7 +4104,7 @@ func (s *genState) genValue(v *ssa.Value) { p := Prog(asm) p.To.Type = obj.TYPE_REG p.To.Reg = r - } else if x == r && v.AuxInt == 1 { + } else if x == r && v.AuxInt2Int64() == 1 { var asm int switch v.Op { case ssa.OpAMD64SUBQconst: @@ -4130,7 +4130,7 @@ func (s *genState) genValue(v *ssa.Value) { p := Prog(asm) p.From.Type = obj.TYPE_MEM p.From.Reg = x - p.From.Offset = -v.AuxInt + p.From.Offset = -v.AuxInt2Int64() p.To.Type = obj.TYPE_REG p.To.Reg = r } @@ -4157,7 +4157,7 @@ func (s *genState) genValue(v *ssa.Value) { } p := Prog(v.Op.Asm()) p.From.Type = obj.TYPE_CONST - p.From.Offset = v.AuxInt + p.From.Offset = v.AuxInt2Int64() p.To.Type = obj.TYPE_REG p.To.Reg = r case ssa.OpAMD64SBBQcarrymask, ssa.OpAMD64SBBLcarrymask: @@ -4204,29 +4204,18 @@ func (s *genState) genValue(v *ssa.Value) { p.From.Type = obj.TYPE_REG p.From.Reg = regnum(v.Args[0]) p.To.Type = obj.TYPE_CONST - p.To.Offset = v.AuxInt + 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.AuxInt + 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 - var i int64 - switch v.Op { - case ssa.OpAMD64MOVBconst: - i = int64(v.AuxInt8()) - case ssa.OpAMD64MOVWconst: - i = int64(v.AuxInt16()) - case ssa.OpAMD64MOVLconst: - i = int64(v.AuxInt32()) - case ssa.OpAMD64MOVQconst: - i = v.AuxInt - } - p.From.Offset = i + p.From.Offset = v.AuxInt2Int64() p.To.Type = obj.TYPE_REG p.To.Reg = x // If flags are live at this instruction, suppress the diff --git a/src/cmd/compile/internal/gc/testdata/arith_ssa.go b/src/cmd/compile/internal/gc/testdata/arith_ssa.go index 821c0dd12d..f4bea0ed11 100644 --- a/src/cmd/compile/internal/gc/testdata/arith_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/arith_ssa.go @@ -10,6 +10,42 @@ 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() { @@ -394,6 +430,7 @@ func main() { testOverflowConstShift() testArithConstShift() testArithRshConst() + testLargeConst() if failed { panic("failed") diff --git a/src/cmd/compile/internal/ssa/value.go b/src/cmd/compile/internal/ssa/value.go index c2ea6ee202..cc8c9fe871 100644 --- a/src/cmd/compile/internal/ssa/value.go +++ b/src/cmd/compile/internal/ssa/value.go @@ -77,6 +77,25 @@ func (v *Value) AuxInt32() int32 { } 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) -- cgit v1.3 From 40f2b57e0b007aaabe2b6ec5650223d047cd1452 Mon Sep 17 00:00:00 2001 From: Alexandru Moșoi Date: Mon, 22 Feb 2016 17:14:53 +0100 Subject: [dev.ssa] cmd/compile/internal/ssa: eliminate phis during deadcode removal MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit While investigating the differences between 19710 (remove tautological controls) and 12960 (bounds and nil propagation) I observed that part of the wins of 19710 come from missed opportunities for deadcode elimination due to phis. See for example runtime.stackcacherelease. 19710 happens much later than 12960 and has more chances to eliminate bounds. Size of pkg/tool/linux_amd64/* excluding compile: -this -12960 95882248 +this -12960 95880120 -this +12960 95581512 +this +12960 95555224 This change saves about 25k. Change-Id: Id2f4e55fc92b71595842ce493c3ed527d424fe0e Reviewed-on: https://go-review.googlesource.com/19728 Reviewed-by: David Chase Run-TryBot: Alexandru Moșoi TryBot-Result: Gobot Gobot --- src/cmd/compile/internal/ssa/deadcode.go | 66 ++++++++++++++++---------------- src/cmd/compile/internal/ssa/phielim.go | 6 ++- 2 files changed, 37 insertions(+), 35 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/deadcode.go b/src/cmd/compile/internal/ssa/deadcode.go index 87244a6248..a33de438e2 100644 --- a/src/cmd/compile/internal/ssa/deadcode.go +++ b/src/cmd/compile/internal/ssa/deadcode.go @@ -234,39 +234,37 @@ func (b *Block) removePred(p *Block) { v.Args[i] = v.Args[n] v.Args[n] = nil // aid GC v.Args = v.Args[:n] - if n == 1 { - v.Op = OpCopy - // 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. - } + 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/phielim.go b/src/cmd/compile/internal/ssa/phielim.go index 20ce592030..d69449ee21 100644 --- a/src/cmd/compile/internal/ssa/phielim.go +++ b/src/cmd/compile/internal/ssa/phielim.go @@ -40,7 +40,11 @@ func phielimValue(v *Value) bool { // are not v itself, then the phi must remain. // Otherwise, we can replace it with a copy. var w *Value - for _, x := range v.Args { + 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 } -- cgit v1.3 From d337e55672c0ea6c29af2615e5fa345941f822c4 Mon Sep 17 00:00:00 2001 From: Alexandru Moșoi Date: Tue, 23 Feb 2016 21:48:33 +0100 Subject: [dev.ssa] cmd/compile/internal/ssa: simplify convert in more cases MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Saves about 2k for binaries in pkg/tool/linux_amd64. Also useful when opt runs after cse (as in 12960) which reorders arguments for commutative operations such as Add64. Change-Id: I49ad53afa53db9736bd35c425f4fb35fb511fd63 Reviewed-on: https://go-review.googlesource.com/19827 Run-TryBot: Alexandru Moșoi TryBot-Result: Gobot Gobot Reviewed-by: David Chase Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/gen/generic.rules | 1 + src/cmd/compile/internal/ssa/rewritegeneric.go | 21 +++++++++++++++++++++ 2 files changed, 22 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index 4d43105557..ac24337920 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -586,6 +586,7 @@ // 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 diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index 7916c6d8f4..08ab2e14a6 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -1428,6 +1428,27 @@ func rewriteValuegeneric_OpConvert(v *Value, config *Config) bool { 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 -- cgit v1.3 From 8906d2a171153ab337a88d4e9f59a7626ac55019 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Mon, 22 Feb 2016 23:19:00 -0800 Subject: [dev.ssa] cmd/compile: leave JMPs in when using -N Helps keep line numbers around for debugging, particularly for break and continue statements (which often compile down to nothing). Update #14379 Change-Id: I6ea06aa887b0450d9ba4f11e319e5c263f5a98ba Reviewed-on: https://go-review.googlesource.com/19848 Reviewed-by: David Chase --- src/cmd/compile/internal/gc/ssa.go | 5 ++++- src/cmd/compile/internal/ssa/critical.go | 1 + 2 files changed, 5 insertions(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 13d8663706..598f120155 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -3627,7 +3627,10 @@ func genssa(f *ssa.Func, ptxt *obj.Prog, gcargs, gclocals *Sym) { } // Emit control flow instructions for block var next *ssa.Block - if i < len(f.Blocks)-1 { + if i < len(f.Blocks)-1 && Debug['N'] == 0 { + // If -N, leave next==nil so every block with successors + // ends in a JMP. Helps keep line numbers for otherwise + // empty blocks. next = f.Blocks[i+1] } x := Pc diff --git a/src/cmd/compile/internal/ssa/critical.go b/src/cmd/compile/internal/ssa/critical.go index ba75450875..9fea0ec1cd 100644 --- a/src/cmd/compile/internal/ssa/critical.go +++ b/src/cmd/compile/internal/ssa/critical.go @@ -21,6 +21,7 @@ func critical(f *Func) { // 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) -- cgit v1.3 From b96189d1a046f7a70a632bd02106bd15e096dfa1 Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Tue, 23 Feb 2016 17:52:17 -0600 Subject: [dev.ssa] cmd/compile: speed up cse MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Construct better initial partitions by recursively comparing values and their arguments. This saves one second on compile of arithConst_ssa.go (4.3s to 3.3s) and shows a 3-5% increase with compilebench. name old time/op new time/op delta Template 266ms ± 3% 253ms ± 4% -5.08% (p=0.032 n=5+5) GoTypes 927ms ± 3% 885ms ± 2% -4.55% (p=0.016 n=5+5) Compiler 3.91s ± 3% 3.73s ± 2% -4.49% (p=0.008 n=5+5) MakeBash 31.6s ± 1% 30.5s ± 3% -3.51% (p=0.016 n=5+5) Change-Id: I6ede31ff459131ccfed69531acfbd06b19837700 Reviewed-on: https://go-review.googlesource.com/19838 Reviewed-by: David Chase --- src/cmd/compile/internal/ssa/cse.go | 161 +++++++++++++---------------------- src/cmd/compile/internal/ssa/type.go | 3 + 2 files changed, 62 insertions(+), 102 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/cse.go b/src/cmd/compile/internal/ssa/cse.go index 44bd87683d..f7958542aa 100644 --- a/src/cmd/compile/internal/ssa/cse.go +++ b/src/cmd/compile/internal/ssa/cse.go @@ -9,6 +9,10 @@ import ( "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. @@ -30,8 +34,12 @@ func cse(f *Func) { // 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 } @@ -42,7 +50,7 @@ func cse(f *Func) { a = append(a, v) } } - partition := partitionValues(a) + partition := partitionValues(a, auxIDs) // map from value id back to eqclass id valueEqClass := make([]ID, f.NumValues()) @@ -202,8 +210,7 @@ type eqclass []*Value // 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) []eqclass { - auxIDs := map[interface{}]int32{} +func partitionValues(a []*Value, auxIDs auxmap) []eqclass { sort.Sort(sortvalues{a, auxIDs}) var partition []eqclass @@ -212,30 +219,7 @@ func partitionValues(a []*Value) []eqclass { j := 1 for ; j < len(a); j++ { w := a[j] - rootsDiffer := v.Op != w.Op || - v.AuxInt != w.AuxInt || - len(v.Args) != len(w.Args) || - v.Op == OpPhi && v.Block != w.Block || - v.Aux != w.Aux - if rootsDiffer || - len(v.Args) >= 1 && (v.Args[0].Op != w.Args[0].Op || - v.Args[0].AuxInt != w.Args[0].AuxInt) || - len(v.Args) >= 2 && (v.Args[1].Op != w.Args[1].Op || - v.Args[1].AuxInt != w.Args[1].AuxInt) || - v.Type.Compare(w.Type) != CMPeq { - if Debug > 3 { - fmt.Printf("CSE.partitionValues separates %s from %s, AuxInt=%v, Aux=%v, Type.compare=%v", - v.LongString(), w.LongString(), v.AuxInt != w.AuxInt, v.Aux != w.Aux, v.Type.Compare(w.Type)) - if !rootsDiffer { - if len(v.Args) >= 1 { - fmt.Printf(", a0Op=%v, a0AuxInt=%v", v.Args[0].Op != w.Args[0].Op, v.Args[0].AuxInt != w.Args[0].AuxInt) - if len(v.Args) >= 2 { - fmt.Printf(", a1Op=%v, a1AuxInt=%v", v.Args[1].Op != w.Args[1].Op, v.Args[1].AuxInt != w.Args[1].AuxInt) - } - } - } - fmt.Printf("\n") - } + if cmpVal(v, w, auxIDs, cmpDepth) != CMPeq { break } } @@ -247,100 +231,73 @@ func partitionValues(a []*Value) []eqclass { return partition } - -// Sort values to make the initial partition. -type sortvalues struct { - a []*Value // array of values - auxIDs map[interface{}]int32 // aux -> aux ID map +func lt2Cmp(isLt bool) Cmp { + if isLt { + return CMPlt + } + return CMPgt } -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] +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 v.Op < w.Op + return lt2Cmp(v.Op < w.Op) } if v.AuxInt != w.AuxInt { - return v.AuxInt < w.AuxInt - } - if v.Aux == nil && w.Aux != nil { // cheap aux check - expensive one below. - return true - } - if v.Aux != nil && w.Aux == nil { - return false + return lt2Cmp(v.AuxInt < w.AuxInt) } if len(v.Args) != len(w.Args) { - return len(v.Args) < len(w.Args) + return lt2Cmp(len(v.Args) < len(w.Args)) } - if v.Op == OpPhi && v.Block.ID != w.Block.ID { - return v.Block.ID < w.Block.ID + if v.Op == OpPhi && v.Block != w.Block { + return lt2Cmp(v.Block.ID < w.Block.ID) } - if len(v.Args) >= 1 { - vOp := v.Args[0].Op - wOp := w.Args[0].Op - if vOp != wOp { - return vOp < wOp - } - vAuxInt := v.Args[0].AuxInt - wAuxInt := w.Args[0].AuxInt - if vAuxInt != wAuxInt { - return vAuxInt < wAuxInt + 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 len(v.Args) >= 2 { - vOp = v.Args[1].Op - wOp = w.Args[1].Op - if vOp != wOp { - return vOp < wOp + if depth > 0 { + for i := range v.Args { + if v.Args[i] == w.Args[i] { + // skip comparing equal args + continue } - - vAuxInt = v.Args[1].AuxInt - wAuxInt = w.Args[1].AuxInt - if vAuxInt != wAuxInt { - return vAuxInt < wAuxInt + if ac := cmpVal(v.Args[i], w.Args[i], auxIDs, depth-1); ac != CMPeq { + return ac } } } - // Sort by type, using the ssa.Type Compare method - if v.Type != w.Type { - c := v.Type.Compare(w.Type) - if c != CMPeq { - return c == CMPlt - } - } + return CMPeq +} - // Aux fields are interfaces with no comparison - // method. Use a map to number distinct ones, - // and use those numbers for comparison. - if v.Aux != w.Aux { - x := sv.auxIDs[v.Aux] - if x == 0 { - x = int32(len(sv.auxIDs)) + 1 - sv.auxIDs[v.Aux] = x - } - y := sv.auxIDs[w.Aux] - if y == 0 { - y = int32(len(sv.auxIDs)) + 1 - sv.auxIDs[w.Aux] = y - } - if x != y { - return x < y - } - } +// Sort values to make the initial partition. +type sortvalues struct { + a []*Value // array of values + auxIDs auxmap // aux -> aux ID map +} - // TODO(khr): is the above really ok to do? We're building - // the aux->auxID map online as sort is asking about it. If - // sort has some internal randomness, then the numbering might - // change from run to run. That will make the ordering of - // partitions random. It won't break the compiler but may - // make it nondeterministic. We could fix this by computing - // the aux->auxID map ahead of time, but the hope is here that - // we won't need to compute the mapping for many aux fields - // because the values they are in are otherwise unique. +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/type.go b/src/cmd/compile/internal/ssa/type.go index afe04fa043..a23989c82e 100644 --- a/src/cmd/compile/internal/ssa/type.go +++ b/src/cmd/compile/internal/ssa/type.go @@ -95,6 +95,9 @@ func (t *CompilerType) Compare(u Type) Cmp { 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 { -- cgit v1.3 From 288817b05a0ea1671c87b7c3ed021fed874d0caa Mon Sep 17 00:00:00 2001 From: David Chase Date: Tue, 23 Feb 2016 21:09:39 -0500 Subject: [dev.ssa] cmd/compile: reduce line number churn in generated code In regalloc, make LoadReg instructions use the line number of their *use*, not their *source*. This reduces the tendency of debugger stepping to "jump around" the program. Change-Id: I59e2eeac4dca9168d8af3a93effbc5bdacac2881 Reviewed-on: https://go-review.googlesource.com/19836 Run-TryBot: David Chase TryBot-Result: Gobot Gobot Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/regalloc.go | 10 +++++----- src/cmd/compile/internal/ssa/tighten.go | 2 +- 2 files changed, 6 insertions(+), 6 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go index a55f81d4ac..e900a3cfb8 100644 --- a/src/cmd/compile/internal/ssa/regalloc.go +++ b/src/cmd/compile/internal/ssa/regalloc.go @@ -396,7 +396,7 @@ func (s *regAllocState) allocReg(v *Value, mask regMask) register { // 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) *Value { +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. @@ -430,7 +430,7 @@ func (s *regAllocState) allocValToReg(v *Value, mask regMask, nospill bool) *Val if s.regs[r2].v != v { panic("bad register state") } - c = s.curBlock.NewValue1(v.Line, OpCopy, v.Type, s.regs[r2].c) + 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) @@ -441,7 +441,7 @@ func (s *regAllocState) allocValToReg(v *Value, mask regMask, nospill bool) *Val if logSpills { fmt.Println("regalloc: load spill") } - c = s.curBlock.NewValue1(v.Line, OpLoadReg, v.Type, vi.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()) @@ -894,7 +894,7 @@ func (s *regAllocState) regalloc(f *Func) { // TODO: remove flag input from regspec.inputs. continue } - args[i.idx] = s.allocValToReg(v.Args[i.idx], i.regs, true) + 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. @@ -951,7 +951,7 @@ func (s *regAllocState) regalloc(f *Func) { // 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) + 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 diff --git a/src/cmd/compile/internal/ssa/tighten.go b/src/cmd/compile/internal/ssa/tighten.go index 6726c06e76..ecb43c101d 100644 --- a/src/cmd/compile/internal/ssa/tighten.go +++ b/src/cmd/compile/internal/ssa/tighten.go @@ -16,7 +16,7 @@ package ssa // 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([]int, f.NumValues()) + uses := make([]int32, f.NumValues()) // For each value, whether that value is ever an arg to a phi value. phi := make([]bool, f.NumValues()) -- cgit v1.3 From e173ab14345b1f205a8f14e25a81184752a9d43b Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Wed, 24 Feb 2016 13:08:00 -0800 Subject: [dev.ssa] cmd/compile: update TODO Remove the stuff that's already done. Change-Id: I3b4fc827240d45dd051dc36897883532d8900a0c Reviewed-on: https://go-review.googlesource.com/19906 Reviewed-by: David Chase --- src/cmd/compile/internal/ssa/TODO | 14 -------------- 1 file changed, 14 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/TODO b/src/cmd/compile/internal/ssa/TODO index 5e5cb4b865..91983476a2 100644 --- a/src/cmd/compile/internal/ssa/TODO +++ b/src/cmd/compile/internal/ssa/TODO @@ -14,11 +14,8 @@ Optimizations (better compiled code) ------------------------------------ - Reduce register pressure in scheduler - More strength reduction: multiply -> shift/add combos (Worth doing?) -- Strength reduction: constant divides -> multiply -- Expand current optimizations to all bit widths - Add a value range propagation pass (for bounds elim & bitwidth reduction) - Make dead store pass inter-block -- (x86) More combining address arithmetic into loads/stores - redundant CMP in sequences like this: SUBQ $8, AX CMP AX, $0 @@ -31,15 +28,6 @@ Optimizations (better compiled code) - If strings are being passed around without being interpreted (ptr and len feilds being accessed) pass them in xmm registers? Same for interfaces? -- boolean logic: movb/xorb$1/testb/jeq -> movb/testb/jne -- (ADDQconst (SUBQconst x)) and vice-versa -- store followed by load to same address -- (CMPconst [0] (AND x y)) -> (TEST x y) -- more (LOAD (ADDQ )) -> LOADIDX -- CMPL/SETEQ/TESTB/JEQ -> CMPL/JEQ - CMPL/SETGE/TESTB/JEQ -- blockEQ (CMP x x) -- better computing of &&/|| in non-if/for contexts - OpArrayIndex should take its index in AuxInt, not a full value. - remove FLAGS from REP instruction clobbers - (x86) Combine loads into other ops @@ -52,10 +40,8 @@ Optimizations (better compiled code) Optimizations (better compiler) ------------------------------- - Smaller Value.Type (int32 or ptr)? Get rid of types altogether? -- Recycle dead Values (and Blocks) explicitly instead of using GC - OpStore uses 3 args. Increase the size of Value.argstorage to 3? - Constant cache -- Reuseable slices (e.g. []int of size NumValues()) cached in Func - 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 -- cgit v1.3 From ed737fd8cdc1a668027bb5f5dac8879afabcca3b Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Wed, 24 Feb 2016 10:29:27 -0800 Subject: [dev.ssa] cmd/compile: fix @ rewrite rules The @ directive used to read the target block after some value structure had already changed. I don't think it was ever really a bug, but it's confusing. It might fail like this: (Foo x y) -> @v.Args[0].Block (Bar y (Baz ...)) v.Op = Bar v.Args[0] = y v.Args[1] = v.Args[0].Block.NewValue(Baz, ...) That new value is allocated in the block of y, not the block of x. Anyway, read the destination block first so this potential bug can't happen. Change-Id: Ie41d2fc349b35cefaa319fa9327808bcb781b4e2 Reviewed-on: https://go-review.googlesource.com/19900 Run-TryBot: Todd Neal TryBot-Result: Gobot Gobot Reviewed-by: Todd Neal --- src/cmd/compile/internal/ssa/TODO | 2 -- src/cmd/compile/internal/ssa/gen/rulegen.go | 19 ++++++++++--------- src/cmd/compile/internal/ssa/rewriteAMD64.go | 18 ++++++++++++------ src/cmd/compile/internal/ssa/rewritegeneric.go | 7 +++++-- 4 files changed, 27 insertions(+), 19 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/TODO b/src/cmd/compile/internal/ssa/TODO index 91983476a2..69356d6226 100644 --- a/src/cmd/compile/internal/ssa/TODO +++ b/src/cmd/compile/internal/ssa/TODO @@ -7,8 +7,6 @@ Coverage Correctness ----------- - Debugging info (check & fix as much as we can) -- @ directive in rewrites might read overwritten data. Save @loc - in variable before modifying v. Optimizations (better compiled code) ------------------------------------ diff --git a/src/cmd/compile/internal/ssa/gen/rulegen.go b/src/cmd/compile/internal/ssa/gen/rulegen.go index b9aa51d165..56bb82c85d 100644 --- a/src/cmd/compile/internal/ssa/gen/rulegen.go +++ b/src/cmd/compile/internal/ssa/gen/rulegen.go @@ -259,7 +259,7 @@ func genRules(arch 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, "b")) + 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)) @@ -415,16 +415,17 @@ func genMatch0(w io.Writer, arch arch, match, v string, m map[string]string, top } func genResult(w io.Writer, arch arch, result string) { - loc := "b" + move := false if result[0] == '@' { // parse @block directive s := strings.SplitN(result[1:], " ", 2) - loc = s[0] + fmt.Fprintf(w, "b = %s\n", s[0]) result = s[1] + move = true } - genResult0(w, arch, result, new(int), true, loc) + genResult0(w, arch, result, new(int), true, move) } -func genResult0(w io.Writer, arch arch, result string, alloc *int, top bool, loc string) string { +func genResult0(w io.Writer, arch arch, result string, alloc *int, top, move bool) string { if result[0] != '(' { // variable if top { @@ -469,7 +470,7 @@ func genResult0(w io.Writer, arch arch, result string, alloc *int, top bool, loc } } var v string - if top && loc == "b" { + if top && !move { v = "v" fmt.Fprintf(w, "v.reset(%s)\n", opName(s[0], arch)) if typeOverride { @@ -481,8 +482,8 @@ func genResult0(w io.Writer, arch arch, result string, alloc *int, top bool, loc } v = fmt.Sprintf("v%d", *alloc) *alloc++ - fmt.Fprintf(w, "%s := %s.NewValue0(v.Line, %s, %s)\n", v, loc, opName(s[0], arch), opType) - if top { + 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) @@ -501,7 +502,7 @@ func genResult0(w io.Writer, arch arch, result string, alloc *int, top bool, loc fmt.Fprintf(w, "%s.Aux = %s\n", v, x) } else { // regular argument (sexpr or variable) - x := genResult0(w, arch, a, alloc, false, loc) + x := genResult0(w, arch, a, alloc, false, move) fmt.Fprintf(w, "%s.AddArg(%s)\n", v, x) } } diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 601e9b8ce3..bf74331dd3 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -5339,7 +5339,8 @@ func rewriteValueAMD64_OpAMD64MOVBQSX(v *Value, config *Config) bool { sym := v.Args[0].Aux ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] - v0 := v.Args[0].Block.NewValue0(v.Line, OpAMD64MOVBQSXload, v.Type) + b = v.Args[0].Block + v0 := b.NewValue0(v.Line, OpAMD64MOVBQSXload, v.Type) v.reset(OpCopy) v.AddArg(v0) v0.AuxInt = off @@ -5381,7 +5382,8 @@ func rewriteValueAMD64_OpAMD64MOVBQZX(v *Value, config *Config) bool { sym := v.Args[0].Aux ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] - v0 := v.Args[0].Block.NewValue0(v.Line, OpAMD64MOVBQZXload, v.Type) + b = v.Args[0].Block + v0 := b.NewValue0(v.Line, OpAMD64MOVBQZXload, v.Type) v.reset(OpCopy) v.AddArg(v0) v0.AuxInt = off @@ -5920,7 +5922,8 @@ func rewriteValueAMD64_OpAMD64MOVLQSX(v *Value, config *Config) bool { sym := v.Args[0].Aux ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] - v0 := v.Args[0].Block.NewValue0(v.Line, OpAMD64MOVLQSXload, v.Type) + b = v.Args[0].Block + v0 := b.NewValue0(v.Line, OpAMD64MOVLQSXload, v.Type) v.reset(OpCopy) v.AddArg(v0) v0.AuxInt = off @@ -5962,7 +5965,8 @@ func rewriteValueAMD64_OpAMD64MOVLQZX(v *Value, config *Config) bool { sym := v.Args[0].Aux ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] - v0 := v.Args[0].Block.NewValue0(v.Line, OpAMD64MOVLQZXload, v.Type) + b = v.Args[0].Block + v0 := b.NewValue0(v.Line, OpAMD64MOVLQZXload, v.Type) v.reset(OpCopy) v.AddArg(v0) v0.AuxInt = off @@ -7419,7 +7423,8 @@ func rewriteValueAMD64_OpAMD64MOVWQSX(v *Value, config *Config) bool { sym := v.Args[0].Aux ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] - v0 := v.Args[0].Block.NewValue0(v.Line, OpAMD64MOVWQSXload, v.Type) + b = v.Args[0].Block + v0 := b.NewValue0(v.Line, OpAMD64MOVWQSXload, v.Type) v.reset(OpCopy) v.AddArg(v0) v0.AuxInt = off @@ -7461,7 +7466,8 @@ func rewriteValueAMD64_OpAMD64MOVWQZX(v *Value, config *Config) bool { sym := v.Args[0].Aux ptr := v.Args[0].Args[0] mem := v.Args[0].Args[1] - v0 := v.Args[0].Block.NewValue0(v.Line, OpAMD64MOVWQZXload, v.Type) + b = v.Args[0].Block + v0 := b.NewValue0(v.Line, OpAMD64MOVWQZXload, v.Type) v.reset(OpCopy) v.AddArg(v0) v0.AuxInt = off diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index 08ab2e14a6..4f29cf5348 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -7102,10 +7102,13 @@ func rewriteValuegeneric_OpStructSelect(v *Value, config *Config) bool { if !(!config.fe.CanSSA(t)) { break } - v0 := v.Args[0].Block.NewValue0(v.Line, OpLoad, v.Type) + b = v.Args[0].Block + v0 := b.NewValue0(v.Line, OpLoad, v.Type) v.reset(OpCopy) v.AddArg(v0) - v1 := v.Args[0].Block.NewValue0(v.Line, OpOffPtr, v.Type.PtrTo()) + 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) -- cgit v1.3 From a5325761cd42f2a10566fd421f8c8b0189bedc18 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Wed, 24 Feb 2016 12:58:47 -0800 Subject: [dev.ssa] cmd/compile: identical values are the same pointer Forgot the obvious case. Allows us to remove the load in: func f(p *int, x int) int { *p = x + 5 return *p } Change-Id: I93686d8240bab3a1d166b88e224cf71e3d947aef Reviewed-on: https://go-review.googlesource.com/19905 Run-TryBot: Keith Randall Reviewed-by: Brad Fitzpatrick TryBot-Result: Gobot Gobot --- src/cmd/compile/internal/ssa/rewrite.go | 3 +++ 1 file changed, 3 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go index 4197b0da88..60509d214e 100644 --- a/src/cmd/compile/internal/ssa/rewrite.go +++ b/src/cmd/compile/internal/ssa/rewrite.go @@ -204,6 +204,9 @@ func uaddOvf(a, b int64) bool { // 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 && -- cgit v1.3 From fb54e0305fe209dd7ef36b901d28e7ee9b649442 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Wed, 24 Feb 2016 16:19:20 -0800 Subject: [dev.ssa] cmd/compile: small improvements Found looking at mapaccess1_faststr. runtime.throw never returns. Do x+y+c with an LEA. Change-Id: I27ea6669324242a6302397cbdc73230891d97591 Reviewed-on: https://go-review.googlesource.com/19911 Run-TryBot: Keith Randall TryBot-Result: Gobot Gobot Reviewed-by: David Chase --- src/cmd/compile/internal/gc/ssa.go | 5 +-- src/cmd/compile/internal/ssa/TODO | 8 +++++ src/cmd/compile/internal/ssa/gen/AMD64.rules | 6 +++- src/cmd/compile/internal/ssa/rewriteAMD64.go | 48 ++++++++++++++++++++++++++++ 4 files changed, 64 insertions(+), 3 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 598f120155..4d381e5070 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -544,8 +544,9 @@ func (s *state) stmt(n *Node) { // Expression statements case OCALLFUNC, OCALLMETH, OCALLINTER: s.call(n, callNormal) - if n.Op == OCALLFUNC && n.Left.Op == ONAME && n.Left.Class == PFUNC && n.Left.Sym.Pkg == Runtimepkg && - (n.Left.Sym.Name == "gopanic" || n.Left.Sym.Name == "selectgo") { + 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")) { m := s.mem() b := s.endBlock() b.Kind = ssa.BlockExit diff --git a/src/cmd/compile/internal/ssa/TODO b/src/cmd/compile/internal/ssa/TODO index 69356d6226..57bed9a9a3 100644 --- a/src/cmd/compile/internal/ssa/TODO +++ b/src/cmd/compile/internal/ssa/TODO @@ -34,6 +34,14 @@ Optimizations (better compiled code) flag regeneration. - In forms like if ... { call } else { no call }, mark the call branch as unlikely. - 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) ------------------------------- diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 15457b8f6d..033fb27b3f 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -558,6 +558,11 @@ (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) @@ -818,7 +823,6 @@ (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) diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index bf74331dd3..a84b35974b 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -1075,6 +1075,38 @@ func rewriteValueAMD64_OpAMD64ADDQ(v *Value, config *Config) bool { 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) @@ -1136,6 +1168,22 @@ func rewriteValueAMD64_OpAMD64ADDQ(v *Value, config *Config) bool { 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) -- cgit v1.3 From 378a86368279ffdfecc50e91c4bcb61e72957d21 Mon Sep 17 00:00:00 2001 From: David Chase Date: Thu, 25 Feb 2016 13:10:51 -0500 Subject: [dev.ssa] cmd/compile: enhance command line option processing for SSA The -d compiler flag can also specify ssa phase and flag, for example -d=ssa/generic_cse/time,ssa/generic_cse/stats Spaces in the phase names can be specified with an underscore. Flags currently parsed (not necessarily recognized by the phases yet) are: on, off, mem, time, debug, stats, and test On, off and time are handled in the harness, debug, stats, and test are interpreted by the phase itself. The pass is now attached to the Func being compiled, and a new method logStats(key, ...value) on *Func to encourage a semi-standardized format for that output. Output fields are separated by tabs to ease digestion by awk and spreadsheets. For example, if f.pass.stats > 0 { f.logStat("CSE REWRITES", rewrites) } Change-Id: I16db2b5af64c50ca9a47efeb51d961147a903abc Reviewed-on: https://go-review.googlesource.com/19885 Reviewed-by: Keith Randall Reviewed-by: Todd Neal --- src/cmd/compile/internal/gc/lex.go | 18 ++++- src/cmd/compile/internal/gc/ssa.go | 55 +++---------- src/cmd/compile/internal/ssa/compile.go | 125 ++++++++++++++++++++++-------- src/cmd/compile/internal/ssa/config.go | 90 ++++++++++++++++++++- src/cmd/compile/internal/ssa/cse.go | 10 +-- src/cmd/compile/internal/ssa/func.go | 20 ++++- src/cmd/compile/internal/ssa/func_test.go | 6 ++ 7 files changed, 240 insertions(+), 84 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/lex.go b/src/cmd/compile/internal/gc/lex.go index 51ad6162bf..46122d264d 100644 --- a/src/cmd/compile/internal/gc/lex.go +++ b/src/cmd/compile/internal/gc/lex.go @@ -55,7 +55,6 @@ var debugtab = []struct { {"typeassert", &Debug_typeassert}, // print information about type assertion inlining {"wb", &Debug_wb}, // print information about write barriers {"export", &Debug_export}, // print export data - {"ssa", &ssa.Debug}, // ssa debugging flag } const ( @@ -286,6 +285,23 @@ func Main() { } } } + // 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) } } diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 4d381e5070..a463f9dfc5 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -6,7 +6,6 @@ package gc import ( "bytes" - "crypto/sha1" "fmt" "html" "math" @@ -24,6 +23,15 @@ 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 @@ -67,42 +75,7 @@ func shouldssa(fn *Node) bool { return localpkg.Name == pkg } - gossahash := os.Getenv("GOSSAHASH") - if gossahash == "" || gossahash == "y" || gossahash == "Y" { - return true - } - if gossahash == "n" || gossahash == "N" { - return false - } - - // Check the hash of the name against a partial input hash. - // We use this feature to do a binary search within a package 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, gossahash) { - fmt.Printf("GOSSAHASH triggered %s\n", name) - return true - } - - // Iteratively try additional hashes to allow tests for multi-point - // failure. - for i := 0; true; i++ { - ev := fmt.Sprintf("GOSSAHASH%d", i) - evv := os.Getenv(ev) - if evv == "" { - break - } - if strings.HasSuffix(hstr, evv) { - fmt.Printf("%s triggered %s\n", ev, name) - return true - } - } - - return false + return initssa().DebugHashMatch("GOSSAHASH", name) } // buildssa builds an SSA function. @@ -123,12 +96,8 @@ func buildssa(fn *Node) *ssa.Func { // TODO(khr): build config just once at the start of the compiler binary ssaExp.log = printssa - ssaExp.unimplemented = false - ssaExp.mustImplement = true - if ssaConfig == nil { - ssaConfig = ssa.NewConfig(Thearch.Thestring, &ssaExp, Ctxt, Debug['N'] == 0) - } - s.config = ssaConfig + + s.config = initssa() s.f = s.config.NewFunc() s.f.Name = name s.exitCode = fn.Func.Exit diff --git a/src/cmd/compile/internal/ssa/compile.go b/src/cmd/compile/internal/ssa/compile.go index dfead98c65..23dab9e273 100644 --- a/src/cmd/compile/internal/ssa/compile.go +++ b/src/cmd/compile/internal/ssa/compile.go @@ -8,11 +8,10 @@ import ( "fmt" "log" "runtime" + "strings" "time" ) -var Debug int - // 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 @@ -47,22 +46,23 @@ func Compile(f *Func) { 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 { + 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 { - tEnd := time.Now() - time := tEnd.Sub(tStart).Nanoseconds() var stats string if logMemStats { @@ -79,6 +79,20 @@ func Compile(f *Func) { printFunc(f) f.Config.HTML.WriteFunc(fmt.Sprintf("after %s %s", 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) } @@ -90,39 +104,84 @@ 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? - {"early phielim", phielim, false}, - {"early copyelim", copyelim, false}, - {"early deadcode", deadcode, false}, // remove generated dead code to avoid doing pointless work during opt - {"short circuit", shortcircuit, false}, - {"decompose user", decomposeUser, true}, - {"decompose builtin", decomposeBuiltIn, true}, - {"opt", opt, true}, // TODO: split required rules and optimizing rules - {"zero arg cse", zcse, true}, // required to merge OpSB values - {"opt deadcode", deadcode, false}, // remove any blocks orphaned during opt - {"generic cse", cse, false}, - {"nilcheckelim", nilcheckelim, false}, - {"generic deadcode", deadcode, false}, - {"fuse", fuse, false}, - {"dse", dse, false}, - {"tighten", tighten, false}, // move values closer to their uses - {"lower", lower, true}, - {"lowered cse", cse, false}, - {"lowered deadcode", deadcode, true}, - {"checkLower", checkLower, true}, - {"late phielim", phielim, false}, - {"late copyelim", copyelim, false}, - {"late deadcode", deadcode, false}, - {"critical", critical, true}, // remove critical edges - {"layout", layout, true}, // schedule blocks - {"schedule", schedule, true}, // schedule values - {"flagalloc", flagalloc, true}, // allocate flags register - {"regalloc", regalloc, true}, // allocate int & float registers + stack slots - {"trim", trim, false}, // remove empty blocks + {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: "nilcheckelim", fn: nilcheckelim}, + {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: "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. diff --git a/src/cmd/compile/internal/ssa/config.go b/src/cmd/compile/internal/ssa/config.go index 81061a7219..8657509c5c 100644 --- a/src/cmd/compile/internal/ssa/config.go +++ b/src/cmd/compile/internal/ssa/config.go @@ -4,7 +4,13 @@ package ssa -import "cmd/internal/obj" +import ( + "cmd/internal/obj" + "crypto/sha1" + "fmt" + "os" + "strings" +) type Config struct { arch string // "amd64", etc. @@ -20,6 +26,10 @@ type Config struct { // 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 @@ -120,6 +130,8 @@ func NewConfig(arch string, fe Frontend, ctxt *obj.Link, optimize bool) *Config c.blocks[i].ID = ID(i) } + c.logfiles = make(map[string]*os.File) + return c } @@ -145,3 +157,79 @@ func (c *Config) Unimplementedf(line int32, msg string, args ...interface{}) { } 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/cse.go b/src/cmd/compile/internal/ssa/cse.go index f7958542aa..c44748535b 100644 --- a/src/cmd/compile/internal/ssa/cse.go +++ b/src/cmd/compile/internal/ssa/cse.go @@ -61,7 +61,7 @@ func cse(f *Func) { } } for i, e := range partition { - if Debug > 1 && len(e) > 500 { + 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()) @@ -72,7 +72,7 @@ func cse(f *Func) { for _, v := range e { valueEqClass[v.ID] = ID(i) } - if Debug > 2 && len(e) > 1 { + if f.pass.debug > 2 && len(e) > 1 { fmt.Printf("CSE.partition #%d:", i) for _, v := range e { fmt.Printf(" %s", v.String()) @@ -163,7 +163,7 @@ func cse(f *Func) { } } - rewrites := 0 + rewrites := int64(0) // Apply substitutions for _, b := range f.Blocks { @@ -186,8 +186,8 @@ func cse(f *Func) { } } } - if Debug > 0 && rewrites > 0 { - fmt.Printf("CSE: %d rewrites\n", rewrites) + if f.pass.stats > 0 { + f.logStat("CSE REWRITES", rewrites) } } diff --git a/src/cmd/compile/internal/ssa/func.go b/src/cmd/compile/internal/ssa/func.go index 6e101ec1cb..9441110769 100644 --- a/src/cmd/compile/internal/ssa/func.go +++ b/src/cmd/compile/internal/ssa/func.go @@ -4,12 +4,16 @@ package ssa -import "math" +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 @@ -89,6 +93,20 @@ func (f *Func) newValue(op Op, t Type, b *Block, line int32) *Value { 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 { diff --git a/src/cmd/compile/internal/ssa/func_test.go b/src/cmd/compile/internal/ssa/func_test.go index 53213d2c11..fa6a1a8751 100644 --- a/src/cmd/compile/internal/ssa/func_test.go +++ b/src/cmd/compile/internal/ssa/func_test.go @@ -134,12 +134,18 @@ type fun struct { 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. -- cgit v1.3 From d3f15ff6bc353d94b7249f33bb030ee1f7ee887e Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Thu, 25 Feb 2016 11:40:51 -0800 Subject: [dev.ssa] cmd/compile: shrink stack guard Our stack frame sizes look pretty good now. Lower the stack guard from 1024 to 720. Tip is currently using 720. We could go lower (to 640 at least) except PPC doesn't like that. Change-Id: Ie5f96c0e822435638223f1e8a2bd1a1eed68e6aa Reviewed-on: https://go-review.googlesource.com/19922 Run-TryBot: Keith Randall TryBot-Result: Gobot Gobot Reviewed-by: David Chase --- src/cmd/internal/obj/stack.go | 2 +- src/runtime/stack.go | 2 +- test/nosplit.go | 4 ++-- 3 files changed, 4 insertions(+), 4 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/internal/obj/stack.go b/src/cmd/internal/obj/stack.go index 1a2ee12291..80f6c6c164 100644 --- a/src/cmd/internal/obj/stack.go +++ b/src/cmd/internal/obj/stack.go @@ -11,7 +11,7 @@ const ( STACKSYSTEM = 0 StackSystem = STACKSYSTEM StackBig = 4096 - StackGuard = 1024*stackGuardMultiplier + StackSystem + StackGuard = 720*stackGuardMultiplier + StackSystem StackSmall = 128 StackLimit = StackGuard - StackSystem - StackSmall ) diff --git a/src/runtime/stack.go b/src/runtime/stack.go index ba1a1bb143..81059965d9 100644 --- a/src/runtime/stack.go +++ b/src/runtime/stack.go @@ -90,7 +90,7 @@ const ( // The stack guard is a pointer this many bytes above the // bottom of the stack. - _StackGuard = 1024*sys.StackGuardMultiplier + _StackSystem + _StackGuard = 720*sys.StackGuardMultiplier + _StackSystem // After a stack split check the SP is allowed to be this // many bytes below the stack guard. This saves an instruction diff --git a/test/nosplit.go b/test/nosplit.go index 2bf7077808..082fc3b0e6 100644 --- a/test/nosplit.go +++ b/test/nosplit.go @@ -302,13 +302,13 @@ TestCases: // Instead of rewriting the test cases above, adjust // the first stack frame to use up the extra bytes. if i == 0 { - size += (1024 - 128) - 128 + size += (720 - 128) - 128 // Noopt builds have a larger stackguard. // 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 += 1024 + size += 720 } } } -- cgit v1.3 From 4a346e7489038a0913f590da98a12f6e660b683a Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Thu, 25 Feb 2016 13:45:22 -0800 Subject: [dev.ssa] cmd/compile: get rid of nil checks before float loads/stores Just like we do for integer loads/stores. Update #14511 Change-Id: Ic6ca6b54301438a5701ea5fb0be755451cb24d45 Reviewed-on: https://go-review.googlesource.com/19923 Reviewed-by: Josh Bleecher Snyder Run-TryBot: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 9 ++++++++- test/nilptr3.go | 18 ++++++++++++++++++ test/nilptr3_ssa.go | 15 +++++++++++++++ 3 files changed, 41 insertions(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index a463f9dfc5..a64bdd07bd 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -4588,7 +4588,9 @@ func (s *genState) genValue(v *ssa.Value) { 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.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") @@ -4605,6 +4607,11 @@ func (s *genState) genValue(v *ssa.Value) { } } 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 } diff --git a/test/nilptr3.go b/test/nilptr3.go index 1ba774d839..258547733c 100644 --- a/test/nilptr3.go +++ b/test/nilptr3.go @@ -193,3 +193,21 @@ func f4(x *[10]int) { x = y _ = &x[9] // ERROR "removed repeated 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 "generated nil check" + // On ARM, the nil check on this store gets removed. On other archs, + // it doesn't. Makes this hard to test. SSA will always remove it. + //*q = x + _ = x +} diff --git a/test/nilptr3_ssa.go b/test/nilptr3_ssa.go index d324076114..ba60a64602 100644 --- a/test/nilptr3_ssa.go +++ b/test/nilptr3_ssa.go @@ -192,3 +192,18 @@ func f4(x *[10]int) { 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" +} -- cgit v1.3 From 91f69c675de947e169ebec60b68a752e3ccc6912 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Fri, 26 Feb 2016 16:32:01 -0800 Subject: [dev.ssa] cmd/compile: with -N, don't put JMPs after calls plive doesn't like the fact that we put JMPs right after CALL ops to select{send,recv}. Fixes SSA -N build. Change-Id: I9b3c9e5293196094fd5a6206dd2f99784951f7a9 Reviewed-on: https://go-review.googlesource.com/19982 Run-TryBot: Keith Randall TryBot-Result: Gobot Gobot Reviewed-by: David Chase --- src/cmd/compile/internal/gc/ssa.go | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index a64bdd07bd..9847806110 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -3597,10 +3597,11 @@ func genssa(f *ssa.Func, ptxt *obj.Prog, gcargs, gclocals *Sym) { } // Emit control flow instructions for block var next *ssa.Block - if i < len(f.Blocks)-1 && Debug['N'] == 0 { + 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. Helps keep line numbers for otherwise - // empty blocks. + // 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 -- cgit v1.3 From 4e95dfed0197ee6fdf96dc1aa632297a28a1cd95 Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Sat, 27 Feb 2016 08:04:48 -0600 Subject: [dev.ssa] cmd/compile: add max arg length to opcodes Add the max arg length to opcodes and use it in zcse. Doesn't affect speed, but allows better checking in checkFunc and removes the need to keep a list of zero arg opcodes up to date. Change-Id: I157c6587154604119720ec6228b767b6e52bb5c7 Reviewed-on: https://go-review.googlesource.com/19994 Reviewed-by: Keith Randall Run-TryBot: Todd Neal TryBot-Result: Gobot Gobot --- src/cmd/compile/internal/ssa/check.go | 7 + src/cmd/compile/internal/ssa/fuse_test.go | 6 +- src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 494 ++++++------ src/cmd/compile/internal/ssa/gen/genericOps.go | 553 ++++++------- src/cmd/compile/internal/ssa/gen/main.go | 7 +- src/cmd/compile/internal/ssa/gen/rulegen.go | 8 +- src/cmd/compile/internal/ssa/nilcheck_test.go | 7 +- src/cmd/compile/internal/ssa/op.go | 7 +- src/cmd/compile/internal/ssa/opGen.go | 1023 ++++++++++++++++++------ src/cmd/compile/internal/ssa/zcse.go | 21 +- 10 files changed, 1328 insertions(+), 805 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/check.go b/src/cmd/compile/internal/ssa/check.go index 796d899f7c..54f774004e 100644 --- a/src/cmd/compile/internal/ssa/check.go +++ b/src/cmd/compile/internal/ssa/check.go @@ -148,6 +148,13 @@ func checkFunc(f *Func) { } 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 diff --git a/src/cmd/compile/internal/ssa/fuse_test.go b/src/cmd/compile/internal/ssa/fuse_test.go index 3ce8ea54b3..937fb71031 100644 --- a/src/cmd/compile/internal/ssa/fuse_test.go +++ b/src/cmd/compile/internal/ssa/fuse_test.go @@ -14,7 +14,7 @@ func TestFuseEliminatesOneBranch(t *testing.T) { Goto("checkPtr")), Bloc("checkPtr", Valu("ptr1", OpLoad, ptrType, 0, nil, "sb", "mem"), - Valu("nilptr", OpConstNil, ptrType, 0, nil, "sb"), + Valu("nilptr", OpConstNil, ptrType, 0, nil), Valu("bool1", OpNeqPtr, TypeBool, 0, nil, "ptr1", "nilptr"), If("bool1", "then", "exit")), Bloc("then", @@ -42,7 +42,7 @@ func TestFuseEliminatesBothBranches(t *testing.T) { Goto("checkPtr")), Bloc("checkPtr", Valu("ptr1", OpLoad, ptrType, 0, nil, "sb", "mem"), - Valu("nilptr", OpConstNil, ptrType, 0, nil, "sb"), + Valu("nilptr", OpConstNil, ptrType, 0, nil), Valu("bool1", OpNeqPtr, TypeBool, 0, nil, "ptr1", "nilptr"), If("bool1", "then", "else")), Bloc("then", @@ -75,7 +75,7 @@ func TestFuseHandlesPhis(t *testing.T) { Goto("checkPtr")), Bloc("checkPtr", Valu("ptr1", OpLoad, ptrType, 0, nil, "sb", "mem"), - Valu("nilptr", OpConstNil, ptrType, 0, nil, "sb"), + Valu("nilptr", OpConstNil, ptrType, 0, nil), Valu("bool1", OpNeqPtr, TypeBool, 0, nil, "ptr1", "nilptr"), If("bool1", "then", "else")), Bloc("then", diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index d139145e04..b0c7ecf181 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -144,273 +144,273 @@ func init() { // TODO: 2-address instructions. Mark ops as needing matching input/output regs. var AMD64ops = []opData{ // fp ops - {name: "ADDSS", reg: fp21, asm: "ADDSS"}, // fp32 add - {name: "ADDSD", reg: fp21, asm: "ADDSD"}, // fp64 add - {name: "SUBSS", reg: fp21x15, asm: "SUBSS"}, // fp32 sub - {name: "SUBSD", reg: fp21x15, asm: "SUBSD"}, // fp64 sub - {name: "MULSS", reg: fp21, asm: "MULSS"}, // fp32 mul - {name: "MULSD", reg: fp21, asm: "MULSD"}, // fp64 mul - {name: "DIVSS", reg: fp21x15, asm: "DIVSS"}, // fp32 div - {name: "DIVSD", reg: fp21x15, asm: "DIVSD"}, // fp64 div - - {name: "MOVSSload", reg: fpload, asm: "MOVSS", aux: "SymOff"}, // fp32 load - {name: "MOVSDload", reg: fpload, asm: "MOVSD", aux: "SymOff"}, // fp64 load + {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", reg: fploadidx, asm: "MOVSS", aux: "SymOff"}, // fp32 load - {name: "MOVSDloadidx8", reg: fploadidx, asm: "MOVSD", aux: "SymOff"}, // fp64 load + {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", reg: fpstore, asm: "MOVSS", aux: "SymOff"}, // fp32 store - {name: "MOVSDstore", reg: fpstore, asm: "MOVSD", aux: "SymOff"}, // fp64 store - {name: "MOVSSstoreidx4", reg: fpstoreidx, asm: "MOVSS", aux: "SymOff"}, // fp32 indexed by 4i store - {name: "MOVSDstoreidx8", reg: fpstoreidx, asm: "MOVSD", aux: "SymOff"}, // fp64 indexed by 8i store + {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", reg: gp21, asm: "ADDQ"}, // arg0 + arg1 - {name: "ADDL", reg: gp21, asm: "ADDL"}, // arg0 + arg1 - {name: "ADDW", reg: gp21, asm: "ADDW"}, // arg0 + arg1 - {name: "ADDB", reg: gp21, asm: "ADDB"}, // arg0 + arg1 - {name: "ADDQconst", reg: gp11, asm: "ADDQ", aux: "Int64", typ: "UInt64"}, // arg0 + auxint - {name: "ADDLconst", reg: gp11, asm: "ADDL", aux: "Int32"}, // arg0 + auxint - {name: "ADDWconst", reg: gp11, asm: "ADDW", aux: "Int16"}, // arg0 + auxint - {name: "ADDBconst", reg: gp11, asm: "ADDB", aux: "Int8"}, // arg0 + auxint - - {name: "SUBQ", reg: gp21, asm: "SUBQ"}, // arg0 - arg1 - {name: "SUBL", reg: gp21, asm: "SUBL"}, // arg0 - arg1 - {name: "SUBW", reg: gp21, asm: "SUBW"}, // arg0 - arg1 - {name: "SUBB", reg: gp21, asm: "SUBB"}, // arg0 - arg1 - {name: "SUBQconst", reg: gp11, asm: "SUBQ", aux: "Int64"}, // arg0 - auxint - {name: "SUBLconst", reg: gp11, asm: "SUBL", aux: "Int32"}, // arg0 - auxint - {name: "SUBWconst", reg: gp11, asm: "SUBW", aux: "Int16"}, // arg0 - auxint - {name: "SUBBconst", reg: gp11, asm: "SUBB", aux: "Int8"}, // arg0 - auxint - - {name: "MULQ", reg: gp21, asm: "IMULQ"}, // arg0 * arg1 - {name: "MULL", reg: gp21, asm: "IMULL"}, // arg0 * arg1 - {name: "MULW", reg: gp21, asm: "IMULW"}, // arg0 * arg1 - {name: "MULB", reg: gp21, asm: "IMULW"}, // arg0 * arg1 - {name: "MULQconst", reg: gp11, asm: "IMULQ", aux: "Int64"}, // arg0 * auxint - {name: "MULLconst", reg: gp11, asm: "IMULL", aux: "Int32"}, // arg0 * auxint - {name: "MULWconst", reg: gp11, asm: "IMULW", aux: "Int16"}, // arg0 * auxint - {name: "MULBconst", reg: gp11, asm: "IMULW", aux: "Int8"}, // arg0 * auxint - - {name: "HMULQ", reg: gp11hmul, asm: "IMULQ"}, // (arg0 * arg1) >> width - {name: "HMULL", reg: gp11hmul, asm: "IMULL"}, // (arg0 * arg1) >> width - {name: "HMULW", reg: gp11hmul, asm: "IMULW"}, // (arg0 * arg1) >> width - {name: "HMULB", reg: gp11hmul, asm: "IMULB"}, // (arg0 * arg1) >> width - {name: "HMULQU", reg: gp11hmul, asm: "MULQ"}, // (arg0 * arg1) >> width - {name: "HMULLU", reg: gp11hmul, asm: "MULL"}, // (arg0 * arg1) >> width - {name: "HMULWU", reg: gp11hmul, asm: "MULW"}, // (arg0 * arg1) >> width - {name: "HMULBU", reg: gp11hmul, asm: "MULB"}, // (arg0 * arg1) >> width - - {name: "AVGQU", reg: gp21}, // (arg0 + arg1) / 2 as unsigned, all 64 result bits - - {name: "DIVQ", reg: gp11div, asm: "IDIVQ"}, // arg0 / arg1 - {name: "DIVL", reg: gp11div, asm: "IDIVL"}, // arg0 / arg1 - {name: "DIVW", reg: gp11div, asm: "IDIVW"}, // arg0 / arg1 - {name: "DIVQU", reg: gp11div, asm: "DIVQ"}, // arg0 / arg1 - {name: "DIVLU", reg: gp11div, asm: "DIVL"}, // arg0 / arg1 - {name: "DIVWU", reg: gp11div, asm: "DIVW"}, // arg0 / arg1 - - {name: "MODQ", reg: gp11mod, asm: "IDIVQ"}, // arg0 % arg1 - {name: "MODL", reg: gp11mod, asm: "IDIVL"}, // arg0 % arg1 - {name: "MODW", reg: gp11mod, asm: "IDIVW"}, // arg0 % arg1 - {name: "MODQU", reg: gp11mod, asm: "DIVQ"}, // arg0 % arg1 - {name: "MODLU", reg: gp11mod, asm: "DIVL"}, // arg0 % arg1 - {name: "MODWU", reg: gp11mod, asm: "DIVW"}, // arg0 % arg1 - - {name: "ANDQ", reg: gp21, asm: "ANDQ"}, // arg0 & arg1 - {name: "ANDL", reg: gp21, asm: "ANDL"}, // arg0 & arg1 - {name: "ANDW", reg: gp21, asm: "ANDW"}, // arg0 & arg1 - {name: "ANDB", reg: gp21, asm: "ANDB"}, // arg0 & arg1 - {name: "ANDQconst", reg: gp11, asm: "ANDQ", aux: "Int64"}, // arg0 & auxint - {name: "ANDLconst", reg: gp11, asm: "ANDL", aux: "Int32"}, // arg0 & auxint - {name: "ANDWconst", reg: gp11, asm: "ANDW", aux: "Int16"}, // arg0 & auxint - {name: "ANDBconst", reg: gp11, asm: "ANDB", aux: "Int8"}, // arg0 & auxint - - {name: "ORQ", reg: gp21, asm: "ORQ"}, // arg0 | arg1 - {name: "ORL", reg: gp21, asm: "ORL"}, // arg0 | arg1 - {name: "ORW", reg: gp21, asm: "ORW"}, // arg0 | arg1 - {name: "ORB", reg: gp21, asm: "ORB"}, // arg0 | arg1 - {name: "ORQconst", reg: gp11, asm: "ORQ", aux: "Int64"}, // arg0 | auxint - {name: "ORLconst", reg: gp11, asm: "ORL", aux: "Int32"}, // arg0 | auxint - {name: "ORWconst", reg: gp11, asm: "ORW", aux: "Int16"}, // arg0 | auxint - {name: "ORBconst", reg: gp11, asm: "ORB", aux: "Int8"}, // arg0 | auxint - - {name: "XORQ", reg: gp21, asm: "XORQ"}, // arg0 ^ arg1 - {name: "XORL", reg: gp21, asm: "XORL"}, // arg0 ^ arg1 - {name: "XORW", reg: gp21, asm: "XORW"}, // arg0 ^ arg1 - {name: "XORB", reg: gp21, asm: "XORB"}, // arg0 ^ arg1 - {name: "XORQconst", reg: gp11, asm: "XORQ", aux: "Int64"}, // arg0 ^ auxint - {name: "XORLconst", reg: gp11, asm: "XORL", aux: "Int32"}, // arg0 ^ auxint - {name: "XORWconst", reg: gp11, asm: "XORW", aux: "Int16"}, // arg0 ^ auxint - {name: "XORBconst", reg: gp11, asm: "XORB", aux: "Int8"}, // arg0 ^ auxint - - {name: "CMPQ", reg: gp2flags, asm: "CMPQ", typ: "Flags"}, // arg0 compare to arg1 - {name: "CMPL", reg: gp2flags, asm: "CMPL", typ: "Flags"}, // arg0 compare to arg1 - {name: "CMPW", reg: gp2flags, asm: "CMPW", typ: "Flags"}, // arg0 compare to arg1 - {name: "CMPB", reg: gp2flags, asm: "CMPB", typ: "Flags"}, // arg0 compare to arg1 - {name: "CMPQconst", reg: gp1flags, asm: "CMPQ", typ: "Flags", aux: "Int64"}, // arg0 compare to auxint - {name: "CMPLconst", reg: gp1flags, asm: "CMPL", typ: "Flags", aux: "Int32"}, // arg0 compare to auxint - {name: "CMPWconst", reg: gp1flags, asm: "CMPW", typ: "Flags", aux: "Int16"}, // arg0 compare to auxint - {name: "CMPBconst", reg: gp1flags, asm: "CMPB", typ: "Flags", aux: "Int8"}, // arg0 compare to auxint - - {name: "UCOMISS", reg: fp2flags, asm: "UCOMISS", typ: "Flags"}, // arg0 compare to arg1, f32 - {name: "UCOMISD", reg: fp2flags, asm: "UCOMISD", typ: "Flags"}, // arg0 compare to arg1, f64 - - {name: "TESTQ", reg: gp2flags, asm: "TESTQ", typ: "Flags"}, // (arg0 & arg1) compare to 0 - {name: "TESTL", reg: gp2flags, asm: "TESTL", typ: "Flags"}, // (arg0 & arg1) compare to 0 - {name: "TESTW", reg: gp2flags, asm: "TESTW", typ: "Flags"}, // (arg0 & arg1) compare to 0 - {name: "TESTB", reg: gp2flags, asm: "TESTB", typ: "Flags"}, // (arg0 & arg1) compare to 0 - {name: "TESTQconst", reg: gp1flags, asm: "TESTQ", typ: "Flags", aux: "Int64"}, // (arg0 & auxint) compare to 0 - {name: "TESTLconst", reg: gp1flags, asm: "TESTL", typ: "Flags", aux: "Int32"}, // (arg0 & auxint) compare to 0 - {name: "TESTWconst", reg: gp1flags, asm: "TESTW", typ: "Flags", aux: "Int16"}, // (arg0 & auxint) compare to 0 - {name: "TESTBconst", reg: gp1flags, asm: "TESTB", typ: "Flags", aux: "Int8"}, // (arg0 & auxint) compare to 0 - - {name: "SHLQ", reg: gp21shift, asm: "SHLQ"}, // arg0 << arg1, shift amount is mod 64 - {name: "SHLL", reg: gp21shift, asm: "SHLL"}, // arg0 << arg1, shift amount is mod 32 - {name: "SHLW", reg: gp21shift, asm: "SHLW"}, // arg0 << arg1, shift amount is mod 32 - {name: "SHLB", reg: gp21shift, asm: "SHLB"}, // arg0 << arg1, shift amount is mod 32 - {name: "SHLQconst", reg: gp11, asm: "SHLQ", aux: "Int64"}, // arg0 << auxint, shift amount 0-63 - {name: "SHLLconst", reg: gp11, asm: "SHLL", aux: "Int32"}, // arg0 << auxint, shift amount 0-31 - {name: "SHLWconst", reg: gp11, asm: "SHLW", aux: "Int16"}, // arg0 << auxint, shift amount 0-31 - {name: "SHLBconst", reg: gp11, asm: "SHLB", aux: "Int8"}, // arg0 << auxint, shift amount 0-31 + {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: "ADDW"}, // arg0 + arg1 + {name: "ADDB", argLength: 2, reg: gp21, asm: "ADDB"}, // 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: "ADDW", aux: "Int16"}, // arg0 + auxint + {name: "ADDBconst", argLength: 1, reg: gp11, asm: "ADDB", 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: "SUBW"}, // arg0 - arg1 + {name: "SUBB", argLength: 2, reg: gp21, asm: "SUBB"}, // 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: "SUBW", aux: "Int16"}, // arg0 - auxint + {name: "SUBBconst", argLength: 1, reg: gp11, asm: "SUBB", 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: "ANDW"}, // arg0 & arg1 + {name: "ANDB", argLength: 2, reg: gp21, asm: "ANDB"}, // 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: "ANDW", aux: "Int16"}, // arg0 & auxint + {name: "ANDBconst", argLength: 1, reg: gp11, asm: "ANDB", 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: "ORW"}, // arg0 | arg1 + {name: "ORB", argLength: 2, reg: gp21, asm: "ORB"}, // 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: "ORW", aux: "Int16"}, // arg0 | auxint + {name: "ORBconst", argLength: 1, reg: gp11, asm: "ORB", 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: "XORW"}, // arg0 ^ arg1 + {name: "XORB", argLength: 2, reg: gp21, asm: "XORB"}, // 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: "XORW", aux: "Int16"}, // arg0 ^ auxint + {name: "XORBconst", argLength: 1, reg: gp11, asm: "XORB", 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: "SHLW"}, // arg0 << arg1, shift amount is mod 32 + {name: "SHLB", argLength: 2, reg: gp21shift, asm: "SHLB"}, // 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: "SHLW", aux: "Int16"}, // arg0 << auxint, shift amount 0-31 + {name: "SHLBconst", argLength: 1, reg: gp11, asm: "SHLB", 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", reg: gp21shift, asm: "SHRQ"}, // unsigned arg0 >> arg1, shift amount is mod 64 - {name: "SHRL", reg: gp21shift, asm: "SHRL"}, // unsigned arg0 >> arg1, shift amount is mod 32 - {name: "SHRW", reg: gp21shift, asm: "SHRW"}, // unsigned arg0 >> arg1, shift amount is mod 32 - {name: "SHRB", reg: gp21shift, asm: "SHRB"}, // unsigned arg0 >> arg1, shift amount is mod 32 - {name: "SHRQconst", reg: gp11, asm: "SHRQ", aux: "Int64"}, // unsigned arg0 >> auxint, shift amount 0-63 - {name: "SHRLconst", reg: gp11, asm: "SHRL", aux: "Int32"}, // unsigned arg0 >> auxint, shift amount 0-31 - {name: "SHRWconst", reg: gp11, asm: "SHRW", aux: "Int16"}, // unsigned arg0 >> auxint, shift amount 0-31 - {name: "SHRBconst", reg: gp11, asm: "SHRB", aux: "Int8"}, // unsigned arg0 >> auxint, shift amount 0-31 - - {name: "SARQ", reg: gp21shift, asm: "SARQ"}, // signed arg0 >> arg1, shift amount is mod 64 - {name: "SARL", reg: gp21shift, asm: "SARL"}, // signed arg0 >> arg1, shift amount is mod 32 - {name: "SARW", reg: gp21shift, asm: "SARW"}, // signed arg0 >> arg1, shift amount is mod 32 - {name: "SARB", reg: gp21shift, asm: "SARB"}, // signed arg0 >> arg1, shift amount is mod 32 - {name: "SARQconst", reg: gp11, asm: "SARQ", aux: "Int64"}, // signed arg0 >> auxint, shift amount 0-63 - {name: "SARLconst", reg: gp11, asm: "SARL", aux: "Int32"}, // signed arg0 >> auxint, shift amount 0-31 - {name: "SARWconst", reg: gp11, asm: "SARW", aux: "Int16"}, // signed arg0 >> auxint, shift amount 0-31 - {name: "SARBconst", reg: gp11, asm: "SARB", aux: "Int8"}, // signed arg0 >> auxint, shift amount 0-31 - - {name: "ROLQconst", reg: gp11, asm: "ROLQ", aux: "Int64"}, // arg0 rotate left auxint, rotate amount 0-63 - {name: "ROLLconst", reg: gp11, asm: "ROLL", aux: "Int32"}, // arg0 rotate left auxint, rotate amount 0-31 - {name: "ROLWconst", reg: gp11, asm: "ROLW", aux: "Int16"}, // arg0 rotate left auxint, rotate amount 0-15 - {name: "ROLBconst", reg: gp11, asm: "ROLB", aux: "Int8"}, // arg0 rotate left auxint, rotate amount 0-7 + {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", reg: gp11, asm: "NEGQ"}, // -arg0 - {name: "NEGL", reg: gp11, asm: "NEGL"}, // -arg0 - {name: "NEGW", reg: gp11, asm: "NEGW"}, // -arg0 - {name: "NEGB", reg: gp11, asm: "NEGB"}, // -arg0 + {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: "NEGW"}, // -arg0 + {name: "NEGB", argLength: 1, reg: gp11, asm: "NEGB"}, // -arg0 - {name: "NOTQ", reg: gp11, asm: "NOTQ"}, // ^arg0 - {name: "NOTL", reg: gp11, asm: "NOTL"}, // ^arg0 - {name: "NOTW", reg: gp11, asm: "NOTW"}, // ^arg0 - {name: "NOTB", reg: gp11, asm: "NOTB"}, // ^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: "NOTW"}, // ^arg0 + {name: "NOTB", argLength: 1, reg: gp11, asm: "NOTB"}, // ^arg0 - {name: "SQRTSD", reg: fp11, asm: "SQRTSD"}, // sqrt(arg0) + {name: "SQRTSD", argLength: 1, reg: fp11, asm: "SQRTSD"}, // sqrt(arg0) - {name: "SBBQcarrymask", reg: flagsgp, asm: "SBBQ"}, // (int64)(-1) if carry is set, 0 if carry is clear. - {name: "SBBLcarrymask", reg: flagsgp, asm: "SBBL"}, // (int32)(-1) if carry is set, 0 if carry is clear. + {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", reg: readflags, asm: "SETEQ"}, // extract == condition from arg0 - {name: "SETNE", reg: readflags, asm: "SETNE"}, // extract != condition from arg0 - {name: "SETL", reg: readflags, asm: "SETLT"}, // extract signed < condition from arg0 - {name: "SETLE", reg: readflags, asm: "SETLE"}, // extract signed <= condition from arg0 - {name: "SETG", reg: readflags, asm: "SETGT"}, // extract signed > condition from arg0 - {name: "SETGE", reg: readflags, asm: "SETGE"}, // extract signed >= condition from arg0 - {name: "SETB", reg: readflags, asm: "SETCS"}, // extract unsigned < condition from arg0 - {name: "SETBE", reg: readflags, asm: "SETLS"}, // extract unsigned <= condition from arg0 - {name: "SETA", reg: readflags, asm: "SETHI"}, // extract unsigned > condition from arg0 - {name: "SETAE", reg: readflags, asm: "SETCC"}, // extract unsigned >= condition from arg0 + {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", reg: flagsgpax, asm: "SETEQ"}, // extract == condition from arg0 - {name: "SETNEF", reg: flagsgpax, asm: "SETNE"}, // extract != condition from arg0 - {name: "SETORD", reg: flagsgp, asm: "SETPC"}, // extract "ordered" (No Nan present) condition from arg0 - {name: "SETNAN", reg: flagsgp, asm: "SETPS"}, // extract "unordered" (Nan present) condition from arg0 + {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", reg: flagsgp, asm: "SETHI"}, // extract floating > condition from arg0 - {name: "SETGEF", reg: flagsgp, asm: "SETCC"}, // extract floating >= 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", reg: gp11nf, asm: "MOVBQSX"}, // sign extend arg0 from int8 to int64 - {name: "MOVBQZX", reg: gp11nf, asm: "MOVBQZX"}, // zero extend arg0 from int8 to int64 - {name: "MOVWQSX", reg: gp11nf, asm: "MOVWQSX"}, // sign extend arg0 from int16 to int64 - {name: "MOVWQZX", reg: gp11nf, asm: "MOVWQZX"}, // zero extend arg0 from int16 to int64 - {name: "MOVLQSX", reg: gp11nf, asm: "MOVLQSX"}, // sign extend arg0 from int32 to int64 - {name: "MOVLQZX", reg: gp11nf, asm: "MOVLQZX"}, // zero extend arg0 from int32 to int64 + {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", reg: fpgp, asm: "CVTTSD2SL"}, // convert float64 to int32 - {name: "CVTTSD2SQ", reg: fpgp, asm: "CVTTSD2SQ"}, // convert float64 to int64 - {name: "CVTTSS2SL", reg: fpgp, asm: "CVTTSS2SL"}, // convert float32 to int32 - {name: "CVTTSS2SQ", reg: fpgp, asm: "CVTTSS2SQ"}, // convert float32 to int64 - {name: "CVTSL2SS", reg: gpfp, asm: "CVTSL2SS"}, // convert int32 to float32 - {name: "CVTSL2SD", reg: gpfp, asm: "CVTSL2SD"}, // convert int32 to float64 - {name: "CVTSQ2SS", reg: gpfp, asm: "CVTSQ2SS"}, // convert int64 to float32 - {name: "CVTSQ2SD", reg: gpfp, asm: "CVTSQ2SD"}, // convert int64 to float64 - {name: "CVTSD2SS", reg: fp11, asm: "CVTSD2SS"}, // convert float64 to float32 - {name: "CVTSS2SD", reg: fp11, asm: "CVTSS2SD"}, // convert float32 to float64 - - {name: "PXOR", reg: fp21, asm: "PXOR"}, // exclusive or, applied to X regs for float negation. - - {name: "LEAQ", reg: gp11sb, aux: "SymOff", rematerializeable: true}, // arg0 + auxint + offset encoded in aux - {name: "LEAQ1", reg: gp21sb, aux: "SymOff"}, // arg0 + arg1 + auxint + aux - {name: "LEAQ2", reg: gp21sb, aux: "SymOff"}, // arg0 + 2*arg1 + auxint + aux - {name: "LEAQ4", reg: gp21sb, aux: "SymOff"}, // arg0 + 4*arg1 + auxint + aux - {name: "LEAQ8", reg: gp21sb, aux: "SymOff"}, // arg0 + 8*arg1 + auxint + aux + {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", reg: gpload, asm: "MOVB", aux: "SymOff", typ: "UInt8"}, // load byte from arg0+auxint+aux. arg1=mem - {name: "MOVBQSXload", reg: gpload, asm: "MOVBQSX", aux: "SymOff"}, // ditto, extend to int64 - {name: "MOVBQZXload", reg: gpload, asm: "MOVBQZX", aux: "SymOff"}, // ditto, extend to uint64 - {name: "MOVWload", reg: gpload, asm: "MOVW", aux: "SymOff", typ: "UInt16"}, // load 2 bytes from arg0+auxint+aux. arg1=mem - {name: "MOVWQSXload", reg: gpload, asm: "MOVWQSX", aux: "SymOff"}, // ditto, extend to int64 - {name: "MOVWQZXload", reg: gpload, asm: "MOVWQZX", aux: "SymOff"}, // ditto, extend to uint64 - {name: "MOVLload", reg: gpload, asm: "MOVL", aux: "SymOff", typ: "UInt32"}, // load 4 bytes from arg0+auxint+aux. arg1=mem - {name: "MOVLQSXload", reg: gpload, asm: "MOVLQSX", aux: "SymOff"}, // ditto, extend to int64 - {name: "MOVLQZXload", reg: gpload, asm: "MOVLQZX", aux: "SymOff"}, // ditto, extend to uint64 - {name: "MOVQload", reg: gpload, asm: "MOVQ", aux: "SymOff", typ: "UInt64"}, // load 8 bytes from arg0+auxint+aux. arg1=mem - {name: "MOVBstore", reg: gpstore, asm: "MOVB", aux: "SymOff", typ: "Mem"}, // store byte in arg1 to arg0+auxint+aux. arg2=mem - {name: "MOVWstore", reg: gpstore, asm: "MOVW", aux: "SymOff", typ: "Mem"}, // store 2 bytes in arg1 to arg0+auxint+aux. arg2=mem - {name: "MOVLstore", reg: gpstore, asm: "MOVL", aux: "SymOff", typ: "Mem"}, // store 4 bytes in arg1 to arg0+auxint+aux. arg2=mem - {name: "MOVQstore", reg: gpstore, asm: "MOVQ", aux: "SymOff", typ: "Mem"}, // store 8 bytes in arg1 to arg0+auxint+aux. arg2=mem - {name: "MOVOload", reg: fpload, asm: "MOVUPS", aux: "SymOff", typ: "Int128"}, // load 16 bytes from arg0+auxint+aux. arg1=mem - {name: "MOVOstore", reg: fpstore, asm: "MOVUPS", aux: "SymOff", typ: "Mem"}, // store 16 bytes in arg1 to arg0+auxint+aux. arg2=mem + {name: "MOVBload", argLength: 2, reg: gpload, asm: "MOVB", 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: "MOVW", 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", reg: gploadidx, asm: "MOVB", aux: "SymOff"}, // load a byte from arg0+arg1+auxint+aux. arg2=mem - {name: "MOVWloadidx2", reg: gploadidx, asm: "MOVW", aux: "SymOff"}, // load 2 bytes from arg0+2*arg1+auxint+aux. arg2=mem - {name: "MOVLloadidx4", reg: gploadidx, asm: "MOVL", aux: "SymOff"}, // load 4 bytes from arg0+4*arg1+auxint+aux. arg2=mem - {name: "MOVQloadidx8", reg: gploadidx, asm: "MOVQ", aux: "SymOff"}, // load 8 bytes from arg0+8*arg1+auxint+aux. arg2=mem + {name: "MOVBloadidx1", argLength: 3, reg: gploadidx, asm: "MOVB", aux: "SymOff"}, // load a byte from arg0+arg1+auxint+aux. arg2=mem + {name: "MOVWloadidx2", argLength: 3, reg: gploadidx, asm: "MOVW", 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", reg: gpstoreidx, asm: "MOVB", aux: "SymOff"}, // store byte in arg2 to arg0+arg1+auxint+aux. arg3=mem - {name: "MOVWstoreidx2", reg: gpstoreidx, asm: "MOVW", aux: "SymOff"}, // store 2 bytes in arg2 to arg0+2*arg1+auxint+aux. arg3=mem - {name: "MOVLstoreidx4", reg: gpstoreidx, asm: "MOVL", aux: "SymOff"}, // store 4 bytes in arg2 to arg0+4*arg1+auxint+aux. arg3=mem - {name: "MOVQstoreidx8", reg: gpstoreidx, asm: "MOVQ", aux: "SymOff"}, // store 8 bytes in arg2 to arg0+8*arg1+auxint+aux. arg3=mem + {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", 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", reg: gpstoreconst, asm: "MOVW", aux: "SymValAndOff", typ: "Mem"}, // store low 2 bytes of ... - {name: "MOVLstoreconst", reg: gpstoreconst, asm: "MOVL", aux: "SymValAndOff", typ: "Mem"}, // store low 4 bytes of ... - {name: "MOVQstoreconst", reg: gpstoreconst, asm: "MOVQ", aux: "SymValAndOff", typ: "Mem"}, // store 8 bytes of ... + {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", 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", reg: gpstoreconstidx, asm: "MOVW", aux: "SymValAndOff", typ: "Mem"}, // store low 2 bytes of ... 2*arg1 ... - {name: "MOVLstoreconstidx4", reg: gpstoreconstidx, asm: "MOVL", aux: "SymValAndOff", typ: "Mem"}, // store low 4 bytes of ... 4*arg1 ... - {name: "MOVQstoreconstidx8", reg: gpstoreconstidx, asm: "MOVQ", aux: "SymValAndOff", typ: "Mem"}, // store 8 bytes of ... 8*arg1 ... + {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) @@ -418,8 +418,9 @@ func init() { // auxint = offset into duffzero code to start executing // returns mem { - name: "DUFFZERO", - aux: "Int64", + name: "DUFFZERO", + aux: "Int64", + argLength: 3, reg: regInfo{ inputs: []regMask{buildReg("DI"), buildReg("X0")}, clobbers: buildReg("DI FLAGS"), @@ -433,18 +434,19 @@ func init() { // arg3 = mem // returns mem { - name: "REPSTOSQ", + name: "REPSTOSQ", + argLength: 4, reg: regInfo{ inputs: []regMask{buildReg("DI"), buildReg("CX"), buildReg("AX")}, clobbers: buildReg("DI CX FLAGS"), }, }, - {name: "CALLstatic", reg: regInfo{clobbers: callerSave}, aux: "SymOff"}, // call static function aux.(*gc.Sym). arg0=mem, auxint=argsize, returns mem - {name: "CALLclosure", 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", reg: regInfo{clobbers: callerSave}, aux: "Int64"}, // call deferproc. arg0=mem, auxint=argsize, returns mem - {name: "CALLgo", reg: regInfo{clobbers: callerSave}, aux: "Int64"}, // call newproc. arg0=mem, auxint=argsize, returns mem - {name: "CALLinter", reg: regInfo{inputs: []regMask{gp}, clobbers: callerSave}, aux: "Int64"}, // call fn by pointer. arg0=codeptr, arg1=mem, auxint=argsize, returns mem + {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 @@ -452,8 +454,9 @@ func init() { // auxint = offset from duffcopy symbol to call // returns memory { - name: "DUFFCOPY", - aux: "Int64", + 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 @@ -466,7 +469,8 @@ func init() { // arg3 = mem // returns memory { - name: "REPMOVSQ", + name: "REPMOVSQ", + argLength: 4, reg: regInfo{ inputs: []regMask{buildReg("DI"), buildReg("SI"), buildReg("CX")}, clobbers: buildReg("DI SI CX"), @@ -478,23 +482,23 @@ func init() { // 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"}, // reverse direction of arg0 + {name: "InvertFlags", argLength: 1}, // reverse direction of arg0 // Pseudo-ops - {name: "LoweredGetG", reg: gp01}, // arg0=mem + {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", reg: regInfo{inputs: []regMask{gpsp}, clobbers: flags}}, + {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", reg: gp11nf, asm: "MOVQ"}, + {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 diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go index 9f53024b21..31e45c45ea 100644 --- a/src/cmd/compile/internal/ssa/gen/genericOps.go +++ b/src/cmd/compile/internal/ssa/gen/genericOps.go @@ -8,129 +8,129 @@ 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", commutative: true}, // arg0 + arg1 - {name: "Add16", commutative: true}, - {name: "Add32", commutative: true}, - {name: "Add64", commutative: true}, - {name: "AddPtr"}, // For address calculations. arg0 is a pointer and arg1 is an int. - {name: "Add32F"}, - {name: "Add64F"}, + {name: "Add8", argLength: 2, commutative: true}, // arg0 + arg1 + {name: "Add16", argLength: 2, commutative: true}, + {name: "Add32", argLength: 2, commutative: true}, + {name: "Add64", argLength: 2, commutative: true}, + {name: "AddPtr", argLength: 2}, // For address calculations. arg0 is a pointer and arg1 is an int. + {name: "Add32F", argLength: 2}, + {name: "Add64F", argLength: 2}, // TODO: Add64C, Add128C - {name: "Sub8"}, // arg0 - arg1 - {name: "Sub16"}, - {name: "Sub32"}, - {name: "Sub64"}, - {name: "SubPtr"}, - {name: "Sub32F"}, - {name: "Sub64F"}, - - {name: "Mul8", commutative: true}, // arg0 * arg1 - {name: "Mul16", commutative: true}, - {name: "Mul32", commutative: true}, - {name: "Mul64", commutative: true}, - {name: "Mul32F"}, - {name: "Mul64F"}, - - {name: "Div32F"}, // arg0 / arg1 - {name: "Div64F"}, - - {name: "Hmul8"}, // (arg0 * arg1) >> width - {name: "Hmul8u"}, - {name: "Hmul16"}, - {name: "Hmul16u"}, - {name: "Hmul32"}, - {name: "Hmul32u"}, - {name: "Hmul64"}, - {name: "Hmul64u"}, + {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"}, // (uint64(arg0) + uint64(arg1)) / 2, correct to all 64 bits. - - {name: "Div8"}, // arg0 / arg1 - {name: "Div8u"}, - {name: "Div16"}, - {name: "Div16u"}, - {name: "Div32"}, - {name: "Div32u"}, - {name: "Div64"}, - {name: "Div64u"}, - - {name: "Mod8"}, // arg0 % arg1 - {name: "Mod8u"}, - {name: "Mod16"}, - {name: "Mod16u"}, - {name: "Mod32"}, - {name: "Mod32u"}, - {name: "Mod64"}, - {name: "Mod64u"}, - - {name: "And8", commutative: true}, // arg0 & arg1 - {name: "And16", commutative: true}, - {name: "And32", commutative: true}, - {name: "And64", commutative: true}, - - {name: "Or8", commutative: true}, // arg0 | arg1 - {name: "Or16", commutative: true}, - {name: "Or32", commutative: true}, - {name: "Or64", commutative: true}, - - {name: "Xor8", commutative: true}, // arg0 ^ arg1 - {name: "Xor16", commutative: true}, - {name: "Xor32", commutative: true}, - {name: "Xor64", commutative: true}, + {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"}, // arg0 << arg1 - {name: "Lsh8x16"}, - {name: "Lsh8x32"}, - {name: "Lsh8x64"}, - {name: "Lsh16x8"}, - {name: "Lsh16x16"}, - {name: "Lsh16x32"}, - {name: "Lsh16x64"}, - {name: "Lsh32x8"}, - {name: "Lsh32x16"}, - {name: "Lsh32x32"}, - {name: "Lsh32x64"}, - {name: "Lsh64x8"}, - {name: "Lsh64x16"}, - {name: "Lsh64x32"}, - {name: "Lsh64x64"}, - - {name: "Rsh8x8"}, // arg0 >> arg1, signed - {name: "Rsh8x16"}, - {name: "Rsh8x32"}, - {name: "Rsh8x64"}, - {name: "Rsh16x8"}, - {name: "Rsh16x16"}, - {name: "Rsh16x32"}, - {name: "Rsh16x64"}, - {name: "Rsh32x8"}, - {name: "Rsh32x16"}, - {name: "Rsh32x32"}, - {name: "Rsh32x64"}, - {name: "Rsh64x8"}, - {name: "Rsh64x16"}, - {name: "Rsh64x32"}, - {name: "Rsh64x64"}, - - {name: "Rsh8Ux8"}, // arg0 >> arg1, unsigned - {name: "Rsh8Ux16"}, - {name: "Rsh8Ux32"}, - {name: "Rsh8Ux64"}, - {name: "Rsh16Ux8"}, - {name: "Rsh16Ux16"}, - {name: "Rsh16Ux32"}, - {name: "Rsh16Ux64"}, - {name: "Rsh32Ux8"}, - {name: "Rsh32Ux16"}, - {name: "Rsh32Ux32"}, - {name: "Rsh32Ux64"}, - {name: "Rsh64Ux8"}, - {name: "Rsh64Ux16"}, - {name: "Rsh64Ux32"}, - {name: "Rsh64Ux64"}, + {name: "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)) @@ -152,102 +152,103 @@ var genericOps = []opData{ // for rotates is hashing and crypto code with constant // distance, rotate instructions are only substituted // when arg1 is a constant between 1 and A-1, inclusive. - {name: "Lrot8", aux: "Int64"}, - {name: "Lrot16", aux: "Int64"}, - {name: "Lrot32", aux: "Int64"}, - {name: "Lrot64", aux: "Int64"}, + {name: "Lrot8", argLength: 1, aux: "Int64"}, + {name: "Lrot16", argLength: 1, aux: "Int64"}, + {name: "Lrot32", argLength: 1, aux: "Int64"}, + {name: "Lrot64", argLength: 1, aux: "Int64"}, // 2-input comparisons - {name: "Eq8", commutative: true}, // arg0 == arg1 - {name: "Eq16", commutative: true}, - {name: "Eq32", commutative: true}, - {name: "Eq64", commutative: true}, - {name: "EqPtr", commutative: true}, - {name: "EqInter"}, // arg0 or arg1 is nil; other cases handled by frontend - {name: "EqSlice"}, // arg0 or arg1 is nil; other cases handled by frontend - {name: "Eq32F"}, - {name: "Eq64F"}, - - {name: "Neq8", commutative: true}, // arg0 != arg1 - {name: "Neq16", commutative: true}, - {name: "Neq32", commutative: true}, - {name: "Neq64", commutative: true}, - {name: "NeqPtr", commutative: true}, - {name: "NeqInter"}, // arg0 or arg1 is nil; other cases handled by frontend - {name: "NeqSlice"}, // arg0 or arg1 is nil; other cases handled by frontend - {name: "Neq32F"}, - {name: "Neq64F"}, - - {name: "Less8"}, // arg0 < arg1 - {name: "Less8U"}, - {name: "Less16"}, - {name: "Less16U"}, - {name: "Less32"}, - {name: "Less32U"}, - {name: "Less64"}, - {name: "Less64U"}, - {name: "Less32F"}, - {name: "Less64F"}, - - {name: "Leq8"}, // arg0 <= arg1 - {name: "Leq8U"}, - {name: "Leq16"}, - {name: "Leq16U"}, - {name: "Leq32"}, - {name: "Leq32U"}, - {name: "Leq64"}, - {name: "Leq64U"}, - {name: "Leq32F"}, - {name: "Leq64F"}, - - {name: "Greater8"}, // arg0 > arg1 - {name: "Greater8U"}, - {name: "Greater16"}, - {name: "Greater16U"}, - {name: "Greater32"}, - {name: "Greater32U"}, - {name: "Greater64"}, - {name: "Greater64U"}, - {name: "Greater32F"}, - {name: "Greater64F"}, - - {name: "Geq8"}, // arg0 <= arg1 - {name: "Geq8U"}, - {name: "Geq16"}, - {name: "Geq16U"}, - {name: "Geq32"}, - {name: "Geq32U"}, - {name: "Geq64"}, - {name: "Geq64U"}, - {name: "Geq32F"}, - {name: "Geq64F"}, + {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"}, // !arg0 - - {name: "Neg8"}, // -arg0 - {name: "Neg16"}, - {name: "Neg32"}, - {name: "Neg64"}, - {name: "Neg32F"}, - {name: "Neg64F"}, - - {name: "Com8"}, // ^arg0 - {name: "Com16"}, - {name: "Com32"}, - {name: "Com64"}, - - {name: "Sqrt"}, // sqrt(arg0), float64 only - - // Data movement - {name: "Phi", variableLength: true}, // select an argument based on which predecessor block we came from - {name: "Copy"}, // output = arg0 + {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"}, + {name: "Convert", argLength: 2}, // constants. Constant values are stored in the aux or // auxint fields. @@ -271,108 +272,108 @@ var genericOps = []opData{ // on whether it is a global or stack variable). The Aux field identifies the // variable. It will be either an *ExternSymbol (with arg0=SB), *ArgSymbol (arg0=SP), // or *AutoSymbol (arg0=SP). - {name: "Addr", aux: "Sym"}, // Address of a variable. Arg0=SP or SB. Aux identifies the variable. + {name: "Addr", argLength: 1, aux: "Sym"}, // Address of a variable. Arg0=SP or SB. Aux identifies the variable. {name: "SP"}, // stack pointer {name: "SB", typ: "Uintptr"}, // static base pointer (a.k.a. globals pointer) {name: "Func", aux: "Sym"}, // entry address of a function // Memory operations - {name: "Load"}, // Load from arg0. arg1=memory - {name: "Store", typ: "Mem", aux: "Int64"}, // Store arg1 to arg0. arg2=memory, auxint=size. Returns memory. - {name: "Move", aux: "Int64"}, // arg0=destptr, arg1=srcptr, arg2=mem, auxint=size. Returns memory. - {name: "Zero", aux: "Int64"}, // arg0=destptr, arg1=mem, auxint=size. Returns memory. + {name: "Load", argLength: 2}, // Load from arg0. arg1=memory + {name: "Store", argLength: 3, typ: "Mem", aux: "Int64"}, // Store arg1 to arg0. arg2=memory, auxint=size. Returns memory. + {name: "Move", argLength: 3, aux: "Int64"}, // arg0=destptr, arg1=srcptr, arg2=mem, auxint=size. Returns memory. + {name: "Zero", argLength: 2, aux: "Int64"}, // arg0=destptr, arg1=mem, auxint=size. Returns memory. // Function calls. Arguments to the call have already been written to the stack. // Return values appear on the stack. The method receiver, if any, is treated // as a phantom first argument. - {name: "ClosureCall", aux: "Int64"}, // arg0=code pointer, arg1=context ptr, arg2=memory. auxint=arg size. Returns memory. - {name: "StaticCall", aux: "SymOff"}, // call function aux.(*gc.Sym), arg0=memory. auxint=arg size. Returns memory. - {name: "DeferCall", aux: "Int64"}, // defer call. arg0=memory, auxint=arg size. Returns memory. - {name: "GoCall", aux: "Int64"}, // go call. arg0=memory, auxint=arg size. Returns memory. - {name: "InterCall", aux: "Int64"}, // interface call. arg0=code pointer, arg1=memory, auxint=arg size. Returns memory. + {name: "ClosureCall", argLength: 3, aux: "Int64"}, // arg0=code pointer, arg1=context ptr, arg2=memory. auxint=arg size. Returns memory. + {name: "StaticCall", argLength: 1, aux: "SymOff"}, // call function aux.(*gc.Sym), arg0=memory. auxint=arg size. Returns memory. + {name: "DeferCall", argLength: 1, aux: "Int64"}, // defer call. arg0=memory, auxint=arg size. Returns memory. + {name: "GoCall", argLength: 1, aux: "Int64"}, // go call. arg0=memory, auxint=arg size. Returns memory. + {name: "InterCall", argLength: 2, aux: "Int64"}, // interface call. arg0=code pointer, arg1=memory, auxint=arg size. Returns memory. // Conversions: signed extensions, zero (unsigned) extensions, truncations - {name: "SignExt8to16", typ: "Int16"}, - {name: "SignExt8to32"}, - {name: "SignExt8to64"}, - {name: "SignExt16to32"}, - {name: "SignExt16to64"}, - {name: "SignExt32to64"}, - {name: "ZeroExt8to16", typ: "UInt16"}, - {name: "ZeroExt8to32"}, - {name: "ZeroExt8to64"}, - {name: "ZeroExt16to32"}, - {name: "ZeroExt16to64"}, - {name: "ZeroExt32to64"}, - {name: "Trunc16to8"}, - {name: "Trunc32to8"}, - {name: "Trunc32to16"}, - {name: "Trunc64to8"}, - {name: "Trunc64to16"}, - {name: "Trunc64to32"}, - - {name: "Cvt32to32F"}, - {name: "Cvt32to64F"}, - {name: "Cvt64to32F"}, - {name: "Cvt64to64F"}, - {name: "Cvt32Fto32"}, - {name: "Cvt32Fto64"}, - {name: "Cvt64Fto32"}, - {name: "Cvt64Fto64"}, - {name: "Cvt32Fto64F"}, - {name: "Cvt64Fto32F"}, + {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", typ: "Bool"}, // arg0 != nil - {name: "IsInBounds", typ: "Bool"}, // 0 <= arg0 < arg1 - {name: "IsSliceInBounds", typ: "Bool"}, // 0 <= arg0 <= arg1 - {name: "NilCheck", typ: "Void"}, // arg0=ptr, arg1=mem. Panics if arg0 is nil, returns void. + {name: "IsNonNil", argLength: 1, typ: "Bool"}, // arg0 != nil + {name: "IsInBounds", argLength: 2, typ: "Bool"}, // 0 <= arg0 < arg1 + {name: "IsSliceInBounds", argLength: 2, typ: "Bool"}, // 0 <= arg0 <= arg1 + {name: "NilCheck", argLength: 2, typ: "Void"}, // arg0=ptr, arg1=mem. Panics if arg0 is nil, returns void. // Pseudo-ops - {name: "GetG"}, // runtime.getg() (read g pointer). arg0=mem - {name: "GetClosurePtr"}, // get closure pointer from dedicated register + {name: "GetG", argLength: 1}, // runtime.getg() (read g pointer). arg0=mem + {name: "GetClosurePtr"}, // get closure pointer from dedicated register // Indexing operations - {name: "ArrayIndex"}, // arg0=array, arg1=index. Returns a[i] - {name: "PtrIndex"}, // arg0=ptr, arg1=index. Computes ptr+sizeof(*v.type)*index, where index is extended to ptrwidth type - {name: "OffPtr", aux: "Int64"}, // arg0 + auxint (arg0 and result are pointers) + {name: "ArrayIndex", argLength: 2}, // arg0=array, arg1=index. Returns a[i] + {name: "PtrIndex", argLength: 2}, // arg0=ptr, arg1=index. Computes ptr+sizeof(*v.type)*index, where index is extended to ptrwidth type + {name: "OffPtr", argLength: 1, aux: "Int64"}, // arg0 + auxint (arg0 and result are pointers) // Slices - {name: "SliceMake"}, // arg0=ptr, arg1=len, arg2=cap - {name: "SlicePtr", typ: "BytePtr"}, // ptr(arg0) - {name: "SliceLen"}, // len(arg0) - {name: "SliceCap"}, // cap(arg0) + {name: "SliceMake", argLength: 3}, // arg0=ptr, arg1=len, arg2=cap + {name: "SlicePtr", argLength: 1, typ: "BytePtr"}, // ptr(arg0) + {name: "SliceLen", argLength: 1}, // len(arg0) + {name: "SliceCap", argLength: 1}, // cap(arg0) // Complex (part/whole) - {name: "ComplexMake"}, // arg0=real, arg1=imag - {name: "ComplexReal"}, // real(arg0) - {name: "ComplexImag"}, // imag(arg0) + {name: "ComplexMake", argLength: 2}, // arg0=real, arg1=imag + {name: "ComplexReal", argLength: 1}, // real(arg0) + {name: "ComplexImag", argLength: 1}, // imag(arg0) // Strings - {name: "StringMake"}, // arg0=ptr, arg1=len - {name: "StringPtr"}, // ptr(arg0) - {name: "StringLen"}, // len(arg0) + {name: "StringMake", argLength: 2}, // arg0=ptr, arg1=len + {name: "StringPtr", argLength: 1}, // ptr(arg0) + {name: "StringLen", argLength: 1}, // len(arg0) // Interfaces - {name: "IMake"}, // arg0=itab, arg1=data - {name: "ITab", typ: "BytePtr"}, // arg0=interface, returns itable field - {name: "IData"}, // arg0=interface, returns data field + {name: "IMake", argLength: 2}, // arg0=itab, arg1=data + {name: "ITab", argLength: 1, typ: "BytePtr"}, // arg0=interface, returns itable field + {name: "IData", argLength: 1}, // arg0=interface, returns data field // Structs - {name: "StructMake0"}, // Returns struct with 0 fields. - {name: "StructMake1"}, // arg0=field0. Returns struct. - {name: "StructMake2"}, // arg0,arg1=field0,field1. Returns struct. - {name: "StructMake3"}, // arg0..2=field0..2. Returns struct. - {name: "StructMake4"}, // arg0..3=field0..3. Returns struct. - {name: "StructSelect", aux: "Int64"}, // arg0=struct, auxint=field index. Returns the auxint'th field. + {name: "StructMake0"}, // Returns struct with 0 fields. + {name: "StructMake1", argLength: 1}, // arg0=field0. Returns struct. + {name: "StructMake2", argLength: 2}, // arg0,arg1=field0,field1. Returns struct. + {name: "StructMake3", argLength: 3}, // arg0..2=field0..2. Returns struct. + {name: "StructMake4", argLength: 4}, // arg0..3=field0..3. Returns struct. + {name: "StructSelect", argLength: 1, aux: "Int64"}, // arg0=struct, auxint=field index. Returns the auxint'th field. // Spill&restore ops for the register allocator. These are // semantically identical to OpCopy; they do not take/return // stores like regular memory ops do. We can get away without memory // args because we know there is no aliasing of spill slots on the stack. - {name: "StoreReg"}, - {name: "LoadReg"}, + {name: "StoreReg", argLength: 1}, + {name: "LoadReg", argLength: 1}, // Used during ssa construction. Like Copy, but the arg has not been specified yet. {name: "FwdRef"}, @@ -380,9 +381,9 @@ var genericOps = []opData{ // Unknown value. Used for Values whose values don't matter because they are dead code. {name: "Unknown"}, - {name: "VarDef", aux: "Sym", typ: "Mem"}, // aux is a *gc.Node of a variable that is about to be initialized. arg0=mem, returns mem - {name: "VarKill", aux: "Sym"}, // aux is a *gc.Node of a variable that is known to be dead. arg0=mem, returns mem - {name: "VarLive", aux: "Sym"}, // aux is a *gc.Node of a variable that must be kept live. arg0=mem, returns mem + {name: "VarDef", argLength: 1, aux: "Sym", typ: "Mem"}, // aux is a *gc.Node of a variable that is about to be initialized. arg0=mem, returns mem + {name: "VarKill", argLength: 1, aux: "Sym"}, // aux is a *gc.Node of a variable that is known to be dead. arg0=mem, returns mem + {name: "VarLive", argLength: 1, aux: "Sym"}, // aux is a *gc.Node of a variable that must be kept live. arg0=mem, returns mem } // kind control successors implicit exit diff --git a/src/cmd/compile/internal/ssa/gen/main.go b/src/cmd/compile/internal/ssa/gen/main.go index bb4188c349..5ba8483f61 100644 --- a/src/cmd/compile/internal/ssa/gen/main.go +++ b/src/cmd/compile/internal/ssa/gen/main.go @@ -32,8 +32,8 @@ type opData struct { typ string // default result type aux string rematerializeable bool - variableLength bool // this operation has a variable number of arguments - commutative bool // this operation is commutative (e.g. addition) + 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 { @@ -126,6 +126,8 @@ func genOp() { 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) @@ -191,6 +193,7 @@ func genOp() { var err error b, err = format.Source(b) if err != nil { + fmt.Printf("%s\n", w.Bytes()) panic(err) } diff --git a/src/cmd/compile/internal/ssa/gen/rulegen.go b/src/cmd/compile/internal/ssa/gen/rulegen.go index 56bb82c85d..55287c187d 100644 --- a/src/cmd/compile/internal/ssa/gen/rulegen.go +++ b/src/cmd/compile/internal/ssa/gen/rulegen.go @@ -398,14 +398,14 @@ func genMatch0(w io.Writer, arch arch, match, v string, m map[string]string, top variableLength := false for _, op := range genericOps { - if op.name == s[0] { - variableLength = op.variableLength + if op.name == s[0] && op.argLength == -1 { + variableLength = true break } } for _, op := range arch.ops { - if op.name == s[0] { - variableLength = op.variableLength + if op.name == s[0] && op.argLength == -1 { + variableLength = true break } } diff --git a/src/cmd/compile/internal/ssa/nilcheck_test.go b/src/cmd/compile/internal/ssa/nilcheck_test.go index b90d11e540..2d1dbc6f3e 100644 --- a/src/cmd/compile/internal/ssa/nilcheck_test.go +++ b/src/cmd/compile/internal/ssa/nilcheck_test.go @@ -177,7 +177,8 @@ func TestNilcheckAddPtr(t *testing.T) { Valu("sb", OpSB, TypeInvalid, 0, nil), Goto("checkPtr")), Bloc("checkPtr", - Valu("ptr1", OpAddPtr, ptrType, 0, nil, "sb"), + 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", @@ -355,7 +356,7 @@ func TestNilcheckUser(t *testing.T) { Goto("checkPtr")), Bloc("checkPtr", Valu("ptr1", OpLoad, ptrType, 0, nil, "sb", "mem"), - Valu("nilptr", OpConstNil, ptrType, 0, nil, "sb"), + Valu("nilptr", OpConstNil, ptrType, 0, nil), Valu("bool1", OpNeqPtr, TypeBool, 0, nil, "ptr1", "nilptr"), If("bool1", "secondCheck", "exit")), Bloc("secondCheck", @@ -394,7 +395,7 @@ func TestNilcheckBug(t *testing.T) { Goto("checkPtr")), Bloc("checkPtr", Valu("ptr1", OpLoad, ptrType, 0, nil, "sb", "mem"), - Valu("nilptr", OpConstNil, ptrType, 0, nil, "sb"), + Valu("nilptr", OpConstNil, ptrType, 0, nil), Valu("bool1", OpNeqPtr, TypeBool, 0, nil, "ptr1", "nilptr"), If("bool1", "secondCheck", "couldBeNil")), Bloc("couldBeNil", diff --git a/src/cmd/compile/internal/ssa/op.go b/src/cmd/compile/internal/ssa/op.go index c118a6c609..7b2a8f8f04 100644 --- a/src/cmd/compile/internal/ssa/op.go +++ b/src/cmd/compile/internal/ssa/op.go @@ -19,9 +19,10 @@ type opInfo struct { asm int reg regInfo auxType auxType - generic bool // this is a generic (arch-independent) opcode - rematerializeable bool // this op is rematerializeable - commutative bool // this operation is commutative (e.g. addition) + 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 { diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index ae257c0ba6..bd985cabde 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -585,8 +585,9 @@ var opcodeTable = [...]opInfo{ {name: "OpInvalid"}, { - name: "ADDSS", - asm: x86.AADDSS, + 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 @@ -598,8 +599,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "ADDSD", - asm: x86.AADDSD, + 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 @@ -611,8 +613,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SUBSS", - asm: x86.ASUBSS, + 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 @@ -625,8 +628,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SUBSD", - asm: x86.ASUBSD, + 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 @@ -639,8 +643,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MULSS", - asm: x86.AMULSS, + 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 @@ -652,8 +657,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MULSD", - asm: x86.AMULSD, + 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 @@ -665,8 +671,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "DIVSS", - asm: x86.ADIVSS, + 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 @@ -679,8 +686,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "DIVSD", - asm: x86.ADIVSD, + 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 @@ -695,6 +703,7 @@ var opcodeTable = [...]opInfo{ { name: "MOVSSload", auxType: auxSymOff, + argLen: 2, asm: x86.AMOVSS, reg: regInfo{ inputs: []inputInfo{ @@ -708,6 +717,7 @@ var opcodeTable = [...]opInfo{ { name: "MOVSDload", auxType: auxSymOff, + argLen: 2, asm: x86.AMOVSD, reg: regInfo{ inputs: []inputInfo{ @@ -721,6 +731,7 @@ var opcodeTable = [...]opInfo{ { name: "MOVSSconst", auxType: auxFloat, + argLen: 0, rematerializeable: true, asm: x86.AMOVSS, reg: regInfo{ @@ -732,6 +743,7 @@ var opcodeTable = [...]opInfo{ { name: "MOVSDconst", auxType: auxFloat, + argLen: 0, rematerializeable: true, asm: x86.AMOVSD, reg: regInfo{ @@ -743,6 +755,7 @@ var opcodeTable = [...]opInfo{ { name: "MOVSSloadidx4", auxType: auxSymOff, + argLen: 3, asm: x86.AMOVSS, reg: regInfo{ inputs: []inputInfo{ @@ -757,6 +770,7 @@ var opcodeTable = [...]opInfo{ { name: "MOVSDloadidx8", auxType: auxSymOff, + argLen: 3, asm: x86.AMOVSD, reg: regInfo{ inputs: []inputInfo{ @@ -771,6 +785,7 @@ var opcodeTable = [...]opInfo{ { name: "MOVSSstore", auxType: auxSymOff, + argLen: 3, asm: x86.AMOVSS, reg: regInfo{ inputs: []inputInfo{ @@ -782,6 +797,7 @@ var opcodeTable = [...]opInfo{ { name: "MOVSDstore", auxType: auxSymOff, + argLen: 3, asm: x86.AMOVSD, reg: regInfo{ inputs: []inputInfo{ @@ -793,6 +809,7 @@ var opcodeTable = [...]opInfo{ { name: "MOVSSstoreidx4", auxType: auxSymOff, + argLen: 4, asm: x86.AMOVSS, reg: regInfo{ inputs: []inputInfo{ @@ -805,6 +822,7 @@ var opcodeTable = [...]opInfo{ { name: "MOVSDstoreidx8", auxType: auxSymOff, + argLen: 4, asm: x86.AMOVSD, reg: regInfo{ inputs: []inputInfo{ @@ -815,8 +833,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "ADDQ", - asm: x86.AADDQ, + 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 @@ -829,8 +848,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "ADDL", - asm: x86.AADDL, + 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 @@ -843,8 +863,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "ADDW", - asm: x86.AADDW, + name: "ADDW", + argLen: 2, + asm: x86.AADDW, reg: regInfo{ inputs: []inputInfo{ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -857,8 +878,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "ADDB", - asm: x86.AADDB, + name: "ADDB", + argLen: 2, + asm: x86.AADDB, reg: regInfo{ inputs: []inputInfo{ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -873,6 +895,7 @@ var opcodeTable = [...]opInfo{ { name: "ADDQconst", auxType: auxInt64, + argLen: 1, asm: x86.AADDQ, reg: regInfo{ inputs: []inputInfo{ @@ -887,6 +910,7 @@ var opcodeTable = [...]opInfo{ { name: "ADDLconst", auxType: auxInt32, + argLen: 1, asm: x86.AADDL, reg: regInfo{ inputs: []inputInfo{ @@ -901,6 +925,7 @@ var opcodeTable = [...]opInfo{ { name: "ADDWconst", auxType: auxInt16, + argLen: 1, asm: x86.AADDW, reg: regInfo{ inputs: []inputInfo{ @@ -915,6 +940,7 @@ var opcodeTable = [...]opInfo{ { name: "ADDBconst", auxType: auxInt8, + argLen: 1, asm: x86.AADDB, reg: regInfo{ inputs: []inputInfo{ @@ -927,8 +953,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SUBQ", - asm: x86.ASUBQ, + 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 @@ -941,8 +968,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SUBL", - asm: x86.ASUBL, + 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 @@ -955,8 +983,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SUBW", - asm: x86.ASUBW, + name: "SUBW", + argLen: 2, + asm: x86.ASUBW, reg: regInfo{ inputs: []inputInfo{ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -969,8 +998,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SUBB", - asm: x86.ASUBB, + name: "SUBB", + argLen: 2, + asm: x86.ASUBB, reg: regInfo{ inputs: []inputInfo{ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -985,6 +1015,7 @@ var opcodeTable = [...]opInfo{ { name: "SUBQconst", auxType: auxInt64, + argLen: 1, asm: x86.ASUBQ, reg: regInfo{ inputs: []inputInfo{ @@ -999,6 +1030,7 @@ var opcodeTable = [...]opInfo{ { name: "SUBLconst", auxType: auxInt32, + argLen: 1, asm: x86.ASUBL, reg: regInfo{ inputs: []inputInfo{ @@ -1013,6 +1045,7 @@ var opcodeTable = [...]opInfo{ { name: "SUBWconst", auxType: auxInt16, + argLen: 1, asm: x86.ASUBW, reg: regInfo{ inputs: []inputInfo{ @@ -1027,6 +1060,7 @@ var opcodeTable = [...]opInfo{ { name: "SUBBconst", auxType: auxInt8, + argLen: 1, asm: x86.ASUBB, reg: regInfo{ inputs: []inputInfo{ @@ -1039,8 +1073,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MULQ", - asm: x86.AIMULQ, + 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 @@ -1053,8 +1088,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MULL", - asm: x86.AIMULL, + 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 @@ -1067,8 +1103,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MULW", - asm: x86.AIMULW, + 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 @@ -1081,8 +1118,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MULB", - asm: x86.AIMULW, + 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 @@ -1097,6 +1135,7 @@ var opcodeTable = [...]opInfo{ { name: "MULQconst", auxType: auxInt64, + argLen: 1, asm: x86.AIMULQ, reg: regInfo{ inputs: []inputInfo{ @@ -1111,6 +1150,7 @@ var opcodeTable = [...]opInfo{ { name: "MULLconst", auxType: auxInt32, + argLen: 1, asm: x86.AIMULL, reg: regInfo{ inputs: []inputInfo{ @@ -1125,6 +1165,7 @@ var opcodeTable = [...]opInfo{ { name: "MULWconst", auxType: auxInt16, + argLen: 1, asm: x86.AIMULW, reg: regInfo{ inputs: []inputInfo{ @@ -1139,6 +1180,7 @@ var opcodeTable = [...]opInfo{ { name: "MULBconst", auxType: auxInt8, + argLen: 1, asm: x86.AIMULW, reg: regInfo{ inputs: []inputInfo{ @@ -1151,8 +1193,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "HMULQ", - asm: x86.AIMULQ, + name: "HMULQ", + argLen: 2, + asm: x86.AIMULQ, reg: regInfo{ inputs: []inputInfo{ {0, 1}, // .AX @@ -1165,8 +1208,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "HMULL", - asm: x86.AIMULL, + name: "HMULL", + argLen: 2, + asm: x86.AIMULL, reg: regInfo{ inputs: []inputInfo{ {0, 1}, // .AX @@ -1179,8 +1223,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "HMULW", - asm: x86.AIMULW, + name: "HMULW", + argLen: 2, + asm: x86.AIMULW, reg: regInfo{ inputs: []inputInfo{ {0, 1}, // .AX @@ -1193,8 +1238,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "HMULB", - asm: x86.AIMULB, + name: "HMULB", + argLen: 2, + asm: x86.AIMULB, reg: regInfo{ inputs: []inputInfo{ {0, 1}, // .AX @@ -1207,8 +1253,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "HMULQU", - asm: x86.AMULQ, + name: "HMULQU", + argLen: 2, + asm: x86.AMULQ, reg: regInfo{ inputs: []inputInfo{ {0, 1}, // .AX @@ -1221,8 +1268,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "HMULLU", - asm: x86.AMULL, + name: "HMULLU", + argLen: 2, + asm: x86.AMULL, reg: regInfo{ inputs: []inputInfo{ {0, 1}, // .AX @@ -1235,8 +1283,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "HMULWU", - asm: x86.AMULW, + name: "HMULWU", + argLen: 2, + asm: x86.AMULW, reg: regInfo{ inputs: []inputInfo{ {0, 1}, // .AX @@ -1249,8 +1298,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "HMULBU", - asm: x86.AMULB, + name: "HMULBU", + argLen: 2, + asm: x86.AMULB, reg: regInfo{ inputs: []inputInfo{ {0, 1}, // .AX @@ -1263,7 +1313,8 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "AVGQU", + 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 @@ -1276,8 +1327,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "DIVQ", - asm: x86.AIDIVQ, + name: "DIVQ", + argLen: 2, + asm: x86.AIDIVQ, reg: regInfo{ inputs: []inputInfo{ {0, 1}, // .AX @@ -1290,8 +1342,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "DIVL", - asm: x86.AIDIVL, + name: "DIVL", + argLen: 2, + asm: x86.AIDIVL, reg: regInfo{ inputs: []inputInfo{ {0, 1}, // .AX @@ -1304,8 +1357,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "DIVW", - asm: x86.AIDIVW, + name: "DIVW", + argLen: 2, + asm: x86.AIDIVW, reg: regInfo{ inputs: []inputInfo{ {0, 1}, // .AX @@ -1318,8 +1372,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "DIVQU", - asm: x86.ADIVQ, + name: "DIVQU", + argLen: 2, + asm: x86.ADIVQ, reg: regInfo{ inputs: []inputInfo{ {0, 1}, // .AX @@ -1332,8 +1387,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "DIVLU", - asm: x86.ADIVL, + name: "DIVLU", + argLen: 2, + asm: x86.ADIVL, reg: regInfo{ inputs: []inputInfo{ {0, 1}, // .AX @@ -1346,8 +1402,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "DIVWU", - asm: x86.ADIVW, + name: "DIVWU", + argLen: 2, + asm: x86.ADIVW, reg: regInfo{ inputs: []inputInfo{ {0, 1}, // .AX @@ -1360,8 +1417,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MODQ", - asm: x86.AIDIVQ, + name: "MODQ", + argLen: 2, + asm: x86.AIDIVQ, reg: regInfo{ inputs: []inputInfo{ {0, 1}, // .AX @@ -1374,8 +1432,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MODL", - asm: x86.AIDIVL, + name: "MODL", + argLen: 2, + asm: x86.AIDIVL, reg: regInfo{ inputs: []inputInfo{ {0, 1}, // .AX @@ -1388,8 +1447,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MODW", - asm: x86.AIDIVW, + name: "MODW", + argLen: 2, + asm: x86.AIDIVW, reg: regInfo{ inputs: []inputInfo{ {0, 1}, // .AX @@ -1402,8 +1462,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MODQU", - asm: x86.ADIVQ, + name: "MODQU", + argLen: 2, + asm: x86.ADIVQ, reg: regInfo{ inputs: []inputInfo{ {0, 1}, // .AX @@ -1416,8 +1477,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MODLU", - asm: x86.ADIVL, + name: "MODLU", + argLen: 2, + asm: x86.ADIVL, reg: regInfo{ inputs: []inputInfo{ {0, 1}, // .AX @@ -1430,8 +1492,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MODWU", - asm: x86.ADIVW, + name: "MODWU", + argLen: 2, + asm: x86.ADIVW, reg: regInfo{ inputs: []inputInfo{ {0, 1}, // .AX @@ -1444,8 +1507,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "ANDQ", - asm: x86.AANDQ, + 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 @@ -1458,8 +1522,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "ANDL", - asm: x86.AANDL, + 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 @@ -1472,8 +1537,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "ANDW", - asm: x86.AANDW, + name: "ANDW", + argLen: 2, + asm: x86.AANDW, reg: regInfo{ inputs: []inputInfo{ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -1486,8 +1552,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "ANDB", - asm: x86.AANDB, + name: "ANDB", + argLen: 2, + asm: x86.AANDB, reg: regInfo{ inputs: []inputInfo{ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -1502,6 +1569,7 @@ var opcodeTable = [...]opInfo{ { name: "ANDQconst", auxType: auxInt64, + argLen: 1, asm: x86.AANDQ, reg: regInfo{ inputs: []inputInfo{ @@ -1516,6 +1584,7 @@ var opcodeTable = [...]opInfo{ { name: "ANDLconst", auxType: auxInt32, + argLen: 1, asm: x86.AANDL, reg: regInfo{ inputs: []inputInfo{ @@ -1530,6 +1599,7 @@ var opcodeTable = [...]opInfo{ { name: "ANDWconst", auxType: auxInt16, + argLen: 1, asm: x86.AANDW, reg: regInfo{ inputs: []inputInfo{ @@ -1544,6 +1614,7 @@ var opcodeTable = [...]opInfo{ { name: "ANDBconst", auxType: auxInt8, + argLen: 1, asm: x86.AANDB, reg: regInfo{ inputs: []inputInfo{ @@ -1556,8 +1627,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "ORQ", - asm: x86.AORQ, + 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 @@ -1570,8 +1642,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "ORL", - asm: x86.AORL, + 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 @@ -1584,8 +1657,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "ORW", - asm: x86.AORW, + name: "ORW", + argLen: 2, + asm: x86.AORW, reg: regInfo{ inputs: []inputInfo{ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -1598,8 +1672,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "ORB", - asm: x86.AORB, + name: "ORB", + argLen: 2, + asm: x86.AORB, reg: regInfo{ inputs: []inputInfo{ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -1614,6 +1689,7 @@ var opcodeTable = [...]opInfo{ { name: "ORQconst", auxType: auxInt64, + argLen: 1, asm: x86.AORQ, reg: regInfo{ inputs: []inputInfo{ @@ -1628,6 +1704,7 @@ var opcodeTable = [...]opInfo{ { name: "ORLconst", auxType: auxInt32, + argLen: 1, asm: x86.AORL, reg: regInfo{ inputs: []inputInfo{ @@ -1642,6 +1719,7 @@ var opcodeTable = [...]opInfo{ { name: "ORWconst", auxType: auxInt16, + argLen: 1, asm: x86.AORW, reg: regInfo{ inputs: []inputInfo{ @@ -1656,6 +1734,7 @@ var opcodeTable = [...]opInfo{ { name: "ORBconst", auxType: auxInt8, + argLen: 1, asm: x86.AORB, reg: regInfo{ inputs: []inputInfo{ @@ -1668,8 +1747,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "XORQ", - asm: x86.AXORQ, + 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 @@ -1682,8 +1762,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "XORL", - asm: x86.AXORL, + 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 @@ -1696,8 +1777,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "XORW", - asm: x86.AXORW, + name: "XORW", + argLen: 2, + asm: x86.AXORW, reg: regInfo{ inputs: []inputInfo{ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -1710,8 +1792,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "XORB", - asm: x86.AXORB, + name: "XORB", + argLen: 2, + asm: x86.AXORB, reg: regInfo{ inputs: []inputInfo{ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -1726,6 +1809,7 @@ var opcodeTable = [...]opInfo{ { name: "XORQconst", auxType: auxInt64, + argLen: 1, asm: x86.AXORQ, reg: regInfo{ inputs: []inputInfo{ @@ -1740,6 +1824,7 @@ var opcodeTable = [...]opInfo{ { name: "XORLconst", auxType: auxInt32, + argLen: 1, asm: x86.AXORL, reg: regInfo{ inputs: []inputInfo{ @@ -1754,6 +1839,7 @@ var opcodeTable = [...]opInfo{ { name: "XORWconst", auxType: auxInt16, + argLen: 1, asm: x86.AXORW, reg: regInfo{ inputs: []inputInfo{ @@ -1768,6 +1854,7 @@ var opcodeTable = [...]opInfo{ { name: "XORBconst", auxType: auxInt8, + argLen: 1, asm: x86.AXORB, reg: regInfo{ inputs: []inputInfo{ @@ -1780,8 +1867,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "CMPQ", - asm: x86.ACMPQ, + 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 @@ -1793,8 +1881,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "CMPL", - asm: x86.ACMPL, + 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 @@ -1806,8 +1895,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "CMPW", - asm: x86.ACMPW, + 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 @@ -1819,8 +1909,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "CMPB", - asm: x86.ACMPB, + 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 @@ -1834,6 +1925,7 @@ var opcodeTable = [...]opInfo{ { name: "CMPQconst", auxType: auxInt64, + argLen: 1, asm: x86.ACMPQ, reg: regInfo{ inputs: []inputInfo{ @@ -1847,6 +1939,7 @@ var opcodeTable = [...]opInfo{ { name: "CMPLconst", auxType: auxInt32, + argLen: 1, asm: x86.ACMPL, reg: regInfo{ inputs: []inputInfo{ @@ -1860,6 +1953,7 @@ var opcodeTable = [...]opInfo{ { name: "CMPWconst", auxType: auxInt16, + argLen: 1, asm: x86.ACMPW, reg: regInfo{ inputs: []inputInfo{ @@ -1873,6 +1967,7 @@ var opcodeTable = [...]opInfo{ { name: "CMPBconst", auxType: auxInt8, + argLen: 1, asm: x86.ACMPB, reg: regInfo{ inputs: []inputInfo{ @@ -1884,8 +1979,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "UCOMISS", - asm: x86.AUCOMISS, + 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 @@ -1897,8 +1993,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "UCOMISD", - asm: x86.AUCOMISD, + 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 @@ -1910,8 +2007,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "TESTQ", - asm: x86.ATESTQ, + 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 @@ -1923,8 +2021,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "TESTL", - asm: x86.ATESTL, + 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 @@ -1936,8 +2035,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "TESTW", - asm: x86.ATESTW, + 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 @@ -1949,8 +2049,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "TESTB", - asm: x86.ATESTB, + 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 @@ -1964,6 +2065,7 @@ var opcodeTable = [...]opInfo{ { name: "TESTQconst", auxType: auxInt64, + argLen: 1, asm: x86.ATESTQ, reg: regInfo{ inputs: []inputInfo{ @@ -1977,6 +2079,7 @@ var opcodeTable = [...]opInfo{ { name: "TESTLconst", auxType: auxInt32, + argLen: 1, asm: x86.ATESTL, reg: regInfo{ inputs: []inputInfo{ @@ -1990,6 +2093,7 @@ var opcodeTable = [...]opInfo{ { name: "TESTWconst", auxType: auxInt16, + argLen: 1, asm: x86.ATESTW, reg: regInfo{ inputs: []inputInfo{ @@ -2003,6 +2107,7 @@ var opcodeTable = [...]opInfo{ { name: "TESTBconst", auxType: auxInt8, + argLen: 1, asm: x86.ATESTB, reg: regInfo{ inputs: []inputInfo{ @@ -2014,8 +2119,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SHLQ", - asm: x86.ASHLQ, + name: "SHLQ", + argLen: 2, + asm: x86.ASHLQ, reg: regInfo{ inputs: []inputInfo{ {1, 2}, // .CX @@ -2028,8 +2134,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SHLL", - asm: x86.ASHLL, + name: "SHLL", + argLen: 2, + asm: x86.ASHLL, reg: regInfo{ inputs: []inputInfo{ {1, 2}, // .CX @@ -2042,8 +2149,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SHLW", - asm: x86.ASHLW, + name: "SHLW", + argLen: 2, + asm: x86.ASHLW, reg: regInfo{ inputs: []inputInfo{ {1, 2}, // .CX @@ -2056,8 +2164,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SHLB", - asm: x86.ASHLB, + name: "SHLB", + argLen: 2, + asm: x86.ASHLB, reg: regInfo{ inputs: []inputInfo{ {1, 2}, // .CX @@ -2072,6 +2181,7 @@ var opcodeTable = [...]opInfo{ { name: "SHLQconst", auxType: auxInt64, + argLen: 1, asm: x86.ASHLQ, reg: regInfo{ inputs: []inputInfo{ @@ -2086,6 +2196,7 @@ var opcodeTable = [...]opInfo{ { name: "SHLLconst", auxType: auxInt32, + argLen: 1, asm: x86.ASHLL, reg: regInfo{ inputs: []inputInfo{ @@ -2100,6 +2211,7 @@ var opcodeTable = [...]opInfo{ { name: "SHLWconst", auxType: auxInt16, + argLen: 1, asm: x86.ASHLW, reg: regInfo{ inputs: []inputInfo{ @@ -2114,6 +2226,7 @@ var opcodeTable = [...]opInfo{ { name: "SHLBconst", auxType: auxInt8, + argLen: 1, asm: x86.ASHLB, reg: regInfo{ inputs: []inputInfo{ @@ -2126,8 +2239,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SHRQ", - asm: x86.ASHRQ, + name: "SHRQ", + argLen: 2, + asm: x86.ASHRQ, reg: regInfo{ inputs: []inputInfo{ {1, 2}, // .CX @@ -2140,8 +2254,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SHRL", - asm: x86.ASHRL, + name: "SHRL", + argLen: 2, + asm: x86.ASHRL, reg: regInfo{ inputs: []inputInfo{ {1, 2}, // .CX @@ -2154,8 +2269,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SHRW", - asm: x86.ASHRW, + name: "SHRW", + argLen: 2, + asm: x86.ASHRW, reg: regInfo{ inputs: []inputInfo{ {1, 2}, // .CX @@ -2168,8 +2284,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SHRB", - asm: x86.ASHRB, + name: "SHRB", + argLen: 2, + asm: x86.ASHRB, reg: regInfo{ inputs: []inputInfo{ {1, 2}, // .CX @@ -2184,6 +2301,7 @@ var opcodeTable = [...]opInfo{ { name: "SHRQconst", auxType: auxInt64, + argLen: 1, asm: x86.ASHRQ, reg: regInfo{ inputs: []inputInfo{ @@ -2198,6 +2316,7 @@ var opcodeTable = [...]opInfo{ { name: "SHRLconst", auxType: auxInt32, + argLen: 1, asm: x86.ASHRL, reg: regInfo{ inputs: []inputInfo{ @@ -2212,6 +2331,7 @@ var opcodeTable = [...]opInfo{ { name: "SHRWconst", auxType: auxInt16, + argLen: 1, asm: x86.ASHRW, reg: regInfo{ inputs: []inputInfo{ @@ -2226,6 +2346,7 @@ var opcodeTable = [...]opInfo{ { name: "SHRBconst", auxType: auxInt8, + argLen: 1, asm: x86.ASHRB, reg: regInfo{ inputs: []inputInfo{ @@ -2238,8 +2359,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SARQ", - asm: x86.ASARQ, + name: "SARQ", + argLen: 2, + asm: x86.ASARQ, reg: regInfo{ inputs: []inputInfo{ {1, 2}, // .CX @@ -2252,8 +2374,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SARL", - asm: x86.ASARL, + name: "SARL", + argLen: 2, + asm: x86.ASARL, reg: regInfo{ inputs: []inputInfo{ {1, 2}, // .CX @@ -2266,8 +2389,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SARW", - asm: x86.ASARW, + name: "SARW", + argLen: 2, + asm: x86.ASARW, reg: regInfo{ inputs: []inputInfo{ {1, 2}, // .CX @@ -2280,8 +2404,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SARB", - asm: x86.ASARB, + name: "SARB", + argLen: 2, + asm: x86.ASARB, reg: regInfo{ inputs: []inputInfo{ {1, 2}, // .CX @@ -2296,6 +2421,7 @@ var opcodeTable = [...]opInfo{ { name: "SARQconst", auxType: auxInt64, + argLen: 1, asm: x86.ASARQ, reg: regInfo{ inputs: []inputInfo{ @@ -2310,6 +2436,7 @@ var opcodeTable = [...]opInfo{ { name: "SARLconst", auxType: auxInt32, + argLen: 1, asm: x86.ASARL, reg: regInfo{ inputs: []inputInfo{ @@ -2324,6 +2451,7 @@ var opcodeTable = [...]opInfo{ { name: "SARWconst", auxType: auxInt16, + argLen: 1, asm: x86.ASARW, reg: regInfo{ inputs: []inputInfo{ @@ -2338,6 +2466,7 @@ var opcodeTable = [...]opInfo{ { name: "SARBconst", auxType: auxInt8, + argLen: 1, asm: x86.ASARB, reg: regInfo{ inputs: []inputInfo{ @@ -2352,6 +2481,7 @@ var opcodeTable = [...]opInfo{ { name: "ROLQconst", auxType: auxInt64, + argLen: 1, asm: x86.AROLQ, reg: regInfo{ inputs: []inputInfo{ @@ -2366,6 +2496,7 @@ var opcodeTable = [...]opInfo{ { name: "ROLLconst", auxType: auxInt32, + argLen: 1, asm: x86.AROLL, reg: regInfo{ inputs: []inputInfo{ @@ -2380,6 +2511,7 @@ var opcodeTable = [...]opInfo{ { name: "ROLWconst", auxType: auxInt16, + argLen: 1, asm: x86.AROLW, reg: regInfo{ inputs: []inputInfo{ @@ -2394,6 +2526,7 @@ var opcodeTable = [...]opInfo{ { name: "ROLBconst", auxType: auxInt8, + argLen: 1, asm: x86.AROLB, reg: regInfo{ inputs: []inputInfo{ @@ -2406,8 +2539,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "NEGQ", - asm: x86.ANEGQ, + 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 @@ -2419,8 +2553,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "NEGL", - asm: x86.ANEGL, + 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 @@ -2432,8 +2567,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "NEGW", - asm: x86.ANEGW, + name: "NEGW", + argLen: 1, + asm: x86.ANEGW, reg: regInfo{ inputs: []inputInfo{ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -2445,8 +2581,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "NEGB", - asm: x86.ANEGB, + name: "NEGB", + argLen: 1, + asm: x86.ANEGB, reg: regInfo{ inputs: []inputInfo{ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -2458,8 +2595,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "NOTQ", - asm: x86.ANOTQ, + 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 @@ -2471,8 +2609,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "NOTL", - asm: x86.ANOTL, + 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 @@ -2484,8 +2623,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "NOTW", - asm: x86.ANOTW, + name: "NOTW", + argLen: 1, + asm: x86.ANOTW, reg: regInfo{ inputs: []inputInfo{ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -2497,8 +2637,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "NOTB", - asm: x86.ANOTB, + name: "NOTB", + argLen: 1, + asm: x86.ANOTB, reg: regInfo{ inputs: []inputInfo{ {0, 65535}, // .AX .CX .DX .BX .SP .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -2510,8 +2651,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SQRTSD", - asm: x86.ASQRTSD, + 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 @@ -2522,8 +2664,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SBBQcarrymask", - asm: x86.ASBBQ, + name: "SBBQcarrymask", + argLen: 1, + asm: x86.ASBBQ, reg: regInfo{ inputs: []inputInfo{ {0, 8589934592}, // .FLAGS @@ -2534,8 +2677,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SBBLcarrymask", - asm: x86.ASBBL, + name: "SBBLcarrymask", + argLen: 1, + asm: x86.ASBBL, reg: regInfo{ inputs: []inputInfo{ {0, 8589934592}, // .FLAGS @@ -2546,8 +2690,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SETEQ", - asm: x86.ASETEQ, + name: "SETEQ", + argLen: 1, + asm: x86.ASETEQ, reg: regInfo{ inputs: []inputInfo{ {0, 8589934592}, // .FLAGS @@ -2558,8 +2703,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SETNE", - asm: x86.ASETNE, + name: "SETNE", + argLen: 1, + asm: x86.ASETNE, reg: regInfo{ inputs: []inputInfo{ {0, 8589934592}, // .FLAGS @@ -2570,8 +2716,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SETL", - asm: x86.ASETLT, + name: "SETL", + argLen: 1, + asm: x86.ASETLT, reg: regInfo{ inputs: []inputInfo{ {0, 8589934592}, // .FLAGS @@ -2582,8 +2729,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SETLE", - asm: x86.ASETLE, + name: "SETLE", + argLen: 1, + asm: x86.ASETLE, reg: regInfo{ inputs: []inputInfo{ {0, 8589934592}, // .FLAGS @@ -2594,8 +2742,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SETG", - asm: x86.ASETGT, + name: "SETG", + argLen: 1, + asm: x86.ASETGT, reg: regInfo{ inputs: []inputInfo{ {0, 8589934592}, // .FLAGS @@ -2606,8 +2755,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SETGE", - asm: x86.ASETGE, + name: "SETGE", + argLen: 1, + asm: x86.ASETGE, reg: regInfo{ inputs: []inputInfo{ {0, 8589934592}, // .FLAGS @@ -2618,8 +2768,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SETB", - asm: x86.ASETCS, + name: "SETB", + argLen: 1, + asm: x86.ASETCS, reg: regInfo{ inputs: []inputInfo{ {0, 8589934592}, // .FLAGS @@ -2630,8 +2781,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SETBE", - asm: x86.ASETLS, + name: "SETBE", + argLen: 1, + asm: x86.ASETLS, reg: regInfo{ inputs: []inputInfo{ {0, 8589934592}, // .FLAGS @@ -2642,8 +2794,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SETA", - asm: x86.ASETHI, + name: "SETA", + argLen: 1, + asm: x86.ASETHI, reg: regInfo{ inputs: []inputInfo{ {0, 8589934592}, // .FLAGS @@ -2654,8 +2807,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SETAE", - asm: x86.ASETCC, + name: "SETAE", + argLen: 1, + asm: x86.ASETCC, reg: regInfo{ inputs: []inputInfo{ {0, 8589934592}, // .FLAGS @@ -2666,8 +2820,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SETEQF", - asm: x86.ASETEQ, + name: "SETEQF", + argLen: 1, + asm: x86.ASETEQ, reg: regInfo{ inputs: []inputInfo{ {0, 8589934592}, // .FLAGS @@ -2679,8 +2834,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SETNEF", - asm: x86.ASETNE, + name: "SETNEF", + argLen: 1, + asm: x86.ASETNE, reg: regInfo{ inputs: []inputInfo{ {0, 8589934592}, // .FLAGS @@ -2692,8 +2848,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SETORD", - asm: x86.ASETPC, + name: "SETORD", + argLen: 1, + asm: x86.ASETPC, reg: regInfo{ inputs: []inputInfo{ {0, 8589934592}, // .FLAGS @@ -2704,8 +2861,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SETNAN", - asm: x86.ASETPS, + name: "SETNAN", + argLen: 1, + asm: x86.ASETPS, reg: regInfo{ inputs: []inputInfo{ {0, 8589934592}, // .FLAGS @@ -2716,8 +2874,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SETGF", - asm: x86.ASETHI, + name: "SETGF", + argLen: 1, + asm: x86.ASETHI, reg: regInfo{ inputs: []inputInfo{ {0, 8589934592}, // .FLAGS @@ -2728,8 +2887,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "SETGEF", - asm: x86.ASETCC, + name: "SETGEF", + argLen: 1, + asm: x86.ASETCC, reg: regInfo{ inputs: []inputInfo{ {0, 8589934592}, // .FLAGS @@ -2740,8 +2900,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVBQSX", - asm: x86.AMOVBQSX, + 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 @@ -2752,8 +2913,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVBQZX", - asm: x86.AMOVBQZX, + 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 @@ -2764,8 +2926,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVWQSX", - asm: x86.AMOVWQSX, + 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 @@ -2776,8 +2939,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVWQZX", - asm: x86.AMOVWQZX, + 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 @@ -2788,8 +2952,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVLQSX", - asm: x86.AMOVLQSX, + 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 @@ -2800,8 +2965,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVLQZX", - asm: x86.AMOVLQZX, + 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 @@ -2814,6 +2980,7 @@ var opcodeTable = [...]opInfo{ { name: "MOVBconst", auxType: auxInt8, + argLen: 0, rematerializeable: true, asm: x86.AMOVB, reg: regInfo{ @@ -2825,6 +2992,7 @@ var opcodeTable = [...]opInfo{ { name: "MOVWconst", auxType: auxInt16, + argLen: 0, rematerializeable: true, asm: x86.AMOVW, reg: regInfo{ @@ -2836,6 +3004,7 @@ var opcodeTable = [...]opInfo{ { name: "MOVLconst", auxType: auxInt32, + argLen: 0, rematerializeable: true, asm: x86.AMOVL, reg: regInfo{ @@ -2847,6 +3016,7 @@ var opcodeTable = [...]opInfo{ { name: "MOVQconst", auxType: auxInt64, + argLen: 0, rematerializeable: true, asm: x86.AMOVQ, reg: regInfo{ @@ -2856,8 +3026,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "CVTTSD2SL", - asm: x86.ACVTTSD2SL, + 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 @@ -2868,8 +3039,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "CVTTSD2SQ", - asm: x86.ACVTTSD2SQ, + 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 @@ -2880,8 +3052,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "CVTTSS2SL", - asm: x86.ACVTTSS2SL, + 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 @@ -2892,8 +3065,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "CVTTSS2SQ", - asm: x86.ACVTTSS2SQ, + 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 @@ -2904,8 +3078,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "CVTSL2SS", - asm: x86.ACVTSL2SS, + 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 @@ -2916,8 +3091,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "CVTSL2SD", - asm: x86.ACVTSL2SD, + 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 @@ -2928,8 +3104,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "CVTSQ2SS", - asm: x86.ACVTSQ2SS, + 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 @@ -2940,8 +3117,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "CVTSQ2SD", - asm: x86.ACVTSQ2SD, + 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 @@ -2952,8 +3130,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "CVTSD2SS", - asm: x86.ACVTSD2SS, + 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 @@ -2964,8 +3143,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "CVTSS2SD", - asm: x86.ACVTSS2SD, + 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 @@ -2976,8 +3156,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "PXOR", - asm: x86.APXOR, + 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 @@ -2991,6 +3172,7 @@ var opcodeTable = [...]opInfo{ { name: "LEAQ", auxType: auxSymOff, + argLen: 1, rematerializeable: true, reg: regInfo{ inputs: []inputInfo{ @@ -3004,6 +3186,7 @@ var opcodeTable = [...]opInfo{ { 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 @@ -3017,6 +3200,7 @@ var opcodeTable = [...]opInfo{ { 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 @@ -3030,6 +3214,7 @@ var opcodeTable = [...]opInfo{ { 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 @@ -3043,6 +3228,7 @@ var opcodeTable = [...]opInfo{ { 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 @@ -3056,6 +3242,7 @@ var opcodeTable = [...]opInfo{ { name: "MOVBload", auxType: auxSymOff, + argLen: 2, asm: x86.AMOVB, reg: regInfo{ inputs: []inputInfo{ @@ -3069,6 +3256,7 @@ var opcodeTable = [...]opInfo{ { name: "MOVBQSXload", auxType: auxSymOff, + argLen: 2, asm: x86.AMOVBQSX, reg: regInfo{ inputs: []inputInfo{ @@ -3082,6 +3270,7 @@ var opcodeTable = [...]opInfo{ { name: "MOVBQZXload", auxType: auxSymOff, + argLen: 2, asm: x86.AMOVBQZX, reg: regInfo{ inputs: []inputInfo{ @@ -3095,6 +3284,7 @@ var opcodeTable = [...]opInfo{ { name: "MOVWload", auxType: auxSymOff, + argLen: 2, asm: x86.AMOVW, reg: regInfo{ inputs: []inputInfo{ @@ -3108,6 +3298,7 @@ var opcodeTable = [...]opInfo{ { name: "MOVWQSXload", auxType: auxSymOff, + argLen: 2, asm: x86.AMOVWQSX, reg: regInfo{ inputs: []inputInfo{ @@ -3121,6 +3312,7 @@ var opcodeTable = [...]opInfo{ { name: "MOVWQZXload", auxType: auxSymOff, + argLen: 2, asm: x86.AMOVWQZX, reg: regInfo{ inputs: []inputInfo{ @@ -3134,6 +3326,7 @@ var opcodeTable = [...]opInfo{ { name: "MOVLload", auxType: auxSymOff, + argLen: 2, asm: x86.AMOVL, reg: regInfo{ inputs: []inputInfo{ @@ -3147,6 +3340,7 @@ var opcodeTable = [...]opInfo{ { name: "MOVLQSXload", auxType: auxSymOff, + argLen: 2, asm: x86.AMOVLQSX, reg: regInfo{ inputs: []inputInfo{ @@ -3160,6 +3354,7 @@ var opcodeTable = [...]opInfo{ { name: "MOVLQZXload", auxType: auxSymOff, + argLen: 2, asm: x86.AMOVLQZX, reg: regInfo{ inputs: []inputInfo{ @@ -3173,6 +3368,7 @@ var opcodeTable = [...]opInfo{ { name: "MOVQload", auxType: auxSymOff, + argLen: 2, asm: x86.AMOVQ, reg: regInfo{ inputs: []inputInfo{ @@ -3186,6 +3382,7 @@ var opcodeTable = [...]opInfo{ { name: "MOVBstore", auxType: auxSymOff, + argLen: 3, asm: x86.AMOVB, reg: regInfo{ inputs: []inputInfo{ @@ -3197,6 +3394,7 @@ var opcodeTable = [...]opInfo{ { name: "MOVWstore", auxType: auxSymOff, + argLen: 3, asm: x86.AMOVW, reg: regInfo{ inputs: []inputInfo{ @@ -3208,6 +3406,7 @@ var opcodeTable = [...]opInfo{ { name: "MOVLstore", auxType: auxSymOff, + argLen: 3, asm: x86.AMOVL, reg: regInfo{ inputs: []inputInfo{ @@ -3219,6 +3418,7 @@ var opcodeTable = [...]opInfo{ { name: "MOVQstore", auxType: auxSymOff, + argLen: 3, asm: x86.AMOVQ, reg: regInfo{ inputs: []inputInfo{ @@ -3230,6 +3430,7 @@ var opcodeTable = [...]opInfo{ { name: "MOVOload", auxType: auxSymOff, + argLen: 2, asm: x86.AMOVUPS, reg: regInfo{ inputs: []inputInfo{ @@ -3243,6 +3444,7 @@ var opcodeTable = [...]opInfo{ { name: "MOVOstore", auxType: auxSymOff, + argLen: 3, asm: x86.AMOVUPS, reg: regInfo{ inputs: []inputInfo{ @@ -3254,6 +3456,7 @@ var opcodeTable = [...]opInfo{ { name: "MOVBloadidx1", auxType: auxSymOff, + argLen: 3, asm: x86.AMOVB, reg: regInfo{ inputs: []inputInfo{ @@ -3268,6 +3471,7 @@ var opcodeTable = [...]opInfo{ { name: "MOVWloadidx2", auxType: auxSymOff, + argLen: 3, asm: x86.AMOVW, reg: regInfo{ inputs: []inputInfo{ @@ -3282,6 +3486,7 @@ var opcodeTable = [...]opInfo{ { name: "MOVLloadidx4", auxType: auxSymOff, + argLen: 3, asm: x86.AMOVL, reg: regInfo{ inputs: []inputInfo{ @@ -3296,6 +3501,7 @@ var opcodeTable = [...]opInfo{ { name: "MOVQloadidx8", auxType: auxSymOff, + argLen: 3, asm: x86.AMOVQ, reg: regInfo{ inputs: []inputInfo{ @@ -3310,6 +3516,7 @@ var opcodeTable = [...]opInfo{ { name: "MOVBstoreidx1", auxType: auxSymOff, + argLen: 4, asm: x86.AMOVB, reg: regInfo{ inputs: []inputInfo{ @@ -3322,6 +3529,7 @@ var opcodeTable = [...]opInfo{ { name: "MOVWstoreidx2", auxType: auxSymOff, + argLen: 4, asm: x86.AMOVW, reg: regInfo{ inputs: []inputInfo{ @@ -3334,6 +3542,7 @@ var opcodeTable = [...]opInfo{ { name: "MOVLstoreidx4", auxType: auxSymOff, + argLen: 4, asm: x86.AMOVL, reg: regInfo{ inputs: []inputInfo{ @@ -3346,6 +3555,7 @@ var opcodeTable = [...]opInfo{ { name: "MOVQstoreidx8", auxType: auxSymOff, + argLen: 4, asm: x86.AMOVQ, reg: regInfo{ inputs: []inputInfo{ @@ -3358,6 +3568,7 @@ var opcodeTable = [...]opInfo{ { name: "MOVBstoreconst", auxType: auxSymValAndOff, + argLen: 2, asm: x86.AMOVB, reg: regInfo{ inputs: []inputInfo{ @@ -3368,6 +3579,7 @@ var opcodeTable = [...]opInfo{ { name: "MOVWstoreconst", auxType: auxSymValAndOff, + argLen: 2, asm: x86.AMOVW, reg: regInfo{ inputs: []inputInfo{ @@ -3378,6 +3590,7 @@ var opcodeTable = [...]opInfo{ { name: "MOVLstoreconst", auxType: auxSymValAndOff, + argLen: 2, asm: x86.AMOVL, reg: regInfo{ inputs: []inputInfo{ @@ -3388,6 +3601,7 @@ var opcodeTable = [...]opInfo{ { name: "MOVQstoreconst", auxType: auxSymValAndOff, + argLen: 2, asm: x86.AMOVQ, reg: regInfo{ inputs: []inputInfo{ @@ -3398,6 +3612,7 @@ var opcodeTable = [...]opInfo{ { name: "MOVBstoreconstidx1", auxType: auxSymValAndOff, + argLen: 3, asm: x86.AMOVB, reg: regInfo{ inputs: []inputInfo{ @@ -3409,6 +3624,7 @@ var opcodeTable = [...]opInfo{ { name: "MOVWstoreconstidx2", auxType: auxSymValAndOff, + argLen: 3, asm: x86.AMOVW, reg: regInfo{ inputs: []inputInfo{ @@ -3420,6 +3636,7 @@ var opcodeTable = [...]opInfo{ { name: "MOVLstoreconstidx4", auxType: auxSymValAndOff, + argLen: 3, asm: x86.AMOVL, reg: regInfo{ inputs: []inputInfo{ @@ -3431,6 +3648,7 @@ var opcodeTable = [...]opInfo{ { name: "MOVQstoreconstidx8", auxType: auxSymValAndOff, + argLen: 3, asm: x86.AMOVQ, reg: regInfo{ inputs: []inputInfo{ @@ -3442,6 +3660,7 @@ var opcodeTable = [...]opInfo{ { name: "DUFFZERO", auxType: auxInt64, + argLen: 3, reg: regInfo{ inputs: []inputInfo{ {0, 128}, // .DI @@ -3452,6 +3671,7 @@ var opcodeTable = [...]opInfo{ }, { name: "MOVOconst", + argLen: 0, rematerializeable: true, reg: regInfo{ outputs: []regMask{ @@ -3460,7 +3680,8 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "REPSTOSQ", + name: "REPSTOSQ", + argLen: 4, reg: regInfo{ inputs: []inputInfo{ {0, 128}, // .DI @@ -3473,6 +3694,7 @@ var opcodeTable = [...]opInfo{ { 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 }, @@ -3480,6 +3702,7 @@ var opcodeTable = [...]opInfo{ { name: "CALLclosure", auxType: auxInt64, + argLen: 3, reg: regInfo{ inputs: []inputInfo{ {1, 4}, // .DX @@ -3491,6 +3714,7 @@ var opcodeTable = [...]opInfo{ { 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 }, @@ -3498,6 +3722,7 @@ var opcodeTable = [...]opInfo{ { 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 }, @@ -3505,6 +3730,7 @@ var opcodeTable = [...]opInfo{ { 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 @@ -3515,6 +3741,7 @@ var opcodeTable = [...]opInfo{ { name: "DUFFCOPY", auxType: auxInt64, + argLen: 3, reg: regInfo{ inputs: []inputInfo{ {0, 128}, // .DI @@ -3524,7 +3751,8 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "REPMOVSQ", + name: "REPMOVSQ", + argLen: 4, reg: regInfo{ inputs: []inputInfo{ {0, 128}, // .DI @@ -3535,11 +3763,13 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "InvertFlags", - reg: regInfo{}, + name: "InvertFlags", + argLen: 1, + reg: regInfo{}, }, { - name: "LoweredGetG", + name: "LoweredGetG", + argLen: 1, reg: regInfo{ outputs: []regMask{ 65519, // .AX .CX .DX .BX .BP .SI .DI .R8 .R9 .R10 .R11 .R12 .R13 .R14 .R15 @@ -3547,7 +3777,8 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "LoweredGetClosurePtr", + name: "LoweredGetClosurePtr", + argLen: 0, reg: regInfo{ outputs: []regMask{ 4, // .DX @@ -3555,7 +3786,8 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "LoweredNilCheck", + 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 @@ -3564,8 +3796,9 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "MOVQconvert", - asm: x86.AMOVQ, + 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 @@ -3576,1174 +3809,1452 @@ var opcodeTable = [...]opInfo{ }, }, { - name: "FlagEQ", - reg: regInfo{}, + name: "FlagEQ", + argLen: 0, + reg: regInfo{}, }, { - name: "FlagLT_ULT", - reg: regInfo{}, + name: "FlagLT_ULT", + argLen: 0, + reg: regInfo{}, }, { - name: "FlagLT_UGT", - reg: regInfo{}, + name: "FlagLT_UGT", + argLen: 0, + reg: regInfo{}, }, { - name: "FlagGT_UGT", - reg: regInfo{}, + name: "FlagGT_UGT", + argLen: 0, + reg: regInfo{}, }, { - name: "FlagGT_ULT", - 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, }, } diff --git a/src/cmd/compile/internal/ssa/zcse.go b/src/cmd/compile/internal/ssa/zcse.go index 3206e19974..664fbae9f0 100644 --- a/src/cmd/compile/internal/ssa/zcse.go +++ b/src/cmd/compile/internal/ssa/zcse.go @@ -16,10 +16,8 @@ func zcse(f *Func) { for i := 0; i < len(b.Values); { v := b.Values[i] next := true - switch v.Op { - case OpSB, OpConst64, OpConst32, OpConst16, OpConst8, OpConst64F, - OpConst32F, OpConstBool, OpConstNil, OpConstSlice, OpConstInterface: - key := vkey{v.Op, keyFor(v), typeStr(v)} + 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 { @@ -47,11 +45,8 @@ func zcse(f *Func) { for _, b := range f.Blocks { for _, v := range b.Values { for i, a := range v.Args { - // TODO: encode arglen in the opcode table, then do this switch with a table lookup? - switch a.Op { - case OpSB, OpConst64, OpConst32, OpConst16, OpConst8, OpConst64F, - OpConst32F, OpConstBool, OpConstNil, OpConstSlice, OpConstInterface: - key := vkey{a.Op, keyFor(a), typeStr(a)} + 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 } @@ -64,8 +59,9 @@ func zcse(f *Func) { // vkey is a type used to uniquely identify a zero arg value. type vkey struct { op Op - a int64 // aux - t string // type + ai int64 // aux int + ax interface{} // aux + t string // type } // typeStr returns a string version of the type of v. @@ -89,7 +85,6 @@ func keyFor(v *Value) int64 { case OpConst8, OpConstBool: return int64(int8(v.AuxInt)) default: - // Also matches OpSB, OpConstNil, OpConstSlice, OpConstInterface: - return 0 + return v.AuxInt } } -- cgit v1.3 From bdea1d58cfc55a5156c8df392cfc3133589389db Mon Sep 17 00:00:00 2001 From: Alexandru Moșoi Date: Fri, 19 Feb 2016 12:14:42 +0100 Subject: [dev.ssa] cmd/compile/internal/ssa: remove proven redundant controls. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * It does very simple bounds checking elimination. E.g. removes the second check in for i := range a { a[i]++; a[i++]; } * Improves on the following redundant expression: return a6 || (a6 || (a6 || a4)) || (a6 || (a4 || a6 || (false || a6))) * Linear in the number of block edges. I patched in CL 12960 that does bounds, nil and constant propagation to make sure this CL is not just redundant. Size of pkg/tool/linux_amd64/* (excluding compile which is affected by this change): With IsInBounds and IsSliceInBounds -this -12960 92285080 +this -12960 91947416 -this +12960 91978976 +this +12960 91923088 Gain is ~110% of 12960. Without IsInBounds and IsSliceInBounds (older run) -this -12960 95515512 +this -12960 95492536 -this +12960 95216920 +this +12960 95204440 Shaves 22k on its own. * Can we handle IsInBounds better with this? In for i := range a { a[i]++; } the bounds checking at a[i] is not eliminated. Change-Id: I98957427399145fb33693173fd4d5a8d71c7cc20 Reviewed-on: https://go-review.googlesource.com/19710 Reviewed-by: David Chase Reviewed-by: Keith Randall Run-TryBot: Alexandru Moșoi TryBot-Result: Gobot Gobot --- src/cmd/compile/internal/ssa/compile.go | 5 + src/cmd/compile/internal/ssa/prove.go | 359 ++++++++++++++++++++++++++++++++ test/prove.go | 207 ++++++++++++++++++ 3 files changed, 571 insertions(+) create mode 100644 src/cmd/compile/internal/ssa/prove.go create mode 100644 test/prove.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/compile.go b/src/cmd/compile/internal/ssa/compile.go index 23dab9e273..5e68ea004e 100644 --- a/src/cmd/compile/internal/ssa/compile.go +++ b/src/cmd/compile/internal/ssa/compile.go @@ -165,6 +165,7 @@ var passes = [...]pass{ {name: "opt deadcode", fn: deadcode}, // remove any blocks orphaned during opt {name: "generic cse", fn: cse}, {name: "nilcheckelim", fn: nilcheckelim}, + {name: "prove", fn: prove}, {name: "generic deadcode", fn: deadcode}, {name: "fuse", fn: fuse}, {name: "dse", fn: dse}, @@ -193,6 +194,10 @@ type constraint struct { } 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"}, diff --git a/src/cmd/compile/internal/ssa/prove.go b/src/cmd/compile/internal/ssa/prove.go new file mode 100644 index 0000000000..f0f4649896 --- /dev/null +++ b/src/cmd/compile/internal/ssa/prove.go @@ -0,0 +1,359 @@ +// 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) + 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) + } + } + + // 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 := range domTree[node.block.ID] { + 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/test/prove.go b/test/prove.go new file mode 100644 index 0000000000..0f5b8ce87f --- /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() { +} -- cgit v1.3 From 34f048c9d9cfd839703f96834ec6bd0a500e4b00 Mon Sep 17 00:00:00 2001 From: David Chase Date: Sun, 28 Feb 2016 15:58:17 -0500 Subject: [dev.ssa] cmd/compile: small optimization to prove using sdom tweak MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Exposed data already in sdom to avoid recreating it in prove. Change-Id: I834c9c03ed8faeaee013e5a1b3f955908f0e0915 Reviewed-on: https://go-review.googlesource.com/19999 Run-TryBot: David Chase Reviewed-by: Keith Randall TryBot-Result: Gobot Gobot Reviewed-by: Alexandru Moșoi --- src/cmd/compile/internal/ssa/prove.go | 10 +--------- src/cmd/compile/internal/ssa/sparsetree.go | 20 ++++++++++++++++++-- 2 files changed, 19 insertions(+), 11 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/prove.go b/src/cmd/compile/internal/ssa/prove.go index f0f4649896..a915e0b5a7 100644 --- a/src/cmd/compile/internal/ssa/prove.go +++ b/src/cmd/compile/internal/ssa/prove.go @@ -127,14 +127,6 @@ var ( func prove(f *Func) { idom := dominators(f) sdom := newSparseTree(f, idom) - 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) - } - } // current node state type walkState int @@ -179,7 +171,7 @@ func prove(f *Func) { saved: saved, }) - for _, s := range domTree[node.block.ID] { + for s := sdom.Child(node.block); s != nil; s = sdom.Sibling(s) { work = append(work, bp{ block: s, state: descend, diff --git a/src/cmd/compile/internal/ssa/sparsetree.go b/src/cmd/compile/internal/ssa/sparsetree.go index 14bcb44b1b..9a08f35d9d 100644 --- a/src/cmd/compile/internal/ssa/sparsetree.go +++ b/src/cmd/compile/internal/ssa/sparsetree.go @@ -5,7 +5,6 @@ package ssa type sparseTreeNode struct { - block *Block child *Block sibling *Block parent *Block @@ -43,7 +42,6 @@ func newSparseTree(f *Func, parentOf []*Block) sparseTree { t := make(sparseTree, f.NumBlocks()) for _, b := range f.Blocks { n := &t[b.ID] - n.block = b if p := parentOf[b.ID]; p != nil { n.parent = p n.sibling = t[p.ID].child @@ -98,6 +96,24 @@ func (t sparseTree) numberBlock(b *Block, n int32) int32 { 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] -- cgit v1.3 From 8107b0012f1d5f808e33f812c456e20554c383c8 Mon Sep 17 00:00:00 2001 From: David Chase Date: Sun, 28 Feb 2016 11:15:22 -0500 Subject: [dev.ssa] cmd/compile: use 32-bit load to read writebarrier Avoid targeting a partial register with load; ensure source of load (writebarrier) is aligned. Better yet would be "CMPB $1,writebarrier" but that requires wrestling with flagalloc (mem operand complicates moving instruction around). Didn't see a change in time for benchcmd -n 10 Build go build net/http Verified that we clean the code up properly: 0x20a8 : mov 0xc30a2(%rip),%eax # 0xc5150 0x20ae : test %al,%al Change-Id: Id5fb8c260eaec27bd727cb0ae1476c60343b0986 Reviewed-on: https://go-review.googlesource.com/19998 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 12 ++++++++---- src/runtime/mgc.go | 7 ++++--- 2 files changed, 12 insertions(+), 7 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 9847806110..8e68c20fb4 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -2718,9 +2718,11 @@ func (s *state) insertWBmove(t *Type, left, right *ssa.Value, line int32) { bEnd := s.f.NewBlock(ssa.BlockPlain) aux := &ssa.ExternSymbol{Types[TBOOL], syslook("writeBarrier", 0).Sym} - flagaddr := s.newValue1A(ssa.OpAddr, Ptrto(Types[TBOOL]), aux, s.sb) + 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. - flag := s.newValue2(ssa.OpLoad, Types[TBOOL], flagaddr, s.mem()) + // 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 @@ -2761,9 +2763,11 @@ func (s *state) insertWBstore(t *Type, left, right *ssa.Value, line int32) { bEnd := s.f.NewBlock(ssa.BlockPlain) aux := &ssa.ExternSymbol{Types[TBOOL], syslook("writeBarrier", 0).Sym} - flagaddr := s.newValue1A(ssa.OpAddr, Ptrto(Types[TBOOL]), aux, s.sb) + 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. - flag := s.newValue2(ssa.OpLoad, Types[TBOOL], flagaddr, s.mem()) + // 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 diff --git a/src/runtime/mgc.go b/src/runtime/mgc.go index 94301c6dc7..102d44160e 100644 --- a/src/runtime/mgc.go +++ b/src/runtime/mgc.go @@ -216,9 +216,10 @@ var gcphase uint32 // 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 -- cgit v1.3 From 1b1d0a9a802deadf8e21517575eed4e6f02d3995 Mon Sep 17 00:00:00 2001 From: Ilya Tocar Date: Fri, 26 Feb 2016 16:48:16 +0300 Subject: [dev.ssa] cmd/compile: Use movups for xmm->xmm mov Movups is 1 byte smaller than movapd that we currently use. Change-Id: I22f771f066529352722a28543535ec43497cb9c5 Reviewed-on: https://go-review.googlesource.com/19938 Reviewed-by: David Chase --- src/cmd/compile/internal/gc/ssa.go | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 8e68c20fb4..b46016f1f2 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -4999,7 +4999,9 @@ 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. - return x86.AMOVAPD + // 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: -- cgit v1.3 From 5c5fa3628ca58dce7cc19bc3939b8a55a6c3eefd Mon Sep 17 00:00:00 2001 From: Ilya Tocar Date: Fri, 26 Feb 2016 17:23:44 +0300 Subject: [dev.ssa] cmd/compile/internal/ssa: replace load of store with a copy This is a AMD64 version of CL19743. Saves additional 1574 bytes in go binary. This also speeds up bzip2 by 1-4% Change-Id: I031ba423663c4e83fdefe44e5296f24143e303da Reviewed-on: https://go-review.googlesource.com/19939 Run-TryBot: Ilya Tocar TryBot-Result: Gobot Gobot Reviewed-by: David Chase --- src/cmd/compile/internal/ssa/gen/AMD64.rules | 6 ++ src/cmd/compile/internal/ssa/rewriteAMD64.go | 88 ++++++++++++++++++++++++++++ 2 files changed, 94 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules index 033fb27b3f..167ec82d18 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64.rules +++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules @@ -608,6 +608,12 @@ (MOVLQSX (MOVLload [off] {sym} ptr mem)) -> @v.Args[0].Block (MOVLQSXload [off] {sym} ptr mem) (MOVLQZX (MOVLload [off] {sym} ptr mem)) -> @v.Args[0].Block (MOVLQZXload [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) diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index a84b35974b..61a617808a 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -5459,6 +5459,28 @@ func rewriteValueAMD64_OpAMD64MOVBQZX(v *Value, config *Config) bool { 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) @@ -6042,6 +6064,28 @@ func rewriteValueAMD64_OpAMD64MOVLQZX(v *Value, config *Config) bool { 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) @@ -6572,6 +6616,28 @@ func rewriteValueAMD64_OpAMD64MOVOstore(v *Value, config *Config) bool { 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) @@ -7543,6 +7609,28 @@ func rewriteValueAMD64_OpAMD64MOVWQZX(v *Value, config *Config) bool { 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) -- cgit v1.3 From f1f366c1e70cb2628ad948d03ef5049763d98451 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Mon, 29 Feb 2016 11:10:08 -0800 Subject: [dev.ssa] cmd/compile: MOVBconst might also clobber flags It gets rewritten to an xor by the linker also. Change-Id: Iae35130325d41bd1a09b7e971190cae6f4e17fac Reviewed-on: https://go-review.googlesource.com/20058 Reviewed-by: David Chase Run-TryBot: Keith Randall TryBot-Result: Gobot Gobot --- src/cmd/compile/internal/gc/ssa.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index b46016f1f2..e81ca14571 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -4649,7 +4649,7 @@ func (s *genState) markMoves(b *ssa.Block) { } for i := len(b.Values) - 1; i >= 0; i-- { v := b.Values[i] - if flive && (v.Op == ssa.OpAMD64MOVWconst || v.Op == ssa.OpAMD64MOVLconst || v.Op == ssa.OpAMD64MOVQconst) { + 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 } -- cgit v1.3 From 194c79c16390187624f648e4af279a11c67b99ce Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Sun, 28 Feb 2016 15:51:11 -0800 Subject: [dev.ssa] cmd/compile: add constant cache MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The cache gets a 62% hit rate while compiling the standard library. name old time/op new time/op delta Template 449ms ± 2% 443ms ± 4% -1.40% (p=0.006 n=23+25) GoTypes 1.54s ± 1% 1.50s ± 2% -2.53% (p=0.000 n=22+22) Compiler 5.51s ± 1% 5.39s ± 1% -2.29% (p=0.000 n=23+25) name old alloc/op new alloc/op delta Template 90.4MB ± 0% 90.0MB ± 0% -0.45% (p=0.000 n=25+25) GoTypes 334MB ± 0% 331MB ± 0% -1.05% (p=0.000 n=25+25) Compiler 1.12GB ± 0% 1.10GB ± 0% -1.57% (p=0.000 n=25+24) name old allocs/op new allocs/op delta Template 681k ± 0% 682k ± 0% +0.26% (p=0.000 n=25+25) GoTypes 2.23M ± 0% 2.23M ± 0% +0.05% (p=0.000 n=23+24) Compiler 6.46M ± 0% 6.46M ± 0% +0.02% (p=0.000 n=24+25) Change-Id: I2629c291892827493d7b55ec4d83f6973a2ab133 Reviewed-on: https://go-review.googlesource.com/20026 Reviewed-by: Keith Randall Run-TryBot: Josh Bleecher Snyder Reviewed-by: Alexandru Moșoi TryBot-Result: Gobot Gobot --- src/cmd/compile/internal/ssa/TODO | 2 +- src/cmd/compile/internal/ssa/func.go | 39 ++++++++++++++++++----------- src/cmd/compile/internal/ssa/gen/rulegen.go | 2 ++ 3 files changed, 28 insertions(+), 15 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/TODO b/src/cmd/compile/internal/ssa/TODO index 57bed9a9a3..4e39d1e9c3 100644 --- a/src/cmd/compile/internal/ssa/TODO +++ b/src/cmd/compile/internal/ssa/TODO @@ -47,7 +47,7 @@ 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? -- Constant cache +- 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 diff --git a/src/cmd/compile/internal/ssa/func.go b/src/cmd/compile/internal/ssa/func.go index 9441110769..7cc5f6c8d9 100644 --- a/src/cmd/compile/internal/ssa/func.go +++ b/src/cmd/compile/internal/ssa/func.go @@ -35,6 +35,8 @@ type Func struct { 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. @@ -270,38 +272,47 @@ func (b *Block) NewValue3I(line int32, op Op, t Type, auxint int64, arg0, arg1, 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 { - // TODO: cache? i := int64(0) if c { i = 1 } - return f.Entry.NewValue0I(line, OpConstBool, t, i) + return f.constVal(line, OpConstBool, t, i) } func (f *Func) ConstInt8(line int32, t Type, c int8) *Value { - // TODO: cache? - return f.Entry.NewValue0I(line, OpConst8, t, int64(c)) + return f.constVal(line, OpConst8, t, int64(c)) } func (f *Func) ConstInt16(line int32, t Type, c int16) *Value { - // TODO: cache? - return f.Entry.NewValue0I(line, OpConst16, t, int64(c)) + return f.constVal(line, OpConst16, t, int64(c)) } func (f *Func) ConstInt32(line int32, t Type, c int32) *Value { - // TODO: cache? - return f.Entry.NewValue0I(line, OpConst32, t, int64(c)) + return f.constVal(line, OpConst32, t, int64(c)) } func (f *Func) ConstInt64(line int32, t Type, c int64) *Value { - // TODO: cache? - return f.Entry.NewValue0I(line, OpConst64, t, c) + return f.constVal(line, OpConst64, t, c) } func (f *Func) ConstFloat32(line int32, t Type, c float64) *Value { - // TODO: cache? - return f.Entry.NewValue0I(line, OpConst32F, t, int64(math.Float64bits(c))) + return f.constVal(line, OpConst32F, t, int64(math.Float64bits(c))) } func (f *Func) ConstFloat64(line int32, t Type, c float64) *Value { - // TODO: cache? - return f.Entry.NewValue0I(line, OpConst64F, t, int64(math.Float64bits(c))) + return f.constVal(line, OpConst64F, t, int64(math.Float64bits(c))) } func (f *Func) Logf(msg string, args ...interface{}) { f.Config.Logf(msg, args...) } diff --git a/src/cmd/compile/internal/ssa/gen/rulegen.go b/src/cmd/compile/internal/ssa/gen/rulegen.go index 55287c187d..c2da3e6489 100644 --- a/src/cmd/compile/internal/ssa/gen/rulegen.go +++ b/src/cmd/compile/internal/ssa/gen/rulegen.go @@ -426,6 +426,8 @@ func genResult(w io.Writer, arch arch, result string) { 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 { -- cgit v1.3 From 6a8a9da572883d7aae7e4618ef2713c716e4edd7 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Sat, 27 Feb 2016 17:49:31 -0800 Subject: [dev.ssa] cmd/compile: Make PPARAMOUT variables SSAable Add writeback code to each return location which copies the final result back to the correct stack location. Cgo plays tricky games by taking the address of a in f(a int) (b int) and then using that address to modify b. So for cgo-generated Go code, disable the SSAing of output args. Update #14511 Change-Id: I95cba727d53699d31124eef41db0e03935862be9 Reviewed-on: https://go-review.googlesource.com/19988 Reviewed-by: Todd Neal Run-TryBot: Keith Randall Reviewed-by: Ian Lance Taylor --- src/cmd/cgo/out.go | 1 + src/cmd/compile/internal/gc/lex.go | 5 ++- src/cmd/compile/internal/gc/ssa.go | 91 +++++++++++++++++++++++++++++--------- 3 files changed, 75 insertions(+), 22 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/cgo/out.go b/src/cmd/cgo/out.go index ca0ec0aaa2..07561bfa2e 100644 --- a/src/cmd/cgo/out.go +++ b/src/cmd/cgo/out.go @@ -458,6 +458,7 @@ func (p *Package) writeDefsFunc(fgo2 io.Writer, n *Name) { } 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/gc/lex.go b/src/cmd/compile/internal/gc/lex.go index 49e5d6561a..8ecc8832d0 100644 --- a/src/cmd/compile/internal/gc/lex.go +++ b/src/cmd/compile/internal/gc/lex.go @@ -862,7 +862,7 @@ func plan9quote(s string) string { return s } -type Pragma uint8 +type Pragma uint16 const ( Nointerface Pragma = 1 << iota @@ -873,6 +873,7 @@ const ( 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 { @@ -1722,6 +1723,8 @@ func (l *lexer) getlinepragma() rune { 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/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 4399470471..0081146872 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -93,6 +93,9 @@ func buildssa(fn *Node) *ssa.Func { 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 @@ -134,16 +137,22 @@ func buildssa(fn *Node) *ssa.Func { s.decladdrs = map[*Node]*ssa.Value{} for _, n := range fn.Func.Dcl { switch n.Class { - case PPARAM: + 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, PPARAMOUT: + case PAUTO: // processed at each use, to prevent Addr coming // before the decl. case PFUNC: @@ -259,6 +268,11 @@ type state struct { // 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 { @@ -520,7 +534,7 @@ func (s *state) stmt(n *Node) { 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.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 @@ -702,19 +716,12 @@ func (s *state) stmt(n *Node) { case ORETURN: s.stmtList(n.List) - s.stmts(s.exitCode) - m := s.mem() - b := s.endBlock() - b.Kind = ssa.BlockRet - b.Control = m + s.exit() case ORETJMP: s.stmtList(n.List) - s.stmts(s.exitCode) - m := s.mem() - b := s.endBlock() - b.Kind = ssa.BlockRetJmp + b := s.exit() + b.Kind = ssa.BlockRetJmp // override BlockRet b.Aux = n.Left.Sym - b.Control = m case OCONTINUE, OBREAK: var op string @@ -863,7 +870,7 @@ func (s *state) stmt(n *Node) { // 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 !canSSA(n.Left) { + if !s.canSSA(n.Left) { s.vars[&memVar] = s.newValue1A(ssa.OpVarKill, ssa.TypeMem, n.Left, s.mem()) } @@ -883,6 +890,34 @@ func (s *state) stmt(n *Node) { } } +// 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 @@ -1317,7 +1352,7 @@ func (s *state) expr(n *Node) *ssa.Value { aux := &ssa.ExternSymbol{n.Type, sym} return s.entryNewValue1A(ssa.OpAddr, Ptrto(n.Type), aux, s.sb) } - if canSSA(n) { + if s.canSSA(n) { return s.variable(n, n.Type) } addr := s.addr(n, false) @@ -2112,7 +2147,7 @@ func (s *state) assign(left *Node, right *ssa.Value, wb, deref bool, line int32) } t := left.Type dowidth(t) - if canSSA(left) { + if s.canSSA(left) { if deref { s.Fatalf("can SSA LHS %s but not RHS %s", left, right) } @@ -2520,7 +2555,7 @@ func (s *state) addr(n *Node, bounded bool) *ssa.Value { // canSSA reports whether n is SSA-able. // n must be an ONAME (or an ODOT sequence with an ONAME base). -func canSSA(n *Node) bool { +func (s *state) canSSA(n *Node) bool { for n.Op == ODOT { n = n.Left } @@ -2534,12 +2569,26 @@ func canSSA(n *Node) bool { return false } switch n.Class { - case PEXTERN, PPARAMOUT, PPARAMREF: + 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) @@ -3447,7 +3496,7 @@ func (s *state) resolveFwdRef(v *ssa.Value) { v.Aux = nil if b == s.f.Entry { // Live variable at start of function. - if canSSA(name) { + if s.canSSA(name) { v.Op = ssa.OpArg v.Aux = name return @@ -4381,7 +4430,7 @@ func (s *genState) genValue(v *ssa.Value) { p.From.Node = n p.From.Sym = Linksym(n.Sym) p.From.Offset = off - if n.Class == PPARAM { + if n.Class == PPARAM || n.Class == PPARAMOUT { p.From.Name = obj.NAME_PARAM p.From.Offset += n.Xoffset } else { @@ -4403,7 +4452,7 @@ func (s *genState) genValue(v *ssa.Value) { p.To.Node = n p.To.Sym = Linksym(n.Sym) p.To.Offset = off - if n.Class == PPARAM { + if n.Class == PPARAM || n.Class == PPARAMOUT { p.To.Name = obj.NAME_PARAM p.To.Offset += n.Xoffset } else { -- cgit v1.3 From e96b232993fa8edb478f32041e08e5cf5c74395d Mon Sep 17 00:00:00 2001 From: Ilya Tocar Date: Mon, 15 Feb 2016 17:01:26 +0300 Subject: [dev.ssa] cmd/compile: promote byte/word operation Writing to low 8/16 bits of register creates false dependency Generate 32-bit operations when possible. Change-Id: I8eb6c1c43a66424eec6baa91a660bceb6b80d1d3 Reviewed-on: https://go-review.googlesource.com/19506 Reviewed-by: Keith Randall Run-TryBot: Ilya Tocar TryBot-Result: Gobot Gobot --- src/cmd/compile/internal/gc/ssa.go | 49 +++++++++----- src/cmd/compile/internal/ssa/gen/AMD64Ops.go | 96 ++++++++++++++-------------- src/cmd/compile/internal/ssa/opGen.go | 64 +++++++++---------- 3 files changed, 112 insertions(+), 97 deletions(-) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 0081146872..a2454e19fe 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -3793,7 +3793,7 @@ func (s *genState) genValue(v *ssa.Value) { case ssa.OpAMD64ADDL: asm = x86.ALEAL case ssa.OpAMD64ADDW: - asm = x86.ALEAW + asm = x86.ALEAL } p := Prog(asm) p.From.Type = obj.TYPE_MEM @@ -3843,9 +3843,15 @@ func (s *genState) genValue(v *ssa.Value) { opregreg(v.Op.Asm(), r, y) if neg { - p := Prog(x86.ANEGQ) // TODO: use correct size? This is mostly a hack until regalloc does 2-address correctly - p.To.Type = obj.TYPE_REG - p.To.Reg = r + 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) @@ -4035,7 +4041,7 @@ func (s *genState) genValue(v *ssa.Value) { case ssa.OpAMD64ADDLconst: asm = x86.AINCL case ssa.OpAMD64ADDWconst: - asm = x86.AINCW + asm = x86.AINCL } p := Prog(asm) p.To.Type = obj.TYPE_REG @@ -4049,7 +4055,7 @@ func (s *genState) genValue(v *ssa.Value) { case ssa.OpAMD64ADDLconst: asm = x86.ADECL case ssa.OpAMD64ADDWconst: - asm = x86.ADECW + asm = x86.ADECL } p := Prog(asm) p.To.Type = obj.TYPE_REG @@ -4071,7 +4077,7 @@ func (s *genState) genValue(v *ssa.Value) { case ssa.OpAMD64ADDLconst: asm = x86.ALEAL case ssa.OpAMD64ADDWconst: - asm = x86.ALEAW + asm = x86.ALEAL } p := Prog(asm) p.From.Type = obj.TYPE_MEM @@ -4131,7 +4137,7 @@ func (s *genState) genValue(v *ssa.Value) { case ssa.OpAMD64SUBLconst: asm = x86.AINCL case ssa.OpAMD64SUBWconst: - asm = x86.AINCW + asm = x86.AINCL } p := Prog(asm) p.To.Type = obj.TYPE_REG @@ -4144,7 +4150,7 @@ func (s *genState) genValue(v *ssa.Value) { case ssa.OpAMD64SUBLconst: asm = x86.ADECL case ssa.OpAMD64SUBWconst: - asm = x86.ADECW + asm = x86.ADECL } p := Prog(asm) p.To.Type = obj.TYPE_REG @@ -4157,7 +4163,7 @@ func (s *genState) genValue(v *ssa.Value) { case ssa.OpAMD64SUBLconst: asm = x86.ALEAL case ssa.OpAMD64SUBWconst: - asm = x86.ALEAW + asm = x86.ALEAL } p := Prog(asm) p.From.Type = obj.TYPE_MEM @@ -4596,8 +4602,8 @@ func (s *genState) genValue(v *ssa.Value) { q := Prog(x86.ASETPS) q.To.Type = obj.TYPE_REG q.To.Reg = x86.REG_AX - // TODO AORQ copied from old code generator, why not AORB? - opregreg(x86.AORQ, regnum(v), 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()) @@ -4606,8 +4612,8 @@ func (s *genState) genValue(v *ssa.Value) { q := Prog(x86.ASETPC) q.To.Type = obj.TYPE_REG q.To.Reg = x86.REG_AX - // TODO AANDQ copied from old code generator, why not AANDB? - opregreg(x86.AANDQ, regnum(v), 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) @@ -5019,7 +5025,15 @@ var ssaRegToReg = [...]int16{ // loadByType returns the load instruction of the given type. func loadByType(t ssa.Type) int { - // For x86, there's no difference between load and store opcodes. + // 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) } @@ -5059,9 +5073,10 @@ func moveByType(t ssa.Type) int { } else { switch t.Size() { case 1: - return x86.AMOVB + // Avoids partial register write + return x86.AMOVL case 2: - return x86.AMOVW + return x86.AMOVL case 4: return x86.AMOVL case 8: diff --git a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go index b0c7ecf181..af08d18978 100644 --- a/src/cmd/compile/internal/ssa/gen/AMD64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/AMD64Ops.go @@ -168,21 +168,21 @@ func init() { // 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: "ADDW"}, // arg0 + arg1 - {name: "ADDB", argLength: 2, reg: gp21, asm: "ADDB"}, // 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: "ADDW", aux: "Int16"}, // arg0 + auxint - {name: "ADDBconst", argLength: 1, reg: gp11, asm: "ADDB", aux: "Int8"}, // 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: "SUBW"}, // arg0 - arg1 - {name: "SUBB", argLength: 2, reg: gp21, asm: "SUBB"}, // 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: "SUBW", aux: "Int16"}, // arg0 - auxint - {name: "SUBBconst", argLength: 1, reg: gp11, asm: "SUBB", aux: "Int8"}, // 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 @@ -220,30 +220,30 @@ func init() { {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: "ANDW"}, // arg0 & arg1 - {name: "ANDB", argLength: 2, reg: gp21, asm: "ANDB"}, // 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: "ANDW", aux: "Int16"}, // arg0 & auxint - {name: "ANDBconst", argLength: 1, reg: gp11, asm: "ANDB", aux: "Int8"}, // 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: "ORW"}, // arg0 | arg1 - {name: "ORB", argLength: 2, reg: gp21, asm: "ORB"}, // 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: "ORW", aux: "Int16"}, // arg0 | auxint - {name: "ORBconst", argLength: 1, reg: gp11, asm: "ORB", aux: "Int8"}, // 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: "XORW"}, // arg0 ^ arg1 - {name: "XORB", argLength: 2, reg: gp21, asm: "XORB"}, // 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: "XORW", aux: "Int16"}, // arg0 ^ auxint - {name: "XORBconst", argLength: 1, reg: gp11, asm: "XORB", aux: "Int8"}, // 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 @@ -268,12 +268,12 @@ func init() { {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: "SHLW"}, // arg0 << arg1, shift amount is mod 32 - {name: "SHLB", argLength: 2, reg: gp21shift, asm: "SHLB"}, // 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: "SHLW", aux: "Int16"}, // arg0 << auxint, shift amount 0-31 - {name: "SHLBconst", argLength: 1, reg: gp11, asm: "SHLB", aux: "Int8"}, // 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 @@ -302,13 +302,13 @@ func init() { // 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: "NEGW"}, // -arg0 - {name: "NEGB", argLength: 1, reg: gp11, asm: "NEGB"}, // -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: "NOTW"}, // ^arg0 - {name: "NOTB", argLength: 1, reg: gp11, asm: "NOTB"}, // ^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) @@ -370,28 +370,28 @@ func init() { // 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: "MOVB", 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: "MOVW", 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 + {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: "MOVB", aux: "SymOff"}, // load a byte from arg0+arg1+auxint+aux. arg2=mem - {name: "MOVWloadidx2", argLength: 3, reg: gploadidx, asm: "MOVW", 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 + {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 diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index bd985cabde..e912b20c2b 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -865,7 +865,7 @@ var opcodeTable = [...]opInfo{ { name: "ADDW", argLen: 2, - asm: x86.AADDW, + 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 @@ -880,7 +880,7 @@ var opcodeTable = [...]opInfo{ { name: "ADDB", argLen: 2, - asm: x86.AADDB, + 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 @@ -926,7 +926,7 @@ var opcodeTable = [...]opInfo{ name: "ADDWconst", auxType: auxInt16, argLen: 1, - asm: x86.AADDW, + 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 @@ -941,7 +941,7 @@ var opcodeTable = [...]opInfo{ name: "ADDBconst", auxType: auxInt8, argLen: 1, - asm: x86.AADDB, + 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 @@ -985,7 +985,7 @@ var opcodeTable = [...]opInfo{ { name: "SUBW", argLen: 2, - asm: x86.ASUBW, + 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 @@ -1000,7 +1000,7 @@ var opcodeTable = [...]opInfo{ { name: "SUBB", argLen: 2, - asm: x86.ASUBB, + 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 @@ -1046,7 +1046,7 @@ var opcodeTable = [...]opInfo{ name: "SUBWconst", auxType: auxInt16, argLen: 1, - asm: x86.ASUBW, + 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 @@ -1061,7 +1061,7 @@ var opcodeTable = [...]opInfo{ name: "SUBBconst", auxType: auxInt8, argLen: 1, - asm: x86.ASUBB, + 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 @@ -1539,7 +1539,7 @@ var opcodeTable = [...]opInfo{ { name: "ANDW", argLen: 2, - asm: x86.AANDW, + 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 @@ -1554,7 +1554,7 @@ var opcodeTable = [...]opInfo{ { name: "ANDB", argLen: 2, - asm: x86.AANDB, + 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 @@ -1600,7 +1600,7 @@ var opcodeTable = [...]opInfo{ name: "ANDWconst", auxType: auxInt16, argLen: 1, - asm: x86.AANDW, + 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 @@ -1615,7 +1615,7 @@ var opcodeTable = [...]opInfo{ name: "ANDBconst", auxType: auxInt8, argLen: 1, - asm: x86.AANDB, + 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 @@ -1659,7 +1659,7 @@ var opcodeTable = [...]opInfo{ { name: "ORW", argLen: 2, - asm: x86.AORW, + 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 @@ -1674,7 +1674,7 @@ var opcodeTable = [...]opInfo{ { name: "ORB", argLen: 2, - asm: x86.AORB, + 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 @@ -1720,7 +1720,7 @@ var opcodeTable = [...]opInfo{ name: "ORWconst", auxType: auxInt16, argLen: 1, - asm: x86.AORW, + 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 @@ -1735,7 +1735,7 @@ var opcodeTable = [...]opInfo{ name: "ORBconst", auxType: auxInt8, argLen: 1, - asm: x86.AORB, + 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 @@ -1779,7 +1779,7 @@ var opcodeTable = [...]opInfo{ { name: "XORW", argLen: 2, - asm: x86.AXORW, + 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 @@ -1794,7 +1794,7 @@ var opcodeTable = [...]opInfo{ { name: "XORB", argLen: 2, - asm: x86.AXORB, + 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 @@ -1840,7 +1840,7 @@ var opcodeTable = [...]opInfo{ name: "XORWconst", auxType: auxInt16, argLen: 1, - asm: x86.AXORW, + 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 @@ -1855,7 +1855,7 @@ var opcodeTable = [...]opInfo{ name: "XORBconst", auxType: auxInt8, argLen: 1, - asm: x86.AXORB, + 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 @@ -2151,7 +2151,7 @@ var opcodeTable = [...]opInfo{ { name: "SHLW", argLen: 2, - asm: x86.ASHLW, + asm: x86.ASHLL, reg: regInfo{ inputs: []inputInfo{ {1, 2}, // .CX @@ -2166,7 +2166,7 @@ var opcodeTable = [...]opInfo{ { name: "SHLB", argLen: 2, - asm: x86.ASHLB, + asm: x86.ASHLL, reg: regInfo{ inputs: []inputInfo{ {1, 2}, // .CX @@ -2212,7 +2212,7 @@ var opcodeTable = [...]opInfo{ name: "SHLWconst", auxType: auxInt16, argLen: 1, - asm: x86.ASHLW, + 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 @@ -2227,7 +2227,7 @@ var opcodeTable = [...]opInfo{ name: "SHLBconst", auxType: auxInt8, argLen: 1, - asm: x86.ASHLB, + 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 @@ -2569,7 +2569,7 @@ var opcodeTable = [...]opInfo{ { name: "NEGW", argLen: 1, - asm: x86.ANEGW, + 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 @@ -2583,7 +2583,7 @@ var opcodeTable = [...]opInfo{ { name: "NEGB", argLen: 1, - asm: x86.ANEGB, + 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 @@ -2625,7 +2625,7 @@ var opcodeTable = [...]opInfo{ { name: "NOTW", argLen: 1, - asm: x86.ANOTW, + 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 @@ -2639,7 +2639,7 @@ var opcodeTable = [...]opInfo{ { name: "NOTB", argLen: 1, - asm: x86.ANOTB, + 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 @@ -3243,7 +3243,7 @@ var opcodeTable = [...]opInfo{ name: "MOVBload", auxType: auxSymOff, argLen: 2, - asm: x86.AMOVB, + 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 @@ -3285,7 +3285,7 @@ var opcodeTable = [...]opInfo{ name: "MOVWload", auxType: auxSymOff, argLen: 2, - asm: x86.AMOVW, + 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 @@ -3457,7 +3457,7 @@ var opcodeTable = [...]opInfo{ name: "MOVBloadidx1", auxType: auxSymOff, argLen: 3, - asm: x86.AMOVB, + 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 @@ -3472,7 +3472,7 @@ var opcodeTable = [...]opInfo{ name: "MOVWloadidx2", auxType: auxSymOff, argLen: 3, - asm: x86.AMOVW, + 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 -- cgit v1.3 From 1f6e9e36b0aba3d2459c80b2c8e905d9cc57f7ce Mon Sep 17 00:00:00 2001 From: Alexandru Moșoi Date: Tue, 1 Mar 2016 13:39:47 +0100 Subject: [dev.ssa] cmd/compile/internal/ssa: distribute multiplication into addition MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * This is a very basic form of straight line strength reduction. * Removes one multiplication from a[b].c++; a[b+1].c++ * It increases pressure on the register allocator because CSE creates more copies of the multiplication sizeof(a[0])*b. Change-Id: I686a18e9c24cc6f8bdfa925713afed034f7d36d0 Reviewed-on: https://go-review.googlesource.com/20091 Run-TryBot: Alexandru Moșoi TryBot-Result: Gobot Gobot Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/gen/generic.rules | 5 ++ src/cmd/compile/internal/ssa/rewritegeneric.go | 70 ++++++++++++++++++++++++++ 2 files changed, 75 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules index ac24337920..11c7b9d7a1 100644 --- a/src/cmd/compile/internal/ssa/gen/generic.rules +++ b/src/cmd/compile/internal/ssa/gen/generic.rules @@ -147,6 +147,11 @@ (Xor16 x (Const16 [c])) && x.Op != OpConst16 -> (Xor16 (Const16 [c]) x) (Xor8 x (Const8 [c])) && x.Op != OpConst8 -> (Xor8 (Const8 [c]) x) +// Distribute multiplication c * (d+x) -> c*d + c*x. Useful for: +// a[i].b = ...; a[i+1].b = ... +(Mul64 (Const64 [c]) (Add64 (Const64 [d]) x)) -> (Add64 (Const64 [c*d]) (Mul64 (Const64 [c]) x)) +(Mul32 (Const32 [c]) (Add32 (Const32 [d]) x)) -> (Add32 (Const32 [c*d]) (Mul32 (Const32 [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 x (Const32 [c])) -> (Lsh64x64 x (Const64 [int64(uint32(c))])) diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index 4f29cf5348..0c71b2c884 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -4044,6 +4044,41 @@ func rewriteValuegeneric_OpMul32(v *Value, config *Config) bool { v.AddArg(x) return true } + // match: (Mul32 (Const32 [c]) (Add32 (Const32 [d]) x)) + // cond: + // result: (Add32 (Const32 [c*d]) (Mul32 (Const32 [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]) @@ -4099,6 +4134,41 @@ func rewriteValuegeneric_OpMul64(v *Value, config *Config) bool { v.AddArg(x) return true } + // match: (Mul64 (Const64 [c]) (Add64 (Const64 [d]) x)) + // cond: + // result: (Add64 (Const64 [c*d]) (Mul64 (Const64 [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]) -- cgit v1.3 From e197f467d51318305439610d44af0e20dae7062f Mon Sep 17 00:00:00 2001 From: Alexandru Moșoi Date: Mon, 29 Feb 2016 19:29:04 +0100 Subject: [dev.ssa] cmd/compile/internal/ssa: simplify boolean phis MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Decreases the generated code slightly. * Similar to phiopt pass from gcc, except it only handles booleans. Handling Eq/Neq had no impact on the generated code. name old time/op new time/op delta Template 453ms ± 4% 451ms ± 4% ~ (p=0.468 n=24+24) GoTypes 1.55s ± 1% 1.55s ± 2% ~ (p=0.287 n=24+25) Compiler 6.53s ± 2% 6.56s ± 1% +0.46% (p=0.050 n=23+23) MakeBash 45.8s ± 2% 45.7s ± 2% ~ (p=0.866 n=24+25) name old text-bytes new text-bytes delta HelloSize 676k ± 0% 676k ± 0% ~ (all samples are equal) CmdGoSize 8.07M ± 0% 8.07M ± 0% -0.03% (p=0.000 n=25+25) Change-Id: Ia62477b7554127958a14cb27f85849b095d63663 Reviewed-on: https://go-review.googlesource.com/20090 Reviewed-by: Keith Randall Run-TryBot: Alexandru Moșoi TryBot-Result: Gobot Gobot --- src/cmd/compile/internal/ssa/compile.go | 1 + src/cmd/compile/internal/ssa/phiopt.go | 86 +++++++++++++++++++++++++++++++++ test/phiopt.go | 43 +++++++++++++++++ 3 files changed, 130 insertions(+) create mode 100644 src/cmd/compile/internal/ssa/phiopt.go create mode 100644 test/phiopt.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/compile.go b/src/cmd/compile/internal/ssa/compile.go index 5e68ea004e..2780e5bcfc 100644 --- a/src/cmd/compile/internal/ssa/compile.go +++ b/src/cmd/compile/internal/ssa/compile.go @@ -164,6 +164,7 @@ var passes = [...]pass{ {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}, diff --git a/src/cmd/compile/internal/ssa/phiopt.go b/src/cmd/compile/internal/ssa/phiopt.go new file mode 100644 index 0000000000..fb17727242 --- /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/test/phiopt.go b/test/phiopt.go new file mode 100644 index 0000000000..9b9b701124 --- /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() { +} -- cgit v1.3 From 9ace455e78d7c00925f35877e432dfa3768f13f3 Mon Sep 17 00:00:00 2001 From: Matthew Dempsky Date: Tue, 1 Mar 2016 10:58:06 -0800 Subject: cmd/compile/internal/ssa: cleanup godocs Add a blank line before the "package ssa" lines so the "autogenerated don't edit" comments don't end up in godoc output. Change-Id: I82bf90d52d426ce1a8e21483fc8f47b3689259c7 Reviewed-on: https://go-review.googlesource.com/20086 Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/gen/main.go | 1 + src/cmd/compile/internal/ssa/gen/rulegen.go | 1 + src/cmd/compile/internal/ssa/opGen.go | 1 + src/cmd/compile/internal/ssa/rewriteAMD64.go | 1 + src/cmd/compile/internal/ssa/rewritegeneric.go | 1 + 5 files changed, 5 insertions(+) (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/gen/main.go b/src/cmd/compile/internal/ssa/gen/main.go index 5ba8483f61..660511e46c 100644 --- a/src/cmd/compile/internal/ssa/gen/main.go +++ b/src/cmd/compile/internal/ssa/gen/main.go @@ -75,6 +75,7 @@ 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\"") diff --git a/src/cmd/compile/internal/ssa/gen/rulegen.go b/src/cmd/compile/internal/ssa/gen/rulegen.go index c2da3e6489..e3e3efac41 100644 --- a/src/cmd/compile/internal/ssa/gen/rulegen.go +++ b/src/cmd/compile/internal/ssa/gen/rulegen.go @@ -140,6 +140,7 @@ func genRules(arch arch) { 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\"") diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go index e912b20c2b..a48766ffc0 100644 --- a/src/cmd/compile/internal/ssa/opGen.go +++ b/src/cmd/compile/internal/ssa/opGen.go @@ -1,5 +1,6 @@ // autogenerated: do not edit! // generated from gen/*Ops.go + package ssa import "cmd/internal/obj/x86" diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 61a617808a..83fc437747 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -1,5 +1,6 @@ // autogenerated from gen/AMD64.rules: do not edit! // generated with: cd gen; go run *.go + package ssa import "math" diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index 0c71b2c884..ad2abc5601 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -1,5 +1,6 @@ // autogenerated from gen/generic.rules: do not edit! // generated with: cd gen; go run *.go + package ssa import "math" -- cgit v1.3 From 6b3462c784df961f22eea0c39490b38093086b83 Mon Sep 17 00:00:00 2001 From: David Chase Date: Sat, 27 Feb 2016 11:54:52 -0500 Subject: [dev.ssa] cmd/compile: adjust branch likeliness for calls/loops Static branch predictions (which guide block ordering) are adjusted based on: loop/not-loop (favor looping) abnormal-exit/not (avoid panic) call/not-call (avoid call) ret/default (treat returns as rare) This appears to make no difference in performance of real code, meaning the compiler itself. The earlier version of this has been stripped down to help make the cost of this only-aesthetic-on-Intel phase be as cheap as possible (we probably want information about inner loops for improving register allocation, but because register allocation follows close behind this pass, conceivably the information could be reused -- so we might do this anyway just to normalize output). For a ./make.bash that takes 200 user seconds, about .75 second is reported in likelyadjust (summing nanoseconds reported with -d=ssa/likelyadjust/time ). Upstream predictions are respected. Includes test, limited to build on amd64 only. Did several iterations on the debugging output to allow some rough checks on behavior. Debug=1 logging notes agree/disagree with earlier passes, allowing analysis like the following: Run on make.bash: GO_GCFLAGS=-d=ssa/likelyadjust/debug \ ./make.bash >& lkly5.log grep 'ranch prediction' lkly5.log | wc -l 78242 // 78k predictions grep 'ranch predi' lkly5.log | egrep -v 'agrees with' | wc -l 29633 // 29k NEW predictions grep 'disagrees' lkly5.log | wc -l 444 // contradicted 444 times grep '< exit' lkly5.log | wc -l 10212 // 10k exit predictions grep '< exit' lkly5.log | egrep 'disagrees' | wc -l 5 // 5 contradicted by previous prediction grep '< exit' lkly5.log | egrep -v 'agrees' | wc -l 702 // 702-5 redundant with previous prediction grep '< call' lkly5.log | egrep -v 'agrees' | wc -l 16699 // 16k new call predictions grep 'stay in loop' lkly5.log | egrep -v 'agrees' | wc -l 3951 // 4k new "remain in loop" predictions Fixes #11451. Change-Id: Iafb0504f7030d304ef4b6dc1aba9a5789151a593 Reviewed-on: https://go-review.googlesource.com/19995 Run-TryBot: David Chase Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/TODO | 3 +- src/cmd/compile/internal/ssa/compile.go | 3 +- src/cmd/compile/internal/ssa/likelyadjust.go | 300 +++++++++++++++++++++++++++ test/opt_branchlikely.go | 85 ++++++++ 4 files changed, 388 insertions(+), 3 deletions(-) create mode 100755 src/cmd/compile/internal/ssa/likelyadjust.go create mode 100644 test/opt_branchlikely.go (limited to 'src/cmd') diff --git a/src/cmd/compile/internal/ssa/TODO b/src/cmd/compile/internal/ssa/TODO index 4e39d1e9c3..a457e67101 100644 --- a/src/cmd/compile/internal/ssa/TODO +++ b/src/cmd/compile/internal/ssa/TODO @@ -24,7 +24,7 @@ Optimizations (better compiled code) - 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 feilds being accessed) pass them in xmm registers? + 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 @@ -32,7 +32,6 @@ Optimizations (better compiled code) Note that this is challenging for ops that generate flags because flagalloc wants to move those instructions around for flag regeneration. -- In forms like if ... { call } else { no call }, mark the call branch as unlikely. - Non-constant rotate detection. - Do 0 <= x && x < n with one unsigned compare - nil-check removal in indexed load/store case: diff --git a/src/cmd/compile/internal/ssa/compile.go b/src/cmd/compile/internal/ssa/compile.go index 2780e5bcfc..f68819c3c2 100644 --- a/src/cmd/compile/internal/ssa/compile.go +++ b/src/cmd/compile/internal/ssa/compile.go @@ -178,7 +178,8 @@ var passes = [...]pass{ {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: "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 diff --git a/src/cmd/compile/internal/ssa/likelyadjust.go b/src/cmd/compile/internal/ssa/likelyadjust.go new file mode 100755 index 0000000000..6ce8705272 --- /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/test/opt_branchlikely.go b/test/opt_branchlikely.go new file mode 100644 index 0000000000..99e914654f --- /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 +} -- cgit v1.3